OSDN Git Service

2011-09-09 Richard Guenther <rguenther@suse.de>
authorrguenth <rguenth@138bc75d-0d04-0410-961f-82ee72b054a4>
Fri, 9 Sep 2011 11:52:51 +0000 (11:52 +0000)
committerrguenth <rguenth@138bc75d-0d04-0410-961f-82ee72b054a4>
Fri, 9 Sep 2011 11:52:51 +0000 (11:52 +0000)
* gimple.h (fold_stmt_inplace): Adjust to take a gimple_stmt_iterator
instead of a statement.
* gimple-fold.c (fold_stmt_inplace): Likewise.
* sese.c (graphite_copy_stmts_from_block): Adjust.
* tree-ssa-dom.c (propagate_rhs_into_lhs): Likewise.
* tree-ssa-forwprop.c (forward_propagate_into_comparison): Use
fold_stmt.
(forward_propagate_addr_into_variable_array_index): Likewise.
(forward_propagate_addr_expr_1): adjust.
(associate_plusminus): Likewise.
(ssa_forward_propagate_and_combine): Likewise.
* tree-ssa-mathopts.c (replace_reciprocal): Adjust.
(execute_cse_reciprocals): Likewise.
* tree-ssa.c (insert_debug_temp_for_var_def): Adjust.

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

gcc/ChangeLog
gcc/gimple-fold.c
gcc/gimple.h
gcc/sese.c
gcc/tree-ssa-dom.c
gcc/tree-ssa-forwprop.c
gcc/tree-ssa-math-opts.c
gcc/tree-ssa.c

index 4ede8ce..8a7e54a 100644 (file)
@@ -1,3 +1,20 @@
+2011-09-09  Richard Guenther  <rguenther@suse.de>
+
+       * gimple.h (fold_stmt_inplace): Adjust to take a gimple_stmt_iterator
+       instead of a statement.
+       * gimple-fold.c (fold_stmt_inplace): Likewise.
+       * sese.c (graphite_copy_stmts_from_block): Adjust.
+       * tree-ssa-dom.c (propagate_rhs_into_lhs): Likewise.
+       * tree-ssa-forwprop.c (forward_propagate_into_comparison): Use
+       fold_stmt.
+       (forward_propagate_addr_into_variable_array_index): Likewise.
+       (forward_propagate_addr_expr_1): adjust.
+       (associate_plusminus): Likewise.
+       (ssa_forward_propagate_and_combine): Likewise.
+       * tree-ssa-mathopts.c (replace_reciprocal): Adjust.
+       (execute_cse_reciprocals): Likewise.
+       * tree-ssa.c (insert_debug_temp_for_var_def): Adjust.
+
 2011-09-09  Nick Clifton  <nickc@redhat.com>
 
        * config/mn10300/mn10300.c (mn10300_split_and_operand_count):
index 9500a6a..d8da030 100644 (file)
@@ -1286,20 +1286,20 @@ fold_stmt (gimple_stmt_iterator *gsi)
   return fold_stmt_1 (gsi, false);
 }
 
-/* Perform the minimal folding on statement STMT.  Only operations like
+/* Perform the minimal folding on statement *GSI.  Only operations like
    *&x created by constant propagation are handled.  The statement cannot
    be replaced with a new one.  Return true if the statement was
    changed, false otherwise.
-   The statement STMT should be in valid gimple form but may
+   The statement *GSI should be in valid gimple form but may
    be in unfolded state as resulting from for example constant propagation
    which can produce *&x = 0.  */
 
 bool
-fold_stmt_inplace (gimple stmt)
+fold_stmt_inplace (gimple_stmt_iterator *gsi)
 {
-  gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
-  bool changed = fold_stmt_1 (&gsi, true);
-  gcc_assert (gsi_stmt (gsi) == stmt);
+  gimple stmt = gsi_stmt (*gsi);
+  bool changed = fold_stmt_1 (gsi, true);
+  gcc_assert (gsi_stmt (*gsi) == stmt);
   return changed;
 }
 
index 80b6cbd..46d8373 100644 (file)
@@ -5068,7 +5068,7 @@ extern void dump_gimple_statistics (void);
 void gimplify_and_update_call_from_tree (gimple_stmt_iterator *, tree);
 tree gimple_fold_builtin (gimple);
 bool fold_stmt (gimple_stmt_iterator *);
