* gimplify.c (gimplify_compound_lval): Check for no handled

	operations, rather than checking for explicit list of nodes.
	(is_gimple_addr_expr_arg_or_indirect): New function.
	(gimplify_addr_expr): Call it and handle INDIRECT_REF; remove
	redundant setting of TREE_INVARIANT.
	(gimplify_expr, case VIEW_CONVERT_EXPR): Call gimplify_compound_lval.
	* tree-gimple.c (is_gimple_addr_expr_arg): Call handled_component_p.


git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@85110 138bc75d-0d04-0410-961f-82ee72b054a4

3 files changed, 37 insertions, 57 deletions

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index bd8785c902c..3a83c0a4cf6 100644
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,13 @@
+2004-07-23  Richard Kenner  <kenner@vlsi1.ultra.nyu.edu>
+
+	* gimplify.c (gimplify_compound_lval): Check for no handled
+	operations, rather than checking for explicit list of nodes.
+	(is_gimple_addr_expr_arg_or_indirect): New function.
+	(gimplify_addr_expr): Call it and handle INDIRECT_REF; remove
+	redundant setting of TREE_INVARIANT.
+	(gimplify_expr, case VIEW_CONVERT_EXPR): Call gimplify_compound_lval.
+	* tree-gimple.c (is_gimple_addr_expr_arg): Call handled_component_p.
+	
 2004-07-23  Diego Novillo  <dnovillo@redhat.com>
 
 	PR tree-optimization/16688
diff --git a/gcc/gimplify.c b/gcc/gimplify.c
index fcbab025053..079622b78d8 100644
--- a/gcc/gimplify.c
+++ b/gcc/gimplify.c
@@ -1509,16 +1509,6 @@ gimplify_compound_lval (tree *expr_p, tree *pre_p,
   enum gimplify_status ret = GS_OK, tret;
   int i;
 
-#if defined ENABLE_CHECKING
-  if (TREE_CODE (*expr_p) != ARRAY_REF
-      && TREE_CODE (*expr_p) != ARRAY_RANGE_REF
-      && TREE_CODE (*expr_p) != COMPONENT_REF
-      && TREE_CODE (*expr_p) != BIT_FIELD_REF
-      && TREE_CODE (*expr_p) != REALPART_EXPR
-      && TREE_CODE (*expr_p) != IMAGPART_EXPR)
-    abort ();
-#endif
-
   /* Create a stack of the subexpressions so later we can walk them in
      order from inner to outer.  */
   VARRAY_TREE_INIT (stack, 10, "stack");
@@ -1531,6 +1521,11 @@ gimplify_compound_lval (tree *expr_p, tree *pre_p,
        p = &TREE_OPERAND (*p, 0))
     VARRAY_PUSH_TREE (stack, *p);
 
+#if defined ENABLE_CHECKING
+  if (VARRAY_ACTIVE_SIZE (stack) == 0)
+    abort ();
+#endif
+
   /* Now STACK is a stack of pointers to all the refs we've walked through
      and P points to the innermost expression.
 
@@ -2714,6 +2709,15 @@ gimplify_modify_expr_rhs (tree *expr_p, tree *from_p, tree *to_p, tree *pre_p,
   return ret;
 }
 
+/* Return true if T is either a valid GIMPLE operand or is an
+   INDIRECT_REF (the latter is valid since we'll strip it off).  */
+
+static bool
+is_gimple_addr_expr_arg_or_indirect (tree t)
+{
+  return (TREE_CODE (t) == INDIRECT_REF || is_gimple_addr_expr_arg (t));
+}
+
 /* Gimplify the MODIFY_EXPR node pointed by EXPR_P.
 
       modify_expr
@@ -3023,9 +3027,18 @@ gimplify_addr_expr (tree *expr_p, tree *pre_p, tree *post_p)
       /* We use fb_either here because the C frontend sometimes takes
 	 the address of a call that returns a struct.  */
       ret = gimplify_expr (&TREE_OPERAND (expr, 0), pre_p, post_p,
-			   is_gimple_addr_expr_arg, fb_either);
+			   is_gimple_addr_expr_arg_or_indirect, fb_either);
       if (ret != GS_ERROR)
 	{
+	  /* The above may have made an INDIRECT ref (e.g, Ada's NULL_EXPR),
+	     so check for it here.  It's not worth checking for the other
+	     cases above.  */
+	  if (TREE_CODE (TREE_OPERAND (expr, 0)) == INDIRECT_REF)
+	    {
+	      *expr_p = TREE_OPERAND (TREE_OPERAND (expr, 0), 0);
+	      break;
+	    }
+
 	  /* Make sure TREE_INVARIANT, TREE_CONSTANT, and TREE_SIDE_EFFECTS
 	     is set properly.  */
 	  recompute_tree_invarant_for_addr_expr (expr);
@@ -3036,11 +3049,6 @@ gimplify_addr_expr (tree *expr_p, tree *pre_p, tree *post_p)
       break;
     }
 
