diff mbox series

[55/77] Use scalar_int_mode in simplify_const_unary_operation

Message ID 87k23cemsj.fsf@linaro.org
State Accepted
Commit 40c4ef22a7b4b70c64d5ce09d9fc5fba60b49420
Headers show
Series Add wrapper classes for machine_modes | expand

Commit Message

Richard Sandiford July 13, 2017, 8:58 a.m. UTC 
The main scalar integer block in simplify_const_unary_operation
had the condition:

  if (CONST_SCALAR_INT_P (op) && width > 0)

where "width > 0" was a roundabout way of testing != VOIDmode.
This patch replaces it with a check for a scalar_int_mode instead.
It also uses the number of bits in the input rather than the output
mode to determine the result of a "count ... bits in zero" operation.
(At the momemnt these modes have to be the same, but it still seems
conceptually wrong to use the number of bits in the output mode.)

The handling of float->integer ops also checked "width > 0",
but this was redundant with the earlier check for MODE_INT.

2017-07-13  Richard Sandiford  <richard.sandiford@linaro.org>
	    Alan Hayward  <alan.hayward@arm.com>
	    David Sherwood  <david.sherwood@arm.com>

gcc/
	* simplify-rtx.c (simplify_const_unary_operation): Use
	is_a <scalar_int_mode> instead of checking for a nonzero
	precision.  Forcibly convert op_mode to a scalar_int_mode
	in that case.  More clearly differentiate the operand and
	result modes and use the former when deciding what the value
	of a count-bits operation should be.  Use is_int_mode instead
	of checking for a MODE_INT.  Remove redundant check for whether
	this mode has a zero precision.

Comments

Jeff Law Aug. 24, 2017, 9:26 p.m. UTC | #1 
On 07/13/2017 02:58 AM, Richard Sandiford wrote:
> The main scalar integer block in simplify_const_unary_operation

> had the condition:

> 

>   if (CONST_SCALAR_INT_P (op) && width > 0)

> 

> where "width > 0" was a roundabout way of testing != VOIDmode.

> This patch replaces it with a check for a scalar_int_mode instead.

> It also uses the number of bits in the input rather than the output

> mode to determine the result of a "count ... bits in zero" operation.

> (At the momemnt these modes have to be the same, but it still seems

> conceptually wrong to use the number of bits in the output mode.)

> 

> The handling of float->integer ops also checked "width > 0",

> but this was redundant with the earlier check for MODE_INT.

> 

> 2017-07-13  Richard Sandiford  <richard.sandiford@linaro.org>

> 	    Alan Hayward  <alan.hayward@arm.com>

> 	    David Sherwood  <david.sherwood@arm.com>

> 

> gcc/

> 	* simplify-rtx.c (simplify_const_unary_operation): Use

> 	is_a <scalar_int_mode> instead of checking for a nonzero

> 	precision.  Forcibly convert op_mode to a scalar_int_mode

> 	in that case.  More clearly differentiate the operand and

> 	result modes and use the former when deciding what the value

> 	of a count-bits operation should be.  Use is_int_mode instead

> 	of checking for a MODE_INT.  Remove redundant check for whether

> 	this mode has a zero precision.

OK.
jeff
diff mbox series

Patch

Index: gcc/simplify-rtx.c
===================================================================
--- gcc/simplify-rtx.c	2017-07-13 09:18:39.593733475 +0100
+++ gcc/simplify-rtx.c	2017-07-13 09:18:48.356023575 +0100
@@ -1685,7 +1685,7 @@  simplify_unary_operation_1 (enum rtx_cod
 simplify_const_unary_operation (enum rtx_code code, machine_mode mode,
 				rtx op, machine_mode op_mode)
 {
-  unsigned int width = GET_MODE_PRECISION (mode);
+  scalar_int_mode result_mode;
 
   if (code == VEC_DUPLICATE)
     {
@@ -1800,10 +1800,13 @@  simplify_const_unary_operation (enum rtx
       return const_double_from_real_value (d, mode);
     }
 
-  if (CONST_SCALAR_INT_P (op) && width > 0)
+  if (CONST_SCALAR_INT_P (op) && is_a <scalar_int_mode> (mode, &result_mode))
     {
+      unsigned int width = GET_MODE_PRECISION (result_mode);
       wide_int result;
-      machine_mode imode = op_mode == VOIDmode ? mode : op_mode;
+      scalar_int_mode imode = (op_mode == VOIDmode
+			       ? result_mode
+			       : as_a <scalar_int_mode> (op_mode));
       rtx_mode_t op0 = rtx_mode_t (op, imode);
       int int_value;
 
@@ -1832,35 +1835,35 @@  simplify_const_unary_operation (enum rtx
 	  break;
 
 	case FFS:
-	  result = wi::shwi (wi::ffs (op0), mode);
+	  result = wi::shwi (wi::ffs (op0), result_mode);
 	  break;
 
 	case CLZ:
 	  if (wi::ne_p (op0, 0))
 	    int_value = wi::clz (op0);
-	  else if (! CLZ_DEFINED_VALUE_AT_ZERO (mode, int_value))
-	    int_value = GET_MODE_PRECISION (mode);
-	  result = wi::shwi (int_value, mode);
+	  else if (! CLZ_DEFINED_VALUE_AT_ZERO (imode, int_value))
+	    int_value = GET_MODE_PRECISION (imode);
+	  result = wi::shwi (int_value, result_mode);
 	  break;
 
 	case CLRSB:
-	  result = wi::shwi (wi::clrsb (op0), mode);
+	  result = wi::shwi (wi::clrsb (op0), result_mode);
 	  break;
 
 	case CTZ:
 	  if (wi::ne_p (op0, 0))
 	    int_value = wi::ctz (op0);
-	  else if (! CTZ_DEFINED_VALUE_AT_ZERO (mode, int_value))
-	    int_value = GET_MODE_PRECISION (mode);
-	  result = wi::shwi (int_value, mode);
+	  else if (! CTZ_DEFINED_VALUE_AT_ZERO (imode, int_value))
+	    int_value = GET_MODE_PRECISION (imode);
+	  result = wi::shwi (int_value, result_mode);
 	  break;
 
 	case POPCOUNT:
-	  result = wi::shwi (wi::popcount (op0), mode);
+	  result = wi::shwi (wi::popcount (op0), result_mode);
 	  break;
 
 	case PARITY:
-	  result = wi::shwi (wi::parity (op0), mode);
+	  result = wi::shwi (wi::parity (op0), result_mode);
 	  break;
 
 	case BSWAP:
@@ -1881,7 +1884,7 @@  simplify_const_unary_operation (enum rtx
 	  return 0;
 	}
 
-      return immed_wide_int_const (result, mode);
+      return immed_wide_int_const (result, result_mode);
     }
 
   else if (CONST_DOUBLE_AS_FLOAT_P (op) 
@@ -1941,9 +1944,9 @@  simplify_const_unary_operation (enum rtx
     }
   else if (CONST_DOUBLE_AS_FLOAT_P (op)
 	   && SCALAR_FLOAT_MODE_P (GET_MODE (op))
-	   && GET_MODE_CLASS (mode) == MODE_INT
-	   && width > 0)
+	   && is_int_mode (mode, &result_mode))
     {
+      unsigned int width = GET_MODE_PRECISION (result_mode);
       /* Although the overflow semantics of RTL's FIX and UNSIGNED_FIX
 	 operators are intentionally left unspecified (to ease implementation
 	 by target backends), for consistency, this routine implements the