* real.h: Don't define REAL_INFINITY or REAL_IS_NOT_DOUBLE.

	Always make REAL_VALUE_TYPE a struct containing an array of
	HOST_WIDE_INT, not a double.  Tidy up the code deciding how
	big it is.  Don't declare or use union real_extract.

	* emit-rtl.c (init_emit_once), varasm.c (immed_real_const_1,
	decode_rtx_const, output_constant_pool), config/a29k/a29k.c
	(print_operand), config/arm/arm.c (output_move_double),
	config/arm/arm.md (consttable_4, consttable_8),
	config/romp/romp.c (output_fpops), config/s390/s390.h
	(ASM_OUTPUT_SPECIAL_POOL_ENTRY), config/xtensa/xtensa.c
	(xtensa_output_literal): Don't use union real_extract.

	* config/dsp16xx/dsp16xx.c (print_operand), config/i860/i860.c
	(sfmode_constant_to_ulong), config/ns32k/merlin.h
	(PRINT_OPERAND), config/ns32k/ns32k.c (print_operand),
	config/pdp11/pdp11.h (PRINT_OPERAND), config/we32k/we32k.h
	(PRINT_OPERAND): Don't use local version of union
	real_extract.

	* config/convex/convex.c (check_float_value), config/vax/vax.c
	(vax_float_literal), config/m88k/m88k.md (divdf3),
	config/dsp16xx/dsp16xx.md (fixuns_trunchfhi2),
	config/pdp11/pdp11.c (output_move_quad): Don't do host
	arithmetic on target floating point quantities.

	* config/a29k/a29k.md, config/dsp16xx/dsp16xx.c
	(output_dsp16xx_float_const): Don't test HOST_FLOAT_FORMAT.

	* fold-const.c (fold), simplify-rtx.c (simplify_binary_real):
	Use MODE_HAS_INFINITIES rather than #ifdef REAL_INFINITY.

	* real.c (earith): Test INFINITY rather than REAL_INFINITY;
	NANS implies INFINITY, so can drop #ifdef NANS inside #ifndef
	INFINITY.
	* print-rtl.c (print_rtx): Disable code which needs
	floating-point emulator.
	* libgcc2.c: Include float.h and use DBL_MANT_DIG,
	FLT_MANT_DIG, to define DF_SIZE and SF_SIZE, rather than
	depending on HOST_FLOAT_FORMAT to be defined properly.

	* ch/grant.c, cp/error.c: Always use REAL_VALUE_TO_DECIMAL;
	don't test REAL_IS_NOT_DOUBLE.

	* config/1750a/1750a.c (get_double, float_label): Delete.
	(print_operand): Delete huge commented-out chunk.  Use
	REAL_VALUE_TO_DECIMAL.
	* config/1750a/1750a-protos.h: Delete prototypes of deleted
	functions.
	* config/convex/convex.h: Always set TARGET_FLOAT_FORMAT to
	IEEE_FLOAT_FORMAT.
	* config/i370/i370.h (PRINT_OPERAND [TARGET_HLASM version]):
	Use REAL_VALUE_TO_DECIMAL as ELF version does.
	* config/m88k/m88k.c (real_power_of_2_operand,
	legitimize_operand): Take the REAL_VALUE_TYPE and/or union
	real_extract out of the union; run the input through
	REAL_VALUE_TO_TARGET_DOUBLE, then plug the pair of longwords
	from that into the union.
	* config/pdp11/pdp11.c (output_move_double): Rearrange
	parentheses to make automatic indenter happy.

	* doc/tm.texi (Cross-compilation): Rename node to "Floating
	Point" and rewrite to describe current situation.  Also adjust
	documentation of REAL_VALUE_TO_TARGET_SINGLE and friends to
	match code.
	* doc/rtl.texi: Adjust cross reference.


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

1 files changed, 13 insertions, 22 deletions

