* doublest.c (convert_doublest_to_floatformat): Rename

floatformat_from_doublest.  Make static.
(convert_floatformat_to_doublest): Rename floatformat_to_doublest.
Make static.
(floatformat_to_doublest): New function.
(floatformat_from_doublest): New function.
(host_float_format, host_double_format, host_long_double_format):
New static variables.
(store_floating, extract_floating): Always use
floatformat_to_doublest and floatformat_from_doublest.
* doublest.h (HOST_LONG_DOUBLE_FORMAT): Delete macro.

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index 20a208d6ce8ba8ace65de2bb1d3b1573db9ae1b1..47fe784219925e40733e59f99cc74699434d9f50 100644 (file)
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,17 @@
+2001-08-11  Andrew Cagney  <ac131313@redhat.com>
+
+       * doublest.c (convert_doublest_to_floatformat): Rename
+       floatformat_from_doublest.  Make static.
+       (convert_floatformat_to_doublest): Rename floatformat_to_doublest.
+       Make static.
+       (floatformat_to_doublest): New function.
+       (floatformat_from_doublest): New function.
+       (host_float_format, host_double_format, host_long_double_format):
+       New static variables.
+       (store_floating, extract_floating): Always use
+       floatformat_to_doublest and floatformat_from_doublest.
+       * doublest.h (HOST_LONG_DOUBLE_FORMAT): Delete macro.
+
 2001-08-11  Andrew Cagney  <ac131313@redhat.com>
 
        * config/mn10300/tm-mn10300.h (INIT_FRAME_PC): Delete.

