This is the mail archive of the
gdb-cvs@sourceware.org
mailing list for the GDB project.
[binutils-gdb] Target FP: Refactor use of host floating-point arithmetic
- From: Ulrich Weigand <uweigand at sourceware dot org>
- To: gdb-cvs at sourceware dot org
- Date: 22 Nov 2017 12:55:28 -0000
- Subject: [binutils-gdb] Target FP: Refactor use of host floating-point arithmetic
https://sourceware.org/git/gitweb.cgi?p=binutils-gdb.git;h=7a26362d360ee34de1e8e927bd7159860fe8354b
commit 7a26362d360ee34de1e8e927bd7159860fe8354b
Author: Ulrich Weigand <ulrich.weigand@de.ibm.com>
Date: Wed Nov 22 13:51:49 2017 +0100
Target FP: Refactor use of host floating-point arithmetic
Prepare for using MPFR to implement floating-point arithmetic by
refactoring the way host floating-point arithmetic is currently used.
In particular, fix the following two problems that cause different
(and incorrect) results due to using host arithmetic:
- Current processing always uses host "long double", and then converts
back to the actual target format. This may introduce rounding errors.
- Conversion of FP values to LONGEST simply does a host C++ type cast.
However the result of such a cast is undefined if the source value
is outside the representable range. MPFR always has defined behavior
here (returns the minimum or maximum representable value).
To fix the first issue, I've now created not just one set of routines
using host FP arithmetic (on long double), but instead three different
sets of routines, one each for host float, double, and long double.
Operations can then be performed in the desired type directly, avoiding
the extra rounding step. Using C++ templates, the three sets can all
share the same source code without duplication.
To fix the second issue, I'm simply enforcing the same conversion rule
(which makes sense anyway) when converting out-of-range values from
FP to LONGEST.
To contain the code complexity with the variety of options now possible,
I've created a new class "target_float_ops". There are a total of five
separate implementations of this:
host_float_ops<float> Implemented via host FP in given type
host_float_ops<double>
host_float_ops<long double>
mpfr_float_ops Implemented via MPFR if available
decimal_float_ops Implemented via libdecnumber
Note instead of using the DOUBLEST define, this always just uses the
"long double" data type. But since we now require C++11 anyway, this
type must in any case be avaialble unconditionally.
Most target floating-point operations simply dispatch to a (virtual)
member routine of this class. Which implementation to choose is
determined from the target types involved, and whether they match
some host type or not. E.g. any operation on a single type that
matches a host type is performed in that type. Operations involving
two types that both match host types are performed in the larger one
(according to C/C++ implicit conversion rules). Operations that
involve any type that does not match a host type are performed using
MPFR. (And of course operations involving decimal FP are performed
using libdecnumber.)
This first patch implements the refactoring of target-float.c as
described above, introduing the host_float_ops and decimal_float_ops
classes, and using them. Use of MPFR is introduced in the second patch.
A bit of special-case handling code is moved around to as to avoid
code duplication between host_float_ops and mpfr_float_ops.
Note that due to the changes mentioned above, I've had to update (fix)
the floating-point register values tested in the gdb.arch/vsx-regs.exp
test case. (The new values now work both with host arithmetic and MPFR.)
gdb/ChangeLog:
2017-11-22 Ulrich Weigand <uweigand@de.ibm.com>
* target-float.c: Do not include <math.h>.
Include <cmath> and <limits>.
(DOUBLEST): Do not define.
(class target_float_ops): New type.
(class host_float_ops): New templated type.
(class decimal_float_ops): New type.
(floatformat_to_doublest): Rename to ...
(host_float_ops<T>::from_target): ... this. Use template type T
instead of DOUBLEST. Use C++ math routines. Update recursive calls.
(host_float_ops<T>::from_target): New overload using a type argument.
(floatformat_from_doublest): Rename to ...
(host_float_ops<T>::to_target): ... this. Use template type T
instead of DOUBLEST. Use C++ math routines. Update recursive calls.
(host_float_ops<T>::to_target): New overload using a type argument.
(floatformat_printf_format): New function.
(struct printf_length_modifier): New templated type.
(floatformat_to_string): Rename to ...
(host_float_ops<T>::to_string): ... this. Use type instead of
floatformat argument. Use floatformat_printf_format and
printf_length_modifier. Remove special handling of invalid numbers,
infinities and NaN (moved to target_float_to_string).
(struct scanf_length_modifier): New templated type.
(floatformat_from_string): Rename to ...
(host_float_ops<T>::from_string): ... this. Use type instead of
floatformat argument. Use scanf_length_modifier.
(floatformat_to_longest): Rename to ...
(host_float_ops<T>::to_longest): ... this. Use type instead of
floatformat argument. Handle out-of-range values deterministically.
(floatformat_from_longest): Rename to ...
(host_float_ops<T>::from_longest): ... this. Use type instead of
floatformat argument.
(floatformat_from_ulongest): Rename to ...
(host_float_ops<T>::from_ulongest): ... this. Use type instead of
floatformat argument.
(floatformat_to_host_double): Rename to ...
(host_float_ops<T>::to_host_double): ... this. Use type instead of
floatformat argument.
(floatformat_from_host_double): Rename to ...
(host_float_ops<T>::from_host_double): ... this. Use type instead of
floatformat argument.
(floatformat_convert): Rename to ...
(host_float_ops<T>::convert): ... this. Use type instead of
floatformat arguments. Remove handling of no-op conversions.
(floatformat_binop): Rename to ...
(host_float_ops<T>::binop): ... this. Use type instead of
floatformat arguments.
(floatformat_compare): Rename to ...
(host_float_ops<T>::compare): ... this. Use type instead of
floatformat arguments.
(match_endianness): Use type instead of length/byte_order arguments.
(set_decnumber_context): Likewise.
(decimal_from_number): Likewise. Update calls.
(decimal_to_number): Likewise.
(decimal_is_zero): Likewise. Update calls. Move to earlier in file.
(decimal_float_ops::to_host_double): New dummy function.
(decimal_float_ops::from_host_double): Likewise.
(decimal_to_string): Rename to ...
(decimal_float_ops::to_string): ... this. Use type instead of
length/byte_order arguments. Update calls.
(decimal_from_string): Rename to ...
(decimal_float_ops::from_string): ... this. Use type instead of
length/byte_order arguments. Update calls.
(decimal_from_longest): Rename to ...
(decimal_float_ops::from_longest): ... this. Use type instead of
length/byte_order arguments. Update calls.
(decimal_from_ulongest): Rename to ...
(decimal_float_ops::from_ulongest): ... this. Use type instead of
length/byte_order arguments. Update calls.
(decimal_to_longest): Rename to ...
(decimal_float_ops::to_longest): ... this. Use type instead of
length/byte_order arguments. Update calls.
(decimal_binop): Rename to ...
(decimal_float_ops::binop): ... this. Use type instead of
length/byte_order arguments. Update calls.
(decimal_compare): Rename to ...
(decimal_float_ops::compare): ... this. Use type instead of
length/byte_order arguments. Update calls.
(decimal_convert): Rename to ...
(decimal_float_ops::convert): ... this. Use type instead of
length/byte_order arguments. Update calls.
(target_float_same_category_p): New function.
(target_float_same_format_p): Likewise.
(target_float_format_length): Likewise.
(enum target_float_ops_kind): New type.
(get_target_float_ops_kind): New function.
(get_target_float_ops): Three new overloaded functions.
(target_float_is_zero): Update call.
(target_float_to_string): Add special handling of invalid numbers,
infinities and NaN (moved from floatformat_to_string). Use
target_float_ops callback.
(target_float_from_string): Use target_float_ops callback.
(target_float_to_longest): Likewise.
(target_float_from_longest): Likewise.
(target_float_from_ulongest): Likewise.
(target_float_to_host_double): Likewise.
(target_float_from_host_double): Likewise.
(target_float_convert): Add special case for no-op conversions.
Use target_float_ops callback.
(target_float_binop): Use target_float_ops callback.
(target_float_compare): Likewise.
gdb/testsuite/ChangeLog:
2017-11-22 Ulrich Weigand <uweigand@de.ibm.com>
* gdb.arch/vsx-regs.exp: Update register content checks.
Diff:
---
gdb/ChangeLog | 107 ++++
gdb/target-float.c | 1052 +++++++++++++++++++++--------------
gdb/testsuite/ChangeLog | 4 +
gdb/testsuite/gdb.arch/vsx-regs.exp | 12 +-
4 files changed, 747 insertions(+), 428 deletions(-)
diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index 63ae72e..b330c7b 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,110 @@
+2017-11-22 Ulrich Weigand <uweigand@de.ibm.com>
+
+ * target-float.c: Do not include <math.h>.
+ Include <cmath> and <limits>.
+ (DOUBLEST): Do not define.
+ (class target_float_ops): New type.
+ (class host_float_ops): New templated type.
+ (class decimal_float_ops): New type.
+
+ (floatformat_to_doublest): Rename to ...
+ (host_float_ops<T>::from_target): ... this. Use template type T
+ instead of DOUBLEST. Use C++ math routines. Update recursive calls.
+ (host_float_ops<T>::from_target): New overload using a type argument.
+ (floatformat_from_doublest): Rename to ...
+ (host_float_ops<T>::to_target): ... this. Use template type T
+ instead of DOUBLEST. Use C++ math routines. Update recursive calls.
+ (host_float_ops<T>::to_target): New overload using a type argument.
+ (floatformat_printf_format): New function.
+ (struct printf_length_modifier): New templated type.
+ (floatformat_to_string): Rename to ...
+ (host_float_ops<T>::to_string): ... this. Use type instead of
+ floatformat argument. Use floatformat_printf_format and
+ printf_length_modifier. Remove special handling of invalid numbers,
+ infinities and NaN (moved to target_float_to_string).
+ (struct scanf_length_modifier): New templated type.
+ (floatformat_from_string): Rename to ...
+ (host_float_ops<T>::from_string): ... this. Use type instead of
+ floatformat argument. Use scanf_length_modifier.
+ (floatformat_to_longest): Rename to ...
+ (host_float_ops<T>::to_longest): ... this. Use type instead of
+ floatformat argument. Handle out-of-range values deterministically.
+ (floatformat_from_longest): Rename to ...
+ (host_float_ops<T>::from_longest): ... this. Use type instead of
+ floatformat argument.
+ (floatformat_from_ulongest): Rename to ...
+ (host_float_ops<T>::from_ulongest): ... this. Use type instead of
+ floatformat argument.
+ (floatformat_to_host_double): Rename to ...
+ (host_float_ops<T>::to_host_double): ... this. Use type instead of
+ floatformat argument.
+ (floatformat_from_host_double): Rename to ...
+ (host_float_ops<T>::from_host_double): ... this. Use type instead of
+ floatformat argument.
+ (floatformat_convert): Rename to ...
+ (host_float_ops<T>::convert): ... this. Use type instead of
+ floatformat arguments. Remove handling of no-op conversions.
+ (floatformat_binop): Rename to ...
+ (host_float_ops<T>::binop): ... this. Use type instead of
+ floatformat arguments.
+ (floatformat_compare): Rename to ...
+ (host_float_ops<T>::compare): ... this. Use type instead of
+ floatformat arguments.
+
+ (match_endianness): Use type instead of length/byte_order arguments.
+ (set_decnumber_context): Likewise.
+ (decimal_from_number): Likewise. Update calls.
+ (decimal_to_number): Likewise.
+ (decimal_is_zero): Likewise. Update calls. Move to earlier in file.
+ (decimal_float_ops::to_host_double): New dummy function.
+ (decimal_float_ops::from_host_double): Likewise.
+ (decimal_to_string): Rename to ...
+ (decimal_float_ops::to_string): ... this. Use type instead of
+ length/byte_order arguments. Update calls.
+ (decimal_from_string): Rename to ...
+ (decimal_float_ops::from_string): ... this. Use type instead of
+ length/byte_order arguments. Update calls.
+ (decimal_from_longest): Rename to ...
+ (decimal_float_ops::from_longest): ... this. Use type instead of
+ length/byte_order arguments. Update calls.
+ (decimal_from_ulongest): Rename to ...
+ (decimal_float_ops::from_ulongest): ... this. Use type instead of
+ length/byte_order arguments. Update calls.
+ (decimal_to_longest): Rename to ...
+ (decimal_float_ops::to_longest): ... this. Use type instead of
+ length/byte_order arguments. Update calls.
+ (decimal_binop): Rename to ...
+ (decimal_float_ops::binop): ... this. Use type instead of
+ length/byte_order arguments. Update calls.
+ (decimal_compare): Rename to ...
+ (decimal_float_ops::compare): ... this. Use type instead of
+ length/byte_order arguments. Update calls.
+ (decimal_convert): Rename to ...
+ (decimal_float_ops::convert): ... this. Use type instead of
+ length/byte_order arguments. Update calls.
+
+ (target_float_same_category_p): New function.
+ (target_float_same_format_p): Likewise.
+ (target_float_format_length): Likewise.
+ (enum target_float_ops_kind): New type.
+ (get_target_float_ops_kind): New function.
+ (get_target_float_ops): Three new overloaded functions.
+
+ (target_float_is_zero): Update call.
+ (target_float_to_string): Add special handling of invalid numbers,
+ infinities and NaN (moved from floatformat_to_string). Use
+ target_float_ops callback.
+ (target_float_from_string): Use target_float_ops callback.
+ (target_float_to_longest): Likewise.
+ (target_float_from_longest): Likewise.
+ (target_float_from_ulongest): Likewise.
+ (target_float_to_host_double): Likewise.
+ (target_float_from_host_double): Likewise.
+ (target_float_convert): Add special case for no-op conversions.
+ Use target_float_ops callback.
+ (target_float_binop): Use target_float_ops callback.
+ (target_float_compare): Likewise.
+
2017-11-22 Yao Qi <yao.qi@linaro.org>
* python/py-gdb-readline.c (gdbpy_readline_wrapper): Use strcpy.
diff --git a/gdb/target-float.c b/gdb/target-float.c
index 8bc027e..8f1b9f6 100644
--- a/gdb/target-float.c
+++ b/gdb/target-float.c
@@ -23,21 +23,48 @@
#include "target-float.h"
-/* Helper routines operating on binary floating-point data. */
+/* Target floating-point operations.
-#include <math.h>
+ We provide multiple implementations of those operations, which differ
+ by the host-side intermediate format they perform computations in.
-#if (defined HAVE_LONG_DOUBLE && defined PRINTF_HAS_LONG_DOUBLE \
- && defined SCANF_HAS_LONG_DOUBLE)
-typedef long double DOUBLEST;
-#else
-typedef double DOUBLEST;
-/* If we can't scan or print long double, we don't want to use it
- anywhere. */
-# undef HAVE_LONG_DOUBLE
-# undef PRINTF_HAS_LONG_DOUBLE
-# undef SCANF_HAS_LONG_DOUBLE
-#endif
+ Those multiple implementations all derive from the following abstract
+ base class, which specifies the set of operations to be implemented. */
+
+class target_float_ops
+{
+public:
+ virtual std::string to_string (const gdb_byte *addr, const struct type *type,
+ const char *format) const = 0;
+ virtual bool from_string (gdb_byte *addr, const struct type *type,
+ const std::string &string) const = 0;
+
+ virtual LONGEST to_longest (const gdb_byte *addr,
+ const struct type *type) const = 0;
+ virtual void from_longest (gdb_byte *addr, const struct type *type,
+ LONGEST val) const = 0;
+ virtual void from_ulongest (gdb_byte *addr, const struct type *type,
+ ULONGEST val) const = 0;
+ virtual double to_host_double (const gdb_byte *addr,
+ const struct type *type) const = 0;
+ virtual void from_host_double (gdb_byte *addr, const struct type *type,
+ double val) const = 0;
+ virtual void convert (const gdb_byte *from, const struct type *from_type,
+ gdb_byte *to, const struct type *to_type) const = 0;
+
+ virtual void binop (enum exp_opcode opcode,
+ const gdb_byte *x, const struct type *type_x,
+ const gdb_byte *y, const struct type *type_y,
+ gdb_byte *res, const struct type *type_res) const = 0;
+ virtual int compare (const gdb_byte *x, const struct type *type_x,
+ const gdb_byte *y, const struct type *type_y) const = 0;
+};
+
+
+/* Helper routines operating on binary floating-point data. */
+
+#include <cmath>
+#include <limits>
/* Different kinds of floatformat numbers recognized by
floatformat_classify. To avoid portability issues, we use local
@@ -447,7 +474,106 @@ floatformat_mantissa (const struct floatformat *fmt,
return res;
}
-/* Convert TO/FROM target to the hosts DOUBLEST floating-point format.
+/* Convert printf format string FORMAT to the otherwise equivalent string
+ which may be used to print a host floating-point number using the length
+ modifier LENGTH (which may be 0 if none is needed). If FORMAT is null,
+ return a format appropriate to print the full precision of a target
+ floating-point number of format FMT. */
+static std::string
+floatformat_printf_format (const struct floatformat *fmt,
+ const char *format, char length)
+{
+ std::string host_format;
+ char conversion;
+
+ if (format == nullptr)
+ {
+ /* If no format was specified, print the number using a format string
+ where the precision is set to the DECIMAL_DIG value for the given
+ floating-point format. This value is computed as
+
+ ceil(1 + p * log10(b)),
+
+ where p is the precision of the floating-point format in bits, and
+ b is the base (which is always 2 for the formats we support). */
+ const double log10_2 = .30102999566398119521;
+ double d_decimal_dig = 1 + floatformat_precision (fmt) * log10_2;
+ int decimal_dig = d_decimal_dig;
+ if (decimal_dig < d_decimal_dig)
+ decimal_dig++;
+
+ host_format = string_printf ("%%.%d", decimal_dig);
+ conversion = 'g';
+ }
+ else
+ {
+ /* Use the specified format, stripping out the conversion character
+ and length modifier, if present. */
+ size_t len = strlen (format);
+ gdb_assert (len > 1);
+ conversion = format[--len];
+ gdb_assert (conversion == 'e' || conversion == 'f' || conversion == 'g'
+ || conversion == 'E' || conversion == 'G');
+ if (format[len - 1] == 'L')
+ len--;
+
+ host_format = std::string (format, len);
+ }
+
+ /* Add the length modifier and conversion character appropriate for
+ handling the appropriate host floating-point type. */
+ if (length)
+ host_format += length;
+ host_format += conversion;
+
+ return host_format;
+}
+
+/* Implementation of target_float_ops using the host floating-point type T
+ as intermediate type. */
+
+template<typename T> class host_float_ops : public target_float_ops
+{
+public:
+ std::string to_string (const gdb_byte *addr, const struct type *type,
+ const char *format) const override;
+ bool from_string (gdb_byte *addr, const struct type *type,
+ const std::string &string) const override;
+
+ LONGEST to_longest (const gdb_byte *addr,
+ const struct type *type) const override;
+ void from_longest (gdb_byte *addr, const struct type *type,
+ LONGEST val) const override;
+ void from_ulongest (gdb_byte *addr, const struct type *type,
+ ULONGEST val) const override;
+ double to_host_double (const gdb_byte *addr,
+ const struct type *type) const override;
+ void from_host_double (gdb_byte *addr, const struct type *type,
+ double val) const override;
+ void convert (const gdb_byte *from, const struct type *from_type,
+ gdb_byte *to, const struct type *to_type) const override;
+
+ void binop (enum exp_opcode opcode,
+ const gdb_byte *x, const struct type *type_x,
+ const gdb_byte *y, const struct type *type_y,
+ gdb_byte *res, const struct type *type_res) const override;
+ int compare (const gdb_byte *x, const struct type *type_x,
+ const gdb_byte *y, const struct type *type_y) const override;
+
+private:
+ void from_target (const struct floatformat *fmt,
+ const gdb_byte *from, T *to) const;
+ void from_target (const struct type *type,
+ const gdb_byte *from, T *to) const;
+
+ void to_target (const struct type *type,
+ const T *from, gdb_byte *to) const;
+ void to_target (const struct floatformat *fmt,
+ const T *from, gdb_byte *to) const;
+};
+
+
+/* Convert TO/FROM target to the host floating-point format T.
If the host and target formats agree, we just copy the raw data
into the appropriate type of variable and return, letting the host
@@ -467,11 +593,11 @@ static const struct floatformat *host_double_format = GDB_HOST_DOUBLE_FORMAT;
static const struct floatformat *host_long_double_format
= GDB_HOST_LONG_DOUBLE_FORMAT;
-/* Convert from FMT to a DOUBLEST. FROM is the address of the extended float.
- Store the DOUBLEST in *TO. */
-static void
-floatformat_to_doublest (const struct floatformat *fmt,
- const void *from, DOUBLEST *to)
+/* Convert target floating-point value at FROM in format FMT to host
+ floating-point format of type T. */
+template<typename T> void
+host_float_ops<T>::from_target (const struct floatformat *fmt,
+ const gdb_byte *from, T *to) const
{
gdb_assert (fmt != NULL);
@@ -501,7 +627,7 @@ floatformat_to_doublest (const struct floatformat *fmt,
}
unsigned char *ufrom = (unsigned char *) from;
- DOUBLEST dto;
+ T dto;
long exponent;
unsigned long mant;
unsigned int mant_bits, mant_off;
@@ -524,7 +650,7 @@ floatformat_to_doublest (const struct floatformat *fmt,
floatformat_to_double (fmt->split_half ? fmt->split_half : fmt,
from, &dto);
- *to = (DOUBLEST) dto;
+ *to = (T) dto;
return;
}
@@ -535,9 +661,9 @@ floatformat_to_doublest (const struct floatformat *fmt,
if (fmt->split_half)
{
- DOUBLEST dtop, dbot;
+ T dtop, dbot;
- floatformat_to_doublest (fmt->split_half, ufrom, &dtop);
+ from_target (fmt->split_half, ufrom, &dtop);
/* Preserve the sign of 0, which is the sign of the top
half. */
if (dtop == 0.0)
@@ -545,9 +671,8 @@ floatformat_to_doublest (const struct floatformat *fmt,
*to = dtop;
return;
}
- floatformat_to_doublest (fmt->split_half,
- ufrom + fmt->totalsize / FLOATFORMAT_CHAR_BIT / 2,
- &dbot);
+ from_target (fmt->split_half,
+ ufrom + fmt->totalsize / FLOATFORMAT_CHAR_BIT / 2, &dbot);
*to = dtop + dbot;
return;
}
@@ -593,7 +718,7 @@ floatformat_to_doublest (const struct floatformat *fmt,
mant = get_field (ufrom, order, fmt->totalsize, mant_off, mant_bits);
- dto += ldexp ((double) mant, exponent - mant_bits);
+ dto += ldexp ((T) mant, exponent - mant_bits);
exponent -= mant_bits;
mant_off += mant_bits;
mant_bits_left -= mant_bits;
@@ -605,11 +730,18 @@ floatformat_to_doublest (const struct floatformat *fmt,
*to = dto;
}
-/* Convert the DOUBLEST *FROM to an extended float in format FMT and
- store where TO points. */
-static void
-floatformat_from_doublest (const struct floatformat *fmt,
- const DOUBLEST *from, void *to)
+template<typename T> void
+host_float_ops<T>::from_target (const struct type *type,
+ const gdb_byte *from, T *to) const
+{
+ from_target (floatformat_from_type (type), from, to);
+}
+
+/* Convert host floating-point value of type T to target floating-point
+ value in format FMT and store at TO. */
+template<typename T> void
+host_float_ops<T>::to_target (const struct floatformat *fmt,
+ const T *from, gdb_byte *to) const
{
gdb_assert (fmt != NULL);
@@ -635,9 +767,9 @@ floatformat_from_doublest (const struct floatformat *fmt,
return;
}
- DOUBLEST dfrom;
+ T dfrom;
int exponent;
- DOUBLEST mant;
+ T mant;
unsigned int mant_bits, mant_off;
int mant_bits_left;
unsigned char *uto = (unsigned char *) to;
@@ -659,7 +791,7 @@ floatformat_from_doublest (const struct floatformat *fmt,
removed via storing in memory, and so the top half really is
the result of converting to double. */
static volatile double dtop, dbot;
- DOUBLEST dtopnv, dbotnv;
+ T dtopnv, dbotnv;
dtop = (double) dfrom;
/* If the rounded top half is Inf, the bottom must be 0 not NaN
@@ -667,13 +799,12 @@ floatformat_from_doublest (const struct floatformat *fmt,
if (dtop + dtop == dtop && dtop != 0.0)
dbot = 0.0;
else
- dbot = (double) (dfrom - (DOUBLEST) dtop);
+ dbot = (double) (dfrom - (T) dtop);
dtopnv = dtop;
dbotnv = dbot;
- floatformat_from_doublest (fmt->split_half, &dtopnv, uto);
- floatformat_from_doublest (fmt->split_half, &dbotnv,
- (uto
- + fmt->totalsize / FLOATFORMAT_CHAR_BIT / 2));
+ to_target (fmt->split_half, &dtopnv, uto);
+ to_target (fmt->split_half, &dbotnv,
+ uto + fmt->totalsize / FLOATFORMAT_CHAR_BIT / 2);
return;
}
@@ -708,11 +839,7 @@ floatformat_from_doublest (const struct floatformat *fmt,
goto finalize_byteorder;
}
-#ifdef HAVE_LONG_DOUBLE
- mant = frexpl (dfrom, &exponent);
-#else
mant = frexp (dfrom, &exponent);
-#endif
if (exponent + fmt->exp_bias <= 0)
{
@@ -790,99 +917,67 @@ floatformat_from_doublest (const struct floatformat *fmt,
floatformat_normalize_byteorder (fmt, newto, to);
}
-/* Convert the byte-stream ADDR, interpreted as floating-point format FMT,
- to a string, optionally using the print format FORMAT. */
-static std::string
-floatformat_to_string (const struct floatformat *fmt,
- const gdb_byte *in, const char *format)
+template<typename T> void
+host_float_ops<T>::to_target (const struct type *type,
+ const T *from, gdb_byte *to) const
{
- /* Unless we need to adhere to a specific format, provide special
- output for certain cases. */
- if (format == nullptr)
- {
- /* Detect invalid representations. */
- if (!floatformat_is_valid (fmt, in))
- return "<invalid float value>";
+ /* Ensure possible padding bytes in the target buffer are zeroed out. */
+ memset (to, 0, TYPE_LENGTH (type));
- /* Handle NaN and Inf. */
- enum float_kind kind = floatformat_classify (fmt, in);
- if (kind == float_nan)
- {
- const char *sign = floatformat_is_negative (fmt, in)? "-" : "";
- const char *mantissa = floatformat_mantissa (fmt, in);
- return string_printf ("%snan(0x%s)", sign, mantissa);
- }
- else if (kind == float_infinite)
- {
- const char *sign = floatformat_is_negative (fmt, in)? "-" : "";
- return string_printf ("%sinf", sign);
- }
- }
+ to_target (floatformat_from_type (type), from, to);
+}
+/* Convert the byte-stream ADDR, interpreted as floating-point type TYPE,
+ to a string, optionally using the print format FORMAT. */
+template<typename T> struct printf_length_modifier
+{
+ static constexpr char value = 0;
+};
+template<> struct printf_length_modifier<long double>
+{
+ static constexpr char value = 'L';
+};
+template<typename T> std::string
+host_float_ops<T>::to_string (const gdb_byte *addr, const struct type *type,
+ const char *format) const
+{
/* Determine the format string to use on the host side. */
- std::string host_format;
- char conversion;
-
- if (format == nullptr)
- {
- /* If no format was specified, print the number using a format string
- where the precision is set to the DECIMAL_DIG value for the given
- floating-point format. This value is computed as
+ constexpr char length = printf_length_modifier<T>::value;
+ const struct floatformat *fmt = floatformat_from_type (type);
+ std::string host_format = floatformat_printf_format (fmt, format, length);
- ceil(1 + p * log10(b)),
-
- where p is the precision of the floating-point format in bits, and
- b is the base (which is always 2 for the formats we support). */
- const double log10_2 = .30102999566398119521;
- double d_decimal_dig = 1 + floatformat_precision (fmt) * log10_2;
- int decimal_dig = d_decimal_dig;
- if (decimal_dig < d_decimal_dig)
- decimal_dig++;
-
- host_format = string_printf ("%%.%d", decimal_dig);
- conversion = 'g';
- }
- else
- {
- /* Use the specified format, stripping out the conversion character
- and length modifier, if present. */
- size_t len = strlen (format);
- gdb_assert (len > 1);
- conversion = format[--len];
- gdb_assert (conversion == 'e' || conversion == 'f' || conversion == 'g'
- || conversion == 'E' || conversion == 'G');
- if (format[len - 1] == 'L')
- len--;
-
- host_format = std::string (format, len);
- }
-
- /* Add the length modifier and conversion character appropriate for
- handling the host DOUBLEST type. */
-#ifdef HAVE_LONG_DOUBLE
- host_format += 'L';
-#endif
- host_format += conversion;
-
- DOUBLEST doub;
- floatformat_to_doublest (fmt, in, &doub);
- return string_printf (host_format.c_str (), doub);
+ T host_float;
+ from_target (type, addr, &host_float);
+ return string_printf (host_format.c_str (), host_float);
}
-/* Parse string STRING into a target floating-number of format FMT and
+/* Parse string IN into a target floating-number of type TYPE and
store it as byte-stream ADDR. Return whether parsing succeeded. */
-static bool
-floatformat_from_string (const struct floatformat *fmt, gdb_byte *out,
- const std::string &in)
+template<typename T> struct scanf_length_modifier
+{
+ static constexpr char value = 0;
+};
+template<> struct scanf_length_modifier<double>
+{
+ static constexpr char value = 'l';
+};
+template<> struct scanf_length_modifier<long double>
+{
+ static constexpr char value = 'L';
+};
+template<typename T> bool
+host_float_ops<T>::from_string (gdb_byte *addr, const struct type *type,
+ const std::string &in) const
{
- DOUBLEST doub;
+ T host_float;
int n, num;
-#ifdef HAVE_LONG_DOUBLE
- const char *scan_format = "%Lg%n";
-#else
- const char *scan_format = "%lg%n";
-#endif
- num = sscanf (in.c_str (), scan_format, &doub, &n);
+
+ std::string scan_format = "%";
+ if (scanf_length_modifier<T>::value)
+ scan_format += scanf_length_modifier<T>::value;
+ scan_format += "g%n";
+
+ num = sscanf (in.c_str (), scan_format.c_str(), &host_float, &n);
/* The sscanf man page suggests not making any assumptions on the effect
of %n on the result, so we don't.
@@ -894,100 +989,96 @@ floatformat_from_string (const struct floatformat *fmt, gdb_byte *out,
if (in[n])
return false;
- floatformat_from_doublest (fmt, &doub, out);
+ to_target (type, &host_float, addr);
return true;
}
-/* Convert the byte-stream ADDR, interpreted as floating-point format FMT,
+/* Convert the byte-stream ADDR, interpreted as floating-point type TYPE,
to an integer value (rounding towards zero). */
-static LONGEST
-floatformat_to_longest (const struct floatformat *fmt, const gdb_byte *addr)
+template<typename T> LONGEST
+host_float_ops<T>::to_longest (const gdb_byte *addr,
+ const struct type *type) const
{
- DOUBLEST d;
- floatformat_to_doublest (fmt, addr, &d);
- return (LONGEST) d;
+ T host_float;
+ from_target (type, addr, &host_float);
+ /* Converting an out-of-range value is undefined behavior in C, but we
+ prefer to return a defined value here. */
+ if (host_float > std::numeric_limits<LONGEST>::max())
+ return std::numeric_limits<LONGEST>::max();
+ if (host_float < std::numeric_limits<LONGEST>::min())
+ return std::numeric_limits<LONGEST>::min();
+ return (LONGEST) host_float;
}
-/* Convert signed integer VAL to a target floating-number of format FMT
+/* Convert signed integer VAL to a target floating-number of type TYPE
and store it as byte-stream ADDR. */
-static void
-floatformat_from_longest (const struct floatformat *fmt, gdb_byte *addr,
- LONGEST val)
+template<typename T> void
+host_float_ops<T>::from_longest (gdb_byte *addr, const struct type *type,
+ LONGEST val) const
{
- DOUBLEST d = (DOUBLEST) val;
- floatformat_from_doublest (fmt, &d, addr);
+ T host_float = (T) val;
+ to_target (type, &host_float, addr);
}
-/* Convert unsigned integer VAL to a target floating-number of format FMT
+/* Convert unsigned integer VAL to a target floating-number of type TYPE
and store it as byte-stream ADDR. */
-static void
-floatformat_from_ulongest (const struct floatformat *fmt, gdb_byte *addr,
- ULONGEST val)
+template<typename T> void
+host_float_ops<T>::from_ulongest (gdb_byte *addr, const struct type *type,
+ ULONGEST val) const
{
- DOUBLEST d = (DOUBLEST) val;
- floatformat_from_doublest (fmt, &d, addr);
+ T host_float = (T) val;
+ to_target (type, &host_float, addr);
}
-/* Convert the byte-stream ADDR, interpreted as floating-point format FMT,
+/* Convert the byte-stream ADDR, interpreted as floating-point type TYPE,
to a floating-point value in the host "double" format. */
-static double
-floatformat_to_host_double (const struct floatformat *fmt,
- const gdb_byte *addr)
+template<typename T> double
+host_float_ops<T>::to_host_double (const gdb_byte *addr,
+ const struct type *type) const
{
- DOUBLEST d;
- floatformat_to_doublest (fmt, addr, &d);
- return (double) d;
+ T host_float;
+ from_target (type, addr, &host_float);
+ return (double) host_float;
}
/* Convert floating-point value VAL in the host "double" format to a target
- floating-number of format FMT and store it as byte-stream ADDR. */
-static void
-floatformat_from_host_double (const struct floatformat *fmt, gdb_byte *addr,
- double val)
+ floating-number of type TYPE and store it as byte-stream ADDR. */
+template<typename T> void
+host_float_ops<T>::from_host_double (gdb_byte *addr, const struct type *type,
+ double val) const
{
- DOUBLEST d = (DOUBLEST) val;
- floatformat_from_doublest (fmt, &d, addr);
+ T host_float = (T) val;
+ to_target (type, &host_float, addr);
}
-/* Convert a floating-point number of format FROM_FMT from the target
- byte-stream FROM to a floating-point number of format TO_FMT, and
+/* Convert a floating-point number of type FROM_TYPE from the target
+ byte-stream FROM to a floating-point number of type TO_TYPE, and
store it to the target byte-stream TO. */
-static void
-floatformat_convert (const gdb_byte *from, const struct floatformat *from_fmt,
- gdb_byte *to, const struct floatformat *to_fmt)
+template<typename T> void
+host_float_ops<T>::convert (const gdb_byte *from,
+ const struct type *from_type,
+ gdb_byte *to,
+ const struct type *to_type) const
{
- if (from_fmt == to_fmt)
- {
- /* The floating-point formats match, so we simply copy the data. */
- memcpy (to, from, floatformat_totalsize_bytes (to_fmt));
- }
- else
- {
- /* The floating-point formats don't match. The best we can do
- (apart from simulating the target FPU) is converting to the
- widest floating-point type supported by the host, and then
- again to the desired type. */
- DOUBLEST d;
-
- floatformat_to_doublest (from_fmt, from, &d);
- floatformat_from_doublest (to_fmt, &d, to);
- }
+ T host_float;
+ from_target (from_type, from, &host_float);
+ to_target (to_type, &host_float, to);
}
/* Perform the binary operation indicated by OPCODE, using as operands the
target byte streams X and Y, interpreted as floating-point numbers of
- formats FMT_X and FMT_Y, respectively. Convert the result to format
- FMT_RES and store it into the byte-stream RES. */
-static void
-floatformat_binop (enum exp_opcode op,
- const struct floatformat *fmt_x, const gdb_byte *x,
- const struct floatformat *fmt_y, const gdb_byte *y,
- const struct floatformat *fmt_result, gdb_byte *result)
+ types TYPE_X and TYPE_Y, respectively. Convert the result to format
+ TYPE_RES and store it into the byte-stream RES. */
+template<typename T> void
+host_float_ops<T>::binop (enum exp_opcode op,
+ const gdb_byte *x, const struct type *type_x,
+ const gdb_byte *y, const struct type *type_y,
+ gdb_byte *res, const struct type *type_res) const
{
- DOUBLEST v1, v2, v = 0;
+ T v1, v2, v = 0;
- floatformat_to_doublest (fmt_x, x, &v1);
- floatformat_to_doublest (fmt_y, y, &v2);
+ from_target (type_x, x, &v1);
+ from_target (type_y, y, &v2);
switch (op)
{
@@ -1028,20 +1119,20 @@ floatformat_binop (enum exp_opcode op,
break;
}
- floatformat_from_doublest (fmt_result, &v, result);
+ to_target (type_res, &v, res);
}
/* Compare the two target byte streams X and Y, interpreted as floating-point
- numbers of formats FMT_X and FMT_Y, respectively. Return zero if X and Y
+ numbers of types TYPE_X and TYPE_Y, respectively. Return zero if X and Y
are equal, -1 if X is less than Y, and 1 otherwise. */
-static int
-floatformat_compare (const struct floatformat *fmt_x, const gdb_byte *x,
- const struct floatformat *fmt_y, const gdb_byte *y)
+template<typename T> int
+host_float_ops<T>::compare (const gdb_byte *x, const struct type *type_x,
+ const gdb_byte *y, const struct type *type_y) const
{
- DOUBLEST v1, v2;
+ T v1, v2;
- floatformat_to_doublest (fmt_x, x, &v1);
- floatformat_to_doublest (fmt_y, y, &v2);
+ from_target (type_x, x, &v1);
+ from_target (type_y, y, &v2);
if (v1 == v2)
return 0;
@@ -1073,9 +1164,11 @@ floatformat_compare (const struct floatformat *fmt_x, const gdb_byte *x,
They are stored in host byte order. This routine does the conversion if
the target byte order is different. */
static void
-match_endianness (const gdb_byte *from, int len, enum bfd_endian byte_order,
- gdb_byte *to)
+match_endianness (const gdb_byte *from, const struct type *type, gdb_byte *to)
{
+ gdb_assert (TYPE_CODE (type) == TYPE_CODE_DECFLOAT);
+
+ int len = TYPE_LENGTH (type);
int i;
#if WORDS_BIGENDIAN
@@ -1084,7 +1177,7 @@ match_endianness (const gdb_byte *from, int len, enum bfd_endian byte_order,
#define OPPOSITE_BYTE_ORDER BFD_ENDIAN_BIG
#endif
- if (byte_order == OPPOSITE_BYTE_ORDER)
+ if (gdbarch_byte_order (get_type_arch (type)) == OPPOSITE_BYTE_ORDER)
for (i = 0; i < len; i++)
to[i] = from[len - i - 1];
else
@@ -1097,9 +1190,11 @@ match_endianness (const gdb_byte *from, int len, enum bfd_endian byte_order,
/* Helper function to get the appropriate libdecnumber context for each size
of decimal float. */
static void
-set_decnumber_context (decContext *ctx, int len)
+set_decnumber_context (decContext *ctx, const struct type *type)
{
- switch (len)
+ gdb_assert (TYPE_CODE (type) == TYPE_CODE_DECFLOAT);
+
+ switch (TYPE_LENGTH (type))
{
case 4:
decContextDefault (ctx, DEC_INIT_DECIMAL32);
@@ -1137,15 +1232,15 @@ decimal_check_errors (decContext *ctx)
for computation to each size of decimal float. */
static void
decimal_from_number (const decNumber *from,
- gdb_byte *to, int len, enum bfd_endian byte_order)
+ gdb_byte *to, const struct type *type)
{
gdb_byte dec[16];
decContext set;
- set_decnumber_context (&set, len);
+ set_decnumber_context (&set, type);
- switch (len)
+ switch (TYPE_LENGTH (type))
{
case 4:
decimal32FromNumber ((decimal32 *) dec, from, &set);
@@ -1161,19 +1256,19 @@ decimal_from_number (const decNumber *from,
break;
}
- match_endianness (dec, len, byte_order, to);
+ match_endianness (dec, type, to);
}
/* Helper function to convert each size of decimal float to libdecnumber's
appropriate representation for computation. */
static void
-decimal_to_number (const gdb_byte *from, int len, enum bfd_endian byte_order,
+decimal_to_number (const gdb_byte *addr, const struct type *type,
decNumber *to)
{
gdb_byte dec[16];
- match_endianness (from, len, byte_order, dec);
+ match_endianness (addr, type, dec);
- switch (len)
+ switch (TYPE_LENGTH (type))
{
case 4:
decimal32ToNumber ((decimal32 *) dec, to);
@@ -1190,16 +1285,70 @@ decimal_to_number (const gdb_byte *from, int len, enum bfd_endian byte_order,
}
}
+/* Returns true if ADDR (which is of type TYPE) is the number zero. */
+static bool
+decimal_is_zero (const gdb_byte *addr, const struct type *type)
+{
+ decNumber number;
+
+ decimal_to_number (addr, type, &number);
+
+ return decNumberIsZero (&number);
+}
+
+
+/* Implementation of target_float_ops using the libdecnumber decNumber type
+ as intermediate format. */
+
+class decimal_float_ops : public target_float_ops
+{
+public:
+ std::string to_string (const gdb_byte *addr, const struct type *type,
+ const char *format) const override;
+ bool from_string (gdb_byte *addr, const struct type *type,
+ const std::string &string) const override;
+
+ LONGEST to_longest (const gdb_byte *addr,
+ const struct type *type) const override;
+ void from_longest (gdb_byte *addr, const struct type *type,
+ LONGEST val) const override;
+ void from_ulongest (gdb_byte *addr, const struct type *type,
+ ULONGEST val) const override;
+ double to_host_double (const gdb_byte *addr,
+ const struct type *type) const override
+ {
+ /* We don't support conversions between target decimal floating-point
+ types and the host double type. */
+ gdb_assert_not_reached ("invalid operation on decimal float");
+ }
+ void from_host_double (gdb_byte *addr, const struct type *type,
+ double val) const override
+ {
+ /* We don't support conversions between target decimal floating-point
+ types and the host double type. */
+ gdb_assert_not_reached ("invalid operation on decimal float");
+ }
+ void convert (const gdb_byte *from, const struct type *from_type,
+ gdb_byte *to, const struct type *to_type) const override;
+
+ void binop (enum exp_opcode opcode,
+ const gdb_byte *x, const struct type *type_x,
+ const gdb_byte *y, const struct type *type_y,
+ gdb_byte *res, const struct type *type_res) const override;
+ int compare (const gdb_byte *x, const struct type *type_x,
+ const gdb_byte *y, const struct type *type_y) const override;
+};
+
/* Convert decimal type to its string representation. LEN is the length
of the decimal type, 4 bytes for decimal32, 8 bytes for decimal64 and
16 bytes for decimal128. */
-static std::string
-decimal_to_string (const gdb_byte *decbytes, int len,
- enum bfd_endian byte_order, const char *format = nullptr)
+std::string
+decimal_float_ops::to_string (const gdb_byte *addr, const struct type *type,
+ const char *format = nullptr) const
{
gdb_byte dec[16];
- match_endianness (decbytes, len, byte_order, dec);
+ match_endianness (addr, type, dec);
if (format != nullptr)
{
@@ -1215,7 +1364,7 @@ decimal_to_string (const gdb_byte *decbytes, int len,
std::string result;
result.resize (MAX_DECIMAL_STRING);
- switch (len)
+ switch (TYPE_LENGTH (type))
{
case 4:
decimal32ToString ((decimal32 *) dec, &result[0]);
@@ -1237,16 +1386,16 @@ decimal_to_string (const gdb_byte *decbytes, int len,
/* Convert the string form of a decimal value to its decimal representation.
LEN is the length of the decimal type, 4 bytes for decimal32, 8 bytes for
decimal64 and 16 bytes for decimal128. */
-static bool
-decimal_from_string (gdb_byte *decbytes, int len, enum bfd_endian byte_order,
- const std::string &string)
+bool
+decimal_float_ops::from_string (gdb_byte *addr, const struct type *type,
+ const std::string &string) const
{
decContext set;
gdb_byte dec[16];
- set_decnumber_context (&set, len);
+ set_decnumber_context (&set, type);
- switch (len)
+ switch (TYPE_LENGTH (type))
{
case 4:
decimal32FromString ((decimal32 *) dec, string.c_str (), &set);
@@ -1262,7 +1411,7 @@ decimal_from_string (gdb_byte *decbytes, int len, enum bfd_endian byte_order,
break;
}
- match_endianness (dec, len, byte_order, decbytes);
+ match_endianness (dec, type, addr);
/* Check for errors in the DFP operation. */
decimal_check_errors (&set);
@@ -1271,9 +1420,9 @@ decimal_from_string (gdb_byte *decbytes, int len, enum bfd_endian byte_order,
}
/* Converts a LONGEST to a decimal float of specified LEN bytes. */
-static void
-decimal_from_longest (LONGEST from,
- gdb_byte *to, int len, enum bfd_endian byte_order)
+void
+decimal_float_ops::from_longest (gdb_byte *addr, const struct type *type,
+ LONGEST from) const
{
decNumber number;
@@ -1284,13 +1433,13 @@ decimal_from_longest (LONGEST from,
decNumberFromInt32 (&number, (int32_t) from);
- decimal_from_number (&number, to, len, byte_order);
+ decimal_from_number (&number, addr, type);
}
/* Converts a ULONGEST to a decimal float of specified LEN bytes. */
-static void
-decimal_from_ulongest (ULONGEST from,
- gdb_byte *to, int len, enum bfd_endian byte_order)
+void
+decimal_float_ops::from_ulongest (gdb_byte *addr, const struct type *type,
+ ULONGEST from) const
{
decNumber number;
@@ -1301,36 +1450,36 @@ decimal_from_ulongest (ULONGEST from,
decNumberFromUInt32 (&number, (uint32_t) from);
- decimal_from_number (&number, to, len, byte_order);
+ decimal_from_number (&number, addr, type);
}
/* Converts a decimal float of LEN bytes to a LONGEST. */
-static LONGEST
-decimal_to_longest (const gdb_byte *from, int len, enum bfd_endian byte_order)
+LONGEST
+decimal_float_ops::to_longest (const gdb_byte *addr,
+ const struct type *type) const
{
/* libdecnumber has a function to convert from decimal to integer, but
it doesn't work when the decimal number has a fractional part. */
- std::string str = decimal_to_string (from, len, byte_order);
+ std::string str = to_string (addr, type);
return strtoll (str.c_str (), NULL, 10);
}
/* Perform operation OP with operands X and Y with sizes LEN_X and LEN_Y
and byte orders BYTE_ORDER_X and BYTE_ORDER_Y, and store value in
RESULT with size LEN_RESULT and byte order BYTE_ORDER_RESULT. */
-static void
-decimal_binop (enum exp_opcode op,
- const gdb_byte *x, int len_x, enum bfd_endian byte_order_x,
- const gdb_byte *y, int len_y, enum bfd_endian byte_order_y,
- gdb_byte *result, int len_result,
- enum bfd_endian byte_order_result)
+void
+decimal_float_ops::binop (enum exp_opcode op,
+ const gdb_byte *x, const struct type *type_x,
+ const gdb_byte *y, const struct type *type_y,
+ gdb_byte *res, const struct type *type_res) const
{
decContext set;
decNumber number1, number2, number3;
- decimal_to_number (x, len_x, byte_order_x, &number1);
- decimal_to_number (y, len_y, byte_order_y, &number2);
+ decimal_to_number (x, type_x, &number1);
+ decimal_to_number (y, type_y, &number2);
- set_decnumber_context (&set, len_result);
+ set_decnumber_context (&set, type_res);
switch (op)
{
@@ -1357,37 +1506,26 @@ decimal_binop (enum exp_opcode op,
/* Check for errors in the DFP operation. */
decimal_check_errors (&set);
- decimal_from_number (&number3, result, len_result, byte_order_result);
-}
-
-/* Returns true if X (which is LEN bytes wide) is the number zero. */
-static int
-decimal_is_zero (const gdb_byte *x, int len, enum bfd_endian byte_order)
-{
- decNumber number;
-
- decimal_to_number (x, len, byte_order, &number);
-
- return decNumberIsZero (&number);
+ decimal_from_number (&number3, res, type_res);
}
/* Compares two numbers numerically. If X is less than Y then the return value
will be -1. If they are equal, then the return value will be 0. If X is
greater than the Y then the return value will be 1. */
-static int
-decimal_compare (const gdb_byte *x, int len_x, enum bfd_endian byte_order_x,
- const gdb_byte *y, int len_y, enum bfd_endian byte_order_y)
+int
+decimal_float_ops::compare (const gdb_byte *x, const struct type *type_x,
+ const gdb_byte *y, const struct type *type_y) const
{
decNumber number1, number2, result;
decContext set;
- int len_result;
+ const struct type *type_result;
- decimal_to_number (x, len_x, byte_order_x, &number1);
- decimal_to_number (y, len_y, byte_order_y, &number2);
+ decimal_to_number (x, type_x, &number1);
+ decimal_to_number (y, type_y, &number2);
/* Perform the comparison in the larger of the two sizes. */
- len_result = len_x > len_y ? len_x : len_y;
- set_decnumber_context (&set, len_result);
+ type_result = TYPE_LENGTH (type_x) > TYPE_LENGTH (type_y) ? type_x : type_y;
+ set_decnumber_context (&set, type_result);
decNumberCompare (&result, &number1, &number2, &set);
@@ -1406,15 +1544,14 @@ decimal_compare (const gdb_byte *x, int len_x, enum bfd_endian byte_order_x,
/* Convert a decimal value from a decimal type with LEN_FROM bytes to a
decimal type with LEN_TO bytes. */
-static void
-decimal_convert (const gdb_byte *from, int len_from,
- enum bfd_endian byte_order_from, gdb_byte *to, int len_to,
- enum bfd_endian byte_order_to)
+void
+decimal_float_ops::convert (const gdb_byte *from, const struct type *from_type,
+ gdb_byte *to, const struct type *to_type) const
{
decNumber number;
- decimal_to_number (from, len_from, byte_order_from, &number);
- decimal_from_number (&number, to, len_to, byte_order_to);
+ decimal_to_number (from, from_type, &number);
+ decimal_from_number (&number, to, to_type);
}
@@ -1423,6 +1560,174 @@ decimal_convert (const gdb_byte *from, int len_from,
"struct type", which may be either a binary or decimal floating-point
type (TYPE_CODE_FLT or TYPE_CODE_DECFLOAT). */
+/* Return whether TYPE1 and TYPE2 are of the same category (binary or
+ decimal floating-point). */
+static bool
+target_float_same_category_p (const struct type *type1,
+ const struct type *type2)
+{
+ return TYPE_CODE (type1) == TYPE_CODE (type2);
+}
+
+/* Return whether TYPE1 and TYPE2 use the same floating-point format. */
+static bool
+target_float_same_format_p (const struct type *type1,
+ const struct type *type2)
+{
+ if (!target_float_same_category_p (type1, type2))
+ return false;
+
+ switch (TYPE_CODE (type1))
+ {
+ case TYPE_CODE_FLT:
+ return floatformat_from_type (type1) == floatformat_from_type (type2);
+
+ case TYPE_CODE_DECFLOAT:
+ return (TYPE_LENGTH (type1) == TYPE_LENGTH (type2)
+ && (gdbarch_byte_order (get_type_arch (type1))
+ == gdbarch_byte_order (get_type_arch (type2))));
+
+ default:
+ gdb_assert_not_reached ("unexpected type code");
+ }
+}
+
+/* Return the size (without padding) of the target floating-point
+ format used by TYPE. */
+static int
+target_float_format_length (const struct type *type)
+{
+ switch (TYPE_CODE (type))
+ {
+ case TYPE_CODE_FLT:
+ return floatformat_totalsize_bytes (floatformat_from_type (type));
+
+ case TYPE_CODE_DECFLOAT:
+ return TYPE_LENGTH (type);
+
+ default:
+ gdb_assert_not_reached ("unexpected type code");
+ }
+}
+
+/* Identifiers of available host-side intermediate formats. These must
+ be sorted so the that the more "general" kinds come later. */
+enum target_float_ops_kind
+{
+ /* Target binary floating-point formats that match a host format. */
+ host_float = 0,
+ host_double,
+ host_long_double,
+ /* Any other target binary floating-point format. */
+ binary,
+ /* Any target decimal floating-point format. */
+ decimal
+};
+
+/* Given a target type TYPE, choose the best host-side intermediate format
+ to perform operations on TYPE in. */
+static enum target_float_ops_kind
+get_target_float_ops_kind (const struct type *type)
+{
+ switch (TYPE_CODE (type))
+ {
+ case TYPE_CODE_FLT:
+ {
+ const struct floatformat *fmt = floatformat_from_type (type);
+
+ /* Binary floating-point formats matching a host format. */
+ if (fmt == host_float_format)
+ return target_float_ops_kind::host_float;
+ if (fmt == host_double_format)
+ return target_float_ops_kind::host_double;
+ if (fmt == host_long_double_format)
+ return target_float_ops_kind::host_long_double;
+
+ /* Any other binary floating-point format. */
+ return target_float_ops_kind::binary;
+ }
+
+ case TYPE_CODE_DECFLOAT:
+ {
+ /* Any decimal floating-point format. */
+ return target_float_ops_kind::decimal;
+ }
+
+ default:
+ gdb_assert_not_reached ("unexpected type code");
+ }
+}
+
+/* Return target_float_ops to peform operations for KIND. */
+static const target_float_ops *
+get_target_float_ops (enum target_float_ops_kind kind)
+{
+ switch (kind)
+ {
+ /* If the type format matches one of the host floating-point
+ types, use that type as intermediate format. */
+ case target_float_ops_kind::host_float:
+ {
+ static host_float_ops<float> host_float_ops_float;
+ return &host_float_ops_float;
+ }
+
+ case target_float_ops_kind::host_double:
+ {
+ static host_float_ops<double> host_float_ops_double;
+ return &host_float_ops_double;
+ }
+
+ case target_float_ops_kind::host_long_double:
+ {
+ static host_float_ops<long double> host_float_ops_long_double;
+ return &host_float_ops_long_double;
+ }
+
+ /* For binary floating-point formats that do not match any host format,
+ use the largest host floating-point type as intermediate format. */
+ case target_float_ops_kind::binary:
+ {
+ static host_float_ops<long double> binary_float_ops;
+ return &binary_float_ops;
+ }
+
+ /* For decimal floating-point types, always use the libdecnumber
+ decNumber type as intermediate format. */
+ case target_float_ops_kind::decimal:
+ {
+ static decimal_float_ops decimal_float_ops;
+ return &decimal_float_ops;
+ }
+
+ default:
+ gdb_assert_not_reached ("unexpected target_float_ops_kind");
+ }
+}
+
+/* Given a target type TYPE, determine the best host-side intermediate format
+ to perform operations on TYPE in. */
+static const target_float_ops *
+get_target_float_ops (const struct type *type)
+{
+ enum target_float_ops_kind kind = get_target_float_ops_kind (type);
+ return get_target_float_ops (kind);
+}
+
+/* The same for operations involving two target types TYPE1 and TYPE2. */
+static const target_float_ops *
+get_target_float_ops (const struct type *type1, const struct type *type2)
+{
+ gdb_assert (TYPE_CODE (type1) == TYPE_CODE (type2));
+
+ enum target_float_ops_kind kind1 = get_target_float_ops_kind (type1);
+ enum target_float_ops_kind kind2 = get_target_float_ops_kind (type2);
+
+ /* Given the way the kinds are sorted, we simply choose the larger one;
+ this will be able to hold values of either type. */
+ return get_target_float_ops (std::max (kind1, kind2));
+}
+
/* Return whether the byte-stream ADDR holds a valid value of
floating-point type TYPE. */
bool
@@ -1447,8 +1752,7 @@ target_float_is_zero (const gdb_byte *addr, const struct type *type)
== float_zero);
if (TYPE_CODE (type) == TYPE_CODE_DECFLOAT)
- return decimal_is_zero (addr, TYPE_LENGTH (type),
- gdbarch_byte_order (get_type_arch (type)));
+ return decimal_is_zero (addr, type);
gdb_assert_not_reached ("unexpected type code");
}
@@ -1459,15 +1763,33 @@ std::string
target_float_to_string (const gdb_byte *addr, const struct type *type,
const char *format)
{
- if (TYPE_CODE (type) == TYPE_CODE_FLT)
- return floatformat_to_string (floatformat_from_type (type), addr, format);
+ /* Unless we need to adhere to a specific format, provide special
+ output for special cases of binary floating-point numbers. */
+ if (format == nullptr && TYPE_CODE (type) == TYPE_CODE_FLT)
+ {
+ const struct floatformat *fmt = floatformat_from_type (type);
- if (TYPE_CODE (type) == TYPE_CODE_DECFLOAT)
- return decimal_to_string (addr, TYPE_LENGTH (type),
- gdbarch_byte_order (get_type_arch (type)),
- format);
+ /* Detect invalid representations. */
+ if (!floatformat_is_valid (fmt, addr))
+ return "<invalid float value>";
- gdb_assert_not_reached ("unexpected type code");
+ /* Handle NaN and Inf. */
+ enum float_kind kind = floatformat_classify (fmt, addr);
+ if (kind == float_nan)
+ {
+ const char *sign = floatformat_is_negative (fmt, addr)? "-" : "";
+ const char *mantissa = floatformat_mantissa (fmt, addr);
+ return string_printf ("%snan(0x%s)", sign, mantissa);
+ }
+ else if (kind == float_infinite)
+ {
+ const char *sign = floatformat_is_negative (fmt, addr)? "-" : "";
+ return string_printf ("%sinf", sign);
+ }
+ }
+
+ const target_float_ops *ops = get_target_float_ops (type);
+ return ops->to_string (addr, type, format);
}
/* Parse string STRING into a target floating-number of type TYPE and
@@ -1476,19 +1798,8 @@ bool
target_float_from_string (gdb_byte *addr, const struct type *type,
const std::string &string)
{
- /* Ensure possible padding bytes in the target buffer are zeroed out. */
- memset (addr, 0, TYPE_LENGTH (type));
-
- if (TYPE_CODE (type) == TYPE_CODE_FLT)
- return floatformat_from_string (floatformat_from_type (type), addr,
- string);
-
- if (TYPE_CODE (type) == TYPE_CODE_DECFLOAT)
- return decimal_from_string (addr, TYPE_LENGTH (type),
- gdbarch_byte_order (get_type_arch (type)),
- string);
-
- gdb_assert_not_reached ("unexpected type code");
+ const target_float_ops *ops = get_target_float_ops (type);
+ return ops->from_string (addr, type, string);
}
/* Convert the byte-stream ADDR, interpreted as floating-point type TYPE,
@@ -1496,14 +1807,8 @@ target_float_from_string (gdb_byte *addr, const struct type *type,
LONGEST
target_float_to_longest (const gdb_byte *addr, const struct type *type)
{
- if (TYPE_CODE (type) == TYPE_CODE_FLT)
- return floatformat_to_longest (floatformat_from_type (type), addr);
-
- if (TYPE_CODE (type) == TYPE_CODE_DECFLOAT)
- return decimal_to_longest (addr, TYPE_LENGTH (type),
- gdbarch_byte_order (get_type_arch (type)));
-
- gdb_assert_not_reached ("unexpected type code");
+ const target_float_ops *ops = get_target_float_ops (type);
+ return ops->to_longest (addr, type);
}
/* Convert signed integer VAL to a target floating-number of type TYPE
@@ -1512,23 +1817,8 @@ void
target_float_from_longest (gdb_byte *addr, const struct type *type,
LONGEST val)
{
- /* Ensure possible padding bytes in the target buffer are zeroed out. */
- memset (addr, 0, TYPE_LENGTH (type));
-
- if (TYPE_CODE (type) == TYPE_CODE_FLT)
- {
- floatformat_from_longest (floatformat_from_type (type), addr, val);
- return;
- }
-
- if (TYPE_CODE (type) == TYPE_CODE_DECFLOAT)
- {
- decimal_from_longest (val, addr, TYPE_LENGTH (type),
- gdbarch_byte_order (get_type_arch (type)));
- return;
- }
-
- gdb_assert_not_reached ("unexpected type code");
+ const target_float_ops *ops = get_target_float_ops (type);
+ ops->from_longest (addr, type, val);
}
/* Convert unsigned integer VAL to a target floating-number of type TYPE
@@ -1537,23 +1827,8 @@ void
target_float_from_ulongest (gdb_byte *addr, const struct type *type,
ULONGEST val)
{
- /* Ensure possible padding bytes in the target buffer are zeroed out. */
- memset (addr, 0, TYPE_LENGTH (type));
-
- if (TYPE_CODE (type) == TYPE_CODE_FLT)
- {
- floatformat_from_ulongest (floatformat_from_type (type), addr, val);
- return;
- }
-
- if (TYPE_CODE (type) == TYPE_CODE_DECFLOAT)
- {
- decimal_from_ulongest (val, addr, TYPE_LENGTH (type),
- gdbarch_byte_order (get_type_arch (type)));
- return;
- }
-
- gdb_assert_not_reached ("unexpected type code");
+ const target_float_ops *ops = get_target_float_ops (type);
+ ops->from_ulongest (addr, type, val);
}
/* Convert the byte-stream ADDR, interpreted as floating-point type TYPE,
@@ -1562,13 +1837,8 @@ double
target_float_to_host_double (const gdb_byte *addr,
const struct type *type)
{
- if (TYPE_CODE (type) == TYPE_CODE_FLT)
- return floatformat_to_host_double (floatformat_from_type (type), addr);
-
- /* We don't support conversions between target decimal floating-point
- types and the host double type here. */
-
- gdb_assert_not_reached ("unexpected type code");
+ const target_float_ops *ops = get_target_float_ops (type);
+ return ops->to_host_double (addr, type);
}
/* Convert floating-point value VAL in the host "double" format to a target
@@ -1577,19 +1847,8 @@ void
target_float_from_host_double (gdb_byte *addr, const struct type *type,
double val)
{
- /* Ensure possible padding bytes in the target buffer are zeroed out. */
- memset (addr, 0, TYPE_LENGTH (type));
-
- if (TYPE_CODE (type) == TYPE_CODE_FLT)
- {
- floatformat_from_host_double (floatformat_from_type (type), addr, val);
- return;
- }
-
- /* We don't support conversions between target decimal floating-point
- types and the host double type here. */
-
- gdb_assert_not_reached ("unexpected type code");
+ const target_float_ops *ops = get_target_float_ops (type);
+ ops->from_host_double (addr, type, val);
}
/* Convert a floating-point number of type FROM_TYPE from the target
@@ -1599,43 +1858,27 @@ void
target_float_convert (const gdb_byte *from, const struct type *from_type,
gdb_byte *to, const struct type *to_type)
{
- /* Ensure possible padding bytes in the target buffer are zeroed out. */
- memset (to, 0, TYPE_LENGTH (to_type));
-
- /* Use direct conversion routines if we have them. */
-
- if (TYPE_CODE (from_type) == TYPE_CODE_FLT
- && TYPE_CODE (to_type) == TYPE_CODE_FLT)
- {
- floatformat_convert (from, floatformat_from_type (from_type),
- to, floatformat_from_type (to_type));
- return;
- }
-
- if (TYPE_CODE (from_type) == TYPE_CODE_DECFLOAT
- && TYPE_CODE (to_type) == TYPE_CODE_DECFLOAT)
- {
- decimal_convert (from, TYPE_LENGTH (from_type),
- gdbarch_byte_order (get_type_arch (from_type)),
- to, TYPE_LENGTH (to_type),
- gdbarch_byte_order (get_type_arch (to_type)));
- return;
- }
-
/* We cannot directly convert between binary and decimal floating-point
types, so go via an intermediary string. */
-
- if ((TYPE_CODE (from_type) == TYPE_CODE_FLT
- && TYPE_CODE (to_type) == TYPE_CODE_DECFLOAT)
- || (TYPE_CODE (from_type) == TYPE_CODE_DECFLOAT
- && TYPE_CODE (to_type) == TYPE_CODE_FLT))
+ if (!target_float_same_category_p (from_type, to_type))
{
std::string str = target_float_to_string (from, from_type);
target_float_from_string (to, to_type, str);
return;
}
- gdb_assert_not_reached ("unexpected type code");
+ /* Convert between two different formats in the same category. */
+ if (!target_float_same_format_p (from_type, to_type))
+ {
+ const target_float_ops *ops = get_target_float_ops (from_type, to_type);
+ ops->convert (from, from_type, to, to_type);
+ return;
+ }
+
+ /* The floating-point formats match, so we simply copy the data, ensuring
+ possible padding bytes in the target buffer are zeroed out. */
+ memset (to, 0, TYPE_LENGTH (to_type));
+ memcpy (to, from, target_float_format_length (to_type));
}
/* Perform the binary operation indicated by OPCODE, using as operands the
@@ -1652,33 +1895,11 @@ target_float_binop (enum exp_opcode opcode,
const gdb_byte *y, const struct type *type_y,
gdb_byte *res, const struct type *type_res)
{
- /* Ensure possible padding bytes in the target buffer are zeroed out. */
- memset (res, 0, TYPE_LENGTH (type_res));
-
- if (TYPE_CODE (type_res) == TYPE_CODE_FLT)
- {
- gdb_assert (TYPE_CODE (type_x) == TYPE_CODE_FLT);
- gdb_assert (TYPE_CODE (type_y) == TYPE_CODE_FLT);
- return floatformat_binop (opcode,
- floatformat_from_type (type_x), x,
- floatformat_from_type (type_y), y,
- floatformat_from_type (type_res), res);
- }
-
- if (TYPE_CODE (type_res) == TYPE_CODE_DECFLOAT)
- {
- gdb_assert (TYPE_CODE (type_x) == TYPE_CODE_DECFLOAT);
- gdb_assert (TYPE_CODE (type_y) == TYPE_CODE_DECFLOAT);
- return decimal_binop (opcode,
- x, TYPE_LENGTH (type_x),
- gdbarch_byte_order (get_type_arch (type_x)),
- y, TYPE_LENGTH (type_y),
- gdbarch_byte_order (get_type_arch (type_y)),
- res, TYPE_LENGTH (type_res),
- gdbarch_byte_order (get_type_arch (type_res)));
- }
+ gdb_assert (target_float_same_category_p (type_x, type_res));
+ gdb_assert (target_float_same_category_p (type_y, type_res));
- gdb_assert_not_reached ("unexpected type code");
+ const target_float_ops *ops = get_target_float_ops (type_x, type_y);
+ ops->binop (opcode, x, type_x, y, type_y, res, type_res);
}
/* Compare the two target byte streams X and Y, interpreted as floating-point
@@ -1692,22 +1913,9 @@ int
target_float_compare (const gdb_byte *x, const struct type *type_x,
const gdb_byte *y, const struct type *type_y)
{
- if (TYPE_CODE (type_x) == TYPE_CODE_FLT)
- {
- gdb_assert (TYPE_CODE (type_y) == TYPE_CODE_FLT);
- return floatformat_compare (floatformat_from_type (type_x), x,
- floatformat_from_type (type_y), y);
- }
+ gdb_assert (target_float_same_category_p (type_x, type_y));
- if (TYPE_CODE (type_x) == TYPE_CODE_DECFLOAT)
- {
- gdb_assert (TYPE_CODE (type_y) == TYPE_CODE_DECFLOAT);
- return decimal_compare (x, TYPE_LENGTH (type_x),
- gdbarch_byte_order (get_type_arch (type_x)),
- y, TYPE_LENGTH (type_y),
- gdbarch_byte_order (get_type_arch (type_y)));
- }
-
- gdb_assert_not_reached ("unexpected type code");
+ const target_float_ops *ops = get_target_float_ops (type_x, type_y);
+ return ops->compare (x, type_x, y, type_y);
}
diff --git a/gdb/testsuite/ChangeLog b/gdb/testsuite/ChangeLog
index 7434105..b916e93 100644
--- a/gdb/testsuite/ChangeLog
+++ b/gdb/testsuite/ChangeLog
@@ -1,3 +1,7 @@
+2017-11-22 Ulrich Weigand <uweigand@de.ibm.com>
+
+ * gdb.arch/vsx-regs.exp: Update register content checks.
+
2017-11-21 Ulrich Weigand <uweigand@de.ibm.com>
* gdb.arch/ppc-longdouble.exp: New file.
diff --git a/gdb/testsuite/gdb.arch/vsx-regs.exp b/gdb/testsuite/gdb.arch/vsx-regs.exp
index e6b8d72..e45aae5 100644
--- a/gdb/testsuite/gdb.arch/vsx-regs.exp
+++ b/gdb/testsuite/gdb.arch/vsx-regs.exp
@@ -61,11 +61,11 @@ set endianness [get_endianness]
# Data sets used throughout the test
if {$endianness == "big"} {
- set vector_register1 ".uint128 = 0x3ff4cccccccccccc0000000000000000, v2_double = .0x1, 0x0., v4_float = .0x1, 0xf99999a0, 0x0, 0x0., v4_int32 = .0x3ff4cccc, 0xcccccccc, 0x0, 0x0., v8_int16 = .0x3ff4, 0xcccc, 0xcccc, 0xcccc, 0x0, 0x0, 0x0, 0x0., v16_int8 = .0x3f, 0xf4, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0.."
+ set vector_register1 ".uint128 = 0x3ff4cccccccccccd0000000000000000, v2_double = .0x1, 0x0., v4_float = .0x1, 0xf9999998, 0x0, 0x0., v4_int32 = .0x3ff4cccc, 0xcccccccd, 0x0, 0x0., v8_int16 = .0x3ff4, 0xcccc, 0xcccc, 0xcccd, 0x0, 0x0, 0x0, 0x0., v16_int8 = .0x3f, 0xf4, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0.."
- set vector_register1_vr ".uint128 = 0x3ff4cccccccccccc0000000100000001, v4_float = .0x1, 0xf99999a0, 0x0, 0x0., v4_int32 = .0x3ff4cccc, 0xcccccccc, 0x1, 0x1., v8_int16 = .0x3ff4, 0xcccc, 0xcccc, 0xcccc, 0x0, 0x1, 0x0, 0x1., v16_int8 = .0x3f, 0xf4, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0x0, 0x0, 0x0, 0x1, 0x0, 0x0, 0x0, 0x1.."
+ set vector_register1_vr ".uint128 = 0x3ff4cccccccccccd0000000100000001, v4_float = .0x1, 0xf9999998, 0x0, 0x0., v4_int32 = .0x3ff4cccc, 0xcccccccd, 0x1, 0x1., v8_int16 = .0x3ff4, 0xcccc, 0xcccc, 0xcccd, 0x0, 0x1, 0x0, 0x1., v16_int8 = .0x3f, 0xf4, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcd, 0x0, 0x0, 0x0, 0x1, 0x0, 0x0, 0x0, 0x1.."
- set vector_register2 "uint128 = 0xdeadbeefdeadbeefdeadbeefdeadbeef, v2_double = .0x1, 0x1., v4_float = .0x0, 0x0, 0x0, 0x0., v4_int32 = .0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef., v8_int16 = .0xdead, 0xbeef, 0xdead, 0xbeef, 0xdead, 0xbeef, 0xdead, 0xbeef., v16_int8 = .0xde, 0xad, 0xbe, 0xef, 0xde, 0xad, 0xbe, 0xef, 0xde, 0xad, 0xbe, 0xef, 0xde, 0xad, 0xbe, 0xef.."
+ set vector_register2 "uint128 = 0xdeadbeefdeadbeefdeadbeefdeadbeef, v2_double = .0x8000000000000000, 0x8000000000000000., v4_float = .0x0, 0x0, 0x0, 0x0., v4_int32 = .0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef., v8_int16 = .0xdead, 0xbeef, 0xdead, 0xbeef, 0xdead, 0xbeef, 0xdead, 0xbeef., v16_int8 = .0xde, 0xad, 0xbe, 0xef, 0xde, 0xad, 0xbe, 0xef, 0xde, 0xad, 0xbe, 0xef, 0xde, 0xad, 0xbe, 0xef.."
set vector_register2_vr "uint128 = 0xdeadbeefdeadbeefdeadbeefdeadbeef, v4_float = .0x0, 0x0, 0x0, 0x0., v4_int32 = .0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef., v8_int16 = .0xdead, 0xbeef, 0xdead, 0xbeef, 0xdead, 0xbeef, 0xdead, 0xbeef., v16_int8 = .0xde, 0xad, 0xbe, 0xef, 0xde, 0xad, 0xbe, 0xef, 0xde, 0xad, 0xbe, 0xef, 0xde, 0xad, 0xbe, 0xef.."
@@ -73,11 +73,11 @@ if {$endianness == "big"} {
set vector_register3_vr ".uint128 = 0x1000000010000000100000001, v4_float = .0x0, 0x0, 0x0, 0x0., v4_int32 = .0x1, 0x1, 0x1, 0x1., v8_int16 = .0x0, 0x1, 0x0, 0x1, 0x0, 0x1, 0x0, 0x1., v16_int8 = .0x0, 0x0, 0x0, 0x1, 0x0, 0x0, 0x0, 0x1, 0x0, 0x0, 0x0, 0x1, 0x0, 0x0, 0x0, 0x1.."
} else {
- set vector_register1 ".uint128 = 0x3ff4cccccccccccc0000000000000000, v2_double = .0x0, 0x1., v4_float = .0x0, 0x0, 0xf99999a0, 0x1., v4_int32 = .0x0, 0x0, 0xcccccccc, 0x3ff4cccc., v8_int16 = .0x0, 0x0, 0x0, 0x0, 0xcccc, 0xcccc, 0xcccc, 0x3ff4., v16_int8 = .0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xf4, 0x3f.."
+ set vector_register1 ".uint128 = 0x3ff4cccccccccccd0000000000000000, v2_double = .0x0, 0x1., v4_float = .0x0, 0x0, 0xf9999998, 0x1., v4_int32 = .0x0, 0x0, 0xcccccccd, 0x3ff4cccc., v8_int16 = .0x0, 0x0, 0x0, 0x0, 0xcccd, 0xcccc, 0xcccc, 0x3ff4., v16_int8 = .0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xcd, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xf4, 0x3f.."
- set vector_register1_vr ".uint128 = 0x3ff4cccccccccccc0000000100000001, v4_float = .0x0, 0x0, 0xf99999a0, 0x1., v4_int32 = .0x1, 0x1, 0xcccccccc, 0x3ff4cccc., v8_int16 = .0x1, 0x0, 0x1, 0x0, 0xcccc, 0xcccc, 0xcccc, 0x3ff4., v16_int8 = .0x1, 0x0, 0x0, 0x0, 0x1, 0x0, 0x0, 0x0, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xf4, 0x3f.."
+ set vector_register1_vr ".uint128 = 0x3ff4cccccccccccd0000000100000001, v4_float = .0x0, 0x0, 0xf9999998, 0x1., v4_int32 = .0x1, 0x1, 0xcccccccd, 0x3ff4cccc., v8_int16 = .0x1, 0x0, 0x1, 0x0, 0xcccd, 0xcccc, 0xcccc, 0x3ff4., v16_int8 = .0x1, 0x0, 0x0, 0x0, 0x1, 0x0, 0x0, 0x0, 0xcd, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xf4, 0x3f.."
- set vector_register2 "uint128 = 0xdeadbeefdeadbeefdeadbeefdeadbeef, v2_double = .0x1, 0x1., v4_float = .0x0, 0x0, 0x0, 0x0., v4_int32 = .0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef., v8_int16 = .0xbeef, 0xdead, 0xbeef, 0xdead, 0xbeef, 0xdead, 0xbeef, 0xdead., v16_int8 = .0xef, 0xbe, 0xad, 0xde, 0xef, 0xbe, 0xad, 0xde, 0xef, 0xbe, 0xad, 0xde, 0xef, 0xbe, 0xad, 0xde.."
+ set vector_register2 "uint128 = 0xdeadbeefdeadbeefdeadbeefdeadbeef, v2_double = .0x8000000000000000, 0x8000000000000000., v4_float = .0x0, 0x0, 0x0, 0x0., v4_int32 = .0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef., v8_int16 = .0xbeef, 0xdead, 0xbeef, 0xdead, 0xbeef, 0xdead, 0xbeef, 0xdead., v16_int8 = .0xef, 0xbe, 0xad, 0xde, 0xef, 0xbe, 0xad, 0xde, 0xef, 0xbe, 0xad, 0xde, 0xef, 0xbe, 0xad, 0xde.."
set vector_register2_vr "uint128 = 0xdeadbeefdeadbeefdeadbeefdeadbeef, v4_float = .0x0, 0x0, 0x0, 0x0., v4_int32 = .0xdeadbeef, 0xdeadbeef, 0xdeadbeef, 0xdeadbeef., v8_int16 = .0xbeef, 0xdead, 0xbeef, 0xdead, 0xbeef, 0xdead, 0xbeef, 0xdead., v16_int8 = .0xef, 0xbe, 0xad, 0xde, 0xef, 0xbe, 0xad, 0xde, 0xef, 0xbe, 0xad, 0xde, 0xef, 0xbe, 0xad, 0xde.."