This adds support to match_simplify_replacement to allowing of the
middle-bbs to have more than 1 statement in a few cases. If we are
replacing the both middle bbs with a fully independent sequence we
can handle that. If we are replacing with a sequence that depends
on the first statement of either (or both) blocks, this allows that.
If the result is defined by part or fully of one of the middle bbs.
Then make the whole bb unconditional.
Note the middle bbs still need to have statements that can't trap nor have
side effects. And each of the statements need to feed into the next instruction
and including into the phi. And there is a limited number of stmts is allowed.
Also have an allow list of expressions type to be used after the first few
stmts.
This allows removal of the manual matching done in
cond_removal_in_builtin_zero_pattern as those have been
moved to match patterns back in r14-362-gc53237cefbad0c and
r14-414-g078339fc04f5de.
Changes since v1:
* v2: Add allow list to feeding_bb_info and add a limit to
the number of stmts to consider. Adds 2 testcases based on 2 pre-existing match
patterns to
show what can be done.
Bootstrapped and tested on x86_64-linux-gnu.
gcc/ChangeLog:
* tree-ssa-phiopt.cc (gsi_next_nondebug_nonnop_non_predict): New
function.
(enum bbfeeding_info): New enum.
(empty_bb_or_one_feeding_into_p): Rename to ...
(feeding_bb_info): This and support few different other cases.
(auto_flow_sensitive): Increase the vect base size to 4.
(auto_flow_sensitive::auto_flow_sensitive(gimple*)): Split out into ...
(auto_flow_sensitive::save_stmt): This.
(auto_flow_sensitive::auto_flow_sensitive(basic_block)): New
constructor.
(match_simplify_replacement): Support More than one statement in the
middle BB.
* params.opt (-param=phiopt-max-feeding-stmts=): New option.
* doc/params.texi (phiopt-max-feeding-stmts): Document.
PR tree-optimization/127166
gcc/testsuite/ChangeLog:
* gcc.dg/tree-ssa/ssa-dom-thread-16.c: Disable phiopt.
* gcc.dg/tree-ssa/clamp-1.c: New test.
* gcc.dg/tree-ssa/umax-sub-1.c: New test.
Signed-off-by: Andrea Pinski <[email protected]>
---
gcc/doc/params.texi | 5 +
gcc/params.opt | 4 +
gcc/testsuite/gcc.dg/tree-ssa/clamp-1.c | 25 ++
.../gcc.dg/tree-ssa/ssa-dom-thread-16.c | 2 +-
gcc/testsuite/gcc.dg/tree-ssa/umax-sub-1.c | 14 +
gcc/tree-ssa-phiopt.cc | 373 +++++++++++++-----
6 files changed, 331 insertions(+), 92 deletions(-)
create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/clamp-1.c
create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/umax-sub-1.c
diff --git a/gcc/doc/params.texi b/gcc/doc/params.texi
index 090af64a7e7..b26513a7ea1 100644
--- a/gcc/doc/params.texi
+++ b/gcc/doc/params.texi
@@ -57,6 +57,11 @@ When factoring statements out of if/then/else, this is the
maximum number
of statements
after the defining statement to be allowed to extend the lifetime of a name.
+@paindex phiopt-max-feeding-stmts
+@item phiopt-max-feeding-stmts
+When deciding if a basic block is too big to phiopt, this decides the maximum
+number of statements that feed into one another is too many. This excludes
converts.
+
@paindex predictable-branch-outcome
@item predictable-branch-outcome
When branch is predicted to be taken with probability lower than this threshold
diff --git a/gcc/params.opt b/gcc/params.opt
index 29a5c7018a8..f0702f97625 100644
--- a/gcc/params.opt
+++ b/gcc/params.opt
@@ -958,6 +958,10 @@ Maximum probability of the entry BB of split region (as a
percentage relative to
Common Joined UInteger Var(param_phiopt_factor_max_stmts_live) Init(5)
Optimization IntegerRange(0, 100) Param
Maximum number of statements allowed between a defining statement and the end
of the basic block before extending the live range is considered profitable.
+-param=phiopt-max-feeding-stmts=
+Common Joined UInteger Var(param_phiopt_max_feeding_stmts) Init(4)
Optimization IntegerRange(1, 100) Param
+Maximum number of statements can considered for each basic block excluding
converts.
+
-param=predictable-branch-outcome=
Common Joined UInteger Var(param_predictable_branch_outcome) Init(2)
IntegerRange(0, 50) Param Optimization
Maximal estimated outcome of branch considered predictable.
diff --git a/gcc/testsuite/gcc.dg/tree-ssa/clamp-1.c
b/gcc/testsuite/gcc.dg/tree-ssa/clamp-1.c
new file mode 100644
index 00000000000..43239772ca0
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/tree-ssa/clamp-1.c
@@ -0,0 +1,25 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-phiopt2-details -fdump-tree-optimized" } */
+
+/* PR tree-optimization/127166 */
+
+unsigned char clip(int x)
+{
+ unsigned u;
+ unsigned char r;
+ u = x;
+ r = x;
+ if (u > 255)
+ {
+ int n = -x;
+ int s = n >> (sizeof(int)*8 - 1);
+ r = s;
+ }
+ return r;
+}
+
+
+/* { dg-final { scan-tree-dump "converted to straightline code" "phiopt2" } }
*/
+/* { dg-final { scan-tree-dump "MAX_EXPR" "phiopt2" } } */
+/* { dg-final { scan-tree-dump "MIN_EXPR" "phiopt2" } } */
+/* { dg-final { scan-tree-dump-not "if " "optimized" } } */
diff --git a/gcc/testsuite/gcc.dg/tree-ssa/ssa-dom-thread-16.c
b/gcc/testsuite/gcc.dg/tree-ssa/ssa-dom-thread-16.c
index e8555f2d963..51b686b1de8 100644
--- a/gcc/testsuite/gcc.dg/tree-ssa/ssa-dom-thread-16.c
+++ b/gcc/testsuite/gcc.dg/tree-ssa/ssa-dom-thread-16.c
@@ -1,5 +1,5 @@
/* { dg-do compile } */
-/* { dg-options "-O2 -fdump-tree-dom2-details -w --param
logical-op-non-short-circuit=1 -fdisable-tree-threadfull1" } */
+/* { dg-options "-O2 -fdump-tree-dom2-details -w --param
logical-op-non-short-circuit=1 -fdisable-tree-threadfull1 -fno-ssa-phiopt" } */
unsigned char
validate_subreg (unsigned int offset, unsigned int isize, unsigned int osize,
int zz, int qq)
{
diff --git a/gcc/testsuite/gcc.dg/tree-ssa/umax-sub-1.c
b/gcc/testsuite/gcc.dg/tree-ssa/umax-sub-1.c
new file mode 100644
index 00000000000..c07eb4154d6
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/tree-ssa/umax-sub-1.c
@@ -0,0 +1,14 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-phiopt2-details -fdump-tree-optimized" } */
+
+signed f1 (signed x)
+{
+ if (x == 0) return 0;
+ unsigned y = x;
+ y -= 1;
+ x = y;
+ return x;
+}
+
+/* { dg-final { scan-tree-dump "converted to straightline code" "phiopt2" } }
*/
+/* { dg-final { scan-tree-dump-not "if " "optimized" } } */
diff --git a/gcc/tree-ssa-phiopt.cc b/gcc/tree-ssa-phiopt.cc
index 6f4eb8fe547..0408780d97a 100644
--- a/gcc/tree-ssa-phiopt.cc
+++ b/gcc/tree-ssa-phiopt.cc
@@ -826,6 +826,19 @@ gimple_simplify_phiopt (bool early_p, tree type, gimple
*comp_stmt,
return NULL;
}
+/* Like gsi_next_nondebug but also skips over NOPs and predicats. */
+static void
+gsi_next_nondebug_nonnop_nonpredict (gimple_stmt_iterator *i)
+{
+ do
+ {
+ gsi_next_nondebug (i);
+ }
+ while (!gsi_end_p (*i)
+ && (gimple_code (**i) == GIMPLE_PREDICT
+ || gimple_code (**i) == GIMPLE_NOP));
+}
+
/* one_feeding_comparison_into_p returns true if BB has one comparison
statement and it sets STMT to that statement. Note the comparison can
be trapping too. */
@@ -890,110 +903,158 @@ one_feeding_comparison_into_p (basic_block bb,
return true;
}
-/* empty_bb_or_one_feeding_into_p returns true if bb was empty basic block
- or it has one cheap preparation statement that feeds into the PHI
- statement and it sets STMT to that statement. */
-static bool
-empty_bb_or_one_feeding_into_p (basic_block bb,
- gimple *phi,
- gimple *&stmt)
+
+enum bbfeeding_info
+{
+ invalid_bb,
+ empty_bb,
+ one_stmt_bb,
+ feeding_bb
+};
+
+/* This returns empty_bb if bb was empty basic block.
+ or returns one_stmt_bb if it has one cheap preparation
+ statement that feeds into the PHI statement and it sets
+ STMT to that statement. Returns feeding_bb if the
+ basic block is not empty but has a sequence of statements
+ feeding into the phi that has no side effects. */
+static bbfeeding_info
+feeding_bb_info (basic_block bb, gimple *phi, gimple *&stmt)
{
stmt = nullptr;
gimple *stmt_to_move = nullptr;
tree lhs;
if (empty_block_p (bb))
- return true;
+ return empty_bb;
if (!single_pred_p (bb))
- return false;
+ return invalid_bb;
/* The middle bb cannot have phi nodes as we don't
move those assignments yet. */
if (!gimple_seq_empty_p (phi_nodes (bb)))
- return false;
+ return invalid_bb;
gimple_stmt_iterator gsi;
gsi = gsi_start_nondebug_after_labels_bb (bb);
+ int stmts = 0;
+ int stmts_minus_convert = 0;
+ bool non_allowed_stmt = false;
while (!gsi_end_p (gsi))
{
- gimple *s = gsi_stmt (gsi);
- gsi_next_nondebug (&gsi);
- /* Skip over Predict and nop statements. */
+ gimple *s = *gsi;
+ gsi_next_nondebug_nonnop_nonpredict (&gsi);
+ // Skip over predict and nop statements which could happen
+ // if they are at the beginging.
if (gimple_code (s) == GIMPLE_PREDICT
|| gimple_code (s) == GIMPLE_NOP)
continue;
- /* If there is more one statement return false. */
- if (stmt_to_move)
- return false;
- stmt_to_move = s;
- }
-
- /* The only statement here was a Predict or a nop statement
- so return true. */
- if (!stmt_to_move)
- return true;
-
- if (gimple_vuse (stmt_to_move))
- return false;
-
- if (gimple_could_trap_p (stmt_to_move)
- || gimple_has_side_effects (stmt_to_move))
- return false;
-
- ssa_op_iter it;
- tree use;
- FOR_EACH_SSA_TREE_OPERAND (use, stmt_to_move, it, SSA_OP_USE)
- if (ssa_name_maybe_undef_p (use))
- return false;
-
- /* Allow assignments but allow some builtin/internal calls.
- As const calls don't match any of the above, yet they could
- still have some side-effects - they could contain
- gimple_could_trap_p statements, like floating point
- exceptions or integer division by zero. See PR70586.
- FIXME: perhaps gimple_has_side_effects or gimple_could_trap_p
- should handle this.
- Allow some known builtin/internal calls that are known not to
- trap: logical functions (e.g. bswap and bit counting). */
- if (!is_gimple_assign (stmt_to_move))
- {
- if (!is_gimple_call (stmt_to_move))
- return false;
- combined_fn cfn = gimple_call_combined_fn (stmt_to_move);
- switch (cfn)
+ stmts++;
+ stmts_minus_convert++;
+ if (stmts_minus_convert > param_phiopt_max_feeding_stmts)
+ return invalid_bb;
+ if (gimple_vuse (s))
+ return invalid_bb;
+ if (gimple_could_trap_p (s)
+ || gimple_has_side_effects (s))
+ return invalid_bb;
+ ssa_op_iter it;
+ tree use;
+ FOR_EACH_SSA_TREE_OPERAND (use, s, it, SSA_OP_USE)
+ if (ssa_name_maybe_undef_p (use))
+ return invalid_bb;
+
+ /* Allow some assignments but allow some builtin/internal calls.
+ As const calls don't match any of the above, yet they could
+ still have some side-effects - they could contain
+ gimple_could_trap_p statements, like floating point
+ exceptions or integer division by zero. See PR70586.
+ FIXME: perhaps gimple_has_side_effects or gimple_could_trap_p
+ should handle this.
+ Allow some known builtin/internal calls that are known not to
+ trap: logical functions (e.g. bswap and bit counting). */
+ if (!is_gimple_assign (s))
{
- default:
- return false;
- CASE_CFN_BSWAP:
- CASE_CFN_BITREVERSE:
- CASE_CFN_FFS:
- CASE_CFN_PARITY:
- CASE_CFN_POPCOUNT:
- CASE_CFN_CLZ:
- CASE_CFN_CTZ:
- case CFN_BUILT_IN_CLRSB:
- case CFN_BUILT_IN_CLRSBL:
- case CFN_BUILT_IN_CLRSBLL:
- lhs = gimple_call_lhs (stmt_to_move);
- break;
+ if (!is_gimple_call (s))
+ return invalid_bb;
+ combined_fn cfn = gimple_call_combined_fn (s);
+ switch (cfn)
+ {
+ default:
+ return invalid_bb;
+ CASE_CFN_BSWAP:
+ CASE_CFN_BITREVERSE:
+ CASE_CFN_FFS:
+ CASE_CFN_PARITY:
+ CASE_CFN_POPCOUNT:
+ CASE_CFN_CLZ:
+ CASE_CFN_CTZ:
+ case CFN_BUILT_IN_CLRSB:
+ case CFN_BUILT_IN_CLRSBL:
+ case CFN_BUILT_IN_CLRSBLL:
+ lhs = gimple_call_lhs (s);
+ // A call can only be the first non-allowed stmt.
+ if (non_allowed_stmt)
+ return invalid_bb;
+ break;
+ }
+ }
+ else
+ {
+ // Only allow a few different for the feeding list.
+ switch (gimple_assign_rhs_code (s))
+ {
+ // Always allow a convert.
+ CASE_CONVERT:
+ stmts_minus_convert --;
+ break;
+ case PLUS_EXPR:
+ case MINUS_EXPR:
+ case ABS_EXPR:
+ case ABSU_EXPR:
+ case BIT_IOR_EXPR:
+ case BIT_XOR_EXPR:
+ case BIT_AND_EXPR:
+ case MIN_EXPR:
+ case MAX_EXPR:
+ case NEGATE_EXPR:
+ break;
+ // Shifts with a constant shifter are on the allow list.
+ case LSHIFT_EXPR:
+ case RSHIFT_EXPR:
+ if (TREE_CODE (gimple_assign_rhs2 (s)) == INTEGER_CST)
+ break;
+ // FALLTHRU
+ default:
+ // Allow all kind of expressions after the first convert.
+ if (stmts_minus_convert > 1 && non_allowed_stmt)
+ return invalid_bb;
+ non_allowed_stmt = true;
+ }
+ lhs = gimple_assign_lhs (s);
}
- }
- else
- lhs = gimple_assign_lhs (stmt_to_move);
- gimple *use_stmt;
- use_operand_p use_p;
+ gimple *use_stmt;
+ use_operand_p use_p;
- /* Allow only a statement which feeds into the other stmt. */
- if (!lhs || TREE_CODE (lhs) != SSA_NAME
- || !single_imm_use (lhs, &use_p, &use_stmt)
- || use_stmt != phi)
- return false;
+ /* Allow only a statement which feeds into the next stmt
+ or the phi (when last statement). */
+ if (!lhs || TREE_CODE (lhs) != SSA_NAME
+ || !single_imm_use (lhs, &use_p, &use_stmt)
+ || use_stmt != (gsi_end_p (gsi) ? phi : *gsi ))
+ return invalid_bb;
+ if (!stmt_to_move)
+ stmt_to_move = s;
+ }
+ /* The only statement here was a Predict or a nop statement
+ so return 1. */
+ if (stmts == 0)
+ return empty_bb;
stmt = stmt_to_move;
- return true;
+ return stmts > 1 ? feeding_bb : one_stmt_bb;
}
/* Move STMT to before GSI and insert its defining
@@ -1025,14 +1086,17 @@ move_stmt (gimple *stmt, gimple_stmt_iterator *gsi,
auto_bitmap &inserted_exprs)
}
/* RAII style class to temporarily remove flow sensitive
- from ssa names defined by a gimple statement. */
+ from ssa names defined by a gimple statement or
+ a whole Basic block. */
class auto_flow_sensitive
{
public:
auto_flow_sensitive (gimple *s);
+ auto_flow_sensitive (basic_block bb);
~auto_flow_sensitive ();
private:
- auto_vec<std::pair<tree, flow_sensitive_info_storage>, 2> stack;
+ auto_vec<std::pair<tree, flow_sensitive_info_storage>, 4> stack;
+ void save_stmt (gimple *s);
};
/* Constructor for auto_flow_sensitive. Saves
@@ -1044,6 +1108,15 @@ auto_flow_sensitive::auto_flow_sensitive (gimple *s)
{
if (!s)
return;
+ save_stmt (s);
+}
+
+/* Saves off the ssa names' flow sensitive information
+ that was defined by gimple statement S and
+ resets it to be non-flow based ones. */
+void
+auto_flow_sensitive::save_stmt (gimple *s)
+{
ssa_op_iter it;
tree def;
FOR_EACH_SSA_TREE_OPERAND (def, s, it, SSA_OP_DEF)
@@ -1054,6 +1127,21 @@ auto_flow_sensitive::auto_flow_sensitive (gimple *s)
}
}
+/* Constructor for auto_flow_sensitive. Saves
+ off the ssa names' flow sensitive information
+ that was defined in the BB and
+ resets it to be non-flow based ones. */
+
+auto_flow_sensitive::auto_flow_sensitive (basic_block bb)
+{
+ if (!bb)
+ return;
+ gimple_stmt_iterator gsi;
+ gsi = gsi_start_nondebug_after_labels_bb (bb);
+ for (; !gsi_end_p (gsi); gsi_next_nondebug (&gsi))
+ save_stmt (*gsi);
+}
+
/* Deconstructor, restores the flow sensitive information
for the SSA names that had been saved off. */
@@ -1112,14 +1200,20 @@ match_simplify_replacement (basic_block cond_bb,
basic_block middle_bb,
/* If the basic block only has a cheap preparation statement,
allow it and move it once the transformation is done. */
- if (!empty_bb_or_one_feeding_into_p (middle_bb, phi, stmt_to_move))
+ bbfeeding_info middle_bb_info = feeding_bb_info (middle_bb,
+ phi, stmt_to_move);
+ if (middle_bb_info == invalid_bb)
return false;
+ bbfeeding_info middle_bb_alt_info = invalid_bb;
if (threeway_p
- && middle_bb != middle_bb_alt
- && !empty_bb_or_one_feeding_into_p (middle_bb_alt, phi,
- stmt_to_move_alt))
- return false;
+ && middle_bb != middle_bb_alt)
+ {
+ middle_bb_alt_info = feeding_bb_info (middle_bb_alt, phi,
+ stmt_to_move_alt);
+ if (middle_bb_alt_info == invalid_bb)
+ return false;
+ }
/* Do not make conditional undefs unconditional. */
if ((TREE_CODE (arg0) == SSA_NAME
@@ -1169,12 +1263,15 @@ match_simplify_replacement (basic_block cond_bb,
basic_block middle_bb,
tree type = TREE_TYPE (gimple_phi_result (phi));
{
- auto_flow_sensitive s1(stmt_to_move);
- auto_flow_sensitive s_alt(stmt_to_move_alt);
+ auto_flow_sensitive s1(middle_bb);
+ basic_block other_bb = nullptr;
+ if (middle_bb_alt_info >= one_stmt_bb)
+ other_bb = middle_bb_alt;
+ auto_flow_sensitive s_alt(other_bb);
result = gimple_simplify_phiopt (early_p, type, stmt,
arg_true, arg_false,
- &seq);
+ &seq);
}
/* For early phiopt, we don't want to lose user generated predictors
@@ -1214,7 +1311,8 @@ match_simplify_replacement (basic_block cond_bb,
basic_block middle_bb,
semantics (that's not IEEE max semantics). */
if (!HONOR_NANS (type) && !HONOR_SIGNED_ZEROS (type))
return false;
- if (stmt_to_move || stmt_to_move_alt)
+ if (middle_bb_info >= one_stmt_bb
+ || middle_bb_alt_info >= one_stmt_bb)
return false;
tree_code cmp = gimple_cond_code (stmt);
if (cmp != LT_EXPR && cmp != LE_EXPR
@@ -1236,11 +1334,104 @@ match_simplify_replacement (basic_block cond_bb,
basic_block middle_bb,
statistics_counter_event (cfun, "Non-IEEE FP MIN/MAX PHI replacement",
1);
}
- if (dump_file && (dump_flags & TDF_FOLDING))
- fprintf (dump_file, "accepted the phiopt match-simplify.\n");
auto_bitmap exprs_maybe_dce;
+ /* One of the middle BBs had more than one statements. */
+ if (middle_bb_info == feeding_bb
+ || middle_bb_alt_info == feeding_bb)
+ {
+ gimple_stmt_iterator gsi = gsi_start (seq);
+ bool ok = true;
+ /* Check to see if any of the new sequence uses the definitions
+ from the middle bbs. */
+ for (gsi = gsi_start (seq); !gsi_end_p (gsi); gsi_next (&gsi))
+ {
+ gimple *s = *gsi;
+ for (unsigned i = 0; i < gimple_num_ops (s); i++)
+ {
+ tree use = gimple_op (s, i);
+ if (!use)
+ continue;
+ if (TREE_CODE (use) != SSA_NAME)
+ continue;
+ gimple *us = SSA_NAME_DEF_STMT (use);
+ if (!us)
+ continue;
+ if (us == stmt_to_move || us == stmt_to_move_alt)
+ continue;
+ basic_block use_bb = gimple_bb (us);
+ /* If an operand is defined from the middle bb
+ where there was more one statement, reject it. */
+ if ((middle_bb_info == feeding_bb
+ && use_bb == middle_bb)
+ || (middle_bb_alt_info == feeding_bb
+ && use_bb == middle_bb_alt))
+ {
+ ok = false;
+ break;
+ }
+ }
+ if (!ok)
+ break;
+ }
+ if (!ok)
+ {
+ if (dump_file && (dump_flags & TDF_FOLDING))
+ fprintf (dump_file, "rejected the phiopt match-simplify for having
more stmts.\n");
+ return false;
+ }
+ statistics_counter_event (cfun, "unconditionalized one middle bb phiopt",
+ 1);
+ // If the result is the one of the arguments or a partial
+ // defined in the middle bb, then make those statements unconditional.
+ if (TREE_CODE (result) == SSA_NAME
+ && (middle_bb_info == feeding_bb
+ || middle_bb_alt_info == feeding_bb))
+ {
+ gimple *us = SSA_NAME_DEF_STMT (result);
+ if (us && ((middle_bb_info == feeding_bb
+ && gimple_bb (us) == middle_bb)
+ || (middle_bb_alt_info == feeding_bb
+ && gimple_bb (us) == middle_bb_alt)))
+ {
+ gimple_stmt_iterator middle_gsi;
+ basic_block use_bb = gimple_bb (us);
+ middle_gsi = gsi_start_nondebug_after_labels_bb (use_bb);
+
+ // Move the statements one at a time until reach the last
+ // statement or the statement that is referenced from the result.
+ while (!gsi_end_p (middle_gsi))
+ {
+ // Skip over nop or predicates
+ // Also don't move debug statements
+ if (gimple_code (*middle_gsi) == GIMPLE_NOP
+ || gimple_code (*middle_gsi) == GIMPLE_PREDICT)
+ {
+ gsi_next_nondebug_nonnop_nonpredict (&middle_gsi);
+ continue;
+ }
+ gsi = gsi_last_bb (cond_bb);
+ gimple *s = *middle_gsi;
+ move_stmt (s, &gsi, exprs_maybe_dce);
+
+ // Reached the last statement that is refenced,
+ // all the rest would be DCEd anyways.
+ if (s == us)
+ break;
+ middle_gsi = gsi_start_nondebug_after_labels_bb (use_bb);
+ }
+ stmt_to_move = nullptr;
+ stmt_to_move_alt = nullptr;
+ statistics_counter_event (cfun, "unconditionalized one middle bb
phiopt",
+ 1);
+ }
+ }
+ }
+
+ if (dump_file && (dump_flags & TDF_FOLDING))
+ fprintf (dump_file, "accepted the phiopt match-simplify.\n");
+
/* Mark the cond statements' lhs/rhs as maybe dce. */
if (TREE_CODE (gimple_cond_lhs (stmt)) == SSA_NAME
&& !SSA_NAME_IS_DEFAULT_DEF (gimple_cond_lhs (stmt)))
@@ -1260,7 +1451,7 @@ match_simplify_replacement (basic_block cond_bb,
basic_block middle_bb,
gsi_insert_seq_before (&gsi, seq, GSI_CONTINUE_LINKING);
}
- /* If there was a statement to move, move it to right before
+ /* If there was one statement to move, move it to right before
the original conditional. */
move_stmt (stmt_to_move, &gsi, exprs_maybe_dce);
move_stmt (stmt_to_move_alt, &gsi, exprs_maybe_dce);
--
2.43.0
