tree-ssa-operands.c (build_ssa_operands, [...]): Ignore a VIEW_CONVERT_EXPR on LHS...

	PR/18664
	* tree-ssa-operands.c (build_ssa_operands, case MODIFY_EXPR):
	Ignore a VIEW_CONVERT_EXPR on LHS when deciding if must or may def.
	* tree-ssa-ccp.c (visit_assignment): If LHS is a VIEW_CONVERT_EXPR,
	add an inverse VIEW_CONVERT_EXPR to const_val.

From-SVN: r91450

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 38eb985f09f26ed31d3f2e329d657591822317ac..6472431065dac2e59eca992e4e024b73dc0806a3 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,5 +1,12 @@
 2004-11-28  Richard Kenner  <kenner@vlsi1.ultra.nyu.edu>
 
+       PR/18664
+       * tree-ssa-operands.c (build_ssa_operands, case MODIFY_EXPR):
+       Ignore a VIEW_CONVERT_EXPR on LHS when deciding if must or may def.
+       * tree-ssa-ccp.c (visit_assignment): If LHS is a VIEW_CONVERT_EXPR,
+       add an inverse VIEW_CONVERT_EXPR to const_val.
+
+       PR/18657
        * tree-nested.c (check_for_nested_with_variably_modified): New.
        (create_nesting_tree): Call it.
 

diff --git a/gcc/tree-ssa-ccp.c b/gcc/tree-ssa-ccp.c
index 31807fec59d9cc528bd26b3f646030a2104890c0..911e57350adaa95c5eeb2f9111d8f520a5bc182c 100644 (file)
--- a/gcc/tree-ssa-ccp.c
+++ b/gcc/tree-ssa-ccp.c
@@ -1053,21 +1053,35 @@ visit_assignment (tree stmt, tree *output_p)
       val = *nval;
     }
   else
-    {
-      /* Evaluate the statement.  */
+    /* Evaluate the statement.  */
       val = evaluate_stmt (stmt);
-    }
 
-  /* FIXME: Hack.  If this was a definition of a bitfield, we need to widen
+  /* If the original LHS was a VIEW_CONVERT_EXPR, modify the constant
+     value to be a VIEW_CONVERT_EXPR of the old constant value.  This is
+     valid because a VIEW_CONVERT_EXPR is valid everywhere an operand of
+     aggregate type is valid.
+
+     ??? Also, if this was a definition of a bitfield, we need to widen
      the constant value into the type of the destination variable.  This
      should not be necessary if GCC represented bitfields properly.  */
   {
-    tree lhs = TREE_OPERAND (stmt, 0);
+    tree orig_lhs = TREE_OPERAND (stmt, 0);
+
+    if (TREE_CODE (orig_lhs) == VIEW_CONVERT_EXPR
+       && val.lattice_val == CONSTANT)
+      {
+       val.const_val = build1 (VIEW_CONVERT_EXPR,
+                               TREE_TYPE (TREE_OPERAND (orig_lhs, 0)),
+                               val.const_val);
+       orig_lhs = TREE_OPERAND (orig_lhs, 1);
+      }
+
     if (val.lattice_val == CONSTANT
-       && TREE_CODE (lhs) == COMPONENT_REF
-       && DECL_BIT_FIELD (TREE_OPERAND (lhs, 1)))
+       && TREE_CODE (orig_lhs) == COMPONENT_REF
+       && DECL_BIT_FIELD (TREE_OPERAND (orig_lhs, 1)))
       {
-       tree w = widen_bitfield (val.const_val, TREE_OPERAND (lhs, 1), lhs);
+       tree w = widen_bitfield (val.const_val, TREE_OPERAND (orig_lhs, 1),
+                                orig_lhs);
 
        if (w && is_gimple_min_invariant (w))
          val.const_val = w;

diff --git a/gcc/tree-ssa-operands.c b/gcc/tree-ssa-operands.c
index 94a83d0184ba52ae5b532ea58271509b577fb24a..f8d70156aba40369b8ffe8a431d943935f20342d 100644 (file)
--- a/gcc/tree-ssa-operands.c
+++ b/gcc/tree-ssa-operands.c
@@ -893,20 +893,33 @@ build_ssa_operands (tree stmt, stmt_ann_t ann, stmt_operands_p old_ops,
   switch (code)
     {
     case MODIFY_EXPR:
-      get_expr_operands (stmt, &TREE_OPERAND (stmt, 1), opf_none);
-      if (TREE_CODE (TREE_OPERAND (stmt, 0)) == ARRAY_REF 
-         || TREE_CODE (TREE_OPERAND (stmt, 0)) == ARRAY_RANGE_REF
-         || TREE_CODE (TREE_OPERAND (stmt, 0)) == COMPONENT_REF
-         || TREE_CODE (TREE_OPERAND (stmt, 0)) == REALPART_EXPR
-         || TREE_CODE (TREE_OPERAND (stmt, 0)) == IMAGPART_EXPR
-         /* Use a V_MAY_DEF if the RHS might throw, as the LHS won't be
-            modified in that case.  FIXME we should represent somehow
-            that it is killed on the fallthrough path.  */
-         || tree_could_throw_p (TREE_OPERAND (stmt, 1)))
-        get_expr_operands (stmt, &TREE_OPERAND (stmt, 0), opf_is_def);
-      else
-        get_expr_operands (stmt, &TREE_OPERAND (stmt, 0), 
-                          opf_is_def | opf_kill_def);
+      /* First get operands from the RHS.  For the LHS, we use a V_MAY_DEF if
+        either only part of LHS is modified or if the RHS might throw,
+        otherwise, use V_MUST_DEF.
+
+        ??? If it might throw, we should represent somehow that it is killed
+        on the fallthrough path.  */
+      {
+       tree lhs = TREE_OPERAND (stmt, 0);
+       int lhs_flags = opf_is_def;
+
+       get_expr_operands (stmt, &TREE_OPERAND (stmt, 1), opf_none);
+
+       /* If the LHS is a VIEW_CONVERT_EXPR, it isn't changing whether
+          or not the entire LHS is modified; that depends on what's
+          inside the VIEW_CONVERT_EXPR.  */
+       if (TREE_CODE (lhs) == VIEW_CONVERT_EXPR)
+         lhs = TREE_OPERAND (lhs, 0);
+
+       if (TREE_CODE (lhs) != ARRAY_REF && TREE_CODE (lhs) != ARRAY_RANGE_REF
+           && TREE_CODE (lhs) != COMPONENT_REF
+           && TREE_CODE (lhs) != BIT_FIELD_REF
+           && TREE_CODE (lhs) != REALPART_EXPR
+           && TREE_CODE (lhs) != IMAGPART_EXPR)
+         lhs_flags |= opf_kill_def;
+
+        get_expr_operands (stmt, &TREE_OPERAND (stmt, 0), lhs_flags);
+      }
       break;
 
     case COND_EXPR: