{
basic_block bb = BASIC_BLOCK_FOR_FN (cfun, x);
if (bb)
- m_gori.exports (bb);
+ m_gori.map ()->exports (bb);
}
m_update = new update_list ();
}
void
ranger_cache::dump_bb (FILE *f, basic_block bb)
{
- m_gori.gori_map::dump (f, bb, false);
+ m_gori.map ()->dump (f, bb, false);
m_on_entry.dump (f, bb);
m_relation->dump (f, bb);
}
current_p = false;
if (had_global)
current_p = r.singleton_p ()
- || m_temporal->current_p (name, m_gori.depend1 (name),
- m_gori.depend2 (name));
+ || m_temporal->current_p (name, m_gori.map ()->depend1 (name),
+ m_gori.map ()->depend2 (name));
else
{
// If no global value has been set and value is VARYING, fold the stmt
if (!changed)
{
// If there are dependencies, make sure this is not out of date.
- if (!m_temporal->current_p (name, m_gori.depend1 (name),
- m_gori.depend2 (name)))
+ if (!m_temporal->current_p (name, m_gori.map ()->depend1 (name),
+ m_gori.map ()->depend2 (name)))
m_temporal->set_timestamp (name);
return;
}
if (r.singleton_p ()
|| (POINTER_TYPE_P (TREE_TYPE (name)) && r.nonzero_p ()))
- m_gori.set_range_invariant (name);
+ m_gori.map ()->set_range_invariant (name);
m_temporal->set_timestamp (name);
}
m_on_entry.set_bb_range (name, bb, r);
// If this range was invariant before, remove invariant.
if (!m_gori.has_edge_range_p (name))
- m_gori.set_range_invariant (name, false);
+ m_gori.map ()->set_range_invariant (name, false);
}
}
if (lhs && gimple_range_ssa_p (op1))
{
if (src.gori ())
- src.gori ()->register_dependency (lhs, op1);
+ src.gori ()->map ()->register_dependency (lhs, op1);
relation_kind rel;
rel = handler.lhs_op1_relation (r, range1, range1);
if (rel != VREL_VARYING)
{
if (src.gori ())
{
- src.gori ()->register_dependency (lhs, op1);
- src.gori ()->register_dependency (lhs, op2);
+ src.gori ()->map ()->register_dependency (lhs, op1);
+ src.gori ()->map ()->register_dependency (lhs, op2);
}
if (gimple_range_ssa_p (op1))
{
tree ssa = TREE_OPERAND (base, 0);
tree lhs = gimple_get_lhs (stmt);
if (lhs && gimple_range_ssa_p (ssa) && src.gori ())
- src.gori ()->register_dependency (lhs, ssa);
+ src.gori ()->map ()->register_dependency (lhs, ssa);
src.get_operand (r, ssa);
range_cast (r, TREE_TYPE (gimple_assign_rhs1 (stmt)));
r.union_ (arg_range);
if (gimple_range_ssa_p (arg) && src.gori ())
- src.gori ()->register_dependency (phi_def, arg);
+ src.gori ()->map ()->register_dependency (phi_def, arg);
}
// Track if all arguments are the same.
// leading to the condition such as:
// c_2 = a_4 < b_7
// if (c_2)
- FOR_EACH_GORI_EXPORT_NAME (*(gori ()), bb, name)
+ FOR_EACH_GORI_EXPORT_NAME (*(gori ()->map ()), bb, name)
{
if (TREE_CODE (TREE_TYPE (name)) != BOOLEAN_TYPE)
continue;
}
// If op1 is in the definition chain, pass lhs back.
- if (gimple_range_ssa_p (op1) && in_chain_p (name, op1))
+ if (gimple_range_ssa_p (op1) && m_map.in_chain_p (name, op1))
return compute_operand_range (r, SSA_NAME_DEF_STMT (op1), lhs, name, src);
return false;
// NAME is not in this stmt, but one of the names in it ought to be
// derived from it.
- bool op1_in_chain = op1 && in_chain_p (name, op1);
- bool op2_in_chain = op2 && in_chain_p (name, op2);
+ bool op1_in_chain = op1 && m_map.in_chain_p (name, op1);
+ bool op2_in_chain = op2 && m_map.in_chain_p (name, op2);
// If neither operand is derived, then this stmt tells us nothing.
if (!op1_in_chain && !op2_in_chain)
// Instead just evaluate the one operand.
if (op1_in_chain && op2_in_chain)
{
- if (in_chain_p (op1, op2) || op1 == op2)
+ if (m_map.in_chain_p (op1, op2) || op1 == op2)
op1_in_chain = false;
- else if (in_chain_p (op2, op1))
+ else if (m_map.in_chain_p (op2, op1))
op2_in_chain = false;
}
// a) both elements are in the defchain
// c = x > y // (x and y are in c's defchain)
if (op1_in_chain)
- res = in_chain_p (vrel_ptr->op1 (), op1)
- && in_chain_p (vrel_ptr->op2 (), op1);
+ res = m_map.in_chain_p (vrel_ptr->op1 (), op1)
+ && m_map.in_chain_p (vrel_ptr->op2 (), op1);
if (!res && op2_in_chain)
- res = in_chain_p (vrel_ptr->op1 (), op2)
- || in_chain_p (vrel_ptr->op2 (), op2);
+ res = m_map.in_chain_p (vrel_ptr->op1 (), op2)
+ || m_map.in_chain_p (vrel_ptr->op2 (), op2);
if (!res)
{
// or b) one relation element is in the defchain of the other and the
{
gimple *stmt = handler.stmt ();
gimple *src_stmt = gimple_range_ssa_p (op) ? SSA_NAME_DEF_STMT (op) : NULL;
- if (!op_in_chain || !src_stmt || chain_import_p (handler.lhs (), op))
+ if (!op_in_chain || !src_stmt || m_map.chain_import_p (handler.lhs (), op))
{
// If op is not in the def chain, or defined in this block,
// use its known value on entry to the block.
return false;
bool change = false;
- bool op1_def_p = in_chain_p (op2, op1);
+ bool op1_def_p = m_map.in_chain_p (op2, op1);
if (!op1_def_p)
- if (!in_chain_p (op1, op2))
+ if (!m_map.in_chain_p (op1, op2))
return false;
tree def_op = op1_def_p ? op1 : op2;
bool
gori_compute::may_recompute_p (tree name, basic_block bb, int depth)
{
- tree dep1 = depend1 (name);
- tree dep2 = depend2 (name);
+ tree dep1 = m_map.depend1 (name);
+ tree dep2 = m_map.depend2 (name);
// If the first dependency is not set, there is no recomputation.
// Dependencies reflect original IL, not current state. Check if the
gcc_checking_assert (depth >= 1);
}
- bool res = (bb ? is_export_p (dep1, bb) : is_export_p (dep1));
+ bool res = (bb ? m_map.is_export_p (dep1, bb)
+ : m_map.is_export_p (dep1));
if (res || depth <= 1)
return res;
// Check another level of recomputation.
}
// Two dependencies terminate the depth of the search.
if (bb)
- return is_export_p (dep1, bb) || is_export_p (dep2, bb);
+ return m_map.is_export_p (dep1, bb) || m_map.is_export_p (dep2, bb);
else
- return is_export_p (dep1) || is_export_p (dep2);
+ return m_map.is_export_p (dep1) || m_map.is_export_p (dep2);
}
// Return TRUE if NAME can be recomputed on edge E. If any direct dependent
{
// Check if NAME is an export or can be recomputed.
if (bb)
- return is_export_p (name, bb) || may_recompute_p (name, bb);
+ return m_map.is_export_p (name, bb) || may_recompute_p (name, bb);
// If no block is specified, check for anywhere in the IL.
- return is_export_p (name) || may_recompute_p (name);
+ return m_map.is_export_p (name) || may_recompute_p (name);
}
// Return TRUE if a range can be calculated or recomputed for NAME on edge E.
fur_stmt src (stmt, &q);
// If NAME can be calculated on the edge, use that.
- if (is_export_p (name, e->src))
+ if (m_map.is_export_p (name, e->src))
{
bool res;
if ((idx = tracer.header ("outgoing_edge")))
}
// Now solve for SSA1 or SSA2 if they are in the dependency chain.
- if (ssa1 && in_chain_p (ssa1, cond_name))
+ if (ssa1 && m_map.in_chain_p (ssa1, cond_name))
{
Value_Range tmp1 (TREE_TYPE (ssa1));
if (compute_operand_range (tmp1, def_stmt, cond_true, ssa1, src))
r1.intersect (tmp1);
}
- if (ssa2 && in_chain_p (ssa2, cond_name))
+ if (ssa2 && m_map.in_chain_p (ssa2, cond_name))
{
Value_Range tmp2 (TREE_TYPE (ssa2));
if (compute_operand_range (tmp2, def_stmt, cond_false, ssa2, src))
void
gori_compute::dump (FILE *f)
{
- gori_map::dump (f);
+ m_map.gori_map::dump (f);
}
// ------------------------------------------------------------------------
class value_relation;
-class gori_compute : public gori_map
+class gori_compute
{
public:
gori_compute (int not_executable_flag = 0);
bool compute_operand_range (vrange &r, gimple *stmt, const vrange &lhs,
tree name, class fur_source &src,
value_relation *rel = NULL);
+ gori_map *map () { return &m_map; }
private:
+ gori_map m_map;
bool refine_using_relation (tree op1, vrange &op1_range,
tree op2, vrange &op2_range,
fur_source &src, relation_kind k);
}
gori_compute &g = m_ranger.gori ();
- bitmap exports = g.exports (bb);
+ bitmap exports = g.map()->exports (bb);
EXECUTE_IF_AND_IN_BITMAP (m_exit_dependencies, exports, 0, i, bi)
{
tree name = ssa_name (i);
// Start with the imports from the exit block...
basic_block exit = m_path[0];
gori_compute &gori = m_ranger.gori ();
- bitmap_copy (dependencies, gori.imports (exit));
+ bitmap_copy (dependencies, gori.map()->imports (exit));
auto_vec<tree> worklist (bitmap_count_bits (dependencies));
bitmap_iterator bi;
{
basic_block bb = m_path[i];
tree name;
- FOR_EACH_GORI_EXPORT_NAME (gori, bb, name)
+ FOR_EACH_GORI_EXPORT_NAME (*(gori.map ()), bb, name)
if (TREE_CODE (TREE_TYPE (name)) == BOOLEAN_TYPE)
bitmap_set_bit (dependencies, SSA_NAME_VERSION (name));
}
// Update any exports in the cache if this is a gimple cond statement.
tree exp;
basic_block bb = gimple_bb (s);
- FOR_EACH_GORI_EXPORT_NAME (m_cache.m_gori, bb, exp)
+ FOR_EACH_GORI_EXPORT_NAME (*(m_cache.m_gori.map ()), bb, exp)
m_cache.propagate_updated_value (exp, bb);
}
}
// an inferred range as well.
Value_Range r (TREE_TYPE (lhs));
r.set_undefined ();
- tree name1 = gori ().depend1 (lhs);
- tree name2 = gori ().depend2 (lhs);
+ tree name1 = gori ().map () ->depend1 (lhs);
+ tree name2 = gori ().map ()->depend2 (lhs);
if ((name1 && infer_oracle ().has_range_p (bb, name1))
|| (name2 && infer_oracle ().has_range_p (bb, name2)))
{
tree name;
gori_compute &gori = m_ranger->gori ();
- FOR_EACH_GORI_EXPORT_NAME (gori, pred_e->src, name)
+ FOR_EACH_GORI_EXPORT_NAME (*(gori.map()), pred_e->src, name)
if (all_uses_feed_or_dominated_by_stmt (name, stmt)
// The condition must post-dominate the definition point.
&& (SSA_NAME_IS_DEFAULT_DEF (name)
gori_compute &gori = m_ranger->gori ();
// Start with the imports to the final conditional.
- bitmap_copy (dependencies, gori.imports (path[0]));
+ bitmap_copy (dependencies, gori.map ()->imports (path[0]));
// Add any other interesting operands we may have missed.
if (gimple_bb (stmt) != path[0])
// Check if every export use is dominated by this branch.
tree name;
- FOR_EACH_GORI_EXPORT_NAME (m_ranger.gori (), e->src, name)
+ FOR_EACH_GORI_EXPORT_NAME (*(m_ranger.gori ().map ()), e->src, name)
{
if (!fully_replaceable (name, e->src))
return;
}
// Set the global value for each.
- FOR_EACH_GORI_EXPORT_NAME (m_ranger.gori (), e->src, name)
+ FOR_EACH_GORI_EXPORT_NAME (*(m_ranger.gori ().map ()), e->src, name)
{
Value_Range r (TREE_TYPE (name));
m_ranger.range_on_entry (r, e->dest, name);
gcc_checking_assert (gimple_code (s) == GIMPLE_COND);
bool dominate_exit_p = true;
- FOR_EACH_GORI_EXPORT_NAME (m_ranger.gori (), e->src, name)
+ FOR_EACH_GORI_EXPORT_NAME (*(m_ranger.gori ().map ()), e->src, name)
{
// Ensure the cache is set for NAME in the succ block.
Value_Range r(TREE_TYPE (name));
// If the exit is dominated, add to the export list. Otherwise if this
// isn't the final VRP pass, leave the call in the IL.
if (dominate_exit_p)
- bitmap_ior_into (all_exports, m_ranger.gori ().exports (e->src));
+ bitmap_ior_into (all_exports,
+ m_ranger.gori ().map ()->exports (e->src));
else if (!final_p)
continue;
projects / thirdparty / gcc.git / commitdiff
