(ASM_OUTPUT_DOUBLE,ASM_OUTPUT_FLOAT): Use REAL_VALUE_ macros.

(ASM_OUTPUT_LONG_DOUBLE): New macro.

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@5575 138bc75d-0d04-0410-961f-82ee72b054a4

diff --git a/gcc/config/i386/osfrose.h b/gcc/config/i386/osfrose.h
index 92ff47e..2259280 100644 (file)
--- a/gcc/config/i386/osfrose.h
+++ b/gcc/config/i386/osfrose.h
@@ -756,47 +756,57 @@ while (0)
    Use "word" pseudos to avoid printing NaNs, infinity, etc.  */
 
 /* This is how to output an assembler line defining a `double' constant.  */
-
 #undef ASM_OUTPUT_DOUBLE
-
-#ifndef        CROSS_COMPILE
 #define        ASM_OUTPUT_DOUBLE(STREAM, VALUE)                                \
 do                                                                     \
   {                                                                    \
     long value_long[2];                                                        \
+    char dstr[30];                                                     \
     REAL_VALUE_TO_TARGET_DOUBLE (VALUE, value_long);                   \
-                                                                       \
-    fprintf (STREAM, "\t.long\t0x%08lx\t\t# %.20g\n\t.long\t0x%08lx\n",        \
-          value_long[0], VALUE, value_long[1]);                        \
+    REAL_VALUE_TO_DECIMAL (VALUE, "%.20g", dstr);                      \
+    if (sizeof (int) == sizeof (long))                                 \
+      fprintf (STREAM, "\t.long\t0x%08x\t\t# %s\n\t.long\t0x%08x\n",   \
+          value_long[0], dstr, value_long[1]);                         \
+     else                                                              \
+      fprintf (STREAM, "\t.long\t0x%08lx\t\t# %s\n\t.long\t0x%08lx\n", \
+          value_long[0], dstr, value_long[1]);                         \
   }                                                                    \
 while (0)
 
-#else
-#define        ASM_OUTPUT_DOUBLE(STREAM, VALUE)                                \
-  fprintf (STREAM, "\t.double\t%.20g\n", VALUE)
-#endif
-
 /* This is how to output an assembler line defining a `float' constant.  */
-
 #undef ASM_OUTPUT_FLOAT
-
-#ifndef        CROSS_COMPILE
 #define        ASM_OUTPUT_FLOAT(STREAM, VALUE)                                 \
 do                                                                     \
   {                                                                    \
     long value_long;                                                   \
+    char dstr[30];                                                     \
     REAL_VALUE_TO_TARGET_SINGLE (VALUE, value_long);                   \
-                                                                       \
-    fprintf (STREAM, "\t.long\t0x%08lx\t\t# %.12g (float)\n",          \
-          value_long, VALUE);                                          \
+    REAL_VALUE_TO_DECIMAL (VALUE, "%.12g", dstr);                      \
+    if (sizeof (int) == sizeof (long))                                 \
+      fprintf (STREAM, "\t.long\t0x%08x\t\t# %s (float)\n",            \
+          value_long, dstr);                                           \
+    else                                                               \
+      fprintf (STREAM, "\t.long\t0x%08lx\t\t# %s (float)\n",           \
+          value_long, dstr);                                           \
   }                                                                    \
 while (0)
 
-#else
-#define        ASM_OUTPUT_FLOAT(STREAM, VALUE)                                 \
-  fprintf (STREAM, "\t.float\t%.12g\n", VALUE)
-#endif
-
+/* This is how to output an assembler line for a `long double' constant.  */
+#undef ASM_OUTPUT_LONG_DOUBLE
+#define ASM_OUTPUT_LONG_DOUBLE(FILE,VALUE)                             \
+do { long l[3];                                                                \
+     char dstr[30];                                                    \
+     REAL_VALUE_TO_TARGET_LONG_DOUBLE (VALUE, l);                      \
+     REAL_VALUE_TO_DECIMAL (VALUE, "%.20g", dstr);                     \
+     if (sizeof (int) == sizeof (long))                                        \
+      fprintf (FILE,                                                   \
+      "\t.long\t0x%08x\t\t# %s\n\t.long\t0x%08x\n\t.long\t0x%08x\n",   \
+      l[0], dstr, l[1], l[2]);                                                 \
+     else                                                              \
+      fprintf (FILE,                                                   \
+      "\t.long\t0x%08lx\t\t# %s\n\t.long\t0x%08lx\n\t.long\t0x%08lx\n",        \
+      l[0], dstr, l[1], l[2]);                                                 \
+   } while (0)
 
 /* Generate calls to memcpy, etc., not bcopy, etc. */
 #define TARGET_MEM_FUNCTIONS

