Switch the license of all .c files to GPLv3.

[thirdparty/binutils-gdb.git] / gdb / doublest.c

diff --git a/gdb/doublest.c b/gdb/doublest.c
index 6e96d78f0c0bc12ba519d458acd000497aed29b4..c7ca993b24f5f4d647eec58a4a84b39d5f7a9bd7 100644 (file)
--- a/gdb/doublest.c
+++ b/gdb/doublest.c
@@ -1,13 +1,14 @@
 /* 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
+
+   Copyright (C) 1986, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
+   1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2007

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

-   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,


@@ -16,9 +17,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.  */
 


@@ -39,22 +38,25 @@
    a system header, what we do if not, etc.  */
 #define FLOATFORMAT_CHAR_BIT 8
 
    a system header, what we do if not, etc.  */
 #define FLOATFORMAT_CHAR_BIT 8
 

-static unsigned long get_field (unsigned char *,
-                               enum floatformat_byteorders,
-                               unsigned int, unsigned int, unsigned int);
+/* The number of bytes that the largest floating-point type that we
+   can convert to doublest will need.  */
+#define FLOATFORMAT_LARGEST_BYTES 16

 
 /* Extract 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 unsigned long
 
 /* Extract 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 unsigned long

-get_field (unsigned char *data, enum floatformat_byteorders order,
+get_field (const bfd_byte *data, enum floatformat_byteorders order,

           unsigned int total_len, unsigned int start, unsigned int len)
 {
   unsigned long result;
   unsigned int cur_byte;
   int cur_bitshift;
 
           unsigned int total_len, unsigned int start, unsigned int len)
 {
   unsigned long result;
   unsigned int cur_byte;
   int cur_bitshift;
 

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

   /* Start at the least significant part of the field.  */
   /* Start at the least significant part of the field.  */

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

     {
       /* 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


@@ -80,7 +82,7 @@ get_field (unsigned char *data, enum floatformat_byteorders order,
   else
     result = 0;
   cur_bitshift += FLOATFORMAT_CHAR_BIT;
   else
     result = 0;
   cur_bitshift += FLOATFORMAT_CHAR_BIT;

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

     ++cur_byte;
   else
     --cur_byte;
     ++cur_byte;
   else
     --cur_byte;


@@ -90,10 +92,15 @@ get_field (unsigned char *data, enum floatformat_byteorders order,
     {
       result |= (unsigned long)*(data + cur_byte) << cur_bitshift;
       cur_bitshift += FLOATFORMAT_CHAR_BIT;
     {
       result |= (unsigned long)*(data + cur_byte) << cur_bitshift;
       cur_bitshift += FLOATFORMAT_CHAR_BIT;

-      if (order == floatformat_little || order == floatformat_littlebyte_bigword)
-       ++cur_byte;
-      else
-       --cur_byte;
+      switch (order)
+       {
+       case floatformat_little:
+         ++cur_byte;
+         break;
+       case floatformat_big:
+         --cur_byte;
+         break;
+       }

     }
   if (len < sizeof(result) * FLOATFORMAT_CHAR_BIT)
     /* Mask out bits which are not part of the field */
     }
   if (len < sizeof(result) * FLOATFORMAT_CHAR_BIT)
     /* Mask out bits which are not part of the field */


@@ -101,6 +108,58 @@ get_field (unsigned char *data, enum floatformat_byteorders order,
   return result;
 }
 
   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.  */
+
+static enum floatformat_byteorders
+floatformat_normalize_byteorder (const struct floatformat *fmt,
+                                const void *from, void *to)
+{
+  const unsigned char *swapin;
+  unsigned char *swapout;
+  int words;
+  
+  if (fmt->byteorder == floatformat_little
+      || fmt->byteorder == floatformat_big)
+    return fmt->byteorder;
+
+  words = fmt->totalsize / FLOATFORMAT_CHAR_BIT;
+  words >>= 2;
+
+  swapout = (unsigned char *)to;
+  swapin = (const unsigned char *)from;
+
+  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
+    {
+      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;
+    }
+}
+  

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


