re PR tree-optimization/48571 (Missed data-dependence for (bogus?) reconstructed array-refs)

2011-08-30  Richard Guenther  <rguenther@suse.de>

	PR middle-end/48571
	* gimple.h (maybe_fold_offset_to_address): Remove.
	(maybe_fold_offset_to_reference): Likewise.
	(maybe_fold_stmt_addition): Likewise.
	(may_propagate_address_into_dereference): Likewise.
	* tree-inline.c (remap_gimple_op_r): Do not reconstruct
	array references.
	* gimple-fold.c (canonicalize_constructor_val): Likewise.
	Canonicalize invariant POINTER_PLUS_EXPRs to invariant MEM_REF
	addresses instead.
	(may_propagate_address_into_dereference): Remove.
	(maybe_fold_offset_to_array_ref): Likewise.
	(maybe_fold_offset_to_reference): Likewise.
	(maybe_fold_offset_to_address): Likewise.
	(maybe_fold_stmt_addition): Likewise.
	(fold_gimple_assign): Do not reconstruct array references but
	instead canonicalize invariant POINTER_PLUS_EXPRs to invariant
	MEM_REF addresses.
	(gimple_fold_stmt_to_constant_1): Likewise.
	* tree-ssa-forwprop.c (forward_propagate_addr_expr_1): Likewise.
	* gimplify.c (gimplify_conversion): Likewise.
	(gimplify_expr): Likewise.

	* gcc.c-torture/execute/pr48571-1.c: New testcase.
	* gcc.dg/tree-ssa/ssa-ccp-25.c: Remove.
	* gcc.dg/tree-ssa/ssa-ccp-26.c: Likewise.
	* gcc.dg/pr36902.c: XFAIL.

From-SVN: r178312

1 files changed, 27 insertions, 42 deletions

diff --git a/gcc/gimplify.c b/gcc/gimplify.c
index a22b5d3..d7bc818 100644
--- a/gcc/gimplify.c
+++ b/gcc/gimplify.c
@@ -1799,7 +1799,6 @@ canonicalize_addr_expr (tree *expr_p)
 static enum gimplify_status
 gimplify_conversion (tree *expr_p)
 {
-  tree tem;
   location_t loc = EXPR_LOCATION (*expr_p);
   gcc_assert (CONVERT_EXPR_P (*expr_p));
 
@@ -1810,17 +1809,6 @@ gimplify_conversion (tree *expr_p)
   if (tree_ssa_useless_type_conversion (*expr_p))
     *expr_p = TREE_OPERAND (*expr_p, 0);
 
-  /* Attempt to avoid NOP_EXPR by producing reference to a subtype.
-     For example this fold (subclass *)&A into &A->subclass avoiding
-     a need for statement.  */
-  if (CONVERT_EXPR_P (*expr_p)
-      && POINTER_TYPE_P (TREE_TYPE (*expr_p))
-      && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (*expr_p, 0)))
-      && (tem = maybe_fold_offset_to_address
-	  (EXPR_LOCATION (*expr_p), TREE_OPERAND (*expr_p, 0),
-	   integer_zero_node, TREE_TYPE (*expr_p))) != NULL_TREE)
-    *expr_p = tem;
-
   /* If we still have a conversion at the toplevel,
      then canonicalize some constructs.  */
   if (CONVERT_EXPR_P (*expr_p))
@@ -7302,36 +7290,33 @@ gimplify_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
 	  goto expr_3;
 
 	case POINTER_PLUS_EXPR:
-          /* Convert ((type *)A)+offset into &A->field_of_type_and_offset.
-	     The second is gimple immediate saving a need for extra statement.
-	   */
-	  if (TREE_CODE (TREE_OPERAND (*expr_p, 1)) == INTEGER_CST
-	      && (tmp = maybe_fold_offset_to_address
-		  (EXPR_LOCATION (*expr_p),
-		   TREE_OPERAND (*expr_p, 0), TREE_OPERAND (*expr_p, 1),
-		   TREE_TYPE (*expr_p))))
-	    {
-	      *expr_p = tmp;
-	      ret = GS_OK;
-	      break;
-	    }
-	  /* Convert (void *)&a + 4 into (void *)&a[1].  */
-	  if (TREE_CODE (TREE_OPERAND (*expr_p, 0)) == NOP_EXPR
-	      && TREE_CODE (TREE_OPERAND (*expr_p, 1)) == INTEGER_CST
-	      && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (*expr_p,
-									0),0)))
-	      && (tmp = maybe_fold_offset_to_address
-		  (EXPR_LOCATION (*expr_p),
-		   TREE_OPERAND (TREE_OPERAND (*expr_p, 0), 0),
-		   TREE_OPERAND (*expr_p, 1),
-		   TREE_TYPE (TREE_OPERAND (TREE_OPERAND (*expr_p, 0),
-					    0)))))
-	     {
-               *expr_p = fold_convert (TREE_TYPE (*expr_p), tmp);
-	       ret = GS_OK;
-	       break;
-	     }
-          /* FALLTHRU */
+	  {
+	    enum gimplify_status r0, r1;
+	    r0 = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p,
+				post_p, is_gimple_val, fb_rvalue);
+	    r1 = gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p,
+				post_p, is_gimple_val, fb_rvalue);
+	    recalculate_side_effects (*expr_p);
+	    ret = MIN (r0, r1);
+	    /* Convert &X + CST to invariant &MEM[&X, CST].  Do this
+	       after gimplifying operands - this is similar to how
+	       it would be folding all gimplified stmts on creation
+	       to have them canonicalized, which is what we eventually
+	       should do anyway.  */
+	    if (TREE_CODE (TREE_OPERAND (*expr_p, 1)) == INTEGER_CST
+		&& is_gimple_min_invariant (TREE_OPERAND (*expr_p, 0)))
+	      {
+		*expr_p = build_fold_addr_expr_with_type_loc
+		   (input_location,
+		    fold_build2 (MEM_REF, TREE_TYPE (TREE_TYPE (*expr_p)),
+				 TREE_OPERAND (*expr_p, 0),
+				 fold_convert (ptr_type_node,
+					       TREE_OPERAND (*expr_p, 1))),
+		    TREE_TYPE (*expr_p));
+		ret = MIN (ret, GS_OK);
+	      }
+	    break;
+	  }
 
 	default:
 	  switch (TREE_CODE_CLASS (TREE_CODE (*expr_p)))