diff mbox series

[50/77] Add helper routines for SUBREG_PROMOTED_VAR_P subregs

Message ID 8760ewg1g8.fsf@linaro.org
State Accepted
Commit 5e4e37bff76a3fbaf4f6e18a343f7c484eeb642e
Headers show
Series Add wrapper classes for machine_modes | expand

Commit Message

Richard Sandiford July 13, 2017, 8:56 a.m. UTC 
When subregs contain promoted values, as indicated by
SUBREG_PROMOTED_VAR_P, both the unpromoted (outer) and
promoted (inner) values are known to be scalar integers.
This patch adds helper routines that get the modes as
scalar_int_modes.

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

gcc/
	* rtl.h (subreg_unpromoted_mode, subreg_promoted_mode): New functions.
	* expr.c (convert_move): Use them.
	(convert_modes): Likewise.
	(store_expr_with_bounds): Likewise.

Comments

Jeff Law Aug. 24, 2017, 4:29 a.m. UTC | #1 
On 07/13/2017 02:56 AM, Richard Sandiford wrote:
> When subregs contain promoted values, as indicated by

> SUBREG_PROMOTED_VAR_P, both the unpromoted (outer) and

> promoted (inner) values are known to be scalar integers.

> This patch adds helper routines that get the modes as

> scalar_int_modes.

> 

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

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

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

> 

> gcc/

> 	* rtl.h (subreg_unpromoted_mode, subreg_promoted_mode): New functions.

> 	* expr.c (convert_move): Use them.

> 	(convert_modes): Likewise.

> 	(store_expr_with_bounds): Likewise.

OK
jeff
diff mbox series

Patch

Index: gcc/rtl.h
===================================================================
--- gcc/rtl.h	2017-07-13 09:18:45.761227536 +0100
+++ gcc/rtl.h	2017-07-13 09:18:46.226190608 +0100
@@ -2766,6 +2766,24 @@  unwrap_const_vec_duplicate (T x)
   return x;
 }
 
+/* Return the unpromoted (outer) mode of SUBREG_PROMOTED_VAR_P subreg X.  */
+
+inline scalar_int_mode
+subreg_unpromoted_mode (rtx x)
+{
+  gcc_checking_assert (SUBREG_PROMOTED_VAR_P (x));
+  return as_a <scalar_int_mode> (GET_MODE (x));
+}
+
+/* Return the promoted (inner) mode of SUBREG_PROMOTED_VAR_P subreg X.  */
+
+inline scalar_int_mode
+subreg_promoted_mode (rtx x)
+{
+  gcc_checking_assert (SUBREG_PROMOTED_VAR_P (x));
+  return as_a <scalar_int_mode> (GET_MODE (SUBREG_REG (x)));
+}
+
 /* In emit-rtl.c */
 extern rtvec gen_rtvec_v (int, rtx *);
 extern rtvec gen_rtvec_v (int, rtx_insn **);
Index: gcc/expr.c
===================================================================
--- gcc/expr.c	2017-07-13 09:18:44.578322246 +0100
+++ gcc/expr.c	2017-07-13 09:18:46.226190608 +0100
@@ -243,7 +243,7 @@  convert_move (rtx to, rtx from, int unsi
   if (GET_CODE (from) == SUBREG
       && SUBREG_PROMOTED_VAR_P (from)
       && is_a <scalar_int_mode> (to_mode, &to_int_mode)
-      && (GET_MODE_PRECISION (GET_MODE (SUBREG_REG (from)))
+      && (GET_MODE_PRECISION (subreg_promoted_mode (from))
 	  >= GET_MODE_PRECISION (to_int_mode))
       && SUBREG_CHECK_PROMOTED_SIGN (from, unsignedp))
     from = gen_lowpart (to_int_mode, from), from_mode = to_int_mode;
@@ -641,7 +641,8 @@  convert_modes (machine_mode mode, machin
   if (GET_CODE (x) == SUBREG
       && SUBREG_PROMOTED_VAR_P (x)
       && is_a <scalar_int_mode> (mode, &int_mode)
-      && GET_MODE_SIZE (GET_MODE (SUBREG_REG (x))) >= GET_MODE_SIZE (int_mode)
+      && (GET_MODE_PRECISION (subreg_promoted_mode (x))
+	  >= GET_MODE_PRECISION (int_mode))
       && SUBREG_CHECK_PROMOTED_SIGN (x, unsignedp))
     x = gen_lowpart (int_mode, SUBREG_REG (x));
 
@@ -5422,6 +5423,8 @@  store_expr_with_bounds (tree exp, rtx ta
        expression.  */
     {
       rtx inner_target = 0;
+      scalar_int_mode outer_mode = subreg_unpromoted_mode (target);
+      scalar_int_mode inner_mode = subreg_promoted_mode (target);
 
       /* We can do the conversion inside EXP, which will often result
 	 in some optimizations.  Do the conversion in two steps: first
@@ -5431,7 +5434,7 @@  store_expr_with_bounds (tree exp, rtx ta
 	 converting modes.  */
       if (INTEGRAL_TYPE_P (TREE_TYPE (exp))
 	  && TREE_TYPE (TREE_TYPE (exp)) == 0
-	  && GET_MODE_PRECISION (GET_MODE (target))
+	  && GET_MODE_PRECISION (outer_mode)
 	     == TYPE_PRECISION (TREE_TYPE (exp)))
 	{
 	  if (!SUBREG_CHECK_PROMOTED_SIGN (target,
@@ -5451,8 +5454,7 @@  store_expr_with_bounds (tree exp, rtx ta
 	    }
 
 	  exp = fold_convert_loc (loc, lang_hooks.types.type_for_mode
-				  (GET_MODE (SUBREG_REG (target)),
-				   SUBREG_PROMOTED_SIGN (target)),
+				  (inner_mode, SUBREG_PROMOTED_SIGN (target)),
 				  exp);
 
 	  inner_target = SUBREG_REG (target);
@@ -5478,10 +5480,9 @@  store_expr_with_bounds (tree exp, rtx ta
 	 sure that we properly convert it.  */
       if (CONSTANT_P (temp) && GET_MODE (temp) == VOIDmode)
 	{
-	  temp = convert_modes (GET_MODE (target), TYPE_MODE (TREE_TYPE (exp)),
+	  temp = convert_modes (outer_mode, TYPE_MODE (TREE_TYPE (exp)),
 				temp, SUBREG_PROMOTED_SIGN (target));
-	  temp = convert_modes (GET_MODE (SUBREG_REG (target)),
-			        GET_MODE (target), temp,
+	  temp = convert_modes (inner_mode, outer_mode, temp,
 				SUBREG_PROMOTED_SIGN (target));
 	}