Fix all failing FPXX tests for tx39-elf.

[platform/upstream/binutils.git] / gdb / doublest.c

diff --git a/gdb/doublest.c b/gdb/doublest.c
index 2030838..ebcb82f 100644 (file)
--- a/gdb/doublest.c
+++ b/gdb/doublest.c
@@ -1,14 +1,12 @@
 /* Floating point routines for GDB, the GNU debugger.
 
 /* Floating point routines for GDB, the GNU debugger.
 

-   Copyright 1986, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
-   1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005 Free Software
-   Foundation, Inc.
+   Copyright (C) 1986-2014 Free Software Foundation, Inc.

 
    This file is part of GDB.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
 
    This file is part of GDB.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by

-   the Free Software Foundation; either version 2 of the License, or
+   the Free Software Foundation; either version 3 of the License, or

    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,


@@ -17,9 +15,7 @@
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License

-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 59 Temple Place - Suite 330,
-   Boston, MA 02111-1307, USA.  */
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

 
 /* Support for converting target fp numbers into host DOUBLEST format.  */
 
 
 /* Support for converting target fp numbers into host DOUBLEST format.  */
 


@@ -30,8 +26,6 @@
 #include "defs.h"
 #include "doublest.h"
 #include "floatformat.h"
 #include "defs.h"
 #include "doublest.h"
 #include "floatformat.h"

-#include "gdb_assert.h"
-#include "gdb_string.h"

 #include "gdbtypes.h"
 #include <math.h>              /* ldexp */
 
 #include "gdbtypes.h"
 #include <math.h>              /* ldexp */
 


@@ -62,12 +56,13 @@ get_field (const bfd_byte *data, enum floatformat_byteorders order,
     {
       /* We start counting from the other end (i.e, from the high bytes
         rather than the low bytes).  As such, we need to be concerned
     {
       /* We start counting from the other end (i.e, from the high bytes
         rather than the low bytes).  As such, we need to be concerned

-        with what happens if bit 0 doesn't start on a byte boundary. 
+        with what happens if bit 0 doesn't start on a byte boundary.

         I.e, we need to properly handle the case where total_len is
         not evenly divisible by 8.  So we compute ``excess'' which
         represents the number of bits from the end of our starting
         I.e, we need to properly handle the case where total_len is
         not evenly divisible by 8.  So we compute ``excess'' which
         represents the number of bits from the end of our starting

-        byte needed to get to bit 0. */
+        byte needed to get to bit 0.  */

       int excess = FLOATFORMAT_CHAR_BIT - (total_len % FLOATFORMAT_CHAR_BIT);
       int excess = FLOATFORMAT_CHAR_BIT - (total_len % FLOATFORMAT_CHAR_BIT);

+

       cur_byte = (total_len / FLOATFORMAT_CHAR_BIT) 
                  - ((start + len + excess) / FLOATFORMAT_CHAR_BIT);
       cur_bitshift = ((start + len + excess) % FLOATFORMAT_CHAR_BIT) 
       cur_byte = (total_len / FLOATFORMAT_CHAR_BIT) 
                  - ((start + len + excess) / FLOATFORMAT_CHAR_BIT);
       cur_bitshift = ((start + len + excess) % FLOATFORMAT_CHAR_BIT) 


@@ -105,14 +100,15 @@ get_field (const bfd_byte *data, enum floatformat_byteorders order,
        }
     }
   if (len < sizeof(result) * FLOATFORMAT_CHAR_BIT)
        }
     }
   if (len < sizeof(result) * FLOATFORMAT_CHAR_BIT)

-    /* Mask out bits which are not part of the field */
+    /* Mask out bits which are not part of the field.  */

     result &= ((1UL << len) - 1);
   return result;
 }
 
     result &= ((1UL << len) - 1);
   return result;
 }
 

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

 static enum floatformat_byteorders
 floatformat_normalize_byteorder (const struct floatformat *fmt,
                                 const void *from, void *to)
 static enum floatformat_byteorders
 floatformat_normalize_byteorder (const struct floatformat *fmt,
                                 const void *from, void *to)


@@ -125,23 +121,40 @@ floatformat_normalize_byteorder (const struct floatformat *fmt,
       || fmt->byteorder == floatformat_big)
     return fmt->byteorder;
 
       || fmt->byteorder == floatformat_big)
     return fmt->byteorder;
 

-  gdb_assert (fmt->byteorder == floatformat_littlebyte_bigword);
-

   words = fmt->totalsize / FLOATFORMAT_CHAR_BIT;
   words >>= 2;
 
   swapout = (unsigned char *)to;
   swapin = (const unsigned char *)from;
 
   words = fmt->totalsize / FLOATFORMAT_CHAR_BIT;
   words >>= 2;
 
   swapout = (unsigned char *)to;
   swapin = (const unsigned char *)from;
 