-bool fold_stmt_inplace (gimple);
+bool fold_stmt_inplace (gimple_stmt_iterator *);
 tree get_symbol_constant_value (tree);
 tree canonicalize_constructor_val (tree);
 extern tree maybe_fold_and_comparisons (enum tree_code, tree, tree, 
index 10a0581..492667e 100644 (file)
@@ -620,7 +620,10 @@ graphite_copy_stmts_from_block (basic_block bb, basic_block new_bb,
 
       if (rename_uses (copy, rename_map, &gsi_tgt, region, loop, iv_map,
                       gloog_error))
-       fold_stmt_inplace (copy);
+       {
+         gcc_assert (gsi_stmt (gsi_tgt) == copy);
+         fold_stmt_inplace (&gsi_tgt);
+       }
 
       update_stmt (copy);
     }
index 18923ae..3902b5c 100644 (file)
@@ -2656,7 +2656,10 @@ propagate_rhs_into_lhs (gimple stmt, tree lhs, tree rhs, bitmap interesting_name
              GIMPLE_ASSIGN, and there is no way to effect such a
              transformation in-place.  We might want to consider
              using the more general fold_stmt here.  */
-         fold_stmt_inplace (use_stmt);
+           {
+             gimple_stmt_iterator gsi = gsi_for_stmt (use_stmt);
+             fold_stmt_inplace (&gsi);
+           }
 
          /* Sometimes propagation can expose new operands to the
             renamer.  */
index 6333ed6..a8737da 100644 (file)
@@ -477,8 +477,8 @@ forward_propagate_into_comparison (gimple_stmt_iterator *gsi)
   if (tmp)
     {
       gimple_assign_set_rhs_from_tree (gsi, tmp);
-      fold_stmt_inplace (stmt);
-      update_stmt (stmt);
+      fold_stmt (gsi);
+      update_stmt (gsi_stmt (*gsi));
 
       if (TREE_CODE (rhs1) == SSA_NAME)
        cfg_changed |= remove_prop_source_from_use (rhs1);
@@ -764,12 +764,8 @@ forward_propagate_addr_into_variable_array_index (tree offset,
        }
     }
   gimple_assign_set_rhs_from_tree (use_stmt_gsi, new_rhs);
-  use_stmt = gsi_stmt (*use_stmt_gsi);
-
-  /* That should have created gimple, so there is no need to
-     record information to undo the propagation.  */
-  fold_stmt_inplace (use_stmt);
-  tidy_after_forward_propagate_addr (use_stmt);
+  fold_stmt (use_stmt_gsi);
+  tidy_after_forward_propagate_addr (gsi_stmt (*use_stmt_gsi));
   return true;
 }
 
@@ -982,7 +978,7 @@ forward_propagate_addr_expr_1 (tree name, tree def_rhs,
          TREE_OPERAND (rhs, 0) = new_ptr;
          TREE_OPERAND (rhs, 1)
            = double_int_to_tree (TREE_TYPE (TREE_OPERAND (rhs, 1)), off);
-         fold_stmt_inplace (use_stmt);
+         fold_stmt_inplace (use_stmt_gsi);
          tidy_after_forward_propagate_addr (use_stmt);
          return res;
        }
@@ -1018,7 +1014,7 @@ forward_propagate_addr_expr_1 (tree name, tree def_rhs,
          gimple_assign_set_rhs1 (use_stmt,
                                  unshare_expr (TREE_OPERAND (def_rhs, 0)));
          *def_rhs_basep = saved;
-         fold_stmt_inplace (use_stmt);
+         fold_stmt_inplace (use_stmt_gsi);
          tidy_after_forward_propagate_addr (use_stmt);
          return res;
        }
@@ -1906,12 +1902,12 @@ simplify_bitwise_binary (gimple_stmt_iterator *gsi)
    always permitted.  Returns true if the CFG was changed.  */
 
 static bool
-associate_plusminus (gimple stmt)
+associate_plusminus (gimple_stmt_iterator *gsi)
 {
+  gimple stmt = gsi_stmt (*gsi);
   tree rhs1 = gimple_assign_rhs1 (stmt);
   tree rhs2 = gimple_assign_rhs2 (stmt);
   enum tree_code code = gimple_assign_rhs_code (stmt);
-  gimple_stmt_iterator gsi;
   bool changed;
 
   /* We can't reassociate at all for saturating types.  */
@@ -1986,7 +1982,6 @@ associate_plusminus (gimple stmt)
      via commutating the addition and contracting operations to zero
      by reassociation.  */
 
-  gsi = gsi_for_stmt (stmt);
   if (TREE_CODE (rhs1) == SSA_NAME)
     {
       gimple def_stmt = SSA_NAME_DEF_STMT (rhs1);
@@ -2006,8 +2001,8 @@ associate_plusminus (gimple stmt)
                          ? TREE_CODE (def_rhs2) : NEGATE_EXPR);
                  rhs1 = def_rhs2;
                  rhs2 = NULL_TREE;
-                 gimple_assign_set_rhs_with_ops (&gsi, code, rhs1, NULL_TREE);
-                 gcc_assert (gsi_stmt (gsi) == stmt);
+                 gimple_assign_set_rhs_with_ops (gsi, code, rhs1, NULL_TREE);
+                 gcc_assert (gsi_stmt (*gsi) == stmt);
                  gimple_set_modified (stmt, true);
                }
              else if (operand_equal_p (def_rhs2, rhs2, 0)
@@ -2017,8 +2012,8 @@ associate_plusminus (gimple stmt)
                  code = TREE_CODE (def_rhs1);
                  rhs1 = def_rhs1;
                  rhs2 = NULL_TREE;
-                 gimple_assign_set_rhs_with_ops (&gsi, code, rhs1, NULL_TREE);
-                 gcc_assert (gsi_stmt (gsi) == stmt);
+                 gimple_assign_set_rhs_with_ops (gsi, code, rhs1, NULL_TREE);
+                 gcc_assert (gsi_stmt (*gsi) == stmt);
                  gimple_set_modified (stmt, true);
                }
              else if (TREE_CODE (rhs2) == INTEGER_CST
@@ -2068,8 +2063,8 @@ associate_plusminus (gimple stmt)
                  code = INTEGER_CST;
                  rhs1 = build_int_cst_type (TREE_TYPE (rhs2), -1);
                  rhs2 = NULL_TREE;
-                 gimple_assign_set_rhs_with_ops (&gsi, code, rhs1, NULL_TREE);
-                 gcc_assert (gsi_stmt (gsi) == stmt);
+                 gimple_assign_set_rhs_with_ops (gsi, code, rhs1, NULL_TREE);
+                 gcc_assert (gsi_stmt (*gsi) == stmt);
                  gimple_set_modified (stmt, true);
                }
              else if (code == PLUS_EXPR
@@ -2079,8 +2074,8 @@ associate_plusminus (gimple stmt)
                  code = NEGATE_EXPR;
                  rhs1 = def_rhs1;
                  rhs2 = NULL_TREE;
-                 gimple_assign_set_rhs_with_ops (&gsi, code, rhs1, NULL_TREE);
-                 gcc_assert (gsi_stmt (gsi) == stmt);
+                 gimple_assign_set_rhs_with_ops (gsi, code, rhs1, NULL_TREE);
+                 gcc_assert (gsi_stmt (*gsi) == stmt);
                  gimple_set_modified (stmt, true);
                }
            }
