gdb/dfp.c - gdb

Functions defined

Macros defined

Source code

  1. /* Decimal floating point support for GDB.

  3.    Copyright (C) 2007-2015 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/>.  */

  20. #include "defs.h"
  21. #include "expression.h"
  22. #include "gdbtypes.h"
  23. #include "value.h"
  24. #include "dfp.h"

  26. /* The order of the following headers is important for making sure
  27.    decNumber structure is large enough to hold decimal128 digits.  */

  29. #include "dpd/decimal128.h"
  30. #include "dpd/decimal64.h"
  31. #include "dpd/decimal32.h"

  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;

  42. #if WORDS_BIGENDIAN
  43. ‌#define OPPOSITE_BYTE_ORDER BFD_ENDIAN_LITTLE
  44. #else
  45. #define OPPOSITE_BYTE_ORDER BFD_ENDIAN_BIG
  46. #endif

  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];

  55.   return;
  56. }

  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.     }

  76.   ctx->traps = 0;
  77. }

  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. }

  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;

  104.   set_decnumber_context (&set, len);

  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. }

  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. }

  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];

  151.   match_endianness (decbytes, len, byte_order, dec);

  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. }

  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];

  180.   set_decnumber_context (&set, len);

  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.     }

  198.   match_endianness (dec, len, byte_order, decbytes);

  200.   /* Check for errors in the DFP operation.  */
  201.   decimal_check_errors (&set);

  203.   return 1;
  204. }

  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;

  217.   type = check_typedef (value_type (from));

  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."));

  224.   l = value_as_long (from);

  226.   if (TYPE_UNSIGNED (type))
  227.     decNumberFromUInt32 (&number, (unsigned int) l);
  228.   else
  229.     decNumberFromInt32 (&number, (int) l);

  231.   decimal_from_number (&number, dec, len);
  232.   match_endianness (dec, len, byte_order, to);
  233. }

  235. /* Converts a value of a float type to a decimal float of
  236.    specified LEN bytes.

  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;

  246.   buffer = xstrprintf ("%.30" DOUBLEST_PRINT_FORMAT, value_as_double (from));

  248.   decimal_from_string (to, len, byte_order, buffer);

  250.   xfree (buffer);
  251. }

  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];

  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. }

  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];

  279.   match_endianness (x, len_x, byte_order_x, dec1);
  280.   match_endianness (y, len_y, byte_order_y, dec2);

  282.   decimal_to_number (dec1, len_x, &number1);
  283.   decimal_to_number (dec2, len_y, &number2);

  285.   set_decnumber_context (&set, len_result);

  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.     }

  310.   /* Check for errors in the DFP operation.  */
  311.   decimal_check_errors (&set);

  313.   decimal_from_number (&number3, dec3, len_result);

  315.   match_endianness (dec3, len_result, byte_order_result, result);
  316. }

  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];

  325.   match_endianness (x, len, byte_order, dec);
  326.   decimal_to_number (dec, len, &number);

  328.   return decNumberIsZero (&number);
  329. }

  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;

  343.   match_endianness (x, len_x, byte_order_x, dec1);
  344.   match_endianness (y, len_y, byte_order_y, dec2);

  346.   decimal_to_number (dec1, len_x, &number1);
  347.   decimal_to_number (dec2, len_y, &number2);

  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);

  353.   decNumberCompare (&result, &number1, &number2, &set);

  355.   /* Check for errors in the DFP operation.  */
  356.   decimal_check_errors (&set);

  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. }

  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];

  378.   match_endianness (from, len_from, byte_order_from, dec);

  380.   decimal_to_number (dec, len_from, &number);
  381.   decimal_from_number (&number, dec, len_to);

  383.   match_endianness (dec, len_to, byte_order_to, to);
  384. }