@@ -117,51 +176,32 @@ convert_floatformat_to_doublest (const struct floatformat *fmt,
   unsigned int mant_bits, mant_off;
   int mant_bits_left;
   int special_exponent;                /* It's a NaN, denorm or zero */
   unsigned int mant_bits, mant_off;
   int mant_bits_left;
   int special_exponent;                /* It's a NaN, denorm or zero */

-
-  /* If the mantissa bits are not contiguous from one end of the
-     mantissa to the other, we need to make a private copy of the
-     source bytes that is in the right order since the unpacking
-     algorithm assumes that the bits are contiguous.
-
-     Swap the bytes individually rather than accessing them through
-     "long *" since we have no guarantee that they start on a long
-     alignment, and also sizeof(long) for the host could be different
-     than sizeof(long) for the target.  FIXME: Assumes sizeof(long)
-     for the target is 4. */
-
-  if (fmt->byteorder == floatformat_littlebyte_bigword)
+  enum floatformat_byteorders order;
+  unsigned char newfrom[FLOATFORMAT_LARGEST_BYTES];
+  enum float_kind kind;
+  
+  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)

     {
     {

-      static unsigned char *newfrom;
-      unsigned char *swapin, *swapout;
-      int longswaps;
+      double dto;
+      floatformat_to_double (fmt, from, &dto);
+      *to = (DOUBLEST) dto;
+      return;
+    }

 
 

-      longswaps = fmt->totalsize / FLOATFORMAT_CHAR_BIT;
-      longswaps >>= 3;
+  order = floatformat_normalize_byteorder (fmt, ufrom, newfrom);

 
 

-      if (newfrom == NULL)
-       {
-         newfrom = (unsigned char *) xmalloc (fmt->totalsize);
-       }
-      swapout = newfrom;
-      swapin = ufrom;
-      ufrom = newfrom;
-      while (longswaps-- > 0)
-       {
-         /* This is ugly, but efficient */
-         *swapout++ = swapin[4];
-         *swapout++ = swapin[5];
-         *swapout++ = swapin[6];
-         *swapout++ = swapin[7];
-         *swapout++ = swapin[0];
-         *swapout++ = swapin[1];
-         *swapout++ = swapin[2];
-         *swapout++ = swapin[3];
-         swapin += 8;
-       }
-    }
+  if (order != fmt->byteorder)
+    ufrom = newfrom;

 
 

-  exponent = get_field (ufrom, fmt->byteorder, fmt->totalsize,
-                       fmt->exp_start, fmt->exp_len);
+  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
      (not knowing if the host has NaN's, or how to build one).  So it will
      end up as an infinity or something close; that is OK.  */
   /* Note that if exponent indicates a NaN, we can't really do anything useful
      (not knowing if the host has NaN's, or how to build one).  So it will
      end up as an infinity or something close; that is OK.  */


@@ -172,8 +212,10 @@ 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. */
+  /* 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)
   if (!special_exponent)
     exponent -= fmt->exp_bias;
   else if (exponent == 0)


@@ -197,8 +239,7 @@ convert_floatformat_to_doublest (const struct floatformat *fmt,
     {
       mant_bits = min (mant_bits_left, 32);
 
     {
       mant_bits = min (mant_bits_left, 32);
 

-      mant = get_field (ufrom, fmt->byteorder, fmt->totalsize,
-                       mant_off, mant_bits);
+      mant = get_field (ufrom, order, fmt->totalsize, mant_off, mant_bits);

 
       dto += ldexp ((double) mant, exponent - mant_bits);
       exponent -= mant_bits;
 
       dto += ldexp ((double) mant, exponent - mant_bits);
       exponent -= mant_bits;


@@ -207,7 +248,7 @@ convert_floatformat_to_doublest (const struct floatformat *fmt,
     }
 
   /* Negate it if negative.  */
     }
 
   /* Negate it if negative.  */

