gdb/doublest.c - gdb

Global variables defined

Functions defined

Macros defined

Source code

  1. /* Floating point routines for GDB, the GNU debugger.

  3.    Copyright (C) 1986-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. /* Support for converting target fp numbers into host DOUBLEST format.  */

  22. /* XXX - This code should really be in libiberty/floatformat.c,
  23.    however configuration issues with libiberty made this very
  24.    difficult to do in the available time.  */

  26. #include "defs.h"
  27. #include "doublest.h"
  28. #include "floatformat.h"
  29. #include "gdbtypes.h"
  30. #include <math.h>                /* ldexp */

  32. /* The odds that CHAR_BIT will be anything but 8 are low enough that I'm not
  33.    going to bother with trying to muck around with whether it is defined in
  34.    a system header, what we do if not, etc.  */
  35. ‌#define FLOATFORMAT_CHAR_BIT 8

  37. /* The number of bytes that the largest floating-point type that we
  38.    can convert to doublest will need.  */
  39. ‌#define FLOATFORMAT_LARGEST_BYTES 16

  41. /* Extract a field which starts at START and is LEN bytes long.  DATA and
  42.    TOTAL_LEN are the thing we are extracting it from, in byteorder ORDER.  */
  43. static unsigned long
  44. ‌get_field (const bfd_byte *data, enum floatformat_byteorders order,
  45.            unsigned int total_len, unsigned int start, unsigned int len)
  46. {
  47.   unsigned long result;
  48.   unsigned int cur_byte;
  49.   int cur_bitshift;

  51.   /* Caller must byte-swap words before calling this routine.  */
  52.   gdb_assert (order == floatformat_little || order == floatformat_big);

  54.   /* Start at the least significant part of the field.  */
  55.   if (order == floatformat_little)
  56.     {
  57.       /* We start counting from the other end (i.e, from the high bytes
  58.          rather than the low bytes).  As such, we need to be concerned
  59.          with what happens if bit 0 doesn't start on a byte boundary.
  60.          I.e, we need to properly handle the case where total_len is
  61.          not evenly divisible by 8.  So we compute ``excess'' which
  62.          represents the number of bits from the end of our starting
  63.          byte needed to get to bit 0.  */
  64.       int excess = FLOATFORMAT_CHAR_BIT - (total_len % FLOATFORMAT_CHAR_BIT);

  66.       cur_byte = (total_len / FLOATFORMAT_CHAR_BIT)
  67.                  - ((start + len + excess) / FLOATFORMAT_CHAR_BIT);
  68.       cur_bitshift = ((start + len + excess) % FLOATFORMAT_CHAR_BIT)
  69.                      - FLOATFORMAT_CHAR_BIT;
  70.     }
  71.   else
  72.     {
  73.       cur_byte = (start + len) / FLOATFORMAT_CHAR_BIT;
  74.       cur_bitshift =
  75.         ((start + len) % FLOATFORMAT_CHAR_BIT) - FLOATFORMAT_CHAR_BIT;
  76.     }
  77.   if (cur_bitshift > -FLOATFORMAT_CHAR_BIT)
  78.     result = *(data + cur_byte) >> (-cur_bitshift);
  79.   else
  80.     result = 0;
  81.   cur_bitshift += FLOATFORMAT_CHAR_BIT;
  82.   if (order == floatformat_little)
  83.     ++cur_byte;
  84.   else
  85.     --cur_byte;

  87.   /* Move towards the most significant part of the field.  */
  88.   while (cur_bitshift < len)
  89.     {
  90.       result |= (unsigned long)*(data + cur_byte) << cur_bitshift;
  91.       cur_bitshift += FLOATFORMAT_CHAR_BIT;
  92.       switch (order)
  93.         {
  94.         case floatformat_little:
  95.           ++cur_byte;
  96.           break;
  97.         case floatformat_big:
  98.           --cur_byte;
  99.           break;
  100.         }
  101.     }
  102.   if (len < sizeof(result) * FLOATFORMAT_CHAR_BIT)
  103.     /* Mask out bits which are not part of the field.  */
  104.     result &= ((1UL << len) - 1);
  105.   return result;
  106. }

  108. /* Normalize the byte order of FROM into TO.  If no normalization is
  109.    needed then FMT->byteorder is returned and TO is not changed;
  110.    otherwise the format of the normalized form in TO is returned.  */

  112. static enum floatformat_byteorders
  113. ‌floatformat_normalize_byteorder (const struct floatformat *fmt,
  114.                                  const void *from, void *to)
  115. {
  116.   const unsigned char *swapin;
  117.   unsigned char *swapout;
  118.   int words;

  120.   if (fmt->byteorder == floatformat_little
  121.       || fmt->byteorder == floatformat_big)
  122.     return fmt->byteorder;

  124.   words = fmt->totalsize / FLOATFORMAT_CHAR_BIT;
  125.   words >>= 2;

  127.   swapout = (unsigned char *)to;
  128.   swapin = (const unsigned char *)from;

  130.   if (fmt->byteorder == floatformat_vax)
  131.     {
  132.       while (words-- > 0)
  133.         {
  134.           *swapout++ = swapin[1];
  135.           *swapout++ = swapin[0];
  136.           *swapout++ = swapin[3];
  137.           *swapout++ = swapin[2];
  138.           swapin += 4;
  139.         }
  140.       /* This may look weird, since VAX is little-endian, but it is
  141.          easier to translate to big-endian than to little-endian.  */
  142.       return floatformat_big;
  143.     }
  144.   else
  145.     {
  146.       gdb_assert (fmt->byteorder == floatformat_littlebyte_bigword);

  148.       while (words-- > 0)
  149.         {
  150.           *swapout++ = swapin[3];
  151.           *swapout++ = swapin[2];
  152.           *swapout++ = swapin[1];
  153.           *swapout++ = swapin[0];
  154.           swapin += 4;
  155.         }
  156.       return floatformat_big;
  157.     }
  158. }

  160. /* Convert from FMT to a DOUBLEST.
  161.    FROM is the address of the extended float.
  162.    Store the DOUBLEST in *TO.  */

  164. static void
  165. ‌convert_floatformat_to_doublest (const struct floatformat *fmt,
  166.                                  const void *from,
  167.                                  DOUBLEST *to)
  168. {
  169.   unsigned char *ufrom = (unsigned char *) from;
  170.   DOUBLEST dto;
  171.   long exponent;
  172.   unsigned long mant;
  173.   unsigned int mant_bits, mant_off;
  174.   int mant_bits_left;
  175.   int special_exponent;                /* It's a NaN, denorm or zero.  */
  176.   enum floatformat_byteorders order;
  177.   unsigned char newfrom[FLOATFORMAT_LARGEST_BYTES];
  178.   enum float_kind kind;

  180.   gdb_assert (fmt->totalsize
  181.               <= FLOATFORMAT_LARGEST_BYTES * FLOATFORMAT_CHAR_BIT);

  183.   /* For non-numbers, reuse libiberty's logic to find the correct
  184.      format.  We do not lose any precision in this case by passing
  185.      through a double.  */
  186.   kind = floatformat_classify (fmt, from);
  187.   if (kind == float_infinite || kind == float_nan)
  188.     {
  189.       double dto;

  191.       floatformat_to_double (fmt->split_half ? fmt->split_half : fmt,
  192.                              from, &dto);
  193.       *to = (DOUBLEST) dto;
  194.       return;
  195.     }

  197.   order = floatformat_normalize_byteorder (fmt, ufrom, newfrom);

  199.   if (order != fmt->byteorder)
  200.     ufrom = newfrom;

  202.   if (fmt->split_half)
  203.     {
  204.       DOUBLEST dtop, dbot;

  206.       floatformat_to_doublest (fmt->split_half, ufrom, &dtop);
  207.       /* Preserve the sign of 0, which is the sign of the top
  208.          half.  */
  209.       if (dtop == 0.0)
  210.         {
  211.           *to = dtop;
  212.           return;
  213.         }
  214.       floatformat_to_doublest (fmt->split_half,
  215.                              ufrom + fmt->totalsize / FLOATFORMAT_CHAR_BIT / 2,
  216.                              &dbot);
  217.       *to = dtop + dbot;
  218.       return;
  219.     }

  221.   exponent = get_field (ufrom, order, fmt->totalsize, fmt->exp_start,
  222.                         fmt->exp_len);
  223.   /* Note that if exponent indicates a NaN, we can't really do anything useful
  224.      (not knowing if the host has NaN's, or how to build one).  So it will
  225.      end up as an infinity or something close; that is OK.  */

  227.   mant_bits_left = fmt->man_len;
  228.   mant_off = fmt->man_start;
  229.   dto = 0.0;

  231.   special_exponent = exponent == 0 || exponent == fmt->exp_nan;

  233.   /* Don't bias NaNs.  Use minimum exponent for denorms.  For
  234.      simplicity, we don't check for zero as the exponent doesn't matter.
  235.      Note the cast to int; exp_bias is unsigned, so it's important to
  236.      make sure the operation is done in signed arithmetic.  */
  237.   if (!special_exponent)
  238.     exponent -= fmt->exp_bias;
  239.   else if (exponent == 0)
  240.     exponent = 1 - fmt->exp_bias;

  242.   /* Build the result algebraically.  Might go infinite, underflow, etc;
  243.      who cares.  */

  245. /* If this format uses a hidden bit, explicitly add it in now.  Otherwise,
  246.    increment the exponent by one to account for the integer bit.  */

  248.   if (!special_exponent)
  249.     {
  250.       if (fmt->intbit == floatformat_intbit_no)
  251.         dto = ldexp (1.0, exponent);
  252.       else
  253.         exponent++;
  254.     }

  256.   while (mant_bits_left > 0)
  257.     {
  258.       mant_bits = min (mant_bits_left, 32);

  260.       mant = get_field (ufrom, order, fmt->totalsize, mant_off, mant_bits);

  262.       dto += ldexp ((double) mant, exponent - mant_bits);
  263.       exponent -= mant_bits;
  264.       mant_off += mant_bits;
  265.       mant_bits_left -= mant_bits;
  266.     }

  268.   /* Negate it if negative.  */
  269.   if (get_field (ufrom, order, fmt->totalsize, fmt->sign_start, 1))
  270.     dto = -dto;
  271.   *to = dto;
  272. }

  274. /* Set a field which starts at START and is LEN bytes long.  DATA and
  275.    TOTAL_LEN are the thing we are extracting it from, in byteorder ORDER.  */
  276. static void
  277. ‌put_field (unsigned char *data, enum floatformat_byteorders order,
  278.            unsigned int total_len, unsigned int start, unsigned int len,
  279.            unsigned long stuff_to_put)
  280. {
  281.   unsigned int cur_byte;
  282.   int cur_bitshift;

  284.   /* Caller must byte-swap words before calling this routine.  */
  285.   gdb_assert (order == floatformat_little || order == floatformat_big);

  287.   /* Start at the least significant part of the field.  */
  288.   if (order == floatformat_little)
  289.     {
  290.       int excess = FLOATFORMAT_CHAR_BIT - (total_len % FLOATFORMAT_CHAR_BIT);

  292.       cur_byte = (total_len / FLOATFORMAT_CHAR_BIT)
  293.                  - ((start + len + excess) / FLOATFORMAT_CHAR_BIT);
  294.       cur_bitshift = ((start + len + excess) % FLOATFORMAT_CHAR_BIT)
  295.                      - FLOATFORMAT_CHAR_BIT;
  296.     }
  297.   else
  298.     {
  299.       cur_byte = (start + len) / FLOATFORMAT_CHAR_BIT;
  300.       cur_bitshift =
  301.         ((start + len) % FLOATFORMAT_CHAR_BIT) - FLOATFORMAT_CHAR_BIT;
  302.     }
  303.   if (cur_bitshift > -FLOATFORMAT_CHAR_BIT)
  304.     {
  305.       *(data + cur_byte) &=
  306.         ~(((1 << ((start + len) % FLOATFORMAT_CHAR_BIT)) - 1)
  307.           << (-cur_bitshift));
  308.       *(data + cur_byte) |=
  309.         (stuff_to_put & ((1 << FLOATFORMAT_CHAR_BIT) - 1)) << (-cur_bitshift);
  310.     }
  311.   cur_bitshift += FLOATFORMAT_CHAR_BIT;
  312.   if (order == floatformat_little)
  313.     ++cur_byte;
  314.   else
  315.     --cur_byte;

  317.   /* Move towards the most significant part of the field.  */
  318.   while (cur_bitshift < len)
  319.     {
  320.       if (len - cur_bitshift < FLOATFORMAT_CHAR_BIT)
  321.         {
  322.           /* This is the last byte.  */
  323.           *(data + cur_byte) &=
  324.             ~((1 << (len - cur_bitshift)) - 1);
  325.           *(data + cur_byte) |= (stuff_to_put >> cur_bitshift);
  326.         }
  327.       else
  328.         *(data + cur_byte) = ((stuff_to_put >> cur_bitshift)
  329.                               & ((1 << FLOATFORMAT_CHAR_BIT) - 1));
  330.       cur_bitshift += FLOATFORMAT_CHAR_BIT;
  331.       if (order == floatformat_little)
  332.         ++cur_byte;
  333.       else
  334.         --cur_byte;
  335.     }
  336. }

  338. /* The converse: convert the DOUBLEST *FROM to an extended float and
  339.    store where TO points.  Neither FROM nor TO have any alignment
  340.    restrictions.  */

  342. static void
  343. ‌convert_doublest_to_floatformat (const struct floatformat *fmt,
  344.                                  const DOUBLEST *from, void *to)
  345. {
  346.   DOUBLEST dfrom;
  347.   int exponent;
  348.   DOUBLEST mant;
  349.   unsigned int mant_bits, mant_off;
  350.   int mant_bits_left;
  351.   unsigned char *uto = (unsigned char *) to;
  352.   enum floatformat_byteorders order = fmt->byteorder;
  353.   unsigned char newto[FLOATFORMAT_LARGEST_BYTES];

  355.   if (order != floatformat_little)
  356.     order = floatformat_big;

  358.   if (order != fmt->byteorder)
  359.     uto = newto;

  361.   memcpy (&dfrom, from, sizeof (dfrom));
  362.   memset (uto, 0, (fmt->totalsize + FLOATFORMAT_CHAR_BIT - 1)
  363.                     / FLOATFORMAT_CHAR_BIT);

  365.   if (fmt->split_half)
  366.     {
  367.       /* Use static volatile to ensure that any excess precision is
  368.          removed via storing in memory, and so the top half really is
  369.          the result of converting to double.  */
  370.       static volatile double dtop, dbot;
  371.       DOUBLEST dtopnv, dbotnv;

  373.       dtop = (double) dfrom;
  374.       /* If the rounded top half is Inf, the bottom must be 0 not NaN
  375.          or Inf.  */
  376.       if (dtop + dtop == dtop && dtop != 0.0)
  377.         dbot = 0.0;
  378.       else
  379.         dbot = (double) (dfrom - (DOUBLEST) dtop);
  380.       dtopnv = dtop;
  381.       dbotnv = dbot;
  382.       floatformat_from_doublest (fmt->split_half, &dtopnv, uto);
  383.       floatformat_from_doublest (fmt->split_half, &dbotnv,
  384.                                (uto
  385.                                 + fmt->totalsize / FLOATFORMAT_CHAR_BIT / 2));
  386.       return;
  387.     }

  389.   if (dfrom == 0)
  390.     return;                        /* Result is zero */
  391.   if (dfrom != dfrom)                /* Result is NaN */
  392.     {
  393.       /* From is NaN */
  394.       put_field (uto, order, fmt->totalsize, fmt->exp_start,
  395.                  fmt->exp_len, fmt->exp_nan);
  396.       /* Be sure it's not infinity, but NaN value is irrel.  */
  397.       put_field (uto, order, fmt->totalsize, fmt->man_start,
  398.                  fmt->man_len, 1);
  399.       goto finalize_byteorder;
  400.     }

  402.   /* If negative, set the sign bit.  */
  403.   if (dfrom < 0)
  404.     {
  405.       put_field (uto, order, fmt->totalsize, fmt->sign_start, 1, 1);
  406.       dfrom = -dfrom;
  407.     }

  409.   if (dfrom + dfrom == dfrom && dfrom != 0.0)        /* Result is Infinity.  */
  410.     {
  411.       /* Infinity exponent is same as NaN's.  */
  412.       put_field (uto, order, fmt->totalsize, fmt->exp_start,
  413.                  fmt->exp_len, fmt->exp_nan);
  414.       /* Infinity mantissa is all zeroes.  */
  415.       put_field (uto, order, fmt->totalsize, fmt->man_start,
  416.                  fmt->man_len, 0);
  417.       goto finalize_byteorder;
  418.     }

  420. #ifdef HAVE_LONG_DOUBLE
  421.   mant = frexpl (dfrom, &exponent);
  422. #else
  423.   mant = frexp (dfrom, &exponent);
  424. #endif

  426.   if (exponent + fmt->exp_bias <= 0)
  427.     {
  428.       /* The value is too small to be expressed in the destination
  429.          type (not enough bits in the exponent.  Treat as 0.  */
  430.       put_field (uto, order, fmt->totalsize, fmt->exp_start,
  431.                  fmt->exp_len, 0);
  432.       put_field (uto, order, fmt->totalsize, fmt->man_start,
  433.                  fmt->man_len, 0);
  434.       goto finalize_byteorder;
  435.     }

  437.   if (exponent + fmt->exp_bias >= (1 << fmt->exp_len))
  438.     {
  439.       /* The value is too large to fit into the destination.
  440.          Treat as infinity.  */
  441.       put_field (uto, order, fmt->totalsize, fmt->exp_start,
  442.                  fmt->exp_len, fmt->exp_nan);
  443.       put_field (uto, order, fmt->totalsize, fmt->man_start,
  444.                  fmt->man_len, 0);
  445.       goto finalize_byteorder;
  446.     }

  448.   put_field (uto, order, fmt->totalsize, fmt->exp_start, fmt->exp_len,
  449.              exponent + fmt->exp_bias - 1);

  451.   mant_bits_left = fmt->man_len;
  452.   mant_off = fmt->man_start;
  453.   while (mant_bits_left > 0)
  454.     {
  455.       unsigned long mant_long;

  457.       mant_bits = mant_bits_left < 32 ? mant_bits_left : 32;

  459.       mant *= 4294967296.0;
  460.       mant_long = ((unsigned long) mant) & 0xffffffffL;
  461.       mant -= mant_long;

  463.       /* If the integer bit is implicit, then we need to discard it.
  464.          If we are discarding a zero, we should be (but are not) creating
  465.          a denormalized number which means adjusting the exponent
  466.          (I think).  */
  467.       if (mant_bits_left == fmt->man_len
  468.           && fmt->intbit == floatformat_intbit_no)
  469.         {
  470.           mant_long <<= 1;
  471.           mant_long &= 0xffffffffL;
  472.           /* If we are processing the top 32 mantissa bits of a doublest
  473.              so as to convert to a float value with implied integer bit,
  474.              we will only be putting 31 of those 32 bits into the
  475.              final value due to the discarding of the top bit.  In the
  476.              case of a small float value where the number of mantissa
  477.              bits is less than 32, discarding the top bit does not alter
  478.              the number of bits we will be adding to the result.  */
  479.           if (mant_bits == 32)
  480.             mant_bits -= 1;
  481.         }

  483.       if (mant_bits < 32)
  484.         {
  485.           /* The bits we want are in the most significant MANT_BITS bits of
  486.              mant_long.  Move them to the least significant.  */
  487.           mant_long >>= 32 - mant_bits;
  488.         }

  490.       put_field (uto, order, fmt->totalsize,
  491.                  mant_off, mant_bits, mant_long);
  492.       mant_off += mant_bits;
  493.       mant_bits_left -= mant_bits;
  494.     }

  496. finalize_byteorder:
  497.   /* Do we need to byte-swap the words in the result?  */
  498.   if (order != fmt->byteorder)
  499.     floatformat_normalize_byteorder (fmt, newto, to);
  500. }

  502. /* Check if VAL (which is assumed to be a floating point number whose
  503.    format is described by FMT) is negative.  */

  505. int
  506. ‌floatformat_is_negative (const struct floatformat *fmt,
  507.                          const bfd_byte *uval)
  508. {
  509.   enum floatformat_byteorders order;
  510.   unsigned char newfrom[FLOATFORMAT_LARGEST_BYTES];

  512.   gdb_assert (fmt != NULL);
  513.   gdb_assert (fmt->totalsize
  514.               <= FLOATFORMAT_LARGEST_BYTES * FLOATFORMAT_CHAR_BIT);

  516.   /* An IBM long double (a two element array of double) always takes the
  517.      sign of the first double.  */
  518.   if (fmt->split_half)
  519.     fmt = fmt->split_half;

  521.   order = floatformat_normalize_byteorder (fmt, uval, newfrom);

  523.   if (order != fmt->byteorder)
  524.     uval = newfrom;

  526.   return get_field (uval, order, fmt->totalsize, fmt->sign_start, 1);
  527. }

  529. /* Check if VAL is "not a number" (NaN) for FMT.  */

  531. enum float_kind
  532. ‌floatformat_classify (const struct floatformat *fmt,
  533.                       const bfd_byte *uval)
  534. {
  535.   long exponent;
  536.   unsigned long mant;
  537.   unsigned int mant_bits, mant_off;
  538.   int mant_bits_left;
  539.   enum floatformat_byteorders order;
  540.   unsigned char newfrom[FLOATFORMAT_LARGEST_BYTES];
  541.   int mant_zero;

  543.   gdb_assert (fmt != NULL);
  544.   gdb_assert (fmt->totalsize
  545.               <= FLOATFORMAT_LARGEST_BYTES * FLOATFORMAT_CHAR_BIT);

  547.   /* An IBM long double (a two element array of double) can be classified
  548.      by looking at the first double.  inf and nan are specified as
  549.      ignoring the second double.  zero and subnormal will always have
  550.      the second double 0.0 if the long double is correctly rounded.  */
  551.   if (fmt->split_half)
  552.     fmt = fmt->split_half;

  554.   order = floatformat_normalize_byteorder (fmt, uval, newfrom);

  556.   if (order != fmt->byteorder)
  557.     uval = newfrom;

  559.   exponent = get_field (uval, order, fmt->totalsize, fmt->exp_start,
  560.                         fmt->exp_len);

  562.   mant_bits_left = fmt->man_len;
  563.   mant_off = fmt->man_start;

  565.   mant_zero = 1;
  566.   while (mant_bits_left > 0)
  567.     {
  568.       mant_bits = min (mant_bits_left, 32);

  570.       mant = get_field (uval, order, fmt->totalsize, mant_off, mant_bits);

  572.       /* If there is an explicit integer bit, mask it off.  */
  573.       if (mant_off == fmt->man_start
  574.           && fmt->intbit == floatformat_intbit_yes)
  575.         mant &= ~(1 << (mant_bits - 1));

  577.       if (mant)
  578.         {
  579.           mant_zero = 0;
  580.           break;
  581.         }

  583.       mant_off += mant_bits;
  584.       mant_bits_left -= mant_bits;
  585.     }

  587.   /* If exp_nan is not set, assume that inf, NaN, and subnormals are not
  588.      supported.  */
  589.   if (! fmt->exp_nan)
  590.     {
  591.       if (mant_zero)
  592.         return float_zero;
  593.       else
  594.         return float_normal;
  595.     }

  597.   if (exponent == 0 && !mant_zero)
  598.     return float_subnormal;

  600.   if (exponent == fmt->exp_nan)
  601.     {
  602.       if (mant_zero)
  603.         return float_infinite;
  604.       else
  605.         return float_nan;
  606.     }

  608.   if (mant_zero)
  609.     return float_zero;

  611.   return float_normal;
  612. }

  614. /* Convert the mantissa of VAL (which is assumed to be a floating
  615.    point number whose format is described by FMT) into a hexadecimal
  616.    and store it in a static string.  Return a pointer to that string.  */

  618. const char *
  619. ‌floatformat_mantissa (const struct floatformat *fmt,
  620.                       const bfd_byte *val)
  621. {
  622.   unsigned char *uval = (unsigned char *) val;
  623.   unsigned long mant;
  624.   unsigned int mant_bits, mant_off;
  625.   int mant_bits_left;
  626.   static char res[50];
  627.   char buf[9];
  628.   int len;
  629.   enum floatformat_byteorders order;
  630.   unsigned char newfrom[FLOATFORMAT_LARGEST_BYTES];

  632.   gdb_assert (fmt != NULL);
  633.   gdb_assert (fmt->totalsize
  634.               <= FLOATFORMAT_LARGEST_BYTES * FLOATFORMAT_CHAR_BIT);

  636.   /* For IBM long double (a two element array of double), return the
  637.      mantissa of the first double.  The problem with returning the
  638.      actual mantissa from both doubles is that there can be an
  639.      arbitrary number of implied 0's or 1's between the mantissas
  640.      of the first and second double.  In any case, this function
  641.      is only used for dumping out nans, and a nan is specified to
  642.      ignore the value in the second double.  */
  643.   if (fmt->split_half)
  644.     fmt = fmt->split_half;

  646.   order = floatformat_normalize_byteorder (fmt, uval, newfrom);

  648.   if (order != fmt->byteorder)
  649.     uval = newfrom;

  651.   if (! fmt->exp_nan)
  652.     return 0;

  654.   /* Make sure we have enough room to store the mantissa.  */
  655.   gdb_assert (sizeof res > ((fmt->man_len + 7) / 8) * 2);

  657.   mant_off = fmt->man_start;
  658.   mant_bits_left = fmt->man_len;
  659.   mant_bits = (mant_bits_left % 32) > 0 ? mant_bits_left % 32 : 32;

  661.   mant = get_field (uval, order, fmt->totalsize, mant_off, mant_bits);

  663.   len = xsnprintf (res, sizeof res, "%lx", mant);

  665.   mant_off += mant_bits;
  666.   mant_bits_left -= mant_bits;

  668.   while (mant_bits_left > 0)
  669.     {
  670.       mant = get_field (uval, order, fmt->totalsize, mant_off, 32);

  672.       xsnprintf (buf, sizeof buf, "%08lx", mant);
  673.       gdb_assert (len + strlen (buf) <= sizeof res);
  674.       strcat (res, buf);

  676.       mant_off += 32;
  677.       mant_bits_left -= 32;
  678.     }

  680.   return res;
  681. }


  684. /* Convert TO/FROM target to the hosts DOUBLEST floating-point format.

  686.    If the host and target formats agree, we just copy the raw data
  687.    into the appropriate type of variable and return, letting the host
  688.    increase precision as necessary.  Otherwise, we call the conversion
  689.    routine and let it do the dirty work.  */

  691. ‌static const struct floatformat *host_float_format = GDB_HOST_FLOAT_FORMAT;
  692. ‌static const struct floatformat *host_double_format = GDB_HOST_DOUBLE_FORMAT;
  693. ‌static const struct floatformat *host_long_double_format
  694.   = GDB_HOST_LONG_DOUBLE_FORMAT;

  696. void
  697. ‌floatformat_to_doublest (const struct floatformat *fmt,
  698.                          const void *in, DOUBLEST *out)
  699. {
  700.   gdb_assert (fmt != NULL);
  701.   if (fmt == host_float_format)
  702.     {
  703.       float val;

  705.       memcpy (&val, in, sizeof (val));
  706.       *out = val;
  707.     }
  708.   else if (fmt == host_double_format)
  709.     {
  710.       double val;

  712.       memcpy (&val, in, sizeof (val));
  713.       *out = val;
  714.     }
  715.   else if (fmt == host_long_double_format)
  716.     {
  717.       long double val;

  719.       memcpy (&val, in, sizeof (val));
  720.       *out = val;
  721.     }
  722.   else
  723.     convert_floatformat_to_doublest (fmt, in, out);
  724. }

  726. void
  727. ‌floatformat_from_doublest (const struct floatformat *fmt,
  728.                            const DOUBLEST *in, void *out)
  729. {
  730.   gdb_assert (fmt != NULL);
  731.   if (fmt == host_float_format)
  732.     {
  733.       float val = *in;

  735.       memcpy (out, &val, sizeof (val));
  736.     }
  737.   else if (fmt == host_double_format)
  738.     {
  739.       double val = *in;

  741.       memcpy (out, &val, sizeof (val));
  742.     }
  743.   else if (fmt == host_long_double_format)
  744.     {
  745.       long double val = *in;

  747.       memcpy (out, &val, sizeof (val));
  748.     }
  749.   else
  750.     convert_doublest_to_floatformat (fmt, in, out);
  751. }


  754. /* Return a floating-point format for a floating-point variable of
  755.    length LEN.  If no suitable floating-point format is found, an
  756.    error is thrown.

  758.    We need this functionality since information about the
  759.    floating-point format of a type is not always available to GDB; the
  760.    debug information typically only tells us the size of a
  761.    floating-point type.

  763.    FIXME: kettenis/2001-10-28: In many places, particularly in
  764.    target-dependent code, the format of floating-point types is known,
  765.    but not passed on by GDB.  This should be fixed.  */

  767. static const struct floatformat *
  768. ‌floatformat_from_length (struct gdbarch *gdbarch, int len)
  769. {
  770.   const struct floatformat *format;

  772.   if (len * TARGET_CHAR_BIT == gdbarch_half_bit (gdbarch))
  773.     format = gdbarch_half_format (gdbarch)
  774.                [gdbarch_byte_order (gdbarch)];
  775.   else if (len * TARGET_CHAR_BIT == gdbarch_float_bit (gdbarch))
  776.     format = gdbarch_float_format (gdbarch)
  777.                [gdbarch_byte_order (gdbarch)];
  778.   else if (len * TARGET_CHAR_BIT == gdbarch_double_bit (gdbarch))
  779.     format = gdbarch_double_format (gdbarch)
  780.                [gdbarch_byte_order (gdbarch)];
  781.   else if (len * TARGET_CHAR_BIT == gdbarch_long_double_bit (gdbarch))
  782.     format = gdbarch_long_double_format (gdbarch)
  783.                [gdbarch_byte_order (gdbarch)];
  784.   /* On i386 the 'long double' type takes 96 bits,
  785.      while the real number of used bits is only 80,
  786.      both in processor and in memory.
  787.      The code below accepts the real bit size.  */
  788.   else if ((gdbarch_long_double_format (gdbarch) != NULL)
  789.            && (len * TARGET_CHAR_BIT
  790.                == gdbarch_long_double_format (gdbarch)[0]->totalsize))
  791.     format = gdbarch_long_double_format (gdbarch)
  792.                [gdbarch_byte_order (gdbarch)];
  793.   else
  794.     format = NULL;
  795.   if (format == NULL)
  796.     error (_("Unrecognized %d-bit floating-point type."),
  797.            len * TARGET_CHAR_BIT);
  798.   return format;
  799. }

  801. const struct floatformat *
  802. ‌floatformat_from_type (const struct type *type)
  803. {
  804.   struct gdbarch *gdbarch = get_type_arch (type);

  806.   gdb_assert (TYPE_CODE (type) == TYPE_CODE_FLT);
  807.   if (TYPE_FLOATFORMAT (type) != NULL)
  808.     return TYPE_FLOATFORMAT (type)[gdbarch_byte_order (gdbarch)];
  809.   else
  810.     return floatformat_from_length (gdbarch, TYPE_LENGTH (type));
  811. }

  813. /* Extract a floating-point number of type TYPE from a target-order
  814.    byte-stream at ADDR.  Returns the value as type DOUBLEST.  */

  816. DOUBLEST
  817. ‌extract_typed_floating (const void *addr, const struct type *type)
  818. {
  819.   const struct floatformat *fmt = floatformat_from_type (type);
  820.   DOUBLEST retval;

  822.   floatformat_to_doublest (fmt, addr, &retval);
  823.   return retval;
  824. }

  826. /* Store VAL as a floating-point number of type TYPE to a target-order
  827.    byte-stream at ADDR.  */

  829. void
  830. ‌store_typed_floating (void *addr, const struct type *type, DOUBLEST val)
  831. {
  832.   const struct floatformat *fmt = floatformat_from_type (type);

  834.   /* FIXME: kettenis/2001-10-28: It is debatable whether we should
  835.      zero out any remaining bytes in the target buffer when TYPE is
  836.      longer than the actual underlying floating-point format.  Perhaps
  837.      we should store a fixed bitpattern in those remaining bytes,
  838.      instead of zero, or perhaps we shouldn't touch those remaining
  839.      bytes at all.

  841.      NOTE: cagney/2001-10-28: With the way things currently work, it
  842.      isn't a good idea to leave the end bits undefined.  This is
  843.      because GDB writes out the entire sizeof(<floating>) bits of the
  844.      floating-point type even though the value might only be stored
  845.      in, and the target processor may only refer to, the first N <
  846.      TYPE_LENGTH (type) bits.  If the end of the buffer wasn't
  847.      initialized, GDB would write undefined data to the target.  An
  848.      errant program, refering to that undefined data, would then
  849.      become non-deterministic.

  851.      See also the function convert_typed_floating below.  */
  852.   memset (addr, 0, TYPE_LENGTH (type));

  854.   floatformat_from_doublest (fmt, &val, addr);
  855. }

  857. /* Convert a floating-point number of type FROM_TYPE from a
  858.    target-order byte-stream at FROM to a floating-point number of type
  859.    TO_TYPE, and store it to a target-order byte-stream at TO.  */

  861. void
  862. ‌convert_typed_floating (const void *from, const struct type *from_type,
  863.                         void *to, const struct type *to_type)
  864. {
  865.   const struct floatformat *from_fmt = floatformat_from_type (from_type);
  866.   const struct floatformat *to_fmt = floatformat_from_type (to_type);

  868.   if (from_fmt == NULL || to_fmt == NULL)
  869.     {
  870.       /* If we don't know the floating-point format of FROM_TYPE or
  871.          TO_TYPE, there's not much we can do.  We might make the
  872.          assumption that if the length of FROM_TYPE and TO_TYPE match,
  873.          their floating-point format would match too, but that
  874.          assumption might be wrong on targets that support
  875.          floating-point types that only differ in endianness for
  876.          example.  So we warn instead, and zero out the target buffer.  */
  877.       warning (_("Can't convert floating-point number to desired type."));
  878.       memset (to, 0, TYPE_LENGTH (to_type));
  879.     }
  880.   else if (from_fmt == to_fmt)
  881.     {
  882.       /* We're in business.  The floating-point format of FROM_TYPE
  883.          and TO_TYPE match.  However, even though the floating-point
  884.          format matches, the length of the type might still be
  885.          different.  Make sure we don't overrun any buffers.  See
  886.          comment in store_typed_floating for a discussion about
  887.          zeroing out remaining bytes in the target buffer.  */
  888.       memset (to, 0, TYPE_LENGTH (to_type));
  889.       memcpy (to, from, min (TYPE_LENGTH (from_type), TYPE_LENGTH (to_type)));
  890.     }
  891.   else
  892.     {
  893.       /* The floating-point types don't match.  The best we can do
  894.          (apart from simulating the target FPU) is converting to the
  895.          widest floating-point type supported by the host, and then
  896.          again to the desired type.  */
  897.       DOUBLEST d;

  899.       floatformat_to_doublest (from_fmt, from, &d);
  900.       floatformat_from_doublest (to_fmt, &d, to);
  901.     }
  902. }