diff --git a/gcc/varasm.c b/gcc/varasm.c
index 098757edd64..ef9e87242cd 100644
--- a/gcc/varasm.c
+++ b/gcc/varasm.c
@@ -2215,14 +2215,8 @@ immed_real_const_1 (d, mode)
      REAL_VALUE_TYPE d;
      enum machine_mode mode;
 {
-  union real_extract u;
   rtx r;
 
-  /* Get the desired `double' value as a sequence of ints
-     since that is how they are stored in a CONST_DOUBLE.  */
-
-  u.d = d;
-
   /* Detect special cases.  Check for NaN first, because some ports
      (specifically the i386) do not emit correct ieee-fp code by default, and
      thus will generate a core dump here if we pass a NaN to REAL_VALUES_EQUAL
@@ -2234,10 +2228,10 @@ immed_real_const_1 (d, mode)
   else if (! REAL_VALUE_ISNAN (d) && REAL_VALUES_EQUAL (dconst2, d))
     return CONST2_RTX (mode);
 
-  if (sizeof u == sizeof (HOST_WIDE_INT))
-    return immed_double_const (u.i[0], 0, mode);
-  if (sizeof u == 2 * sizeof (HOST_WIDE_INT))
-    return immed_double_const (u.i[0], u.i[1], mode);
+  if (sizeof (REAL_VALUE_TYPE) == sizeof (HOST_WIDE_INT))
+    return immed_double_const (d.r[0], 0, mode);
+  if (sizeof (REAL_VALUE_TYPE) == 2 * sizeof (HOST_WIDE_INT))
+    return immed_double_const (d.r[0], d.r[1], mode);
 
   /* The rest of this function handles the case where
      a float value requires more than 2 ints of space.
@@ -2247,7 +2241,7 @@ immed_real_const_1 (d, mode)
      If one is found, return it.  */
   if (cfun != 0)
     for (r = const_double_chain; r; r = CONST_DOUBLE_CHAIN (r))
-      if (! memcmp ((char *) &CONST_DOUBLE_LOW (r), (char *) &u, sizeof u)
+      if (! memcmp ((char *) &CONST_DOUBLE_LOW (r), (char *) &d, sizeof d)
 	  && GET_MODE (r) == mode)
 	return r;
 
@@ -2259,7 +2253,7 @@ immed_real_const_1 (d, mode)
      freed memory.  */
   r = rtx_alloc (CONST_DOUBLE);
   PUT_MODE (r, mode);
-  memcpy ((char *) &CONST_DOUBLE_LOW (r), (char *) &u, sizeof u);
+  memcpy ((char *) &CONST_DOUBLE_LOW (r), (char *) &d, sizeof d);
 
   /* If we aren't inside a function, don't put r on the
      const_double_chain.  */
@@ -2383,7 +2377,7 @@ struct rtx_const
   ENUM_BITFIELD(kind) kind : 16;
   ENUM_BITFIELD(machine_mode) mode : 16;
   union {
-    union real_extract du;
+    REAL_VALUE_TYPE du;
     struct addr_const addr;
     struct {HOST_WIDE_INT high, low;} di;
 
@@ -3571,8 +3565,7 @@ decode_rtx_const (mode, x, value)
       if (GET_MODE (x) != VOIDmode)
 	{
 	  value->mode = GET_MODE (x);
-	  memcpy ((char *) &value->un.du,
-		  (char *) &CONST_DOUBLE_LOW (x), sizeof value->un.du);
+	  REAL_VALUE_FROM_CONST_DOUBLE (value->un.du, x);
 	}
       else
 	{
@@ -3962,7 +3955,7 @@ output_constant_pool (fnname, fndecl)
 {
   struct pool_constant *pool;
   rtx x;
-  union real_extract u;
+  REAL_VALUE_TYPE r;
 
   /* It is possible for gcc to call force_const_mem and then to later
      discard the instructions which refer to the constant.  In such a
@@ -4040,8 +4033,8 @@ output_constant_pool (fnname, fndecl)
 	  if (GET_CODE (x) != CONST_DOUBLE)
 	    abort ();
 
-	  memcpy ((char *) &u, (char *) &CONST_DOUBLE_LOW (x), sizeof u);
-	  assemble_real (u.d, pool->mode, pool->align);
+	  REAL_VALUE_FROM_CONST_DOUBLE (r, x);
+	  assemble_real (r, pool->mode, pool->align);
 	  break;
 
 	case MODE_INT:
@@ -4062,10 +4055,8 @@ output_constant_pool (fnname, fndecl)
 	    for (i = 0; i < units; i++)
 	      {
 		elt = CONST_VECTOR_ELT (x, i);
-		memcpy ((char *) &u,
-			(char *) &CONST_DOUBLE_LOW (elt),
-			sizeof u);
-		assemble_real (u.d, GET_MODE_INNER (pool->mode), pool->align);
+		REAL_VALUE_FROM_CONST_DOUBLE (r, elt);
+		assemble_real (r, GET_MODE_INNER (pool->mode), pool->align);
 	      }
 	  }
 	  break;