Common Report Var(flag_tree_vrp) Init(0) Optimization
Perform Value Range Propagation on trees.
+ftree-rvrp
+Common Report Var(flag_tree_rvrp) Init(1) Optimization
+Perform New Ranger Value Range Propagation on trees.
+
+
fsplit-paths
Common Report Var(flag_split_paths) Init(0) Optimization
Split paths leading to loop backedges.
#include "tree-cfgcleanup.h"
#include "vr-values.h"
#include "gimple-ssa-evrp-analyze.h"
+#include "ssa-range.h"
+#include "ssa-range-global.h"
+
class evrp_folder : public substitute_and_fold_engine
{
return new pass_early_vrp (ctxt);
}
+
+/* Main entry point for the early Ranger vrp pass. */
+
+static bool
+argument_ok_to_propagate (tree name)
+{
+ if (TREE_CODE (name) != SSA_NAME)
+ return true;
+ if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name))
+ {
+ // From may_propagate_copy
+ if (SSA_NAME_IS_DEFAULT_DEF (name) && (SSA_NAME_VAR (name) == NULL_TREE
+ || TREE_CODE (SSA_NAME_VAR (name)) == VAR_DECL))
+ return true;
+ }
+ // probably dont need this.
+ if (virtual_operand_p (name))
+ return false;
+ return true;
+}
+
+static unsigned int
+execute_ranger_vrp ()
+{
+ path_ranger ranger;
+
+ basic_block bb;
+ irange r;
+ wide_int i;
+ unsigned x;
+ bitmap_iterator bi;
+ bitmap touched = BITMAP_ALLOC (NULL);
+
+ FOR_EACH_BB_FN (bb, cfun)
+ {
+ gcond *cond;
+ gimple *stmt = last_stmt (bb);
+ if (stmt && (cond = dyn_cast <gcond *> (stmt)))
+ {
+ if (dump_file)
+ {
+ fprintf (dump_file, "Considering ");
+ print_gimple_stmt (dump_file, cond, 0,0);
+ }
+ if (ranger.path_range_stmt (r, stmt))
+ {
+ if (dump_file)
+ {
+ fprintf (dump_file, "Found a range for the expression: ");
+ r.dump (dump_file);
+ fprintf (dump_file, "\n");
+ }
+
+ if (r.singleton_p (i))
+ {
+ if (!argument_ok_to_propagate (gimple_cond_lhs (cond)) ||
+ !argument_ok_to_propagate (gimple_cond_rhs (cond)))
+ {
+ if (dump_file)
+ {
+ fprintf (dump_file, "Found BB%d branch",bb->index);
+ print_gimple_stmt (dump_file, stmt, 0, 0);
+ fprintf (dump_file, "cannot eliminate. proprules.\n");
+ fprintf (stderr,"\n *********************** caught one\n");
+ }
+ continue;
+ }
+
+ /* If either operand is an ssa_name, set the touched bit for
+ potential removal later if no uses are left. */
+ tree t = valid_irange_ssa (gimple_cond_lhs (cond));
+ if (t)
+ bitmap_set_bit (touched, SSA_NAME_VERSION (t));
+ t = valid_irange_ssa (gimple_cond_rhs (cond));
+ if (t)
+ bitmap_set_bit (touched, SSA_NAME_VERSION (t));
+
+ if (dump_file)
+ {
+ fprintf (dump_file, "eliminating BB%d branch",bb->index);
+ print_gimple_stmt (dump_file, stmt, 0, 0);
+ }
+
+ /* Rewrite the condition to either true or false. */
+ if (wi::eq_p (i, 0))
+ gimple_cond_make_false (cond);
+ else
+ gimple_cond_make_true (cond);
+
+ if (dump_file)
+ {
+ fprintf (dump_file, "Re-written to: \n");
+ print_gimple_stmt (dump_file, cond, 0, 0);
+ fprintf (dump_file, "\n");
+ }
+ }
+ }
+ }
+
+ }
+
+ // Now visit each name that was rewritten and see if the definiing statement
+ // can be deleted due to no more uses in the program
+ EXECUTE_IF_SET_IN_BITMAP (touched, 0, x, bi)
+ {
+ tree name = ssa_name (x);
+ gimple *s = SSA_NAME_DEF_STMT (name);
+
+ if (s)
+ {
+ if (has_zero_uses (name))
+ {
+ if (dump_file)
+ {
+ fprintf (dump_file, "Should delete");
+ print_gimple_stmt (dump_file, s, 0, 0);
+ }
+ }
+ else
+ {
+ if (dump_file)
+ {
+ fprintf (dump_file, "Still has uses, Could not delete ");
+ print_gimple_stmt (dump_file, s, 0, 0);
+ }
+ }
+ }
+ }
+ return 0;
+}
+
+namespace {
+
+const pass_data pass_data_ranger_vrp =
+{
+ GIMPLE_PASS, /* type */
+ "rvrp", /* name */
+ OPTGROUP_NONE, /* optinfo_flags */
+ TV_TREE_RANGER_VRP, /* tv_id */
+ PROP_ssa, /* properties_required */
+ 0, /* properties_provided */
+ 0, /* properties_destroyed */
+ 0, /* todo_flags_start */
+ ( TODO_cleanup_cfg | TODO_verify_all ),
+};
+
+class pass_ranger_vrp : public gimple_opt_pass
+{
+public:
+ pass_ranger_vrp (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_ranger_vrp, ctxt)
+ {}
+
+ /* opt_pass methods: */
+ opt_pass * clone () { return new pass_ranger_vrp (m_ctxt); }
+ virtual bool gate (function *)
+ {
+ return flag_tree_rvrp != 0;
+ }
+ virtual unsigned int execute (function *)
+ { return execute_ranger_vrp (); }
+
+}; // class pass_vrp
+} // anon namespace
+
+gimple_opt_pass *
+make_pass_ranger_vrp (gcc::context *ctxt)
+{
+ return new pass_ranger_vrp (ctxt);
+}
+
do_per_function (verify_curr_properties,
(void *)(size_t)pass->properties_required);
+ if (pass->name && !strcmp (pass->name, "rvrp"))
+ {
+ path_ranger r;
+ r.exercise (dump_file);
+ }
+
/* Do it! */
todo_after = pass->execute (cfun);
if (!current_function_decl)
symtab->process_new_functions ();
- if (pass->name && !strcmp (pass->name, "ssa"))
- {
- path_ranger r;
- r.exercise (dump_file);
- }
-
pass_fini_dump_file (pass);
if (pass->type != SIMPLE_IPA_PASS && pass->type != IPA_PASS)
execute TODO_rebuild_alias at this point. */
NEXT_PASS (pass_build_ealias);
NEXT_PASS (pass_fre);
+ NEXT_PASS (pass_ranger_vrp);
NEXT_PASS (pass_early_vrp);
NEXT_PASS (pass_merge_phi);
NEXT_PASS (pass_dse);
operator_multiply::op1_irange (irange& r, const irange& lhs,
const irange& op2) const
{
+ wide_int c;
+ // For overflow types. all we know is that the lower "precsion / 2" bits
+ // match up with the range of the LHS. See if we know anything about
+ // the zero bits.
+ if (lhs.singleton_p (c) && TYPE_OVERFLOW_WRAPS (lhs.get_type ()))
+ {
+ return false;
+ }
return op_rr (OPM_DIV, r, lhs, op2);
}
operator_multiply::op2_irange (irange& r, const irange& lhs,
const irange& op1) const
{
+ wide_int c;
+ // For overflow types. all we know is that the lower "precsion / 2" bits
+ // match up with the range of the LHS. See if we know anything about
+ // the zero bits.
+ if (lhs.singleton_p (c) && TYPE_OVERFLOW_WRAPS (lhs.get_type ()))
+ {
+ return false;
+ }
return op_rr (OPM_DIV, r, lhs, op1);
}
~ssa_global_cache ();
bool get_global_range (irange& r, tree name) const;
void set_global_range (tree name, const irange&r);
+ void clear_global_range (tree name);
void clear ();
void copy_to_range_info ();
void dump (FILE *f = stderr);
globals->set_global_range (name, r);
}
+/* Clear the global range for NAME. */
+void
+clear_global_ssa_range (tree name)
+{
+ gcc_assert (globals);
+ globals->clear_global_range (name);
+}
// ---------------------------------------------------------------
/* Initialize a global cache. */
}
}
+/* Set the range for NAME to R in the glonbal cache. */
+void
+ssa_global_cache::clear_global_range (tree name)
+{
+ tab[SSA_NAME_VERSION (name)] = NULL;
+}
+
/* Clear the global cache. */
void
ssa_global_cache::clear ()
bool get_global_ssa_range (irange& r, tree name);
void set_global_ssa_range (tree name, const irange&r);
+void clear_global_ssa_range (tree name);
#endif /* GCC_SSA_RANGE_GLOBAL_H */
irange_operator *handler = irange_op_handler (code);
gcc_assert (handler != NULL);
+ // Empty ranges are viral.
+ if (r1.empty_p ())
+ {
+ if (lhs)
+ res.clear (TREE_TYPE (lhs));
+ else
+ res.clear (r1.get_type ());
+ return true;
+ }
+
/* Single ssa operations require the LHS type as the second range. */
if (lhs)
r2.set_range_for_type (TREE_TYPE (lhs));
else
r2.clear ();
+
return handler->fold_range (res, r1, r2);
}
irange_operator *handler = irange_op_handler (code);
gcc_assert (handler != NULL);
+ // Empty ranges are viral.
+ if (r1.empty_p () || r2.empty_p ())
+ {
+ res.clear (r1.get_type ());
+ return true;
+ }
+
// Make sure this isnt a unary operation being passed a second range.
gcc_assert (op2);
return handler->fold_range (res, r1, r2);
path_ranger::path_range_entry (irange& r, tree name, basic_block bb)
{
gimple *def_stmt;
- basic_block def_bb;
+ basic_block def_bb = NULL;
if (!valid_irange_ssa (name))
return false;
def_stmt = SSA_NAME_DEF_STMT (name);
- if (!def_stmt)
- return false;
+ if (def_stmt)
+ def_bb = gimple_bb (def_stmt);;
- def_bb = gimple_bb (def_stmt);;
if (!def_bb)
def_bb = ENTRY_BLOCK_PTR_FOR_FN (cfun);
if (!valid_irange_ssa (name))
return false;
+ /* Get an initial range for NAME. */
+
gimple *stmt = SSA_NAME_DEF_STMT (name);
if (stmt && gimple_bb (stmt) == e->src)
{
- if (!path_range_of_def (r, stmt))
- get_global_ssa_range (r, name);
+ /* If it is in this block, evaluate it. */
+ if (!path_range_stmt (r, stmt))
+ return false;
}
else
- /* Get the range for the def and possible basic block. */
+ /* The name comes from outside this block, so evaluate it's value on
+ entry to the block. */
if (!path_range_entry (r, name, bb))
- return false;
+ error (" Why can't we get a live on entry range? ");
- /* Now intersect it with what we know about this edge. */
+ /* Now intersect it with what NAME evaluates to on this edge. */
irange edge_range;
if (range_on_edge (edge_range, name, e))
{
/* Avoid infinite recursion by marking this block as calculated. */
block_cache->get_block_ranges (name).set_bb_range_for_type (bb);
- /* Visit each predecessor to reseolve them. */
+ /* Visit each predecessor to resolve them. */
FOR_EACH_EDGE (e, ei, bb->preds)
{
determine_block (name, e->src, def_bb);
{
irange pred_range;
basic_block src = e->src;
- // Should be using range_on_def
+ // Should be using range_on_def??? or something.
if (src == def_bb)
get_global_ssa_range (pred_range, name);
else
block_cache->get_block_ranges (name).set_bb_range (bb, block_result);
}
+
+bool
+path_ranger::process_phi (irange &r, gphi *phi)
+{
+ tree phi_def = gimple_phi_result (phi);
+ unsigned x;
+
+ if (!valid_irange_ssa (phi_def))
+ return false;
+
+ // If this node has already been processed, just return it.
+ if (get_global_ssa_range (r, phi_def))
+ return true;
+
+ // Avoid infinite recursion by initializing global cache
+ r.set_range (phi_def);
+ set_global_ssa_range (phi_def, r);
+
+ // And start with an empty range, unioning in each areument's range.
+ r.clear (TREE_TYPE (phi_def));
+ for (x = 0; x < gimple_phi_num_args (phi); x++)
+ {
+ irange arg_range;
+ tree arg = gimple_phi_arg_def (phi, x);
+ edge e = gimple_phi_arg_edge (phi, x);
+ if (!path_range_edge (arg_range, arg, e))
+ if (!get_operand_range (arg_range, arg))
+ return false;
+
+ normalize_bool_type (r, arg_range);
+ r.union_ (arg_range);
+ if (r.range_for_type_p ())
+ break;
+ }
+
+ set_global_ssa_range (phi_def, r);
+ return true;
+}
+
bool
path_ranger::path_range_stmt (irange& r, tree name, gimple *g)
{
-#if 0
+ return path_get_operand (r, name, gimple_bb (g));
+}
+
+
+bool
+path_ranger::path_range_stmt (irange& r, gimple *g)
+{
+ tree name = gimple_get_lhs (g);
+ irange range_op1, range_op2;
+ range_stmt rn;
+ basic_block bb = gimple_bb (g);
+
if (is_a <gphi *> (g))
{
gphi *phi = as_a <gphi *> (g);
- tree phi_def = gimple_phi_result (phi);
- irange tmp;
- unsigned x;
+ return process_phi (r, phi);
+ }
+
+ // Not all statements have a LHS. */
+ if (name)
+ {
+ // If this STMT has already been processed, return that value.
+ if (get_global_ssa_range (r, name))
+ return true;
+
+ // avoid infinite recursion by initializing global cache
+ r.set_range (name);
+ set_global_ssa_range (name, r);
+ }
- /* Only calculate ranges for PHI defs. */
- if (phi_def != name)
- return false;
+ rn = g;
+ if (!rn.valid ())
+ return false;
- r.clear (TREE_TYPE (name));
+ if (!path_get_operand (range_op1, rn.operand1 (), bb))
+ return false;
+
+ // If this is a unary operation, call fold now.
+ if (!rn.operand2 ())
+ return rn.fold (r, range_op1);
- for (x = 0; x < gimple_phi_num_args (phi); x++)
- {
- bool res;
- tree arg = gimple_phi_arg_def (phi, x);
- if (TREE_CODE (arg) == SSA_NAME)
- res = path_range_edge (tmp, arg, gimple_phi_arg_edge (phi, x));
- else
- res = get_operand_range (tmp, arg);
- if (res)
- r.union_ (tmp);
- else
- {
- r.set_range_for_type (name);
- return false;
- }
- if (r.range_for_type_p ())
- return true;
- }
- return true;
+ if (!path_get_operand (range_op2, rn.operand2 (), bb))
+ return false;
+
+ normalize_bool_type (range_op1, range_op2);
+ bool res = rn.fold (r, range_op1, range_op2);
+ if (name)
+ {
+ if (res)
+ set_global_ssa_range (name, r);
+ else
+ clear_global_ssa_range (name);
}
-#endif
- return range_on_stmt (r, name, g);
+ return res;
}
-static inline bool
+static inline gimple *
ssa_name_same_bb_p (tree name, basic_block bb)
{
gimple *g = SSA_NAME_DEF_STMT (name);
if (!g || gimple_bb (g) != bb)
- return false;
- return true;
+ return NULL;
+ return g;
}
+
+/* Determine a range for NAME in basic block BB.
+ If FULL is true, then rescursively call the path ranger to fully evaluate
+ a range for NAME.
+ if FULL is false, then dont go outside the current block to find a best
+ guess range.
+ if edge E is specified, then only follow E for calculations. */
+
+bool
+path_ranger::path_get_operand (irange &r, tree name, basic_block bb)
+{
+ if (!valid_irange_ssa (name))
+ return get_operand_range (r, name);
+
+ // check if the defining statement is in the same block.
+ gimple *s = ssa_name_same_bb_p (name, bb);
+ if (s)
+ {
+ // This means NAME is defined in the same block, simply try to extract
+ // a range from that statement.
+ if (!path_range_stmt (r, s))
+ return get_operand_range (r, name);
+ return true;
+ }
+
+ if (path_range_entry (r, name, bb))
+ return true;
+ return get_operand_range (r, name);
+}
+
+
bool
path_ranger::path_fold_stmt (irange &r, range_stmt &rn, basic_block bb, edge e)
{
range_stmt rn(g);
if (!rn.valid())
- return false;
-
+ return false;
return path_fold_stmt (r, rn, bb, e);
}
bool
path_ranger::path_range_of_def (irange &r, gimple *g)
{
- tree name = gimple_get_lhs (g);
+ tree name;
basic_block bb = gimple_bb (g);
tree arg;
irange range_op1, range_op2;
if (get_global_ssa_range (r, phi_def))
return true;
- // avoid infinite recursion by initializing global cache
+ // Avoid infinite recursion by initializing global cache
r.set_range (phi_def);
set_global_ssa_range (phi_def, r);
return false;
name = gimple_get_lhs (g);
- gcc_checking_assert (name);
+
+ /* If there is no LHS, then we are simply folding an expression. */
+ if (!name)
+ return path_fold_stmt (r, rn, bb);
if (get_global_ssa_range (r, name))
return true;
bool path_range_reverse (irange &r, tree name, const vec<basic_block> &);
bool path_fold_stmt (irange &r, range_stmt &rn, basic_block bb,
edge e = NULL);
+ bool process_phi (irange &r, gphi *phi);
+ bool path_get_operand (irange &r, tree name, basic_block bb);
+
public:
enum path_range_direction { FORWARD, REVERSE };
path_ranger ();
/* What is the known range of name from its DEF point to edge E. */
bool path_range_edge (irange& r, tree name, edge e);
bool path_range_entry (irange& r, tree name, basic_block bb);
+ // Specifying NAME give the range of NAME before G is executed.
bool path_range_stmt (irange& r, tree name, gimple *g);
+ // no NAME, give the range of the LHS of the statement.
+ bool path_range_stmt (irange& r, gimple *g);
+
bool path_range (irange &r, tree name, const vec<basic_block> &bbs,
enum path_range_direction, edge start_edge = NULL);
// Evaluate expression within a BB as much as possible.
DEFTIMEVAR (TV_TREE_TAIL_MERGE , "tree tail merge")
DEFTIMEVAR (TV_TREE_VRP , "tree VRP")
DEFTIMEVAR (TV_TREE_EARLY_VRP , "tree Early VRP")
+DEFTIMEVAR (TV_TREE_RANGER_VRP , "tree Ranger VRP")
DEFTIMEVAR (TV_TREE_COPY_PROP , "tree copy propagation")
DEFTIMEVAR (TV_FIND_REFERENCED_VARS , "tree find ref. vars")
DEFTIMEVAR (TV_TREE_PTA , "tree PTA")
extern gimple_opt_pass *make_pass_copy_prop (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_isolate_erroneous_paths (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_early_vrp (gcc::context *ctxt);
+extern gimple_opt_pass *make_pass_ranger_vrp (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_vrp (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_uncprop (gcc::context *ctxt);
extern gimple_opt_pass *make_pass_return_slot (gcc::context *ctxt);
projects / thirdparty / gcc.git / commitdiff