@@ -2106,8 +2101,8 @@ associate_plusminus (gimple stmt)
                          ? NEGATE_EXPR : TREE_CODE (def_rhs2));
                  rhs1 = def_rhs2;
                  rhs2 = NULL_TREE;
-                 gimple_assign_set_rhs_with_ops (&gsi, code, rhs1, NULL_TREE);
-                 gcc_assert (gsi_stmt (gsi) == stmt);
+                 gimple_assign_set_rhs_with_ops (gsi, code, rhs1, NULL_TREE);
+                 gcc_assert (gsi_stmt (*gsi) == stmt);
                  gimple_set_modified (stmt, true);
                }
              else if (operand_equal_p (def_rhs2, rhs1, 0)
@@ -2118,8 +2113,8 @@ associate_plusminus (gimple stmt)
                          ? TREE_CODE (def_rhs1) : NEGATE_EXPR);
                  rhs1 = def_rhs1;
                  rhs2 = NULL_TREE;
-                 gimple_assign_set_rhs_with_ops (&gsi, code, rhs1, NULL_TREE);
-                 gcc_assert (gsi_stmt (gsi) == stmt);
+                 gimple_assign_set_rhs_with_ops (gsi, code, rhs1, NULL_TREE);
+                 gcc_assert (gsi_stmt (*gsi) == stmt);
                  gimple_set_modified (stmt, true);
                }
              else if (TREE_CODE (rhs1) == INTEGER_CST
@@ -2168,8 +2163,8 @@ associate_plusminus (gimple stmt)
                  code = INTEGER_CST;
                  rhs1 = build_int_cst_type (TREE_TYPE (rhs1), -1);
                  rhs2 = NULL_TREE;
-                 gimple_assign_set_rhs_with_ops (&gsi, code, rhs1, NULL_TREE);
-                 gcc_assert (gsi_stmt (gsi) == stmt);
+                 gimple_assign_set_rhs_with_ops (gsi, code, rhs1, NULL_TREE);
+                 gcc_assert (gsi_stmt (*gsi) == stmt);
                  gimple_set_modified (stmt, true);
                }
            }
