X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=gcc%2Ftree-ssa-forwprop.c;h=20821ef8b981783f0edc5344a0a29e39af8efd5e;hb=b3f86a4f3fb7430f84442dcbb34db85625c7d44c;hp=2a56b79a42308b92f708a454d752693affcc26dd;hpb=752003127bcf897cc74b9417e170dd4c9d17eef1;p=pf3gnuchains%2Fgcc-fork.git diff --git a/gcc/tree-ssa-forwprop.c b/gcc/tree-ssa-forwprop.c index 2a56b79a423..20821ef8b98 100644 --- a/gcc/tree-ssa-forwprop.c +++ b/gcc/tree-ssa-forwprop.c @@ -369,16 +369,20 @@ rhs_to_tree (tree type, gimple stmt) considered simplified. */ static tree -combine_cond_expr_cond (location_t loc, enum tree_code code, tree type, +combine_cond_expr_cond (gimple stmt, enum tree_code code, tree type, tree op0, tree op1, bool invariant_only) { tree t; gcc_assert (TREE_CODE_CLASS (code) == tcc_comparison); - t = fold_binary_loc (loc, code, type, op0, op1); + fold_defer_overflow_warnings (); + t = fold_binary_loc (gimple_location (stmt), code, type, op0, op1); if (!t) - return NULL_TREE; + { + fold_undefer_overflow_warnings (false, NULL, 0); + return NULL_TREE; + } /* Require that we got a boolean type out if we put one in. */ gcc_assert (TREE_CODE (TREE_TYPE (t)) == TREE_CODE (type)); @@ -388,7 +392,12 @@ combine_cond_expr_cond (location_t loc, enum tree_code code, tree type, /* Bail out if we required an invariant but didn't get one. */ if (!t || (invariant_only && !is_gimple_min_invariant (t))) - return NULL_TREE; + { + fold_undefer_overflow_warnings (false, NULL, 0); + return NULL_TREE; + } + + fold_undefer_overflow_warnings (!gimple_no_warning_p (stmt), stmt, 0); return t; } @@ -398,7 +407,7 @@ combine_cond_expr_cond (location_t loc, enum tree_code code, tree type, were no simplifying combines. */ static tree -forward_propagate_into_comparison_1 (location_t loc, +forward_propagate_into_comparison_1 (gimple stmt, enum tree_code code, tree type, tree op0, tree op1) { @@ -414,7 +423,7 @@ forward_propagate_into_comparison_1 (location_t loc, if (def_stmt && can_propagate_from (def_stmt)) { rhs0 = rhs_to_tree (TREE_TYPE (op1), def_stmt); - tmp = combine_cond_expr_cond (loc, code, type, + tmp = combine_cond_expr_cond (stmt, code, type, rhs0, op1, !single_use0_p); if (tmp) return tmp; @@ -428,7 +437,7 @@ forward_propagate_into_comparison_1 (location_t loc, if (def_stmt && can_propagate_from (def_stmt)) { rhs1 = rhs_to_tree (TREE_TYPE (op0), def_stmt); - tmp = combine_cond_expr_cond (loc, code, type, + tmp = combine_cond_expr_cond (stmt, code, type, op0, rhs1, !single_use1_p); if (tmp) return tmp; @@ -438,7 +447,7 @@ forward_propagate_into_comparison_1 (location_t loc, /* If that wasn't successful either, try both operands. */ if (rhs0 != NULL_TREE && rhs1 != NULL_TREE) - tmp = combine_cond_expr_cond (loc, code, type, + tmp = combine_cond_expr_cond (stmt, code, type, rhs0, rhs1, !(single_use0_p && single_use1_p)); @@ -456,20 +465,19 @@ forward_propagate_into_comparison (gimple_stmt_iterator *gsi) gimple stmt = gsi_stmt (*gsi); tree tmp; bool cfg_changed = false; + tree type = TREE_TYPE (gimple_assign_lhs (stmt)); tree rhs1 = gimple_assign_rhs1 (stmt); tree rhs2 = gimple_assign_rhs2 (stmt); /* Combine the comparison with defining statements. */ - tmp = forward_propagate_into_comparison_1 (gimple_location (stmt), + tmp = forward_propagate_into_comparison_1 (stmt, gimple_assign_rhs_code (stmt), - TREE_TYPE - (gimple_assign_lhs (stmt)), - rhs1, rhs2); - if (tmp) + type, rhs1, rhs2); + if (tmp && useless_type_conversion_p (type, TREE_TYPE (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); @@ -491,7 +499,6 @@ forward_propagate_into_comparison (gimple_stmt_iterator *gsi) static int forward_propagate_into_gimple_cond (gimple stmt) { - location_t loc = gimple_location (stmt); tree tmp; enum tree_code code = gimple_cond_code (stmt); bool cfg_changed = false; @@ -502,7 +509,7 @@ forward_propagate_into_gimple_cond (gimple stmt) if (TREE_CODE_CLASS (gimple_cond_code (stmt)) != tcc_comparison) return 0; - tmp = forward_propagate_into_comparison_1 (loc, code, + tmp = forward_propagate_into_comparison_1 (stmt, code, boolean_type_node, rhs1, rhs2); if (tmp) @@ -526,45 +533,72 @@ forward_propagate_into_gimple_cond (gimple stmt) return (cfg_changed || is_gimple_min_invariant (tmp)) ? 2 : 1; } + /* Canonicalize _Bool == 0 and _Bool != 1 to _Bool != 0 by swapping edges. */ + if ((TREE_CODE (TREE_TYPE (rhs1)) == BOOLEAN_TYPE + || (INTEGRAL_TYPE_P (TREE_TYPE (rhs1)) + && TYPE_PRECISION (TREE_TYPE (rhs1)) == 1)) + && ((code == EQ_EXPR + && integer_zerop (rhs2)) + || (code == NE_EXPR + && integer_onep (rhs2)))) + { + basic_block bb = gimple_bb (stmt); + gimple_cond_set_code (stmt, NE_EXPR); + gimple_cond_set_rhs (stmt, build_zero_cst (TREE_TYPE (rhs1))); + EDGE_SUCC (bb, 0)->flags ^= (EDGE_TRUE_VALUE|EDGE_FALSE_VALUE); + EDGE_SUCC (bb, 1)->flags ^= (EDGE_TRUE_VALUE|EDGE_FALSE_VALUE); + return 1; + } + return 0; } /* Propagate from the ssa name definition statements of COND_EXPR in the rhs of statement STMT into the conditional if that simplifies it. - Returns zero if no statement was changed, one if there were - changes and two if cfg_cleanup needs to run. + Returns true zero if the stmt was changed. */ - This must be kept in sync with forward_propagate_into_gimple_cond. */ - -static int +static bool forward_propagate_into_cond (gimple_stmt_iterator *gsi_p) { gimple stmt = gsi_stmt (*gsi_p); - location_t loc = gimple_location (stmt); tree tmp = NULL_TREE; tree cond = gimple_assign_rhs1 (stmt); + bool swap = false; /* We can do tree combining on SSA_NAME and comparison expressions. */ if (COMPARISON_CLASS_P (cond)) - tmp = forward_propagate_into_comparison_1 (loc, TREE_CODE (cond), + tmp = forward_propagate_into_comparison_1 (stmt, TREE_CODE (cond), boolean_type_node, TREE_OPERAND (cond, 0), TREE_OPERAND (cond, 1)); else if (TREE_CODE (cond) == SSA_NAME) { - tree name = cond, rhs0; + enum tree_code code; + tree name = cond; gimple def_stmt = get_prop_source_stmt (name, true, NULL); if (!def_stmt || !can_propagate_from (def_stmt)) return 0; - rhs0 = gimple_assign_rhs1 (def_stmt); - tmp = combine_cond_expr_cond (loc, NE_EXPR, boolean_type_node, rhs0, - build_int_cst (TREE_TYPE (rhs0), 0), - false); + code = gimple_assign_rhs_code (def_stmt); + if (TREE_CODE_CLASS (code) == tcc_comparison) + tmp = fold_build2_loc (gimple_location (def_stmt), + code, + boolean_type_node, + gimple_assign_rhs1 (def_stmt), + gimple_assign_rhs2 (def_stmt)); + else if ((code == BIT_NOT_EXPR + && TYPE_PRECISION (TREE_TYPE (cond)) == 1) + || (code == BIT_XOR_EXPR + && integer_onep (gimple_assign_rhs2 (def_stmt)))) + { + tmp = gimple_assign_rhs1 (def_stmt); + swap = true; + } } - if (tmp) + if (tmp + && is_gimple_condexpr (tmp)) { if (dump_file && tmp) { @@ -575,11 +609,24 @@ forward_propagate_into_cond (gimple_stmt_iterator *gsi_p) fprintf (dump_file, "'\n"); } - gimple_assign_set_rhs_from_tree (gsi_p, unshare_expr (tmp)); + if (integer_onep (tmp)) + gimple_assign_set_rhs_from_tree (gsi_p, gimple_assign_rhs2 (stmt)); + else if (integer_zerop (tmp)) + gimple_assign_set_rhs_from_tree (gsi_p, gimple_assign_rhs3 (stmt)); + else + { + gimple_assign_set_rhs1 (stmt, unshare_expr (tmp)); + if (swap) + { + tree t = gimple_assign_rhs2 (stmt); + gimple_assign_set_rhs2 (stmt, gimple_assign_rhs3 (stmt)); + gimple_assign_set_rhs3 (stmt, t); + } + } stmt = gsi_stmt (*gsi_p); update_stmt (stmt); - return is_gimple_min_invariant (tmp) ? 2 : 1; + return true; } return 0; @@ -717,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; } @@ -867,7 +910,7 @@ forward_propagate_addr_expr_1 (tree name, tree def_rhs, TREE_TYPE (gimple_assign_rhs1 (use_stmt)))) { tree *def_rhs_basep = &TREE_OPERAND (def_rhs, 0); - tree new_offset, new_base, saved; + tree new_offset, new_base, saved, new_lhs; while (handled_component_p (*def_rhs_basep)) def_rhs_basep = &TREE_OPERAND (*def_rhs_basep, 0); saved = *def_rhs_basep; @@ -886,9 +929,12 @@ forward_propagate_addr_expr_1 (tree name, tree def_rhs, *def_rhs_basep = build2 (MEM_REF, TREE_TYPE (*def_rhs_basep), new_base, new_offset); TREE_THIS_VOLATILE (*def_rhs_basep) = TREE_THIS_VOLATILE (lhs); + TREE_SIDE_EFFECTS (*def_rhs_basep) = TREE_SIDE_EFFECTS (lhs); TREE_THIS_NOTRAP (*def_rhs_basep) = TREE_THIS_NOTRAP (lhs); - gimple_assign_set_lhs (use_stmt, - unshare_expr (TREE_OPERAND (def_rhs, 0))); + new_lhs = unshare_expr (TREE_OPERAND (def_rhs, 0)); + gimple_assign_set_lhs (use_stmt, new_lhs); + TREE_THIS_VOLATILE (new_lhs) = TREE_THIS_VOLATILE (lhs); + TREE_SIDE_EFFECTS (new_lhs) = TREE_SIDE_EFFECTS (lhs); *def_rhs_basep = saved; tidy_after_forward_propagate_addr (use_stmt); /* Continue propagating into the RHS if this was not the @@ -935,7 +981,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; } @@ -948,7 +994,7 @@ forward_propagate_addr_expr_1 (tree name, tree def_rhs, TREE_TYPE (TREE_OPERAND (def_rhs, 0)))) { tree *def_rhs_basep = &TREE_OPERAND (def_rhs, 0); - tree new_offset, new_base, saved; + tree new_offset, new_base, saved, new_rhs; while (handled_component_p (*def_rhs_basep)) def_rhs_basep = &TREE_OPERAND (*def_rhs_basep, 0); saved = *def_rhs_basep; @@ -967,11 +1013,14 @@ forward_propagate_addr_expr_1 (tree name, tree def_rhs, *def_rhs_basep = build2 (MEM_REF, TREE_TYPE (*def_rhs_basep), new_base, new_offset); TREE_THIS_VOLATILE (*def_rhs_basep) = TREE_THIS_VOLATILE (rhs); + TREE_SIDE_EFFECTS (*def_rhs_basep) = TREE_SIDE_EFFECTS (rhs); TREE_THIS_NOTRAP (*def_rhs_basep) = TREE_THIS_NOTRAP (rhs); - gimple_assign_set_rhs1 (use_stmt, - unshare_expr (TREE_OPERAND (def_rhs, 0))); + new_rhs = unshare_expr (TREE_OPERAND (def_rhs, 0)); + gimple_assign_set_rhs1 (use_stmt, new_rhs); + TREE_THIS_VOLATILE (new_rhs) = TREE_THIS_VOLATILE (rhs); + TREE_SIDE_EFFECTS (new_rhs) = TREE_SIDE_EFFECTS (rhs); *def_rhs_basep = saved; - fold_stmt_inplace (use_stmt); + fold_stmt_inplace (use_stmt_gsi); tidy_after_forward_propagate_addr (use_stmt); return res; } @@ -995,31 +1044,21 @@ forward_propagate_addr_expr_1 (tree name, tree def_rhs, return false; rhs2 = gimple_assign_rhs2 (use_stmt); - /* Try to optimize &x[C1] p+ C2 where C2 is a multiple of the size - of the elements in X into &x[C1 + C2/element size]. */ + /* Optimize &x[C1] p+ C2 to &x p+ C3 with C3 = C1 * element_size + C2. */ if (TREE_CODE (rhs2) == INTEGER_CST) { - tree new_rhs = maybe_fold_stmt_addition (gimple_location (use_stmt), - TREE_TYPE (def_rhs), - def_rhs, rhs2); - if (new_rhs) - { - tree type = TREE_TYPE (gimple_assign_lhs (use_stmt)); - new_rhs = unshare_expr (new_rhs); - if (!useless_type_conversion_p (type, TREE_TYPE (new_rhs))) - { - if (!is_gimple_min_invariant (new_rhs)) - new_rhs = force_gimple_operand_gsi (use_stmt_gsi, new_rhs, - true, NULL_TREE, - true, GSI_SAME_STMT); - new_rhs = fold_convert (type, new_rhs); - } - gimple_assign_set_rhs_from_tree (use_stmt_gsi, new_rhs); - use_stmt = gsi_stmt (*use_stmt_gsi); - update_stmt (use_stmt); - tidy_after_forward_propagate_addr (use_stmt); - return true; - } + tree new_rhs = build1_loc (gimple_location (use_stmt), + ADDR_EXPR, TREE_TYPE (def_rhs), + fold_build2 (MEM_REF, + TREE_TYPE (TREE_TYPE (def_rhs)), + unshare_expr (def_rhs), + fold_convert (ptr_type_node, + rhs2))); + gimple_assign_set_rhs_from_tree (use_stmt_gsi, new_rhs); + use_stmt = gsi_stmt (*use_stmt_gsi); + update_stmt (use_stmt); + tidy_after_forward_propagate_addr (use_stmt); + return true; } /* Try to optimize &x[0] p+ OFFSET where OFFSET is defined by @@ -1509,7 +1548,7 @@ simplify_builtin_call (gimple_stmt_iterator *gsi_p, tree callee2) || use_stmt != stmt2)) break; - ptr1_align = get_pointer_alignment (ptr1, BIGGEST_ALIGNMENT); + ptr1_align = get_pointer_alignment (ptr1); /* Construct the new source string literal. */ src_buf = XALLOCAVEC (char, src_len + 1); if (callee1) @@ -1563,7 +1602,8 @@ simplify_builtin_call (gimple_stmt_iterator *gsi_p, tree callee2) if (!is_gimple_val (ptr1)) ptr1 = force_gimple_operand_gsi (gsi_p, ptr1, true, NULL_TREE, true, GSI_SAME_STMT); - gimple_call_set_fndecl (stmt2, built_in_decls [BUILT_IN_MEMCPY]); + gimple_call_set_fndecl (stmt2, + builtin_decl_explicit (BUILT_IN_MEMCPY)); gimple_call_set_arg (stmt2, 0, ptr1); gimple_call_set_arg (stmt2, 1, new_str_cst); gimple_call_set_arg (stmt2, 2, @@ -1869,12 +1909,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. */ @@ -1949,7 +1989,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); @@ -1969,8 +2008,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) @@ -1980,8 +2019,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 @@ -2031,8 +2070,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 @@ -2042,8 +2081,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); } } @@ -2069,8 +2108,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) @@ -2081,8 +2120,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 @@ -2131,8 +2170,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); } } @@ -2142,7 +2181,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))) @@ -2376,21 +2415,23 @@ ssa_forward_propagate_and_combine (void) else gsi_next (&gsi); } - else if (code == POINTER_PLUS_EXPR && can_propagate_from (stmt)) + else if (code == POINTER_PLUS_EXPR) { - if (TREE_CODE (gimple_assign_rhs2 (stmt)) == INTEGER_CST + tree off = gimple_assign_rhs2 (stmt); + if (TREE_CODE (off) == INTEGER_CST + && can_propagate_from (stmt) + && !simple_iv_increment_p (stmt) /* ??? Better adjust the interface to that function instead of building new trees here. */ && forward_propagate_addr_expr - (lhs, - build1 (ADDR_EXPR, - TREE_TYPE (rhs), - fold_build2 (MEM_REF, - TREE_TYPE (TREE_TYPE (rhs)), - rhs, - fold_convert - (ptr_type_node, - gimple_assign_rhs2 (stmt)))))) + (lhs, + build1_loc (gimple_location (stmt), + ADDR_EXPR, TREE_TYPE (rhs), + fold_build2 (MEM_REF, + TREE_TYPE (TREE_TYPE (rhs)), + rhs, + fold_convert (ptr_type_node, + off))))) { release_defs (stmt); todoflags |= TODO_remove_unused_locals; @@ -2399,7 +2440,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); @@ -2439,28 +2480,15 @@ ssa_forward_propagate_and_combine (void) else if (code == COND_EXPR) { /* In this case the entire COND_EXPR is in rhs1. */ - int did_something; - fold_defer_overflow_warnings (); - did_something = forward_propagate_into_cond (&gsi); + changed |= forward_propagate_into_cond (&gsi); stmt = gsi_stmt (gsi); - if (did_something == 2) - cfg_changed = true; - fold_undefer_overflow_warnings - (!TREE_NO_WARNING (rhs1) && did_something, stmt, - WARN_STRICT_OVERFLOW_CONDITIONAL); - changed = did_something != 0; } else if (TREE_CODE_CLASS (code) == tcc_comparison) { - bool no_warning = gimple_no_warning_p (stmt); int did_something; - fold_defer_overflow_warnings (); did_something = forward_propagate_into_comparison (&gsi); if (did_something == 2) cfg_changed = true; - fold_undefer_overflow_warnings - (!no_warning && changed, - stmt, WARN_STRICT_OVERFLOW_CONDITIONAL); changed = did_something != 0; } else if (code == BIT_AND_EXPR @@ -2469,7 +2497,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) @@ -2489,12 +2517,9 @@ ssa_forward_propagate_and_combine (void) case GIMPLE_COND: { int did_something; - fold_defer_overflow_warnings (); did_something = forward_propagate_into_gimple_cond (stmt); if (did_something == 2) cfg_changed = true; - fold_undefer_overflow_warnings - (did_something, stmt, WARN_STRICT_OVERFLOW_CONDITIONAL); changed = did_something != 0; break; }