diff --git a/gdb/doublest.c b/gdb/doublest.c
index af635f223cb822cd4781cb2e3919618426c634d0..287c9ade4c6a2d65336ebdf2eac47fd2d6126288 100644 (file)
--- a/gdb/doublest.c
+++ b/gdb/doublest.c
@@ -104,10 +104,10 @@ get_field (unsigned char *data, enum floatformat_byteorders order,
    FROM is the address of the extended float.
    Store the DOUBLEST in *TO.  */
 
-void
-floatformat_to_doublest (const struct floatformat *fmt,
-                        const void *from,
-                        DOUBLEST *to)
+static void
+convert_floatformat_to_doublest (const struct floatformat *fmt,
+                                const void *from,
+                                DOUBLEST *to)
 {
   unsigned char *ufrom = (unsigned char *) from;
   DOUBLEST dto;
@@ -325,10 +325,10 @@ ldfrexp (long double value, int *eptr)
    and store where TO points.  Neither FROM nor TO have any alignment
    restrictions.  */
 
-void
-floatformat_from_doublest (CONST struct floatformat *fmt,
-                          const DOUBLEST *from,
-                          void *to)
+static void
+convert_doublest_to_floatformat (CONST struct floatformat *fmt,
+                                const DOUBLEST *from,
+                                void *to)
 {
   DOUBLEST dfrom;
   int exponent;
@@ -533,60 +533,102 @@ floatformat_mantissa (const struct floatformat *fmt, char *val)
 
 
 \f
-/* Extract a floating-point number from a target-order byte-stream at ADDR.
-   Returns the value as type DOUBLEST.
+/* Convert TO/FROM target to the hosts DOUBLEST floating-point format.
+
+   If the host and target formats agree, we just copy the raw data
+   into the appropriate type of variable and return, letting the host
+   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;
+
+void
+floatformat_to_doublest (const struct floatformat *fmt,
+                        const void *in, DOUBLEST *out)
+{
+  gdb_assert (fmt != NULL);
+  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_long_double_format)
+    {
+      long double val;
+      memcpy (&val, in, sizeof (val));
+      *out = val;
+    }
+  else
+    convert_floatformat_to_doublest (fmt, in, out);
+}
+
+void
+floatformat_from_doublest (const struct floatformat *fmt,
+                          const DOUBLEST *in, void *out)
+{
+  gdb_assert (fmt != NULL);
+  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_long_double_format)
+    {
+      long double val = *in;
+      memcpy (out, &val, sizeof (val));
+    }
+  else
+    convert_doublest_to_floatformat (fmt, in, out);
+}
 
-   If the host and target formats agree, we just copy the raw data into the
-   appropriate type of variable and return, letting the host increase precision
-   as necessary.  Otherwise, we call the conversion routine and let it do the
-   dirty work.  */
+\f
+/* Extract/store a floating-point number from a target-order
+   byte-stream at ADDR.  Returns the value as type DOUBLEST.  */
 
 DOUBLEST
 extract_floating (const void *addr, int len)
 {
   DOUBLEST dretval;
-
   if (len * TARGET_CHAR_BIT == TARGET_FLOAT_BIT)
     {
-      if (HOST_FLOAT_FORMAT == TARGET_FLOAT_FORMAT)
-       {
-         float retval;
-
-         memcpy (&retval, addr, sizeof (retval));
-         return retval;
-       }
-      else
-       floatformat_to_doublest (TARGET_FLOAT_FORMAT, addr, &dretval);
+      floatformat_to_doublest (TARGET_FLOAT_FORMAT, addr, &dretval);
     }
   else if (len * TARGET_CHAR_BIT == TARGET_DOUBLE_BIT)
     {
-      if (HOST_DOUBLE_FORMAT == TARGET_DOUBLE_FORMAT)
-       {
-         double retval;
-
-         memcpy (&retval, addr, sizeof (retval));
-         return retval;
-       }
-      else
-       floatformat_to_doublest (TARGET_DOUBLE_FORMAT, addr, &dretval);
+      floatformat_to_doublest (TARGET_DOUBLE_FORMAT, addr, &dretval);
     }
   else if (len * TARGET_CHAR_BIT == TARGET_LONG_DOUBLE_BIT)
     {
-      if (HOST_LONG_DOUBLE_FORMAT == TARGET_LONG_DOUBLE_FORMAT)
-       {
-         DOUBLEST retval;
-
-         memcpy (&retval, addr, sizeof (retval));
-         return retval;
-       }
-      else
-       floatformat_to_doublest (TARGET_LONG_DOUBLE_FORMAT, addr, &dretval);
+      floatformat_to_doublest (TARGET_LONG_DOUBLE_FORMAT, addr, &dretval);
     }
   else
     {
       error ("Can't deal with a floating point number of %d bytes.", len);
     }
-
   return dretval;
 }
 
@@ -595,32 +637,15 @@ store_floating (void *addr, int len, DOUBLEST val)
 {
   if (len * TARGET_CHAR_BIT == TARGET_FLOAT_BIT)
     {
-      if (HOST_FLOAT_FORMAT == TARGET_FLOAT_FORMAT)
-       {
-         float floatval = val;
-
-         memcpy (addr, &floatval, sizeof (floatval));
-       }
-      else
-       floatformat_from_doublest (TARGET_FLOAT_FORMAT, &val, addr);
+      floatformat_from_doublest (TARGET_FLOAT_FORMAT, &val, addr);
     }
   else if (len * TARGET_CHAR_BIT == TARGET_DOUBLE_BIT)
     {
-      if (HOST_DOUBLE_FORMAT == TARGET_DOUBLE_FORMAT)
-       {
-         double doubleval = val;
-
-         memcpy (addr, &doubleval, sizeof (doubleval));
-       }
-      else
-       floatformat_from_doublest (TARGET_DOUBLE_FORMAT, &val, addr);
+      floatformat_from_doublest (TARGET_DOUBLE_FORMAT, &val, addr);
     }
   else if (len * TARGET_CHAR_BIT == TARGET_LONG_DOUBLE_BIT)
     {
-      if (HOST_LONG_DOUBLE_FORMAT == TARGET_LONG_DOUBLE_FORMAT)
-       memcpy (addr, &val, sizeof (val));
-      else
-       floatformat_from_doublest (TARGET_LONG_DOUBLE_FORMAT, &val, addr);
+      floatformat_from_doublest (TARGET_LONG_DOUBLE_FORMAT, &val, addr);
     }
   else
     {

diff --git a/gdb/doublest.h b/gdb/doublest.h
index 692280db5f2129957b92f1e566472c29365ec196..2380f160e92ccb16be23197ac0249ab8edf05167 100644 (file)
--- a/gdb/doublest.h
+++ b/gdb/doublest.h
@@ -53,10 +53,6 @@ extern const struct floatformat floatformat_unknown;
 #endif
 #endif
 
-#ifndef HOST_LONG_DOUBLE_FORMAT
-#define HOST_LONG_DOUBLE_FORMAT &floatformat_unknown
-#endif
-
 /* Use `long double' if the host compiler supports it.  (Note that this is not
    necessarily any longer than `double'.  On SunOS/gcc, it's the same as
    double.)  This is necessary because GDB internally converts all floating