-  if (get_field (ufrom, fmt->byteorder, fmt->totalsize, fmt->sign_start, 1))
+  if (get_field (ufrom, order, fmt->totalsize, fmt->sign_start, 1))

     dto = -dto;
   *to = dto;
 }
     dto = -dto;
   *to = dto;
 }


@@ -226,8 +267,11 @@ put_field (unsigned char *data, enum floatformat_byteorders order,
   unsigned int cur_byte;
   int cur_bitshift;
 
   unsigned int cur_byte;
   int cur_bitshift;
 

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

   /* Start at the least significant part of the field.  */
   /* Start at the least significant part of the field.  */

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

     {
       int excess = FLOATFORMAT_CHAR_BIT - (total_len % FLOATFORMAT_CHAR_BIT);
       cur_byte = (total_len / FLOATFORMAT_CHAR_BIT) 
     {
       int excess = FLOATFORMAT_CHAR_BIT - (total_len % FLOATFORMAT_CHAR_BIT);
       cur_byte = (total_len / FLOATFORMAT_CHAR_BIT) 


@@ -250,7 +294,7 @@ put_field (unsigned char *data, enum floatformat_byteorders order,
        (stuff_to_put & ((1 << FLOATFORMAT_CHAR_BIT) - 1)) << (-cur_bitshift);
     }
   cur_bitshift += FLOATFORMAT_CHAR_BIT;
        (stuff_to_put & ((1 << FLOATFORMAT_CHAR_BIT) - 1)) << (-cur_bitshift);
     }
   cur_bitshift += FLOATFORMAT_CHAR_BIT;

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

     ++cur_byte;
   else
     --cur_byte;
     ++cur_byte;
   else
     --cur_byte;


@@ -269,7 +313,7 @@ put_field (unsigned char *data, enum floatformat_byteorders order,
        *(data + cur_byte) = ((stuff_to_put >> cur_bitshift)
                              & ((1 << FLOATFORMAT_CHAR_BIT) - 1));
       cur_bitshift += FLOATFORMAT_CHAR_BIT;
        *(data + cur_byte) = ((stuff_to_put >> cur_bitshift)
                              & ((1 << FLOATFORMAT_CHAR_BIT) - 1));
       cur_bitshift += FLOATFORMAT_CHAR_BIT;

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

        ++cur_byte;
       else
        --cur_byte;
        ++cur_byte;
       else
        --cur_byte;


@@ -322,14 +366,13 @@ ldfrexp (long double value, int *eptr)
 #endif /* HAVE_LONG_DOUBLE */
 
 
 #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
 convert_doublest_to_floatformat (CONST struct floatformat *fmt,
    restrictions.  */
 
 static void
 convert_doublest_to_floatformat (CONST struct floatformat *fmt,

-                                const DOUBLEST *from,
-                                void *to)
+                                const DOUBLEST *from, void *to)

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


@@ -337,6 +380,14 @@ convert_doublest_to_floatformat (CONST struct floatformat *fmt,
   unsigned int mant_bits, mant_off;
   int mant_bits_left;
   unsigned char *uto = (unsigned char *) to;
   unsigned int mant_bits, mant_off;
   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_little)
+    order = floatformat_big;
+
+  if (order != fmt->byteorder)
+    uto = newto;

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


@@ -346,30 +397,30 @@ convert_doublest_to_floatformat (CONST struct floatformat *fmt,
   if (dfrom != dfrom)          /* Result is NaN */
     {
       /* From is NaN */
   if (dfrom != dfrom)          /* Result is NaN */
     {
       /* From is NaN */

-      put_field (uto, fmt->byteorder, fmt->totalsize, fmt->exp_start,
+      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 */
                 fmt->exp_len, fmt->exp_nan);
       /* Be sure it's not infinity, but NaN value is irrel */

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

                 32, 1);
                 32, 1);

-      return;
+      goto finalize_byteorder;

     }
 
   /* If negative, set the sign bit.  */
   if (dfrom < 0)
     {
     }
 
   /* If negative, set the sign bit.  */
   if (dfrom < 0)
     {

-      put_field (uto, fmt->byteorder, fmt->totalsize, fmt->sign_start, 1, 1);
+      put_field (uto, order, fmt->totalsize, fmt->sign_start, 1, 1);

       dfrom = -dfrom;
     }
 
   if (dfrom + dfrom == dfrom && dfrom != 0.0)  /* Result is Infinity */
     {
       /* Infinity exponent is same as NaN's.  */
       dfrom = -dfrom;
     }
 
   if (dfrom + dfrom == dfrom && dfrom != 0.0)  /* Result is Infinity */
     {
       /* Infinity exponent is same as NaN's.  */

-      put_field (uto, fmt->byteorder, fmt->totalsize, fmt->exp_start,
+      put_field (uto, order, fmt->totalsize, fmt->exp_start,

                 fmt->exp_len, fmt->exp_nan);
       /* Infinity mantissa is all zeroes.  */
                 fmt->exp_len, fmt->exp_nan);
       /* Infinity mantissa is all zeroes.  */

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

                 fmt->man_len, 0);
                 fmt->man_len, 0);

-      return;
+      goto finalize_byteorder;

     }
 
 #ifdef HAVE_LONG_DOUBLE
     }
 
 #ifdef HAVE_LONG_DOUBLE