-  while (words-- > 0)
+  if (fmt->byteorder == floatformat_vax)
+    {
+      while (words-- > 0)
+       {
+         *swapout++ = swapin[1];
+         *swapout++ = swapin[0];
+         *swapout++ = swapin[3];
+         *swapout++ = swapin[2];
+         swapin += 4;
+       }
+      /* This may look weird, since VAX is little-endian, but it is
+        easier to translate to big-endian than to little-endian.  */
+      return floatformat_big;
+    }
+  else

     {
     {

-      *swapout++ = swapin[3];
-      *swapout++ = swapin[2];
-      *swapout++ = swapin[1];
-      *swapout++ = swapin[0];
-      swapin += 4;
+      gdb_assert (fmt->byteorder == floatformat_littlebyte_bigword);
+
+      while (words-- > 0)
+       {
+         *swapout++ = swapin[3];
+         *swapout++ = swapin[2];
+         *swapout++ = swapin[1];
+         *swapout++ = swapin[0];
+         swapin += 4;
+       }
+      return floatformat_big;

     }
     }

-  return floatformat_big;

 }
   
 /* Convert from FMT to a DOUBLEST.
 }
   
 /* Convert from FMT to a DOUBLEST.


@@ -159,18 +172,52 @@ convert_floatformat_to_doublest (const struct floatformat *fmt,
   unsigned long mant;
   unsigned int mant_bits, mant_off;
   int mant_bits_left;
   unsigned long mant;
   unsigned int mant_bits, mant_off;
   int mant_bits_left;

-  int special_exponent;                /* It's a NaN, denorm or zero */
+  int special_exponent;                /* It's a NaN, denorm or zero.  */

   enum floatformat_byteorders order;
   unsigned char newfrom[FLOATFORMAT_LARGEST_BYTES];
   enum floatformat_byteorders order;
   unsigned char newfrom[FLOATFORMAT_LARGEST_BYTES];

+  enum float_kind kind;

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

+  /* For non-numbers, reuse libiberty's logic to find the correct
+     format.  We do not lose any precision in this case by passing
+     through a double.  */
+  kind = floatformat_classify (fmt, from);
+  if (kind == float_infinite || kind == float_nan)
+    {
+      double dto;
+
+      floatformat_to_double (fmt->split_half ? fmt->split_half : fmt,
+                            from, &dto);
+      *to = (DOUBLEST) dto;
+      return;
+    }
+

   order = floatformat_normalize_byteorder (fmt, ufrom, newfrom);
 
   if (order != fmt->byteorder)
     ufrom = newfrom;
 
   order = floatformat_normalize_byteorder (fmt, ufrom, newfrom);
 
   if (order != fmt->byteorder)
     ufrom = newfrom;
 

+  if (fmt->split_half)
+    {
+      DOUBLEST dtop, dbot;
+
+      floatformat_to_doublest (fmt->split_half, ufrom, &dtop);
+      /* Preserve the sign of 0, which is the sign of the top
+        half.  */
+      if (dtop == 0.0)
+       {
+         *to = dtop;
+         return;
+       }
+      floatformat_to_doublest (fmt->split_half,
+                            ufrom + fmt->totalsize / FLOATFORMAT_CHAR_BIT / 2,
+                            &dbot);
+      *to = dtop + dbot;
+      return;
+    }
+

   exponent = get_field (ufrom, order, fmt->totalsize, fmt->exp_start,
                        fmt->exp_len);
   /* Note that if exponent indicates a NaN, we can't really do anything useful
   exponent = get_field (ufrom, order, fmt->totalsize, fmt->exp_start,
                        fmt->exp_len);
   /* Note that if exponent indicates a NaN, we can't really do anything useful


@@ -183,17 +230,17 @@ convert_floatformat_to_doublest (const struct floatformat *fmt,
 
   special_exponent = exponent == 0 || exponent == fmt->exp_nan;
 
 
   special_exponent = exponent == 0 || exponent == fmt->exp_nan;
 

-  /* Don't bias NaNs. Use minimum exponent for denorms. For simplicity,
-     we don't check for zero as the exponent doesn't matter.  Note the cast
-     to int; exp_bias is unsigned, so it's important to make sure the
-     operation is done in signed arithmetic.  */
+  /* Don't bias NaNs.  Use minimum exponent for denorms.  For
+     simplicity, we don't check for zero as the exponent doesn't matter.
+     Note the cast to int; exp_bias is unsigned, so it's important to
+     make sure the operation is done in signed arithmetic.  */

   if (!special_exponent)
     exponent -= fmt->exp_bias;
   else if (exponent == 0)
     exponent = 1 - fmt->exp_bias;
 
   /* Build the result algebraically.  Might go infinite, underflow, etc;
   if (!special_exponent)
     exponent -= fmt->exp_bias;
   else if (exponent == 0)
     exponent = 1 - fmt->exp_bias;
 
   /* Build the result algebraically.  Might go infinite, underflow, etc;

-     who cares. */
+     who cares.  */

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


@@ -224,10 +271,6 @@ convert_floatformat_to_doublest (const struct floatformat *fmt,
   *to = dto;
 }
 \f
   *to = dto;
 }
 \f

-static void put_field (unsigned char *, enum floatformat_byteorders,
-                      unsigned int,
-                      unsigned int, unsigned int, unsigned long);
-

 /* Set a field which starts at START and is LEN bytes long.  DATA and
    TOTAL_LEN are the thing we are extracting it from, in byteorder ORDER.  */
 static void
 /* Set a field which starts at START and is LEN bytes long.  DATA and
    TOTAL_LEN are the thing we are extracting it from, in byteorder ORDER.  */
 static void