@@ -2179,7 +2174,7 @@ associate_plusminus (gimple stmt)
 out:
   if (gimple_modified_p (stmt))
     {
-      fold_stmt_inplace (stmt);
+      fold_stmt_inplace (gsi);
       update_stmt (stmt);
       if (maybe_clean_or_replace_eh_stmt (stmt, stmt)
          && gimple_purge_dead_eh_edges (gimple_bb (stmt)))
@@ -2438,7 +2433,7 @@ ssa_forward_propagate_and_combine (void)
              else if (is_gimple_min_invariant (rhs))
                {
                  /* Make sure to fold &a[0] + off_1 here.  */
-                 fold_stmt_inplace (stmt);
+                 fold_stmt_inplace (&gsi);
                  update_stmt (stmt);
                  if (gimple_assign_rhs_code (stmt) == POINTER_PLUS_EXPR)
                    gsi_next (&gsi);
@@ -2495,7 +2490,7 @@ ssa_forward_propagate_and_combine (void)
                  changed = simplify_bitwise_binary (&gsi);
                else if (code == PLUS_EXPR
                         || code == MINUS_EXPR)
-                 changed = associate_plusminus (stmt);
+                 changed = associate_plusminus (&gsi);
                else if (CONVERT_EXPR_CODE_P (code)
                         || code == FLOAT_EXPR
                         || code == FIX_TRUNC_EXPR)
index b8591f9..ed99802 100644 (file)
@@ -398,9 +398,10 @@ replace_reciprocal (use_operand_p use_p)
   if (optimize_bb_for_speed_p (bb)
       && occ->recip_def && use_stmt != occ->recip_def_stmt)
     {
+      gimple_stmt_iterator gsi = gsi_for_stmt (use_stmt);
       gimple_assign_set_rhs_code (use_stmt, MULT_EXPR);
       SET_USE (use_p, occ->recip_def);
-      fold_stmt_inplace (use_stmt);
+      fold_stmt_inplace (&gsi);
       update_stmt (use_stmt);
     }
 }
@@ -610,8 +611,9 @@ execute_cse_reciprocals (void)
 
                  FOR_EACH_IMM_USE_STMT (stmt, ui, arg1)
                    {
+                     gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
                      gimple_assign_set_rhs_code (stmt, MULT_EXPR);
-                     fold_stmt_inplace (stmt);
+                     fold_stmt_inplace (&gsi);
                      update_stmt (stmt);
                    }
                }
index 7564a52..a011593 100644 (file)
@@ -471,7 +471,10 @@ insert_debug_temp_for_var_def (gimple_stmt_iterator *gsi, tree var)
          /* If we didn't replace uses with a debug decl fold the
             resulting expression.  Otherwise we end up with invalid IL.  */
          if (TREE_CODE (value) != DEBUG_EXPR_DECL)
-           fold_stmt_inplace (stmt);
+           {
+             gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
+             fold_stmt_inplace (&gsi);
+           }
        }
       else
        gimple_debug_bind_reset_value (stmt);