2005-12-13 Petr Machata <machata@post.cz>

[pf3gnuchains/gcc-fork.git] / gcc / tree-ssa-ccp.c

diff --git a/gcc/tree-ssa-ccp.c b/gcc/tree-ssa-ccp.c
index 6ec112a..39ba4a8 100644 (file)
--- a/gcc/tree-ssa-ccp.c
+++ b/gcc/tree-ssa-ccp.c
@@ -273,6 +273,32 @@ debug_lattice_value (prop_value_t val)
 }
 
 
+/* The regular is_gimple_min_invariant does a shallow test of the object.
+   It assumes that full gimplification has happened, or will happen on the
+   object.  For a value coming from DECL_INITIAL, this is not true, so we
+   have to be more strict outselves.  */
+
+static bool
+ccp_decl_initial_min_invariant (tree t)
+{
+  if (!is_gimple_min_invariant (t))
+    return false;
+  if (TREE_CODE (t) == ADDR_EXPR)
+    {
+      /* Inline and unroll is_gimple_addressable.  */
+      while (1)
+       {
+         t = TREE_OPERAND (t, 0);
+         if (is_gimple_id (t))
+           return true;
+         if (!handled_component_p (t))
+           return false;
+       }
+    }
+  return true;
+}
+
+
 /* Compute a default value for variable VAR and store it in the
    CONST_VAL array.  The following rules are used to get default
    values:
@@ -316,8 +342,9 @@ get_default_value (tree var)
     }
   else if (TREE_STATIC (sym)
           && TREE_READONLY (sym)
+          && !MTAG_P (sym)
           && DECL_INITIAL (sym)
-          && is_gimple_min_invariant (DECL_INITIAL (sym)))
+          && ccp_decl_initial_min_invariant (DECL_INITIAL (sym)))
     {
       /* Globals and static variables declared 'const' take their
         initial value.  */
@@ -473,6 +500,9 @@ likely_value (tree stmt)
       && TREE_CODE (stmt) != SWITCH_EXPR)
     return VARYING;
 
+  if (is_gimple_min_invariant (get_rhs (stmt)))
+    return CONSTANT;
+
   found_constant = false;
   FOR_EACH_SSA_TREE_OPERAND (use, stmt, iter, SSA_OP_USE|SSA_OP_VUSE)
     {
@@ -658,7 +688,8 @@ ccp_lattice_meet (prop_value_t *val1, prop_value_t *val2)
           && val2->lattice_val == CONSTANT
           && simple_cst_equal (val1->value, val2->value) == 1
           && (!do_store_ccp
-              || simple_cst_equal (val1->mem_ref, val2->mem_ref) == 1))
+              || (val1->mem_ref && val2->mem_ref
+                  && operand_equal_p (val1->mem_ref, val2->mem_ref, 0))))
     {
       /* Ci M Cj = Ci          if (i == j)
         Ci M Cj = VARYING      if (i != j)
@@ -826,7 +857,8 @@ ccp_fold (tree stmt)
       /* If the RHS is a memory load, see if the VUSEs associated with
         it are a valid constant for that memory load.  */
       prop_value_t *val = get_value_loaded_by (stmt, const_val);
-      if (val && simple_cst_equal (val->mem_ref, rhs) == 1)
+      if (val && val->mem_ref
+         && operand_equal_p (val->mem_ref, rhs, 0))
        return val->value;
       else
        return NULL_TREE;
@@ -848,6 +880,10 @@ ccp_fold (tree stmt)
            op0 = get_value (op0, true)->value;
        }
 
+      if ((code == NOP_EXPR || code == CONVERT_EXPR)
+         && tree_ssa_useless_type_conversion_1 (TREE_TYPE (rhs),
+                                                TREE_TYPE (op0)))
+       return op0;
       return fold_unary (code, TREE_TYPE (rhs), op0);
     }
 
@@ -1040,6 +1076,15 @@ fold_const_aggregate_ref (tree t)
          return cval;
       break;
 
+    case REALPART_EXPR:
+    case IMAGPART_EXPR:
+      {
+       tree c = fold_const_aggregate_ref (TREE_OPERAND (t, 0));
+       if (c && TREE_CODE (c) == COMPLEX_CST)
+         return fold_build1 (TREE_CODE (t), TREE_TYPE (t), c);
+       break;
+      }
+    
     default:
       break;
     }
