Upgrade GDB from 7.4.1 to 7.6.1 on the vendor branch
[dragonfly.git] / contrib / gdb-7 / gdb / dfp.c
1 /* Decimal floating point support for GDB.
2
3    Copyright (C) 2007-2013 Free Software Foundation, Inc.
4
5    This file is part of GDB.
6
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.
11
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.
16
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/>.  */
19
20 #include "defs.h"
21 #include "expression.h"
22 #include "gdbtypes.h"
23 #include "value.h"
24 #include "dfp.h"
25
26 /* The order of the following headers is important for making sure
27    decNumber structure is large enough to hold decimal128 digits.  */
28
29 #include "dpd/decimal128.h"
30 #include "dpd/decimal64.h"
31 #include "dpd/decimal32.h"
32
33 /* In GDB, we are using an array of gdb_byte to represent decimal values.
34    They are stored in host byte order.  This routine does the conversion if
35    the target byte order is different.  */
36 static void
37 match_endianness (const gdb_byte *from, int len, enum bfd_endian byte_order,
38                   gdb_byte *to)
39 {
40   int i;
41
42 #if WORDS_BIGENDIAN
43 #define OPPOSITE_BYTE_ORDER BFD_ENDIAN_LITTLE
44 #else
45 #define OPPOSITE_BYTE_ORDER BFD_ENDIAN_BIG
46 #endif
47
48   if (byte_order == OPPOSITE_BYTE_ORDER)
49     for (i = 0; i < len; i++)
50       to[i] = from[len - i - 1];
51   else
52     for (i = 0; i < len; i++)
53       to[i] = from[i];
54
55   return;
56 }
57
58 /* Helper function to get the appropriate libdecnumber context for each size
59    of decimal float.  */
60 static void
61 set_decnumber_context (decContext *ctx, int len)
62 {
63   switch (len)
64     {
65       case 4:
66         decContextDefault (ctx, DEC_INIT_DECIMAL32);
67         break;
68       case 8:
69         decContextDefault (ctx, DEC_INIT_DECIMAL64);
70         break;
71       case 16:
72         decContextDefault (ctx, DEC_INIT_DECIMAL128);
73         break;
74     }
75
76   ctx->traps = 0;
77 }
78
79 /* Check for errors signaled in the decimal context structure.  */
80 static void
81 decimal_check_errors (decContext *ctx)
82 {
83   /* An error here could be a division by zero, an overflow, an underflow or
84      an invalid operation (from the DEC_Errors constant in decContext.h).
85      Since GDB doesn't complain about division by zero, overflow or underflow
86      errors for binary floating, we won't complain about them for decimal
87      floating either.  */
88   if (ctx->status & DEC_IEEE_854_Invalid_operation)
89     {
90       /* Leave only the error bits in the status flags.  */
91       ctx->status &= DEC_IEEE_854_Invalid_operation;
92       error (_("Cannot perform operation: %s"),
93              decContextStatusToString (ctx));
94     }
95 }
96
97 /* Helper function to convert from libdecnumber's appropriate representation
98    for computation to each size of decimal float.  */
99 static void
100 decimal_from_number (const decNumber *from, gdb_byte *to, int len)
101 {
102   decContext set;
103
104   set_decnumber_context (&set, len);
105
106   switch (len)
107     {
108       case 4:
109         decimal32FromNumber ((decimal32 *) to, from, &set);
110         break;
111       case 8:
112         decimal64FromNumber ((decimal64 *) to, from, &set);
113         break;
114       case 16:
115         decimal128FromNumber ((decimal128 *) to, from, &set);
116         break;
117     }
118 }
119
120 /* Helper function to convert each size of decimal float to libdecnumber's
121    appropriate representation for computation.  */
122 static void
123 decimal_to_number (const gdb_byte *from, int len, decNumber *to)
124 {
125   switch (len)
126     {
127       case 4:
128         decimal32ToNumber ((decimal32 *) from, to);
129         break;
130       case 8:
131         decimal64ToNumber ((decimal64 *) from, to);
132         break;
133       case 16:
134         decimal128ToNumber ((decimal128 *) from, to);
135         break;
136       default:
137         error (_("Unknown decimal floating point type."));
138         break;
139     }
140 }
141
142 /* Convert decimal type to its string representation.  LEN is the length
143    of the decimal type, 4 bytes for decimal32, 8 bytes for decimal64 and
144    16 bytes for decimal128.  */
145 void
146 decimal_to_string (const gdb_byte *decbytes, int len,
147                    enum bfd_endian byte_order, char *s)
148 {
149   gdb_byte dec[16];
150
151   match_endianness (decbytes, len, byte_order, dec);
152
153   switch (len)
154     {
155       case 4:
156         decimal32ToString ((decimal32 *) dec, s);
157         break;
158       case 8:
159         decimal64ToString ((decimal64 *) dec, s);
160         break;
161       case 16:
162         decimal128ToString ((decimal128 *) dec, s);
163         break;
164       default:
165         error (_("Unknown decimal floating point type."));
166         break;
167     }
168 }
169
170 /* Convert the string form of a decimal value to its decimal representation.
171    LEN is the length of the decimal type, 4 bytes for decimal32, 8 bytes for
172    decimal64 and 16 bytes for decimal128.  */
173 int
174 decimal_from_string (gdb_byte *decbytes, int len, enum bfd_endian byte_order,
175                      const char *string)
176 {
177   decContext set;
178   gdb_byte dec[16];
179
180   set_decnumber_context (&set, len);
181
182   switch (len)
183     {
184       case 4:
185         decimal32FromString ((decimal32 *) dec, string, &set);
186         break;
187       case 8:
188         decimal64FromString ((decimal64 *) dec, string, &set);
189         break;
190       case 16:
191         decimal128FromString ((decimal128 *) dec, string, &set);
192         break;
193       default:
194         error (_("Unknown decimal floating point type."));
195         break;
196     }
197
198   match_endianness (dec, len, byte_order, decbytes);
199
200   /* Check for errors in the DFP operation.  */
201   decimal_check_errors (&set);
202
203   return 1;
204 }
205
206 /* Converts a value of an integral type to a decimal float of
207    specified LEN bytes.  */
208 void
209 decimal_from_integral (struct value *from,
210                        gdb_byte *to, int len, enum bfd_endian byte_order)
211 {
212   LONGEST l;
213   gdb_byte dec[16];
214   decNumber number;
215   struct type *type;
216
217   type = check_typedef (value_type (from));
218
219   if (TYPE_LENGTH (type) > 4)
220     /* libdecnumber can convert only 32-bit integers.  */
221     error (_("Conversion of large integer to a "
222              "decimal floating type is not supported."));
223
224   l = value_as_long (from);
225
226   if (TYPE_UNSIGNED (type))
227     decNumberFromUInt32 (&number, (unsigned int) l);
228   else
229     decNumberFromInt32 (&number, (int) l);
230
231   decimal_from_number (&number, dec, len);
232   match_endianness (dec, len, byte_order, to);
233 }
234
235 /* Converts a value of a float type to a decimal float of
236    specified LEN bytes.
237
238    This is an ugly way to do the conversion, but libdecnumber does
239    not offer a direct way to do it.  */
240 void
241 decimal_from_floating (struct value *from,
242                        gdb_byte *to, int len, enum bfd_endian byte_order)
243 {
244   char *buffer;
245
246   buffer = xstrprintf ("%.30" DOUBLEST_PRINT_FORMAT, value_as_double (from));
247
248   decimal_from_string (to, len, byte_order, buffer);
249
250   xfree (buffer);
251 }
252
253 /* Converts a decimal float of LEN bytes to a double value.  */
254 DOUBLEST
255 decimal_to_doublest (const gdb_byte *from, int len, enum bfd_endian byte_order)
256 {
257   char buffer[MAX_DECIMAL_STRING];
258
259   /* This is an ugly way to do the conversion, but libdecnumber does
260      not offer a direct way to do it.  */
261   decimal_to_string (from, len, byte_order, buffer);
262   return strtod (buffer, NULL);
263 }
264
265 /* Perform operation OP with operands X and Y with sizes LEN_X and LEN_Y
266    and byte orders BYTE_ORDER_X and BYTE_ORDER_Y, and store value in
267    RESULT with size LEN_RESULT and byte order BYTE_ORDER_RESULT.  */
268 void
269 decimal_binop (enum exp_opcode op,
270                const gdb_byte *x, int len_x, enum bfd_endian byte_order_x,
271                const gdb_byte *y, int len_y, enum bfd_endian byte_order_y,
272                gdb_byte *result, int len_result,
273                enum bfd_endian byte_order_result)
274 {
275   decContext set;
276   decNumber number1, number2, number3;
277   gdb_byte dec1[16], dec2[16], dec3[16];
278
279   match_endianness (x, len_x, byte_order_x, dec1);
280   match_endianness (y, len_y, byte_order_y, dec2);
281
282   decimal_to_number (dec1, len_x, &number1);
283   decimal_to_number (dec2, len_y, &number2);
284
285   set_decnumber_context (&set, len_result);
286
287   switch (op)
288     {
289       case BINOP_ADD:
290         decNumberAdd (&number3, &number1, &number2, &set);
291         break;
292       case BINOP_SUB:
293         decNumberSubtract (&number3, &number1, &number2, &set);
294         break;
295       case BINOP_MUL:
296         decNumberMultiply (&number3, &number1, &number2, &set);
297         break;
298       case BINOP_DIV:
299         decNumberDivide (&number3, &number1, &number2, &set);
300         break;
301       case BINOP_EXP:
302         decNumberPower (&number3, &number1, &number2, &set);
303         break;
304       default:
305         internal_error (__FILE__, __LINE__,
306                         _("Unknown decimal floating point operation."));
307         break;
308     }
309
310   /* Check for errors in the DFP operation.  */
311   decimal_check_errors (&set);
312
313   decimal_from_number (&number3, dec3, len_result);
314
315   match_endianness (dec3, len_result, byte_order_result, result);
316 }
317
318 /* Returns true if X (which is LEN bytes wide) is the number zero.  */
319 int
320 decimal_is_zero (const gdb_byte *x, int len, enum bfd_endian byte_order)
321 {
322   decNumber number;
323   gdb_byte dec[16];
324
325   match_endianness (x, len, byte_order, dec);
326   decimal_to_number (dec, len, &number);
327
328   return decNumberIsZero (&number);
329 }
330
331 /* Compares two numbers numerically.  If X is less than Y then the return value
332    will be -1.  If they are equal, then the return value will be 0.  If X is
333    greater than the Y then the return value will be 1.  */
334 int
335 decimal_compare (const gdb_byte *x, int len_x, enum bfd_endian byte_order_x,
336                  const gdb_byte *y, int len_y, enum bfd_endian byte_order_y)
337 {
338   decNumber number1, number2, result;
339   decContext set;
340   gdb_byte dec1[16], dec2[16];
341   int len_result;
342
343   match_endianness (x, len_x, byte_order_x, dec1);
344   match_endianness (y, len_y, byte_order_y, dec2);
345
346   decimal_to_number (dec1, len_x, &number1);
347   decimal_to_number (dec2, len_y, &number2);
348
349   /* Perform the comparison in the larger of the two sizes.  */
350   len_result = len_x > len_y ? len_x : len_y;
351   set_decnumber_context (&set, len_result);
352
353   decNumberCompare (&result, &number1, &number2, &set);
354
355   /* Check for errors in the DFP operation.  */
356   decimal_check_errors (&set);
357
358   if (decNumberIsNaN (&result))
359     error (_("Comparison with an invalid number (NaN)."));
360   else if (decNumberIsZero (&result))
361     return 0;
362   else if (decNumberIsNegative (&result))
363     return -1;
364   else
365     return 1;
366 }
367
368 /* Convert a decimal value from a decimal type with LEN_FROM bytes to a
369    decimal type with LEN_TO bytes.  */
370 void
371 decimal_convert (const gdb_byte *from, int len_from,
372                  enum bfd_endian byte_order_from, gdb_byte *to, int len_to,
373                  enum bfd_endian byte_order_to)
374 {
375   decNumber number;
376   gdb_byte dec[16];
377
378   match_endianness (from, len_from, byte_order_from, dec);
379
380   decimal_to_number (dec, len_from, &number);
381   decimal_from_number (&number, dec, len_to);
382
383   match_endianness (dec, len_to, byte_order_to, to);
384 }