From 32f7506bdc3956762bcc7dc84133fd7c3a00bb7b Mon Sep 17 00:00:00 2001 From: Aldy Hernandez Date: Mon, 26 Jul 2021 11:53:41 +0200 Subject: [PATCH] Abstract out conditional simplification out of execute_vrp. VRP simplifies conditionals involving casted values outside of the main folding mechanism, because this optimization inhibits the VRP jump threader from threading through the comparison. As part of replacing VRP with an evrp instance, I am making sure we do everything VRP does. Hence, I am abstracting this functionality out so we can call it from from elsewhere. ISTM that when the proposed ranger-based jump threader can handle everything the forward threader does, there will be no need for this optimization to be done outside of the evrp folder. Perhaps we can fold this into the substitute_using_ranges class. But that's further down the line. Also, there is no need to pass a vr_values around, when the base range_query class will do. I fixed this, at it makes it trivial to pass down a ranger or evrp instance. Tested on x86-64 Linux. gcc/ChangeLog: * tree-vrp.c (vrp_simplify_cond_using_ranges): Rename vr_values with range_query. (execute_vrp): Abstract out simplification of conditionals... (simplify_casted_conds): ...here. --- gcc/tree-vrp.c | 39 +++++++++++++++++++++++---------------- 1 file changed, 23 insertions(+), 16 deletions(-) diff --git a/gcc/tree-vrp.c b/gcc/tree-vrp.c index a9c31bc..58111f8 100644 --- a/gcc/tree-vrp.c +++ b/gcc/tree-vrp.c @@ -4359,7 +4359,7 @@ vrp_jump_threader::after_dom_children (basic_block bb) subsequent passes. */ static void -vrp_simplify_cond_using_ranges (vr_values *query, gcond *stmt) +vrp_simplify_cond_using_ranges (range_query *query, gcond *stmt) { tree op0 = gimple_cond_lhs (stmt); tree op1 = gimple_cond_rhs (stmt); @@ -4423,6 +4423,27 @@ vrp_simplify_cond_using_ranges (vr_values *query, gcond *stmt) } } +/* A comparison of an SSA_NAME against a constant where the SSA_NAME + was set by a type conversion can often be rewritten to use the RHS + of the type conversion. Do this optimization for all conditionals + in FUN. + + However, doing so inhibits jump threading through the comparison. + So that transformation is not performed until after jump threading + is complete. */ + +static void +simplify_casted_conds (function *fun, range_query *query) +{ + basic_block bb; + FOR_EACH_BB_FN (bb, fun) + { + gimple *last = last_stmt (bb); + if (last && gimple_code (last) == GIMPLE_COND) + vrp_simplify_cond_using_ranges (query, as_a (last)); + } +} + /* Main entry point to VRP (Value Range Propagation). This pass is loosely based on J. R. C. Patterson, ``Accurate Static Branch Prediction by Value Range Propagation,'' in SIGPLAN Conference on @@ -4519,21 +4540,7 @@ execute_vrp (struct function *fun, bool warn_array_bounds_p) vrp_jump_threader threader (fun, &vrp_vr_values); threader.thread_jumps (); - /* A comparison of an SSA_NAME against a constant where the SSA_NAME - was set by a type conversion can often be rewritten to use the - RHS of the type conversion. - - However, doing so inhibits jump threading through the comparison. - So that transformation is not performed until after jump threading - is complete. */ - basic_block bb; - FOR_EACH_BB_FN (bb, fun) - { - gimple *last = last_stmt (bb); - if (last && gimple_code (last) == GIMPLE_COND) - vrp_simplify_cond_using_ranges (&vrp_vr_values, - as_a (last)); - } + simplify_casted_conds (fun, &vrp_vr_values); free_numbers_of_iterations_estimates (fun); -- 2.7.4