@@ -245,6 +288,7 @@ put_field (unsigned char *data, enum floatformat_byteorders order,
   if (order == floatformat_little)
     {
       int excess = FLOATFORMAT_CHAR_BIT - (total_len % FLOATFORMAT_CHAR_BIT);
   if (order == floatformat_little)
     {
       int excess = FLOATFORMAT_CHAR_BIT - (total_len % FLOATFORMAT_CHAR_BIT);

+

       cur_byte = (total_len / FLOATFORMAT_CHAR_BIT) 
                  - ((start + len + excess) / FLOATFORMAT_CHAR_BIT);
       cur_bitshift = ((start + len + excess) % FLOATFORMAT_CHAR_BIT) 
       cur_byte = (total_len / FLOATFORMAT_CHAR_BIT) 
                  - ((start + len + excess) / FLOATFORMAT_CHAR_BIT);
       cur_bitshift = ((start + len + excess) % FLOATFORMAT_CHAR_BIT) 


@@ -291,60 +335,13 @@ put_field (unsigned char *data, enum floatformat_byteorders order,
     }
 }
 
     }
 }
 

-#ifdef HAVE_LONG_DOUBLE
-/* Return the fractional part of VALUE, and put the exponent of VALUE in *EPTR.
-   The range of the returned value is >= 0.5 and < 1.0.  This is equivalent to
-   frexp, but operates on the long double data type.  */
-
-static long double ldfrexp (long double value, int *eptr);
-
-static long double
-ldfrexp (long double value, int *eptr)
-{
-  long double tmp;
-  int exp;
-
-  /* Unfortunately, there are no portable functions for extracting the exponent
-     of a long double, so we have to do it iteratively by multiplying or dividing
-     by two until the fraction is between 0.5 and 1.0.  */
-
-  if (value < 0.0l)
-    value = -value;
-
-  tmp = 1.0l;
-  exp = 0;
-
-  if (value >= tmp)            /* Value >= 1.0 */
-    while (value >= tmp)
-      {
-       tmp *= 2.0l;
-       exp++;
-      }
-  else if (value != 0.0l)      /* Value < 1.0  and > 0.0 */
-    {
-      while (value < tmp)
-       {
-         tmp /= 2.0l;
-         exp--;
-       }
-      tmp *= 2.0l;
-      exp++;
-    }
-
-  *eptr = exp;
-  return value / tmp;
-}
-#endif /* HAVE_LONG_DOUBLE */
-
-
-/* The converse: convert the DOUBLEST *FROM to an extended float
-   and store where TO points.  Neither FROM nor TO have any alignment
+/* The converse: convert the DOUBLEST *FROM to an extended float and
+   store where TO points.  Neither FROM nor TO have any alignment

    restrictions.  */
 
 static void
    restrictions.  */
 
 static void

-convert_doublest_to_floatformat (CONST struct floatformat *fmt,
-                                const DOUBLEST *from,
-                                void *to)
+convert_doublest_to_floatformat (const struct floatformat *fmt,
+                                const DOUBLEST *from, void *to)

 {
   DOUBLEST dfrom;
   int exponent;
 {
   DOUBLEST dfrom;
   int exponent;


@@ -353,13 +350,42 @@ convert_doublest_to_floatformat (CONST struct floatformat *fmt,
   int mant_bits_left;
   unsigned char *uto = (unsigned char *) to;
   enum floatformat_byteorders order = fmt->byteorder;
   int mant_bits_left;
   unsigned char *uto = (unsigned char *) to;
   enum floatformat_byteorders order = fmt->byteorder;

+  unsigned char newto[FLOATFORMAT_LARGEST_BYTES];

 
 

-  if (order == floatformat_littlebyte_bigword)
+  if (order != floatformat_little)

     order = floatformat_big;
 
     order = floatformat_big;
 

+  if (order != fmt->byteorder)
+    uto = newto;
+

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

+
+  if (fmt->split_half)
+    {
+      /* Use static volatile to ensure that any excess precision is
+        removed via storing in memory, and so the top half really is
+        the result of converting to double.  */
+      static volatile double dtop, dbot;
+      DOUBLEST dtopnv, dbotnv;
+
+      dtop = (double) dfrom;
+      /* If the rounded top half is Inf, the bottom must be 0 not NaN
+        or Inf.  */
+      if (dtop + dtop == dtop && dtop != 0.0)
+       dbot = 0.0;
+      else
+       dbot = (double) (dfrom - (DOUBLEST) dtop);
+      dtopnv = dtop;
+      dbotnv = dbot;
+      floatformat_from_doublest (fmt->split_half, &dtopnv, uto);
+      floatformat_from_doublest (fmt->split_half, &dbotnv,
+                              (uto
+                               + fmt->totalsize / FLOATFORMAT_CHAR_BIT / 2));
+      return;
+    }
+

   if (dfrom == 0)
     return;                    /* Result is zero */
   if (dfrom != dfrom)          /* Result is NaN */
   if (dfrom == 0)
     return;                    /* Result is zero */
   if (dfrom != dfrom)          /* Result is NaN */


@@ -367,9 +393,9 @@ convert_doublest_to_floatformat (CONST struct floatformat *fmt,
       /* From is NaN */
       put_field (uto, order, fmt->totalsize, fmt->exp_start,
                 fmt->exp_len, fmt->exp_nan);
       /* From is NaN */
       put_field (uto, order, fmt->totalsize, fmt->exp_start,
                 fmt->exp_len, fmt->exp_nan);

-      /* Be sure it's not infinity, but NaN value is irrel */
+      /* Be sure it's not infinity, but NaN value is irrel.  */

       put_field (uto, order, fmt->totalsize, fmt->man_start,
       put_field (uto, order, fmt->totalsize, fmt->man_start,

-                32, 1);
+                fmt->man_len, 1);

       goto finalize_byteorder;
     }
 
       goto finalize_byteorder;
     }
 


@@ -380,7 +406,7 @@ convert_doublest_to_floatformat (CONST struct floatformat *fmt,
       dfrom = -dfrom;
     }
 
       dfrom = -dfrom;
     }
 

-  if (dfrom + dfrom == dfrom && dfrom != 0.0)  /* Result is Infinity */
+  if (dfrom + dfrom == dfrom && dfrom != 0.0)  /* Result is Infinity.  */

     {
       /* Infinity exponent is same as NaN's.  */
       put_field (uto, order, fmt->totalsize, fmt->exp_start,
     {
       /* Infinity exponent is same as NaN's.  */
       put_field (uto, order, fmt->totalsize, fmt->exp_start,


@@ -392,11 +418,33 @@ convert_doublest_to_floatformat (CONST struct floatformat *fmt,
     }
 
 #ifdef HAVE_LONG_DOUBLE
     }
 
 #ifdef HAVE_LONG_DOUBLE

-  mant = ldfrexp (dfrom, &exponent);
+  mant = frexpl (dfrom, &exponent);

 #else
   mant = frexp (dfrom, &exponent);
 #endif
 
 #else
   mant = frexp (dfrom, &exponent);
 #endif
 

+  if (exponent + fmt->exp_bias <= 0)
+    {
+      /* The value is too small to be expressed in the destination
+        type (not enough bits in the exponent.  Treat as 0.  */
+      put_field (uto, order, fmt->totalsize, fmt->exp_start,
+                fmt->exp_len, 0);
+      put_field (uto, order, fmt->totalsize, fmt->man_start,
+                fmt->man_len, 0);
+      goto finalize_byteorder;
+    }
+
+  if (exponent + fmt->exp_bias >= (1 << fmt->exp_len))
+    {
+      /* The value is too large to fit into the destination.
+        Treat as infinity.  */
+      put_field (uto, order, fmt->totalsize, fmt->exp_start,
+                fmt->exp_len, fmt->exp_nan);
+      put_field (uto, order, fmt->totalsize, fmt->man_start,
+                fmt->man_len, 0);
+      goto finalize_byteorder;
+    }
+

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


@@ -405,6 +453,7 @@ convert_doublest_to_floatformat (CONST struct floatformat *fmt,
   while (mant_bits_left > 0)
     {
       unsigned long mant_long;
   while (mant_bits_left > 0)
     {
       unsigned long mant_long;

+

       mant_bits = mant_bits_left < 32 ? mant_bits_left : 32;
 
       mant *= 4294967296.0;
       mant_bits = mant_bits_left < 32 ? mant_bits_left : 32;
 
       mant *= 4294967296.0;


@@ -447,24 +496,7 @@ convert_doublest_to_floatformat (CONST struct floatformat *fmt,
  finalize_byteorder:
   /* Do we need to byte-swap the words in the result?  */
   if (order != fmt->byteorder)
  finalize_byteorder:
   /* Do we need to byte-swap the words in the result?  */
   if (order != fmt->byteorder)

-    {
-      int words;
-      unsigned char *curword = uto;
-      unsigned char tmp;
-
-      words = fmt->totalsize / FLOATFORMAT_CHAR_BIT;
-      words >>= 2;
-      while (words-- > 0)
-       {
-         tmp = curword[0];
-         curword[0] = curword[3];
-         curword[3] = tmp;
-         tmp = curword[1];
-         curword[1] = curword[2];
-         curword[2] = tmp;
-         curword += 4;
-       }
-    }
+    floatformat_normalize_byteorder (fmt, newto, to);

 }
 
 /* Check if VAL (which is assumed to be a floating point number whose
 }
 
 /* Check if VAL (which is assumed to be a floating point number whose


@@ -481,6 +513,11 @@ floatformat_is_negative (const struct floatformat *fmt,
   gdb_assert (fmt->totalsize
              <= FLOATFORMAT_LARGEST_BYTES * FLOATFORMAT_CHAR_BIT);
 
   gdb_assert (fmt->totalsize
              <= FLOATFORMAT_LARGEST_BYTES * FLOATFORMAT_CHAR_BIT);
 

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

   order = floatformat_normalize_byteorder (fmt, uval, newfrom);
 
   if (order != fmt->byteorder)
   order = floatformat_normalize_byteorder (fmt, uval, newfrom);
 
   if (order != fmt->byteorder)


@@ -491,9 +528,9 @@ floatformat_is_negative (const struct floatformat *fmt,
 
 /* Check if VAL is "not a number" (NaN) for FMT.  */
 
 
 /* Check if VAL is "not a number" (NaN) for FMT.  */
 

-int
-floatformat_is_nan (const struct floatformat *fmt,
-                   const bfd_byte *uval)
+enum float_kind
+floatformat_classify (const struct floatformat *fmt,
+                     const bfd_byte *uval)

 {
   long exponent;
   unsigned long mant;
 {
   long exponent;
   unsigned long mant;


@@ -501,28 +538,31 @@ floatformat_is_nan (const struct floatformat *fmt,
   int mant_bits_left;
   enum floatformat_byteorders order;
   unsigned char newfrom[FLOATFORMAT_LARGEST_BYTES];
   int mant_bits_left;
   enum floatformat_byteorders order;
   unsigned char newfrom[FLOATFORMAT_LARGEST_BYTES];

+  int mant_zero;

   
   gdb_assert (fmt != NULL);
   gdb_assert (fmt->totalsize
              <= FLOATFORMAT_LARGEST_BYTES * FLOATFORMAT_CHAR_BIT);
 
   
   gdb_assert (fmt != NULL);
   gdb_assert (fmt->totalsize
              <= FLOATFORMAT_LARGEST_BYTES * FLOATFORMAT_CHAR_BIT);
 

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

   order = floatformat_normalize_byteorder (fmt, uval, newfrom);
 
   if (order != fmt->byteorder)
     uval = newfrom;
 
   order = floatformat_normalize_byteorder (fmt, uval, newfrom);
 
   if (order != fmt->byteorder)
     uval = newfrom;
 

-  if (! fmt->exp_nan)
-    return 0;
-

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

-  if (exponent != fmt->exp_nan)
-    return 0;
-

   mant_bits_left = fmt->man_len;
   mant_off = fmt->man_start;
 
   mant_bits_left = fmt->man_len;
   mant_off = fmt->man_start;
 

+  mant_zero = 1;

   while (mant_bits_left > 0)
     {
       mant_bits = min (mant_bits_left, 32);
   while (mant_bits_left > 0)
     {
       mant_bits = min (mant_bits_left, 32);


@@ -535,13 +575,40 @@ floatformat_is_nan (const struct floatformat *fmt,
        mant &= ~(1 << (mant_bits - 1));
 
       if (mant)
        mant &= ~(1 << (mant_bits - 1));
 
       if (mant)

-       return 1;
+       {
+         mant_zero = 0;
+         break;
+       }

 
       mant_off += mant_bits;
       mant_bits_left -= mant_bits;
     }
 
 
       mant_off += mant_bits;
       mant_bits_left -= mant_bits;
     }
 

-  return 0;
+  /* If exp_nan is not set, assume that inf, NaN, and subnormals are not
+     supported.  */
+  if (! fmt->exp_nan)
+    {
+      if (mant_zero)
+       return float_zero;
+      else
+       return float_normal;
+    }
+
+  if (exponent == 0 && !mant_zero)
+    return float_subnormal;
+
+  if (exponent == fmt->exp_nan)
+    {
+      if (mant_zero)
+       return float_infinite;
+      else
+       return float_nan;
+    }
+
+  if (mant_zero)
+    return float_zero;
+
+  return float_normal;

 }
 
 /* Convert the mantissa of VAL (which is assumed to be a floating
 }
 
 /* Convert the mantissa of VAL (which is assumed to be a floating


@@ -558,6 +625,7 @@ floatformat_mantissa (const struct floatformat *fmt,
   int mant_bits_left;
   static char res[50];
   char buf[9];
   int mant_bits_left;
   static char res[50];
   char buf[9];

+  int len;

   enum floatformat_byteorders order;
   unsigned char newfrom[FLOATFORMAT_LARGEST_BYTES];
   
   enum floatformat_byteorders order;
   unsigned char newfrom[FLOATFORMAT_LARGEST_BYTES];
   


@@ -565,6 +633,16 @@ floatformat_mantissa (const struct floatformat *fmt,
   gdb_assert (fmt->totalsize
              <= FLOATFORMAT_LARGEST_BYTES * FLOATFORMAT_CHAR_BIT);
 
   gdb_assert (fmt->totalsize
              <= FLOATFORMAT_LARGEST_BYTES * FLOATFORMAT_CHAR_BIT);
 

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

   order = floatformat_normalize_byteorder (fmt, uval, newfrom);
 
   if (order != fmt->byteorder)
   order = floatformat_normalize_byteorder (fmt, uval, newfrom);
 
   if (order != fmt->byteorder)


@@ -582,16 +660,17 @@ floatformat_mantissa (const struct floatformat *fmt,
 
   mant = get_field (uval, order, fmt->totalsize, mant_off, mant_bits);
 
 
   mant = get_field (uval, order, fmt->totalsize, mant_off, mant_bits);
 

-  sprintf (res, "%lx", mant);
+  len = xsnprintf (res, sizeof res, "%lx", mant);

 
   mant_off += mant_bits;
   mant_bits_left -= mant_bits;
 
   mant_off += mant_bits;
   mant_bits_left -= mant_bits;

-  
+

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

-      sprintf (buf, "%08lx", mant);
+      xsnprintf (buf, sizeof buf, "%08lx", mant);
+      gdb_assert (len + strlen (buf) <= sizeof res);

       strcat (res, buf);
 
       mant_off += 32;
       strcat (res, buf);
 
       mant_off += 32;


@@ -611,7 +690,8 @@ floatformat_mantissa (const struct floatformat *fmt,
 
 static const struct floatformat *host_float_format = GDB_HOST_FLOAT_FORMAT;
 static const struct floatformat *host_double_format = GDB_HOST_DOUBLE_FORMAT;
 
 static const struct floatformat *host_float_format = GDB_HOST_FLOAT_FORMAT;
 static const struct floatformat *host_double_format = GDB_HOST_DOUBLE_FORMAT;

-static const struct floatformat *host_long_double_format = GDB_HOST_LONG_DOUBLE_FORMAT;
+static const struct floatformat *host_long_double_format
+  = GDB_HOST_LONG_DOUBLE_FORMAT;

 
 void
 floatformat_to_doublest (const struct floatformat *fmt,
 
 void
 floatformat_to_doublest (const struct floatformat *fmt,


@@ -621,18 +701,21 @@ floatformat_to_doublest (const struct floatformat *fmt,
   if (fmt == host_float_format)
     {
       float val;
   if (fmt == host_float_format)
     {
       float val;

+

       memcpy (&val, in, sizeof (val));
       *out = val;
     }
   else if (fmt == host_double_format)
     {
       double val;
       memcpy (&val, in, sizeof (val));
       *out = val;
     }
   else if (fmt == host_double_format)
     {
       double val;

+

       memcpy (&val, in, sizeof (val));
       *out = val;
     }
   else if (fmt == host_long_double_format)
     {
       long double val;
       memcpy (&val, in, sizeof (val));
       *out = val;
     }
   else if (fmt == host_long_double_format)
     {
       long double val;

+

       memcpy (&val, in, sizeof (val));
       *out = val;
     }
       memcpy (&val, in, sizeof (val));
       *out = val;
     }


@@ -648,16 +731,19 @@ floatformat_from_doublest (const struct floatformat *fmt,
   if (fmt == host_float_format)
     {
       float val = *in;
   if (fmt == host_float_format)
     {
       float val = *in;

+

       memcpy (out, &val, sizeof (val));
     }
   else if (fmt == host_double_format)
     {
       double val = *in;
       memcpy (out, &val, sizeof (val));
     }
   else if (fmt == host_double_format)
     {
       double val = *in;

+

       memcpy (out, &val, sizeof (val));
     }
   else if (fmt == host_long_double_format)
     {
       long double val = *in;
       memcpy (out, &val, sizeof (val));
     }
   else if (fmt == host_long_double_format)
     {
       long double val = *in;

+

       memcpy (out, &val, sizeof (val));
     }
   else
       memcpy (out, &val, sizeof (val));
     }
   else


@@ -679,27 +765,35 @@ floatformat_from_doublest (const struct floatformat *fmt,
    but not passed on by GDB.  This should be fixed.  */
 
 static const struct floatformat *
    but not passed on by GDB.  This should be fixed.  */
 
 static const struct floatformat *

-floatformat_from_length (int len)
+floatformat_from_length (struct gdbarch *gdbarch, int len)

 {
   const struct floatformat *format;
 {
   const struct floatformat *format;

-  if (len * TARGET_CHAR_BIT == TARGET_FLOAT_BIT)
-    format = TARGET_FLOAT_FORMAT;
-  else if (len * TARGET_CHAR_BIT == TARGET_DOUBLE_BIT)
-    format = TARGET_DOUBLE_FORMAT;
-  else if (len * TARGET_CHAR_BIT == TARGET_LONG_DOUBLE_BIT)
-    format = TARGET_LONG_DOUBLE_FORMAT;
+
+  if (len * TARGET_CHAR_BIT == gdbarch_half_bit (gdbarch))
+    format = gdbarch_half_format (gdbarch)
+              [gdbarch_byte_order (gdbarch)];
+  else if (len * TARGET_CHAR_BIT == gdbarch_float_bit (gdbarch))
+    format = gdbarch_float_format (gdbarch)
+              [gdbarch_byte_order (gdbarch)];
+  else if (len * TARGET_CHAR_BIT == gdbarch_double_bit (gdbarch))
+    format = gdbarch_double_format (gdbarch)
+              [gdbarch_byte_order (gdbarch)];
+  else if (len * TARGET_CHAR_BIT == gdbarch_long_double_bit (gdbarch))
+    format = gdbarch_long_double_format (gdbarch)
+              [gdbarch_byte_order (gdbarch)];

   /* On i386 the 'long double' type takes 96 bits,
      while the real number of used bits is only 80,
   /* On i386 the 'long double' type takes 96 bits,
      while the real number of used bits is only 80,

-     both in processor and in memory.  
+     both in processor and in memory.

      The code below accepts the real bit size.  */ 
      The code below accepts the real bit size.  */ 

-  else if ((TARGET_LONG_DOUBLE_FORMAT != NULL) 
-          && (len * TARGET_CHAR_BIT ==
-               TARGET_LONG_DOUBLE_FORMAT->totalsize))
-    format = TARGET_LONG_DOUBLE_FORMAT;
+  else if ((gdbarch_long_double_format (gdbarch) != NULL)
+          && (len * TARGET_CHAR_BIT
+               == gdbarch_long_double_format (gdbarch)[0]->totalsize))
+    format = gdbarch_long_double_format (gdbarch)
+              [gdbarch_byte_order (gdbarch)];

   else
     format = NULL;
   if (format == NULL)
   else
     format = NULL;
   if (format == NULL)

-    error ("Unrecognized %d-bit floating-point type.",
+    error (_("Unrecognized %d-bit floating-point type."),

           len * TARGET_CHAR_BIT);
   return format;
 }
           len * TARGET_CHAR_BIT);
   return format;
 }


@@ -707,52 +801,13 @@ floatformat_from_length (int len)
 const struct floatformat *
 floatformat_from_type (const struct type *type)
 {
 const struct floatformat *
 floatformat_from_type (const struct type *type)
 {

+  struct gdbarch *gdbarch = get_type_arch (type);
+

   gdb_assert (TYPE_CODE (type) == TYPE_CODE_FLT);
   if (TYPE_FLOATFORMAT (type) != NULL)
   gdb_assert (TYPE_CODE (type) == TYPE_CODE_FLT);
   if (TYPE_FLOATFORMAT (type) != NULL)

-    return TYPE_FLOATFORMAT (type);
+    return TYPE_FLOATFORMAT (type)[gdbarch_byte_order (gdbarch)];

   else
   else

-    return floatformat_from_length (TYPE_LENGTH (type));
-}
-
-/* If the host doesn't define NAN, use zero instead.  */
-#ifndef NAN
-#define NAN 0.0
-#endif
-
-/* Extract a floating-point number of length LEN from a target-order
-   byte-stream at ADDR.  Returns the value as type DOUBLEST.  */
-
-static DOUBLEST
-extract_floating_by_length (const void *addr, int len)
-{
-  const struct floatformat *fmt = floatformat_from_length (len);
-  DOUBLEST val;
-
-  floatformat_to_doublest (fmt, addr, &val);
-  return val;
-}
-
-DOUBLEST
-deprecated_extract_floating (const void *addr, int len)
-{
-  return extract_floating_by_length (addr, len);
-}
-
-/* Store VAL as a floating-point number of length LEN to a
-   target-order byte-stream at ADDR.  */
-
-static void
-store_floating_by_length (void *addr, int len, DOUBLEST val)
-{
-  const struct floatformat *fmt = floatformat_from_length (len);
-
-  floatformat_from_doublest (fmt, &val, addr);
-}
-
-void
-deprecated_store_floating (void *addr, int len, DOUBLEST val)
-{
-  store_floating_by_length (addr, len, val);
+    return floatformat_from_length (gdbarch, TYPE_LENGTH (type));

 }
 
 /* Extract a floating-point number of type TYPE from a target-order
 }
 
 /* Extract a floating-point number of type TYPE from a target-order


@@ -761,16 +816,10 @@ deprecated_store_floating (void *addr, int len, DOUBLEST val)
 DOUBLEST
 extract_typed_floating (const void *addr, const struct type *type)
 {
 DOUBLEST
 extract_typed_floating (const void *addr, const struct type *type)
 {

+  const struct floatformat *fmt = floatformat_from_type (type);

   DOUBLEST retval;
 
   DOUBLEST retval;
 

-  gdb_assert (TYPE_CODE (type) == TYPE_CODE_FLT);
-
-  if (TYPE_FLOATFORMAT (type) == NULL)
-    /* Not all code remembers to set the FLOATFORMAT (language
-       specific code? stabs?) so handle that here as a special case.  */
-    return extract_floating_by_length (addr, TYPE_LENGTH (type));
-
-  floatformat_to_doublest (TYPE_FLOATFORMAT (type), addr, &retval);
+  floatformat_to_doublest (fmt, addr, &retval);

   return retval;
 }
 
   return retval;
 }
 


@@ -780,7 +829,7 @@ extract_typed_floating (const void *addr, const struct type *type)
 void
 store_typed_floating (void *addr, const struct type *type, DOUBLEST val)
 {
 void
 store_typed_floating (void *addr, const struct type *type, DOUBLEST val)
 {

-  gdb_assert (TYPE_CODE (type) == TYPE_CODE_FLT);
+  const struct floatformat *fmt = floatformat_from_type (type);

 
   /* FIXME: kettenis/2001-10-28: It is debatable whether we should
      zero out any remaining bytes in the target buffer when TYPE is
 
   /* FIXME: kettenis/2001-10-28: It is debatable whether we should
      zero out any remaining bytes in the target buffer when TYPE is


@@ -802,12 +851,7 @@ store_typed_floating (void *addr, const struct type *type, DOUBLEST val)
      See also the function convert_typed_floating below.  */
   memset (addr, 0, TYPE_LENGTH (type));
 
      See also the function convert_typed_floating below.  */
   memset (addr, 0, TYPE_LENGTH (type));
 

-  if (TYPE_FLOATFORMAT (type) == NULL)
-    /* Not all code remembers to set the FLOATFORMAT (language
-       specific code? stabs?) so handle that here as a special case.  */
-    store_floating_by_length (addr, TYPE_LENGTH (type), val);
-  else
-    floatformat_from_doublest (TYPE_FLOATFORMAT (type), &val, addr);
+  floatformat_from_doublest (fmt, &val, addr);

 }
 
 /* Convert a floating-point number of type FROM_TYPE from a
 }
 
 /* Convert a floating-point number of type FROM_TYPE from a


@@ -821,9 +865,6 @@ convert_typed_floating (const void *from, const struct type *from_type,
   const struct floatformat *from_fmt = floatformat_from_type (from_type);
   const struct floatformat *to_fmt = floatformat_from_type (to_type);
 
   const struct floatformat *from_fmt = floatformat_from_type (from_type);
   const struct floatformat *to_fmt = floatformat_from_type (to_type);
 

-  gdb_assert (TYPE_CODE (from_type) == TYPE_CODE_FLT);
-  gdb_assert (TYPE_CODE (to_type) == TYPE_CODE_FLT);
-

   if (from_fmt == NULL || to_fmt == NULL)
     {
       /* If we don't know the floating-point format of FROM_TYPE or
   if (from_fmt == NULL || to_fmt == NULL)
     {
       /* If we don't know the floating-point format of FROM_TYPE or


@@ -833,7 +874,7 @@ convert_typed_floating (const void *from, const struct type *from_type,
          assumption might be wrong on targets that support
          floating-point types that only differ in endianness for
          example.  So we warn instead, and zero out the target buffer.  */
          assumption might be wrong on targets that support
          floating-point types that only differ in endianness for
          example.  So we warn instead, and zero out the target buffer.  */

-      warning ("Can't convert floating-point number to desired type.");
+      warning (_("Can't convert floating-point number to desired type."));

       memset (to, 0, TYPE_LENGTH (to_type));
     }
   else if (from_fmt == to_fmt)
       memset (to, 0, TYPE_LENGTH (to_type));
     }
   else if (from_fmt == to_fmt)


@@ -850,7 +891,7 @@ convert_typed_floating (const void *from, const struct type *from_type,
   else
     {
       /* The floating-point types don't match.  The best we can do
   else
     {
       /* The floating-point types don't match.  The best we can do

-         (aport from simulating the target FPU) is converting to the
+         (apart from simulating the target FPU) is converting to the

          widest floating-point type supported by the host, and then
          again to the desired type.  */
       DOUBLEST d;
          widest floating-point type supported by the host, and then
          again to the desired type.  */
       DOUBLEST d;


@@ -859,26 +900,3 @@ convert_typed_floating (const void *from, const struct type *from_type,
       floatformat_from_doublest (to_fmt, &d, to);
     }
 }
       floatformat_from_doublest (to_fmt, &d, to);
     }
 }

-
-const struct floatformat *floatformat_ieee_single[BFD_ENDIAN_UNKNOWN];
-const struct floatformat *floatformat_ieee_double[BFD_ENDIAN_UNKNOWN];
-const struct floatformat *floatformat_ieee_quad[BFD_ENDIAN_UNKNOWN];
-const struct floatformat *floatformat_arm_ext[BFD_ENDIAN_UNKNOWN];
-const struct floatformat *floatformat_ia64_spill[BFD_ENDIAN_UNKNOWN];
-
-extern void _initialize_doublest (void);
-
-extern void
-_initialize_doublest (void)
-{
-  floatformat_ieee_single[BFD_ENDIAN_LITTLE] = &floatformat_ieee_single_little;
-  floatformat_ieee_single[BFD_ENDIAN_BIG] = &floatformat_ieee_single_big;
-  floatformat_ieee_double[BFD_ENDIAN_LITTLE] = &floatformat_ieee_double_little;
-  floatformat_ieee_double[BFD_ENDIAN_BIG] = &floatformat_ieee_double_big;
-  floatformat_arm_ext[BFD_ENDIAN_LITTLE] = &floatformat_arm_ext_littlebyte_bigword;
-  floatformat_arm_ext[BFD_ENDIAN_BIG] = &floatformat_arm_ext_big;
-  floatformat_ia64_spill[BFD_ENDIAN_LITTLE] = &floatformat_ia64_spill_little;
-  floatformat_ia64_spill[BFD_ENDIAN_BIG] = &floatformat_ia64_spill_big;
-  floatformat_ieee_quad[BFD_ENDIAN_LITTLE] = &floatformat_ia64_quad_little;
-  floatformat_ieee_quad[BFD_ENDIAN_BIG] = &floatformat_ia64_quad_big;
-}