diff --git a/gcc/config/i386/sysv4.h b/gcc/config/i386/sysv4.h
index 678209f..2a0a829 100644 (file)
--- a/gcc/config/i386/sysv4.h
+++ b/gcc/config/i386/sysv4.h
@@ -39,9 +39,6 @@ the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
 #define CPP_PREDEFINES \
   "-Di386 -Dunix -D__svr4__ -Asystem(unix) -Asystem(svr4) -Acpu(i386) -Amachine(i386)"
 
-/* If the host and target formats match, output the floats as hex.  */
-#if HOST_FLOAT_FORMAT == TARGET_FLOAT_FORMAT
-#if defined (HOST_WORDS_BIG_ENDIAN) == WORDS_BIG_ENDIAN
 /* This is how to output assembly code to define a `float' constant.
    We always have to use a .long pseudo-op to do this because the native
    SVR4 ELF assembler is buggy and it generates incorrect values when we
@@ -51,7 +48,10 @@ the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
 #define ASM_OUTPUT_FLOAT(FILE,VALUE)                                   \
 do { long value;                                                       \
      REAL_VALUE_TO_TARGET_SINGLE ((VALUE), value);                     \
-     fprintf((FILE), "%s\t0x%x\n", ASM_LONG, value);                   \
+     if (sizeof (int) == sizeof (long))                                        \
+         fprintf((FILE), "%s\t0x%x\n", ASM_LONG, value);               \
+     else                                                              \
+         fprintf((FILE), "%s\t0x%lx\n", ASM_LONG, value);              \
    } while (0)
 
 /* This is how to output assembly code to define a `double' constant.
@@ -63,11 +63,36 @@ do { long value;                                                    \
 #define ASM_OUTPUT_DOUBLE(FILE,VALUE)                                  \
 do { long value[2];                                                    \
      REAL_VALUE_TO_TARGET_DOUBLE ((VALUE), value);                     \
-     fprintf((FILE), "%s\t0x%x\n", ASM_LONG, value[0]);                        \
-     fprintf((FILE), "%s\t0x%x\n", ASM_LONG, value[1]);                        \
+     if (sizeof (int) == sizeof (long))                                        \
+       {                                                               \
+         fprintf((FILE), "%s\t0x%x\n", ASM_LONG, value[0]);            \
+         fprintf((FILE), "%s\t0x%x\n", ASM_LONG, value[1]);            \
+       }                                                               \
+     else                                                              \
+       {                                                               \
+         fprintf((FILE), "%s\t0x%lx\n", ASM_LONG, value[0]);           \
+         fprintf((FILE), "%s\t0x%lx\n", ASM_LONG, value[1]);           \
+       }                                                               \
+   } while (0)
+
+
+#undef ASM_OUTPUT_LONG_DOUBLE
+#define ASM_OUTPUT_LONG_DOUBLE(FILE,VALUE)                             \
+do { long value[3];                                                    \
+     REAL_VALUE_TO_TARGET_LONG_DOUBLE ((VALUE), value);                        \
+     if (sizeof (int) == sizeof (long))                                        \
+       {                                                               \
+         fprintf((FILE), "%s\t0x%x\n", ASM_LONG, value[0]);            \
+         fprintf((FILE), "%s\t0x%x\n", ASM_LONG, value[1]);            \
+         fprintf((FILE), "%s\t0x%x\n", ASM_LONG, value[2]);            \
+       }                                                               \
+     else                                                              \
+       {                                                               \
+         fprintf((FILE), "%s\t0x%lx\n", ASM_LONG, value[0]);           \
+         fprintf((FILE), "%s\t0x%lx\n", ASM_LONG, value[1]);           \
+         fprintf((FILE), "%s\t0x%lx\n", ASM_LONG, value[2]);           \
+       }                                                               \
    } while (0)
-#endif /* word order matches */
-#endif /* HOST_FLOAT_FORMAT == TARGET_FLOAT_FORMAT */
 
 /* Output at beginning of assembler file.  */
 /* The .file command should always begin the output.  */