@@ -1085,7 +1130,11 @@ evaluate_stmt (tree stmt)
       /* The statement produced a nonconstant value.  If the statement
         had UNDEFINED operands, then the result of the statement
         should be UNDEFINED.  Otherwise, the statement is VARYING.  */
-      val.lattice_val = (likelyvalue == UNDEFINED) ? UNDEFINED : VARYING;
+      if (likelyvalue == UNDEFINED || likelyvalue == UNKNOWN_VAL)
+       val.lattice_val = likelyvalue;
+      else
+       val.lattice_val = VARYING;
+
       val.value = NULL_TREE;
     }
 
@@ -1122,7 +1171,8 @@ visit_assignment (tree stmt, tree *output_p)
         we can propagate the value on the RHS.  */
       prop_value_t *nval = get_value_loaded_by (stmt, const_val);
 
-      if (nval && simple_cst_equal (nval->mem_ref, rhs) == 1)
+      if (nval && nval->mem_ref
+         && operand_equal_p (nval->mem_ref, rhs, 0))
        val = *nval;
       else
        val = evaluate_stmt (stmt);
@@ -1540,9 +1590,9 @@ maybe_fold_offset_to_array_ref (tree base, tree offset, tree orig_type)
   if (!integer_zerop (elt_offset))
     idx = int_const_binop (PLUS_EXPR, idx, elt_offset, 0);
 
-  return build (ARRAY_REF, orig_type, base, idx, min_idx,
-               size_int (tree_low_cst (elt_size, 1)
-                         / (TYPE_ALIGN_UNIT (elt_type))));
+  return build4 (ARRAY_REF, orig_type, base, idx, min_idx,
+                size_int (tree_low_cst (elt_size, 1)
+                          / (TYPE_ALIGN_UNIT (elt_type))));
 }
 
 
@@ -1603,7 +1653,7 @@ maybe_fold_offset_to_component_ref (tree record_type, tree base, tree offset,
        {
          if (base_is_ptr)
            base = build1 (INDIRECT_REF, record_type, base);
-         t = build (COMPONENT_REF, field_type, base, f, NULL_TREE);
+         t = build3 (COMPONENT_REF, field_type, base, f, NULL_TREE);
          return t;
        }
       
@@ -1643,7 +1693,7 @@ maybe_fold_offset_to_component_ref (tree record_type, tree base, tree offset,
      nonzero offset into them.  Recurse and hope for a valid match.  */
   if (base_is_ptr)
     base = build1 (INDIRECT_REF, record_type, base);
-  base = build (COMPONENT_REF, field_type, base, f, NULL_TREE);
+  base = build3 (COMPONENT_REF, field_type, base, f, NULL_TREE);
 
   t = maybe_fold_offset_to_array_ref (base, offset, orig_type);
   if (t)
@@ -1693,7 +1743,7 @@ maybe_fold_stmt_indirect (tree expr, tree base, tree offset)
 
       /* Fold away CONST_DECL to its value, if the type is scalar.  */
       if (TREE_CODE (base) == CONST_DECL
-         && is_gimple_min_invariant (DECL_INITIAL (base)))
+         && ccp_decl_initial_min_invariant (DECL_INITIAL (base)))
        return DECL_INITIAL (base);
 
       /* Try folding *(&B+O) to B[X].  */
@@ -1908,7 +1958,7 @@ fold_stmt_r (tree *expr_p, int *walk_subtrees, void *data)
       /* Set TREE_INVARIANT properly so that the value is properly
         considered constant, and so gets propagated as expected.  */
       if (*changed_p)
-        recompute_tree_invarant_for_addr_expr (expr);
+        recompute_tree_invariant_for_addr_expr (expr);
       return NULL_TREE;
 
     case PLUS_EXPR:
@@ -2441,7 +2491,7 @@ execute_fold_all_builtins (void)
                  gcc_assert (ok);
                }
            }
-         update_stmt (*stmtp);
+         mark_new_vars_to_rename (*stmtp);
          if (maybe_clean_or_replace_eh_stmt (old_stmt, *stmtp)
              && tree_purge_dead_eh_edges (bb))
            cfg_changed = true;