Patchwork PATCH RFC: Clean up TREE_THIS_NOTRAP, copy it to MEM_REF

login
register
mail settings
Submitter Eric Botcazou
Date Oct. 13, 2010, 10:54 p.m.
Message ID <201010140054.04056.ebotcazou@adacore.com>
Download mbox | patch
Permalink /patch/67747/
State New
Headers show

Comments

Eric Botcazou - Oct. 13, 2010, 10:54 p.m.
> The TREE_THIS_NOTRAP flag can get lost during inlining.  We have the
> attached hunks in our 4.5-based tree (to be adjusted to MEM_REF).  The
> sched-deps.c hunk is for the IA-64 because it abuses may_trap_p to detect
> non-speculative instructions; when the TREE_THIS_NOTRAP is set, may_trap_p
> returns false, although the instruction is still as speculative as without
> it.

Here is a formal submission (with the associated front-end changes).

Bootstrapped/regtested on x86_64-suse-linux, OK for mainline?


2010-10-13  Eric Botcazou  <ebotcazou@adacore.com>

	* sched-deps.c (sched_insn_is_legitimate_for_speculation): Invoke
	may_trap_or_fault_p instead of may_trap_p predicate.
	* tree.c (substitute_in_expr): Propagate the TREE_THIS_NOTRAP flag.
	(substitute_placeholder_in_expr): Likewise.
	* tree-inline.c (remap_gimple_op_r): Propagate the TREE_THIS_NOTRAP
	flag on MEM_REF nodes.
	(copy_tree_body_r): Propagate the TREE_READONLY and TREE_THIS_NOTRAP
	flags on INDIRECT_REF nodes.
ada/
	* gcc-interface/decl.c (gnat_to_gnu_entity) <E_Array_Type>: Set
	TREE_THIS_NOTRAP on the INDIRECT_REF node built for the template.
	* gcc-interface/trans.c (Identifier_to_gnu): Set TREE_THIS_NOTRAP on
	the INDIRECT_REF node built for objects used by reference.
	* gcc-interface/utils2.c (build_binary_op): Add short-circuit for
	constant result. Set TREE_THIS_NOTRAP on ARRAY_REF and ARRAY_RANGE_REF.
	(gnat_stabilize_reference_1): Propagate the TREE_THIS_NOTRAP flag.
Richard Guenther - Oct. 14, 2010, 8:48 a.m.
On Thu, Oct 14, 2010 at 12:54 AM, Eric Botcazou <ebotcazou@adacore.com> wrote:
>> The TREE_THIS_NOTRAP flag can get lost during inlining.  We have the
>> attached hunks in our 4.5-based tree (to be adjusted to MEM_REF).  The
>> sched-deps.c hunk is for the IA-64 because it abuses may_trap_p to detect
>> non-speculative instructions; when the TREE_THIS_NOTRAP is set, may_trap_p
>> returns false, although the instruction is still as speculative as without
>> it.
>
> Here is a formal submission (with the associated front-end changes).
>
> Bootstrapped/regtested on x86_64-suse-linux, OK for mainline?

Ok (for the middle-end parts).

Thanks,
Richard.

>
> 2010-10-13  Eric Botcazou  <ebotcazou@adacore.com>
>
>        * sched-deps.c (sched_insn_is_legitimate_for_speculation): Invoke
>        may_trap_or_fault_p instead of may_trap_p predicate.
>        * tree.c (substitute_in_expr): Propagate the TREE_THIS_NOTRAP flag.
>        (substitute_placeholder_in_expr): Likewise.
>        * tree-inline.c (remap_gimple_op_r): Propagate the TREE_THIS_NOTRAP
>        flag on MEM_REF nodes.
>        (copy_tree_body_r): Propagate the TREE_READONLY and TREE_THIS_NOTRAP
>        flags on INDIRECT_REF nodes.
> ada/
>        * gcc-interface/decl.c (gnat_to_gnu_entity) <E_Array_Type>: Set
>        TREE_THIS_NOTRAP on the INDIRECT_REF node built for the template.
>        * gcc-interface/trans.c (Identifier_to_gnu): Set TREE_THIS_NOTRAP on
>        the INDIRECT_REF node built for objects used by reference.
>        * gcc-interface/utils2.c (build_binary_op): Add short-circuit for
>        constant result. Set TREE_THIS_NOTRAP on ARRAY_REF and ARRAY_RANGE_REF.
>        (gnat_stabilize_reference_1): Propagate the TREE_THIS_NOTRAP flag.
>
> --
> Eric Botcazou
>

Patch

Index: tree.c
===================================================================
--- tree.c	(revision 165254)
+++ tree.c	(working copy)
@@ -3186,6 +3186,10 @@  substitute_in_expr (tree exp, tree f, tr
       }
 
   TREE_READONLY (new_tree) |= TREE_READONLY (exp);
+
+  if (code == INDIRECT_REF || code == ARRAY_REF || code == ARRAY_RANGE_REF)
+    TREE_THIS_NOTRAP (new_tree) |= TREE_THIS_NOTRAP (exp);
+
   return new_tree;
 }
 
@@ -3353,6 +3357,10 @@  substitute_placeholder_in_expr (tree exp
       }
 
   TREE_READONLY (new_tree) |= TREE_READONLY (exp);
+
+  if (code == INDIRECT_REF || code == ARRAY_REF || code == ARRAY_RANGE_REF)
+    TREE_THIS_NOTRAP (new_tree) |= TREE_THIS_NOTRAP (exp);
+
   return new_tree;
 }
 
Index: ada/gcc-interface/decl.c
===================================================================
--- ada/gcc-interface/decl.c	(revision 165416)
+++ ada/gcc-interface/decl.c	(working copy)
@@ -1942,6 +1942,7 @@  gnat_to_gnu_entity (Entity_Id gnat_entit
 	gnu_template_reference
 	  = build_unary_op (INDIRECT_REF, gnu_template_type, tem);
 	TREE_READONLY (gnu_template_reference) = 1;
+	TREE_THIS_NOTRAP (gnu_template_reference) = 1;
 
 	/* Now create the GCC type for each index and add the fields for that
 	   index to the template.  */
Index: ada/gcc-interface/utils2.c
===================================================================
--- ada/gcc-interface/utils2.c	(revision 165416)
+++ ada/gcc-interface/utils2.c	(working copy)
@@ -960,14 +960,19 @@  build_binary_op (enum tree_code op_code,
     result
       = fold_build2 (op_code, operation_type, left_operand, right_operand);
 
+  if (TREE_CONSTANT (result))
+    ;
+  else if (op_code == ARRAY_REF || op_code == ARRAY_RANGE_REF)
+    {
+      TREE_THIS_NOTRAP (result) = 1;
+      if (TYPE_VOLATILE (operation_type))
+	TREE_THIS_VOLATILE (result) = 1;
+    }
+  else
+    TREE_CONSTANT (result)
+      |= (TREE_CONSTANT (left_operand) && TREE_CONSTANT (right_operand));
+
   TREE_SIDE_EFFECTS (result) |= has_side_effects;
-  TREE_CONSTANT (result)
-    |= (TREE_CONSTANT (left_operand) & TREE_CONSTANT (right_operand)
-	&& op_code != ARRAY_REF && op_code != ARRAY_RANGE_REF);
-
-  if ((op_code == ARRAY_REF || op_code == ARRAY_RANGE_REF)
-      && TYPE_VOLATILE (operation_type))
-    TREE_THIS_VOLATILE (result) = 1;
 
   /* If we are working with modular types, perform the MOD operation
      if something above hasn't eliminated the need for it.  */
@@ -2347,6 +2352,9 @@  gnat_stabilize_reference_1 (tree e, bool
   TREE_SIDE_EFFECTS (result) |= TREE_SIDE_EFFECTS (e);
   TREE_THIS_VOLATILE (result) = TREE_THIS_VOLATILE (e);
 
+  if (code == INDIRECT_REF || code == ARRAY_REF || code == ARRAY_RANGE_REF)
+    TREE_THIS_NOTRAP (result) = TREE_THIS_NOTRAP (e);
+
   return result;
 }
 
Index: ada/gcc-interface/trans.c
===================================================================
--- ada/gcc-interface/trans.c	(revision 165416)
+++ ada/gcc-interface/trans.c	(working copy)
@@ -978,14 +978,22 @@  Identifier_to_gnu (Node_Id gnat_node, tr
 
       if (TREE_CODE (gnu_result) == PARM_DECL
 	  && DECL_BY_DOUBLE_REF_P (gnu_result))
-	gnu_result = build_unary_op (INDIRECT_REF, NULL_TREE, gnu_result);
+	{
+	  gnu_result = build_unary_op (INDIRECT_REF, NULL_TREE, gnu_result);
+	  if (TREE_CODE (gnu_result) == INDIRECT_REF)
+	    TREE_THIS_NOTRAP (gnu_result) = 1;
+	}
 
       if (TREE_CODE (gnu_result) == PARM_DECL
 	  && DECL_BY_COMPONENT_PTR_P (gnu_result))
-	gnu_result
-	  = build_unary_op (INDIRECT_REF, NULL_TREE,
-			    convert (build_pointer_type (gnu_result_type),
-				     gnu_result));
+	{
+	  gnu_result
+	    = build_unary_op (INDIRECT_REF, NULL_TREE,
+			      convert (build_pointer_type (gnu_result_type),
+				       gnu_result));
+	  if (TREE_CODE (gnu_result) == INDIRECT_REF)
+	    TREE_THIS_NOTRAP (gnu_result) = 1;
+	}
 
       /* If it's a renaming pointer and we are at the right binding level,
 	 we can reference the renamed object directly, since the renamed
@@ -1003,7 +1011,11 @@  Identifier_to_gnu (Node_Id gnat_node, tr
 				     DECL_INITIAL (gnu_result));
 
       else
-	gnu_result = build_unary_op (INDIRECT_REF, NULL_TREE, gnu_result);
+	{
+	  gnu_result = build_unary_op (INDIRECT_REF, NULL_TREE, gnu_result);
+	  if (TREE_CODE (gnu_result) == INDIRECT_REF)
+	    TREE_THIS_NOTRAP (gnu_result) = 1;
+	}
 
       if (read_only)
 	TREE_READONLY (gnu_result) = 1;
Index: sched-deps.c
===================================================================
--- sched-deps.c	(revision 165254)
+++ sched-deps.c	(working copy)
@@ -598,8 +598,8 @@  sched_insn_is_legitimate_for_speculation
     /* The following instructions, which depend on a speculatively scheduled
        instruction, cannot be speculatively scheduled along.  */
     {
-      if (may_trap_p (PATTERN (insn)))
-	/* If instruction might trap, it cannot be speculatively scheduled.
+      if (may_trap_or_fault_p (PATTERN (insn)))
+	/* If instruction might fault, it cannot be speculatively scheduled.
 	   For control speculation it's obvious why and for data speculation
 	   it's because the insn might get wrong input if speculation
 	   wasn't successful.  */
Index: tree-inline.c
===================================================================
--- tree-inline.c	(revision 165254)
+++ tree-inline.c	(working copy)
@@ -858,6 +858,7 @@  remap_gimple_op_r (tree *tp, int *walk_s
 		  *tp = fold_build2 (MEM_REF, TREE_TYPE (*tp),
 				     ptr, TREE_OPERAND (*tp, 1));
 		  TREE_THIS_VOLATILE (*tp) = TREE_THIS_VOLATILE (old);
+		  TREE_THIS_NOTRAP (*tp) = TREE_THIS_NOTRAP (old);
 		}
 	      TREE_NO_WARNING (*tp) = TREE_NO_WARNING (old);
 	      *walk_subtrees = 0;
@@ -1087,6 +1088,8 @@  copy_tree_body_r (tree *tp, int *walk_su
 	              *tp = build1 (INDIRECT_REF, type, new_tree);
 		      TREE_THIS_VOLATILE (*tp) = TREE_THIS_VOLATILE (old);
 		      TREE_SIDE_EFFECTS (*tp) = TREE_SIDE_EFFECTS (old);
+		      TREE_READONLY (*tp) = TREE_READONLY (old);
+		      TREE_THIS_NOTRAP (*tp) = TREE_THIS_NOTRAP (old);
 		    }
 		}
 	      *walk_subtrees = 0;