@@ -378,7 +429,7 @@ convert_doublest_to_floatformat (CONST struct floatformat *fmt,
   mant = frexp (dfrom, &exponent);
 #endif
 
   mant = frexp (dfrom, &exponent);
 #endif
 

-  put_field (uto, fmt->byteorder, fmt->totalsize, fmt->exp_start, fmt->exp_len,
+  put_field (uto, order, fmt->totalsize, fmt->exp_start, fmt->exp_len,

             exponent + fmt->exp_bias - 1);
 
   mant_bits_left = fmt->man_len;
             exponent + fmt->exp_bias - 1);
 
   mant_bits_left = fmt->man_len;


@@ -401,7 +452,15 @@ convert_doublest_to_floatformat (CONST struct floatformat *fmt,
        {
          mant_long <<= 1;
          mant_long &= 0xffffffffL;
        {
          mant_long <<= 1;
          mant_long &= 0xffffffffL;

-         mant_bits -= 1;
+          /* If we are processing the top 32 mantissa bits of a doublest
+             so as to convert to a float value with implied integer bit,
+             we will only be putting 31 of those 32 bits into the
+             final value due to the discarding of the top bit.  In the 
+             case of a small float value where the number of mantissa 
+             bits is less than 32, discarding the top bit does not alter
+             the number of bits we will be adding to the result.  */
+          if (mant_bits == 32)
+            mant_bits -= 1;

        }
 
       if (mant_bits < 32)
        }
 
       if (mant_bits < 32)


@@ -411,69 +470,75 @@ convert_doublest_to_floatformat (CONST struct floatformat *fmt,
          mant_long >>= 32 - mant_bits;
        }
 
          mant_long >>= 32 - mant_bits;
        }
 

-      put_field (uto, fmt->byteorder, fmt->totalsize,
+      put_field (uto, order, fmt->totalsize,

                 mant_off, mant_bits, mant_long);
       mant_off += mant_bits;
       mant_bits_left -= mant_bits;
     }
                 mant_off, mant_bits, mant_long);
       mant_off += mant_bits;
       mant_bits_left -= mant_bits;
     }

-  if (fmt->byteorder == floatformat_littlebyte_bigword)
-    {
-      int count;
-      unsigned char *swaplow = uto;
-      unsigned char *swaphigh = uto + 4;
-      unsigned char tmp;

 
 

-      for (count = 0; count < 4; count++)
-       {
-         tmp = *swaplow;
-         *swaplow++ = *swaphigh;
-         *swaphigh++ = tmp;
-       }
-    }
+ finalize_byteorder:
+  /* Do we need to byte-swap the words in the result?  */
+  if (order != fmt->byteorder)
+    floatformat_normalize_byteorder (fmt, newto, to);

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

