gimplify.c (gimplify_compound_lval): Check for no handled operations, rather than...

	* 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.

From-SVN: r85110

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index bd8785c902c336a26d0e1b59c3825da6b89b8a9c..3a83c0a4cf6dc348a7ca12fde7fe11ed83e9cc01 100644 (file)
--- 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 fcbab025053a1bc0091fbae3290e0449ba16cc43..079622b78d87a3d0c64994544c8fa1712718518f 100644 (file)
--- 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 2b119fdab879db51b92db17f20f4f2c954a2d2b9..3d2fff897ed8dd1bd4edda17c70673e251dd78d4 100644 (file)
--- 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