-  /* If the operand is gimplified into a _DECL, mark the address expression
-     as TREE_INVARIANT.  */
-  if (DECL_P (TREE_OPERAND (expr, 0)))
-    TREE_INVARIANT (expr) = 1;
-
   return ret;
 }
 
@@ -3475,6 +3483,7 @@ gimplify_expr (tree *expr_p, tree *pre_p, tree *post_p,
 	case REALPART_EXPR:
 	case IMAGPART_EXPR:
 	case COMPONENT_REF:
+	case VIEW_CONVERT_EXPR:
 	  ret = gimplify_compound_lval (expr_p, pre_p, post_p,
 					fallback ? fallback : fb_rvalue);
 	  break;
@@ -3521,39 +3530,6 @@ gimplify_expr (tree *expr_p, tree *pre_p, tree *post_p,
 	  ret = gimplify_va_arg_expr (expr_p, pre_p, post_p);
 	  break;
 
-	case VIEW_CONVERT_EXPR:
-	  if (VOID_TYPE_P (TREE_TYPE (*expr_p))
-	      || fallback == fb_none)
-	    {
-	      /* Just strip a conversion to void (or in void context) and
-		 try again.  */
-	      *expr_p = TREE_OPERAND (*expr_p, 0);
-	      break;
-	    }
-
-	  /* If both types are BLKmode or if one type is of variable size,
-	     convert this into a pointer punning operation.  This avoids
-	     copies of large data or making a variable-size temporary.
-
-	     ??? The interactions of VIEW_CONVERT_EXPR and aliasing is not at
-	     all clear.  The impact of this transformation is even less
-	     clear.  */
-
-	  if ((TYPE_MODE (TREE_TYPE (*expr_p)) == BLKmode
-	       && TYPE_MODE (TREE_TYPE (TREE_OPERAND (*expr_p, 0))) == BLKmode)
-	      || !TREE_CONSTANT (TYPE_SIZE (TREE_TYPE (*expr_p)))
-	      || !TREE_CONSTANT (TYPE_SIZE (TREE_TYPE
-					    (TREE_OPERAND (*expr_p,0)))))
-	    {
-	      tree restype = TREE_TYPE (*expr_p);
-	      *expr_p = build1 (INDIRECT_REF, TREE_TYPE (*expr_p),
-				fold_convert (build_pointer_type (restype),
-					      build_fold_addr_expr
-					      (TREE_OPERAND (*expr_p, 0))));
-	      break;
-	    }
-	  goto unary;
-
 	case CONVERT_EXPR:
 	case NOP_EXPR:
 	  if (IS_EMPTY_STMT (*expr_p))
@@ -3582,7 +3558,6 @@ gimplify_expr (tree *expr_p, tree *pre_p, tree *post_p,
 	case FIX_CEIL_EXPR:
 	case FIX_FLOOR_EXPR:
 	case FIX_ROUND_EXPR:
-	unary:
 	  /* unary_expr: ... | '(' cast ')' val | ...  */
 	  ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
 			       is_gimple_val, fb_rvalue);
diff --git a/gcc/tree-gimple.c b/gcc/tree-gimple.c
index 2b119fdab87..3d2fff897ed 100644
--- a/gcc/tree-gimple.c
+++ b/gcc/tree-gimple.c
@@ -322,13 +322,8 @@ is_gimple_condexpr (tree t)
 bool
 is_gimple_addr_expr_arg (tree t)
 {
-  return (is_gimple_id (t)
-	  || TREE_CODE (t) == ARRAY_REF
-	  || TREE_CODE (t) == ARRAY_RANGE_REF
-	  || TREE_CODE (t) == COMPONENT_REF
-	  || TREE_CODE (t) == REALPART_EXPR
-	  || TREE_CODE (t) == IMAGPART_EXPR
-	  || TREE_CODE (t) == INDIRECT_REF);
+  return (is_gimple_id (t) || handled_component_p (t)
+	  || TREE_CODE (t) == REALPART_EXPR || TREE_CODE (t) == IMAGPART_EXPR);
 }
 
 /* Return true if T is function invariant.  Or rather a restricted