1 /* Decimal floating point support for GDB.
3 Copyright (C) 2007-2017 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 #include "expression.h"
24 /* The order of the following headers is important for making sure
25 decNumber structure is large enough to hold decimal128 digits. */
27 #include "dpd/decimal128.h"
28 #include "dpd/decimal64.h"
29 #include "dpd/decimal32.h"
31 /* When using decimal128, this is the maximum string length + 1
32 (value comes from libdecnumber's DECIMAL128_String constant). */
33 #define MAX_DECIMAL_STRING 43
35 /* In GDB, we are using an array of gdb_byte to represent decimal values.
36 They are stored in host byte order. This routine does the conversion if
37 the target byte order is different. */
39 match_endianness (const gdb_byte
*from
, int len
, enum bfd_endian byte_order
,
45 #define OPPOSITE_BYTE_ORDER BFD_ENDIAN_LITTLE
47 #define OPPOSITE_BYTE_ORDER BFD_ENDIAN_BIG
50 if (byte_order
== OPPOSITE_BYTE_ORDER
)
51 for (i
= 0; i
< len
; i
++)
52 to
[i
] = from
[len
- i
- 1];
54 for (i
= 0; i
< len
; i
++)
60 /* Helper function to get the appropriate libdecnumber context for each size
63 set_decnumber_context (decContext
*ctx
, int len
)
68 decContextDefault (ctx
, DEC_INIT_DECIMAL32
);
71 decContextDefault (ctx
, DEC_INIT_DECIMAL64
);
74 decContextDefault (ctx
, DEC_INIT_DECIMAL128
);
81 /* Check for errors signaled in the decimal context structure. */
83 decimal_check_errors (decContext
*ctx
)
85 /* An error here could be a division by zero, an overflow, an underflow or
86 an invalid operation (from the DEC_Errors constant in decContext.h).
87 Since GDB doesn't complain about division by zero, overflow or underflow
88 errors for binary floating, we won't complain about them for decimal
90 if (ctx
->status
& DEC_IEEE_854_Invalid_operation
)
92 /* Leave only the error bits in the status flags. */
93 ctx
->status
&= DEC_IEEE_854_Invalid_operation
;
94 error (_("Cannot perform operation: %s"),
95 decContextStatusToString (ctx
));
99 /* Helper function to convert from libdecnumber's appropriate representation
100 for computation to each size of decimal float. */
102 decimal_from_number (const decNumber
*from
, gdb_byte
*to
, int len
)
106 set_decnumber_context (&set
, len
);
111 decimal32FromNumber ((decimal32
*) to
, from
, &set
);
114 decimal64FromNumber ((decimal64
*) to
, from
, &set
);
117 decimal128FromNumber ((decimal128
*) to
, from
, &set
);
122 /* Helper function to convert each size of decimal float to libdecnumber's
123 appropriate representation for computation. */
125 decimal_to_number (const gdb_byte
*from
, int len
, decNumber
*to
)
130 decimal32ToNumber ((decimal32
*) from
, to
);
133 decimal64ToNumber ((decimal64
*) from
, to
);
136 decimal128ToNumber ((decimal128
*) from
, to
);
139 error (_("Unknown decimal floating point type."));
144 /* Convert decimal type to its string representation. LEN is the length
145 of the decimal type, 4 bytes for decimal32, 8 bytes for decimal64 and
146 16 bytes for decimal128. */
148 decimal_to_string (const gdb_byte
*decbytes
, int len
,
149 enum bfd_endian byte_order
)
153 match_endianness (decbytes
, len
, byte_order
, dec
);
156 result
.resize (MAX_DECIMAL_STRING
);
161 decimal32ToString ((decimal32
*) dec
, &result
[0]);
164 decimal64ToString ((decimal64
*) dec
, &result
[0]);
167 decimal128ToString ((decimal128
*) dec
, &result
[0]);
170 error (_("Unknown decimal floating point type."));
177 /* Convert the string form of a decimal value to its decimal representation.
178 LEN is the length of the decimal type, 4 bytes for decimal32, 8 bytes for
179 decimal64 and 16 bytes for decimal128. */
181 decimal_from_string (gdb_byte
*decbytes
, int len
, enum bfd_endian byte_order
,
187 set_decnumber_context (&set
, len
);
192 decimal32FromString ((decimal32
*) dec
, string
.c_str (), &set
);
195 decimal64FromString ((decimal64
*) dec
, string
.c_str (), &set
);
198 decimal128FromString ((decimal128
*) dec
, string
.c_str (), &set
);
201 error (_("Unknown decimal floating point type."));
205 match_endianness (dec
, len
, byte_order
, decbytes
);
207 /* Check for errors in the DFP operation. */
208 decimal_check_errors (&set
);
213 /* Converts a LONGEST to a decimal float of specified LEN bytes. */
215 decimal_from_longest (LONGEST from
,
216 gdb_byte
*to
, int len
, enum bfd_endian byte_order
)
220 if ((int32_t) from
!= from
)
221 /* libdecnumber can convert only 32-bit integers. */
222 error (_("Conversion of large integer to a "
223 "decimal floating type is not supported."));
225 decNumberFromInt32 (&number
, (int32_t) from
);
227 decimal_from_number (&number
, dec
, len
);
228 match_endianness (dec
, len
, byte_order
, to
);
231 /* Converts a ULONGEST to a decimal float of specified LEN bytes. */
233 decimal_from_ulongest (ULONGEST from
,
234 gdb_byte
*to
, int len
, enum bfd_endian byte_order
)
239 if ((uint32_t) from
!= from
)
240 /* libdecnumber can convert only 32-bit integers. */
241 error (_("Conversion of large integer to a "
242 "decimal floating type is not supported."));
244 decNumberFromUInt32 (&number
, (uint32_t) from
);
246 decimal_from_number (&number
, dec
, len
);
247 match_endianness (dec
, len
, byte_order
, to
);
250 /* Converts a decimal float of LEN bytes to a LONGEST. */
252 decimal_to_longest (const gdb_byte
*from
, int len
, enum bfd_endian byte_order
)
254 /* libdecnumber has a function to convert from decimal to integer, but
255 it doesn't work when the decimal number has a fractional part. */
256 std::string str
= decimal_to_string (from
, len
, byte_order
);
257 return strtoll (str
.c_str (), NULL
, 10);
260 /* Converts a value of a float type to a decimal float of
263 This is an ugly way to do the conversion, but libdecnumber does
264 not offer a direct way to do it. */
266 decimal_from_doublest (DOUBLEST from
,
267 gdb_byte
*to
, int len
, enum bfd_endian byte_order
)
269 std::string str
= string_printf ("%.30" DOUBLEST_PRINT_FORMAT
, from
);
270 decimal_from_string (to
, len
, byte_order
, str
);
273 /* Converts a decimal float of LEN bytes to a double value. */
275 decimal_to_doublest (const gdb_byte
*from
, int len
, enum bfd_endian byte_order
)
277 /* This is an ugly way to do the conversion, but libdecnumber does
278 not offer a direct way to do it. */
279 std::string str
= decimal_to_string (from
, len
, byte_order
);
280 return strtod (str
.c_str (), NULL
);
283 /* Perform operation OP with operands X and Y with sizes LEN_X and LEN_Y
284 and byte orders BYTE_ORDER_X and BYTE_ORDER_Y, and store value in
285 RESULT with size LEN_RESULT and byte order BYTE_ORDER_RESULT. */
287 decimal_binop (enum exp_opcode op
,
288 const gdb_byte
*x
, int len_x
, enum bfd_endian byte_order_x
,
289 const gdb_byte
*y
, int len_y
, enum bfd_endian byte_order_y
,
290 gdb_byte
*result
, int len_result
,
291 enum bfd_endian byte_order_result
)
294 decNumber number1
, number2
, number3
;
295 gdb_byte dec1
[16], dec2
[16], dec3
[16];
297 match_endianness (x
, len_x
, byte_order_x
, dec1
);
298 match_endianness (y
, len_y
, byte_order_y
, dec2
);
300 decimal_to_number (dec1
, len_x
, &number1
);
301 decimal_to_number (dec2
, len_y
, &number2
);
303 set_decnumber_context (&set
, len_result
);
308 decNumberAdd (&number3
, &number1
, &number2
, &set
);
311 decNumberSubtract (&number3
, &number1
, &number2
, &set
);
314 decNumberMultiply (&number3
, &number1
, &number2
, &set
);
317 decNumberDivide (&number3
, &number1
, &number2
, &set
);
320 decNumberPower (&number3
, &number1
, &number2
, &set
);
323 internal_error (__FILE__
, __LINE__
,
324 _("Unknown decimal floating point operation."));
328 /* Check for errors in the DFP operation. */
329 decimal_check_errors (&set
);
331 decimal_from_number (&number3
, dec3
, len_result
);
333 match_endianness (dec3
, len_result
, byte_order_result
, result
);
336 /* Returns true if X (which is LEN bytes wide) is the number zero. */
338 decimal_is_zero (const gdb_byte
*x
, int len
, enum bfd_endian byte_order
)
343 match_endianness (x
, len
, byte_order
, dec
);
344 decimal_to_number (dec
, len
, &number
);
346 return decNumberIsZero (&number
);
349 /* Compares two numbers numerically. If X is less than Y then the return value
350 will be -1. If they are equal, then the return value will be 0. If X is
351 greater than the Y then the return value will be 1. */
353 decimal_compare (const gdb_byte
*x
, int len_x
, enum bfd_endian byte_order_x
,
354 const gdb_byte
*y
, int len_y
, enum bfd_endian byte_order_y
)
356 decNumber number1
, number2
, result
;
358 gdb_byte dec1
[16], dec2
[16];
361 match_endianness (x
, len_x
, byte_order_x
, dec1
);
362 match_endianness (y
, len_y
, byte_order_y
, dec2
);
364 decimal_to_number (dec1
, len_x
, &number1
);
365 decimal_to_number (dec2
, len_y
, &number2
);
367 /* Perform the comparison in the larger of the two sizes. */
368 len_result
= len_x
> len_y
? len_x
: len_y
;
369 set_decnumber_context (&set
, len_result
);
371 decNumberCompare (&result
, &number1
, &number2
, &set
);
373 /* Check for errors in the DFP operation. */
374 decimal_check_errors (&set
);
376 if (decNumberIsNaN (&result
))
377 error (_("Comparison with an invalid number (NaN)."));
378 else if (decNumberIsZero (&result
))
380 else if (decNumberIsNegative (&result
))
386 /* Convert a decimal value from a decimal type with LEN_FROM bytes to a
387 decimal type with LEN_TO bytes. */
389 decimal_convert (const gdb_byte
*from
, int len_from
,
390 enum bfd_endian byte_order_from
, gdb_byte
*to
, int len_to
,
391 enum bfd_endian byte_order_to
)
396 match_endianness (from
, len_from
, byte_order_from
, dec
);
398 decimal_to_number (dec
, len_from
, &number
);
399 decimal_from_number (&number
, dec
, len_to
);
401 match_endianness (dec
, len_to
, byte_order_to
, to
);