gdb/dfp.c

   1 /* Decimal floating point support for GDB.
   2
   3    Copyright (C) 2007-2016 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 }