diff mbox series

[RS6000] CONST_DOUBLE tidy

Message ID 20181125121628.GM21617@bubble.grove.modra.org
State New
Headers show
Series [RS6000] CONST_DOUBLE tidy | expand

Commit Message

Alan Modra Nov. 25, 2018, 12:16 p.m. UTC
Once upon a time CONST_DOUBLE was used to hold large integer constants
that didn't fit into a CONST_INT.  Now that CONST_INT is always at
least 64 bits, and the rs6000 backend uses CONST_WIDE_INT for larger
integers, there is no need for old code dealing with integers in
CONST_DOUBLE.  The rs6000 backend also doesn't create DImode subregs
of TFmode CONST_DOUBLE, as once we did.  This patch cleans up a few
leftovers from the past.

Bootstrapped etc. powerpc64le-linux, and powerpc64-linux testing
both -m32 and -m64.

	* config/rs6000/predicates.md (easy_fp_constant): Remove code
	dealing with integers in const_double.  Assert on unexpected
	modes.
	* config/rs6000/rs6000.c (rs6000_emit_move): Comment fixes.
	Don't call easy_fp_constant for Pmode.
	(rs6000_hash_constant): Remove code dealing with integers in
	const_double.
	(rs6000_legitimate_constant_p): Likewise.
	(output_toc): Formatting, use CONST_DOUBLE_P.

Comments

Segher Boessenkool Nov. 28, 2018, 6:14 p.m. UTC | #1
Hi!

On Sun, Nov 25, 2018 at 10:46:28PM +1030, Alan Modra wrote:
> Once upon a time CONST_DOUBLE was used to hold large integer constants
> that didn't fit into a CONST_INT.  Now that CONST_INT is always at
> least 64 bits, and the rs6000 backend uses CONST_WIDE_INT for larger
> integers, there is no need for old code dealing with integers in
> CONST_DOUBLE.  The rs6000 backend also doesn't create DImode subregs
> of TFmode CONST_DOUBLE, as once we did.  This patch cleans up a few
> leftovers from the past.
> 
> Bootstrapped etc. powerpc64le-linux, and powerpc64-linux testing
> both -m32 and -m64.
> 
> 	* config/rs6000/predicates.md (easy_fp_constant): Remove code
> 	dealing with integers in const_double.  Assert on unexpected
> 	modes.
> 	* config/rs6000/rs6000.c (rs6000_emit_move): Comment fixes.
> 	Don't call easy_fp_constant for Pmode.
> 	(rs6000_hash_constant): Remove code dealing with integers in
> 	const_double.
> 	(rs6000_legitimate_constant_p): Likewise.
> 	(output_toc): Formatting, use CONST_DOUBLE_P.