-floatformat_is_negative (const struct floatformat *fmt, char *val)
+floatformat_is_negative (const struct floatformat *fmt,
+                        const bfd_byte *uval)

 {
 {

-  unsigned char *uval = (unsigned char *) val;
+  enum floatformat_byteorders order;
+  unsigned char newfrom[FLOATFORMAT_LARGEST_BYTES];
+  

   gdb_assert (fmt != NULL);
   gdb_assert (fmt != NULL);

-  return get_field (uval, fmt->byteorder, fmt->totalsize, fmt->sign_start, 1);
+  gdb_assert (fmt->totalsize
+             <= FLOATFORMAT_LARGEST_BYTES * FLOATFORMAT_CHAR_BIT);
+
+  order = floatformat_normalize_byteorder (fmt, uval, newfrom);
+
+  if (order != fmt->byteorder)
+    uval = newfrom;
+
+  return get_field (uval, order, fmt->totalsize, fmt->sign_start, 1);

 }
 
 /* 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, char *val)
+enum float_kind
+floatformat_classify (const struct floatformat *fmt,
+                     const bfd_byte *uval)

 {
 {

-  unsigned char *uval = (unsigned char *) val;

   long exponent;
   unsigned long mant;
   unsigned int mant_bits, mant_off;
   int mant_bits_left;
   long exponent;
   unsigned long mant;
   unsigned int mant_bits, mant_off;
   int mant_bits_left;

-
+  enum floatformat_byteorders order;
+  unsigned char newfrom[FLOATFORMAT_LARGEST_BYTES];
+  int mant_zero;
+  

   gdb_assert (fmt != NULL);
   gdb_assert (fmt != NULL);

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

 
 

-  if (! fmt->exp_nan)
-    return 0;
+  order = floatformat_normalize_byteorder (fmt, uval, newfrom);

 
 

-  exponent = get_field (uval, fmt->byteorder, fmt->totalsize,
-                       fmt->exp_start, fmt->exp_len);
+  if (order != fmt->byteorder)
+    uval = newfrom;

 
 

-  if (exponent != fmt->exp_nan)
-    return 0;
+  exponent = get_field (uval, order, fmt->totalsize, fmt->exp_start,
+                       fmt->exp_len);

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

-      mant = get_field (uval, fmt->byteorder, fmt->totalsize,
-                       mant_off, mant_bits);
+      mant = get_field (uval, order, fmt->totalsize, mant_off, mant_bits);

 
       /* If there is an explicit integer bit, mask it off.  */
       if (mant_off == fmt->man_start
 
       /* If there is an explicit integer bit, mask it off.  */
       if (mant_off == fmt->man_start


@@ -481,21 +546,49 @@ floatformat_is_nan (const struct floatformat *fmt, char *val)
        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
    point number whose format is described by FMT) into a hexadecimal
    and store it in a static string.  Return a pointer to that string.  */
 
 }
 
 /* Convert the mantissa of VAL (which is assumed to be a floating
    point number whose format is described by FMT) into a hexadecimal
    and store it in a static string.  Return a pointer to that string.  */
 

-char *
-floatformat_mantissa (const struct floatformat *fmt, char *val)
+const char *
+floatformat_mantissa (const struct floatformat *fmt,
+                     const bfd_byte *val)

 {
   unsigned char *uval = (unsigned char *) val;
   unsigned long mant;
 {
   unsigned char *uval = (unsigned char *) val;
   unsigned long mant;


@@ -503,29 +596,42 @@ floatformat_mantissa (const struct floatformat *fmt, char *val)
   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];
+  
+  gdb_assert (fmt != NULL);
+  gdb_assert (fmt->totalsize
+             <= FLOATFORMAT_LARGEST_BYTES * FLOATFORMAT_CHAR_BIT);
+
+  order = floatformat_normalize_byteorder (fmt, uval, newfrom);
+
+  if (order != fmt->byteorder)
+    uval = newfrom;
+
+  if (! fmt->exp_nan)
+    return 0;

 
   /* Make sure we have enough room to store the mantissa.  */
 
   /* Make sure we have enough room to store the mantissa.  */

-  gdb_assert (fmt != NULL);

   gdb_assert (sizeof res > ((fmt->man_len + 7) / 8) * 2);
 
   mant_off = fmt->man_start;
   mant_bits_left = fmt->man_len;
   mant_bits = (mant_bits_left % 32) > 0 ? mant_bits_left % 32 : 32;
 
   gdb_assert (sizeof res > ((fmt->man_len + 7) / 8) * 2);
 
   mant_off = fmt->man_start;
   mant_bits_left = fmt->man_len;
   mant_bits = (mant_bits_left % 32) > 0 ? mant_bits_left % 32 : 32;
 

-  mant = get_field (uval, fmt->byteorder, 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)
     {
   while (mant_bits_left > 0)
     {

-      mant = get_field (uval, fmt->byteorder, fmt->totalsize,
-                       mant_off, 32);
+      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;


@@ -543,19 +649,9 @@ floatformat_mantissa (const struct floatformat *fmt, char *val)
    increase precision as necessary.  Otherwise, we call the conversion
    routine and let it do the dirty work.  */
 
    increase precision as necessary.  Otherwise, we call the conversion
    routine and let it do the dirty work.  */
 

-#ifndef HOST_FLOAT_FORMAT
-#define HOST_FLOAT_FORMAT 0
-#endif
-#ifndef HOST_DOUBLE_FORMAT
-#define HOST_DOUBLE_FORMAT 0
-#endif
-#ifndef HOST_LONG_DOUBLE_FORMAT
-#define HOST_LONG_DOUBLE_FORMAT 0
-#endif
-
-static const struct floatformat *host_float_format = HOST_FLOAT_FORMAT;
-static const struct floatformat *host_double_format = HOST_DOUBLE_FORMAT;
-static const struct floatformat *host_long_double_format = HOST_LONG_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;

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


@@ -610,8 +706,8 @@ floatformat_from_doublest (const struct floatformat *fmt,
 
 \f
 /* Return a floating-point format for a floating-point variable of
 
 \f
 /* Return a floating-point format for a floating-point variable of

-   length LEN.  Return NULL, if no suitable floating-point format
-   could be found.
+   length LEN.  If no suitable floating-point format is found, an
+   error is thrown.

 
    We need this functionality since information about the
    floating-point format of a type is not always available to GDB; the
 
    We need this functionality since information about the
    floating-point format of a type is not always available to GDB; the


@@ -622,17 +718,34 @@ floatformat_from_doublest (const struct floatformat *fmt,
    target-dependent code, the format of floating-point types is known,
    but not passed on by GDB.  This should be fixed.  */
 
    target-dependent code, the format of floating-point types is known,
    but not passed on by GDB.  This should be fixed.  */
 

-const struct floatformat *
+static const struct floatformat *

 floatformat_from_length (int len)
 {
 floatformat_from_length (int len)
 {

-  if (len * TARGET_CHAR_BIT == TARGET_FLOAT_BIT)
-    return TARGET_FLOAT_FORMAT;
-  else if (len * TARGET_CHAR_BIT == TARGET_DOUBLE_BIT)
-    return TARGET_DOUBLE_FORMAT;
-  else if (len * TARGET_CHAR_BIT == TARGET_LONG_DOUBLE_BIT)
-    return TARGET_LONG_DOUBLE_FORMAT;
-
-  return NULL;
+  const struct floatformat *format;
+  if (len * TARGET_CHAR_BIT == gdbarch_float_bit (current_gdbarch))
+    format = gdbarch_float_format (current_gdbarch)
+              [gdbarch_byte_order (current_gdbarch)];
+  else if (len * TARGET_CHAR_BIT == gdbarch_double_bit (current_gdbarch))
+    format = gdbarch_double_format (current_gdbarch)
+              [gdbarch_byte_order (current_gdbarch)];
+  else if (len * TARGET_CHAR_BIT == gdbarch_long_double_bit (current_gdbarch))
+    format = gdbarch_long_double_format (current_gdbarch)
+              [gdbarch_byte_order (current_gdbarch)];
+  /* 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.  
+     The code below accepts the real bit size.  */ 
+  else if ((gdbarch_long_double_format (current_gdbarch) != NULL) 
+          && (len * TARGET_CHAR_BIT ==
+               gdbarch_long_double_format (current_gdbarch)[0]->totalsize))
+    format = gdbarch_long_double_format (current_gdbarch)
+              [gdbarch_byte_order (current_gdbarch)];
+  else
+    format = NULL;
+  if (format == NULL)
+    error (_("Unrecognized %d-bit floating-point type."),
+          len * TARGET_CHAR_BIT);
+  return format;

 }
 
 const struct floatformat *
 }
 
 const struct floatformat *


@@ -640,7 +753,7 @@ floatformat_from_type (const struct type *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 (current_gdbarch)];

   else
     return floatformat_from_length (TYPE_LENGTH (type));
 }
   else
     return floatformat_from_length (TYPE_LENGTH (type));
 }


@@ -653,40 +766,39 @@ floatformat_from_type (const struct type *type)
 /* Extract a floating-point number of length LEN from a target-order
    byte-stream at ADDR.  Returns the value as type DOUBLEST.  */
 
 /* Extract a floating-point number of length LEN from a target-order
    byte-stream at ADDR.  Returns the value as type DOUBLEST.  */
 

-DOUBLEST
-extract_floating (const void *addr, int len)
+static DOUBLEST
+extract_floating_by_length (const void *addr, int len)

 {
   const struct floatformat *fmt = floatformat_from_length (len);
   DOUBLEST val;
 
 {
   const struct floatformat *fmt = floatformat_from_length (len);
   DOUBLEST val;
 

-  if (fmt == NULL)
-    {
-      warning ("Can't store a floating-point number of %d bytes.", len);
-      return NAN;
-    }
-

   floatformat_to_doublest (fmt, addr, &val);
   return 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.  */
 
 /* Store VAL as a floating-point number of length LEN to a
    target-order byte-stream at ADDR.  */
 

-void
-store_floating (void *addr, int len, DOUBLEST val)
+static void
+store_floating_by_length (void *addr, int len, DOUBLEST val)

 {
   const struct floatformat *fmt = floatformat_from_length (len);
 
 {
   const struct floatformat *fmt = floatformat_from_length (len);
 

-  if (fmt == NULL)
-    {
-      warning ("Can't store a floating-point number of %d bytes.", len);
-      memset (addr, 0, len);
-      return;
-    }
-

   floatformat_from_doublest (fmt, &val, addr);
 }
 
   floatformat_from_doublest (fmt, &val, addr);
 }
 

+void
+deprecated_store_floating (void *addr, int len, DOUBLEST val)
+{
+  store_floating_by_length (addr, len, val);
+}
+

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


@@ -698,9 +810,13 @@ extract_typed_floating (const void *addr, const struct type *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 extract_floating (addr, TYPE_LENGTH (type));
+    /* 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 
+       (TYPE_FLOATFORMAT (type)[gdbarch_byte_order (current_gdbarch)],
+                          addr, &retval);

   return retval;
 }
 
   return retval;
 }
 


@@ -733,9 +849,13 @@ store_typed_floating (void *addr, const struct type *type, DOUBLEST val)
   memset (addr, 0, TYPE_LENGTH (type));
 
   if (TYPE_FLOATFORMAT (type) == NULL)
   memset (addr, 0, TYPE_LENGTH (type));
 
   if (TYPE_FLOATFORMAT (type) == NULL)

-    store_floating (addr, TYPE_LENGTH (type), val);
+    /* 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
   else

-    floatformat_from_doublest (TYPE_FLOATFORMAT (type), &val, addr);
+    floatformat_from_doublest
+       (TYPE_FLOATFORMAT (type)[gdbarch_byte_order (current_gdbarch)],
+       &val, addr);

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


@@ -761,7 +881,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)


@@ -787,3 +907,26 @@ 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;
+}