> diff --git a/gcc/config/rs6000/predicates.md b/gcc/config/rs6000/predicates.md
> index afe1b286833..9fbeb928fe6 100644
> --- a/gcc/config/rs6000/predicates.md
> +++ b/gcc/config/rs6000/predicates.md
> @@ -562,12 +562,11 @@ (define_predicate "vsx_reg_or_cint_operand"
>  (define_predicate "easy_fp_constant"
>    (match_code "const_double")
>  {
> -  if (GET_MODE (op) != mode
> -      || (!SCALAR_FLOAT_MODE_P (mode) && mode != DImode))
> -    return 0;
> +  gcc_assert (GET_MODE (op) == mode
> +	      && SCALAR_FLOAT_MODE_P (mode));

Just put it on one line then?

> -  /* If we are using V.4 style PIC, consider all constants to be hard.  */
> -  if (flag_pic && DEFAULT_ABI == ABI_V4)
> -    return 0;

Did you remove this part by accident?  It isn't mentioned in the changelog.

Okay for trunk if you restore this last part; otherwise, it needs mentioning.
Thanks,


Segher
Alan Modra Nov. 28, 2018, 11:48 p.m. UTC | #2
On Wed, Nov 28, 2018 at 12:14:55PM -0600, Segher Boessenkool wrote:
> On Sun, Nov 25, 2018 at 10:46:28PM +1030, Alan Modra wrote:
> > -  /* If we are using V.4 style PIC, consider all constants to be hard.  */
> > -  if (flag_pic && DEFAULT_ABI == ABI_V4)
> > -    return 0;
> 
> Did you remove this part by accident?  It isn't mentioned in the changelog.

It was deliberate.  Leaving it in would have meant we had

  ...
  if (flag_pic && DEFAULT_ABI == ABI_V4)
    return 0;

  return 0;
}
Segher Boessenkool Nov. 28, 2018, 11:55 p.m. UTC | #3
On Thu, Nov 29, 2018 at 10:18:40AM +1030, Alan Modra wrote:
> On Wed, Nov 28, 2018 at 12:14:55PM -0600, Segher Boessenkool wrote:
> > On Sun, Nov 25, 2018 at 10:46:28PM +1030, Alan Modra wrote:
> > > -  /* If we are using V.4 style PIC, consider all constants to be hard.  */
> > > -  if (flag_pic && DEFAULT_ABI == ABI_V4)
> > > -    return 0;
> > 
> > Did you remove this part by accident?  It isn't mentioned in the changelog.
> 
> It was deliberate.  Leaving it in would have meant we had
> 
>   ...
>   if (flag_pic && DEFAULT_ABI == ABI_V4)
>     return 0;
> 
>   return 0;

Oh, ha :-)  But please put it in the changelog.

Thanks,


Segher
diff mbox series

Patch

diff --git a/gcc/config/rs6000/predicates.md b/gcc/config/rs6000/predicates.md
index afe1b286833..9fbeb928fe6 100644
--- a/gcc/config/rs6000/predicates.md
+++ b/gcc/config/rs6000/predicates.md
@@ -562,12 +562,11 @@  (define_predicate "vsx_reg_or_cint_operand"
 (define_predicate "easy_fp_constant"
   (match_code "const_double")
 {
-  if (GET_MODE (op) != mode
-      || (!SCALAR_FLOAT_MODE_P (mode) && mode != DImode))
-    return 0;
+  gcc_assert (GET_MODE (op) == mode
+	      && SCALAR_FLOAT_MODE_P (mode));
 
   /* Consider all constants with -msoft-float to be easy.  */
-  if (TARGET_SOFT_FLOAT && mode != DImode)
+  if (TARGET_SOFT_FLOAT)
     return 1;
 
   /* 0.0D is not all zero bits.  */
@@ -575,37 +574,15 @@  (define_predicate "easy_fp_constant"
     return 0;
 
   /* The constant 0.0 is easy under VSX.  */
-  if (TARGET_VSX && SCALAR_FLOAT_MODE_P (mode) && op == CONST0_RTX (mode))
+  if (TARGET_VSX && op == CONST0_RTX (mode))
     return 1;
 
-  /* If we are using V.4 style PIC, consider all constants to be hard.  */
-  if (flag_pic && DEFAULT_ABI == ABI_V4)
-    return 0;
-
-  /* If we have real FPRs, consider floating point constants hard (other than
-     0.0 under VSX), so that the constant gets pushed to memory during the
-     early RTL phases.  This has the advantage that double precision constants
-     that can be represented in single precision without a loss of precision
-     will use single precision loads.  */
-
-  switch (mode)
-    {
-    case E_KFmode:
-    case E_IFmode:
-    case E_TFmode:
-    case E_DFmode:
-    case E_SFmode:
-      return 0;
-
-    case E_DImode:
-      return (num_insns_constant (op, DImode) <= 2);
-
-    case E_SImode:
-      return 1;
-
-    default:
-      gcc_unreachable ();
-    }
+  /* Otherwise consider floating point constants hard, so that the
+     constant gets pushed to memory during the early RTL phases.  This
+     has the advantage that double precision constants that can be
+     represented in single precision without a loss of precision will
+     use single precision loads.  */
+   return 0;
 })
 
 ;; Return 1 if the operand is a constant that can loaded with a XXSPLTIB
diff --git a/gcc/config/rs6000/rs6000.c b/gcc/config/rs6000/rs6000.c
index 479dae547fa..42dcb61904c 100644
--- a/gcc/config/rs6000/rs6000.c
+++ b/gcc/config/rs6000/rs6000.c
@@ -9883,13 +9883,10 @@  rs6000_emit_move (rtx dest, rtx source, machine_mode mode)
       debug_rtx (source);
     }
 
-  /* Sanity checks.  Check that we get CONST_DOUBLE only when we should.  */
+  /* Check that we get CONST_WIDE_INT only when we should.  */
   if (CONST_WIDE_INT_P (operands[1])
       && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT)
-    {
-      /* This should be fixed with the introduction of CONST_WIDE_INT.  */
-      gcc_unreachable ();
-    }
+    gcc_unreachable ();
 
 #ifdef HAVE_AS_GNU_ATTRIBUTE
   /* If we use a long double type, set the flags in .gnu_attribute that say
@@ -10228,13 +10225,11 @@  rs6000_emit_move (rtx dest, rtx source, machine_mode mode)
       else if (mode == Pmode
 	       && CONSTANT_P (operands[1])
 	       && GET_CODE (operands[1]) != HIGH
-	       && ((GET_CODE (operands[1]) != CONST_INT
-		    && ! easy_fp_constant (operands[1], mode))
-		   || (GET_CODE (operands[1]) == CONST_INT
-		       && (num_insns_constant (operands[1], mode)
-			   > (TARGET_CMODEL != CMODEL_SMALL ? 3 : 2)))
-		   || (GET_CODE (operands[0]) == REG
-		       && FP_REGNO_P (REGNO (operands[0]))))
+	       && ((REG_P (operands[0])
+		    && FP_REGNO_P (REGNO (operands[0])))
+		   || !CONST_INT_P (operands[1])
+		   || (num_insns_constant (operands[1], mode)
+		       > (TARGET_CMODEL != CMODEL_SMALL ? 3 : 2)))
 	       && !toc_relative_expr_p (operands[1], false, NULL, NULL)
 	       && (TARGET_CMODEL == CMODEL_SMALL
 		   || can_create_pseudo_p ()
@@ -29430,10 +29425,7 @@  rs6000_hash_constant (rtx k)
       }
 
     case CONST_DOUBLE:
-      if (mode != VOIDmode)
-	return real_hash (CONST_DOUBLE_REAL_VALUE (k)) * result;
-      flen = 2;
-      break;
+      return real_hash (CONST_DOUBLE_REAL_VALUE (k)) * result;
 
     case CODE_LABEL:
       fidx = 3;
@@ -29638,9 +29630,9 @@  output_toc (FILE *file, rtx x, int labelno, machine_mode mode)
   /* Handle FP constants specially.  Note that if we have a minimal
      TOC, things we put here aren't actually in the TOC, so we can allow
      FP constants.  */
-  if (GET_CODE (x) == CONST_DOUBLE &&
-      (GET_MODE (x) == TFmode || GET_MODE (x) == TDmode
-       || GET_MODE (x) == IFmode || GET_MODE (x) == KFmode))
+  if (CONST_DOUBLE_P (x)
+      && (GET_MODE (x) == TFmode || GET_MODE (x) == TDmode
+	  || GET_MODE (x) == IFmode || GET_MODE (x) == KFmode))
     {
       long k[4];
 
@@ -29678,8 +29670,8 @@  output_toc (FILE *file, rtx x, int labelno, machine_mode mode)
 	  return;
 	}
     }
-  else if (GET_CODE (x) == CONST_DOUBLE &&
-	   (GET_MODE (x) == DFmode || GET_MODE (x) == DDmode))
+  else if (CONST_DOUBLE_P (x)
+	   && (GET_MODE (x) == DFmode || GET_MODE (x) == DDmode))
     {
       long k[2];
 
@@ -29712,8 +29704,8 @@  output_toc (FILE *file, rtx x, int labelno, machine_mode mode)
 	  return;
 	}
     }
-  else if (GET_CODE (x) == CONST_DOUBLE &&
-	   (GET_MODE (x) == SFmode || GET_MODE (x) == SDmode))
+  else if (CONST_DOUBLE_P (x)
+	   && (GET_MODE (x) == SFmode || GET_MODE (x) == SDmode))
     {
       long l;
 
@@ -37615,11 +37607,13 @@  rs6000_legitimate_constant_p (machine_mode mode, rtx x)
   if (TARGET_ELF && tls_referenced_p (x))
     return false;
 
-  return ((GET_CODE (x) != CONST_DOUBLE && GET_CODE (x) != CONST_VECTOR)
-	  || GET_MODE (x) == VOIDmode
-	  || (TARGET_POWERPC64 && mode == DImode)
-	  || easy_fp_constant (x, mode)
-	  || easy_vector_constant (x, mode));
+  if (CONST_DOUBLE_P (x))
+    return easy_fp_constant (x, mode);
+
+  if (GET_CODE (x) == CONST_VECTOR)
+    return easy_vector_constant (x, mode);
+
+  return true;
 }