[PATCH] Rename predicate class to ipa_predicate
Martin Liška
mliska@suse.cz
Wed Nov 3 10:23:37 GMT 2021
Hello.
The renaming patch fixes a -Wodr warning seen and reported in the PR.
Patch can bootstrap on x86_64-linux-gnu and survives regression tests.
PR bootstrap/102828
gcc/ChangeLog:
* ipa-fnsummary.c (edge_predicate_pool): Rename predicate class to ipa_predicate.
(ipa_fn_summary::account_size_time): Likewise.
(edge_set_predicate): Likewise.
(set_hint_predicate): Likewise.
(add_freqcounting_predicate): Likewise.
(evaluate_conditions_for_known_args): Likewise.
(evaluate_properties_for_edge): Likewise.
(remap_freqcounting_preds_after_dup): Likewise.
(ipa_fn_summary_t::duplicate): Likewise.
(set_cond_stmt_execution_predicate): Likewise.
(set_switch_stmt_execution_predicate): Likewise.
(compute_bb_predicates): Likewise.
(will_be_nonconstant_expr_predicate): Likewise.
(will_be_nonconstant_predicate): Likewise.
(phi_result_unknown_predicate): Likewise.
(predicate_for_phi_result): Likewise.
(analyze_function_body): Likewise.
(compute_fn_summary): Likewise.
(summarize_calls_size_and_time): Likewise.
(estimate_calls_size_and_time): Likewise.
(ipa_call_context::estimate_size_and_time): Likewise.
(remap_edge_summaries): Likewise.
(remap_freqcounting_predicate): Likewise.
(ipa_merge_fn_summary_after_inlining): Likewise.
(ipa_update_overall_fn_summary): Likewise.
(read_ipa_call_summary): Likewise.
(inline_read_section): Likewise.
* ipa-fnsummary.h (struct ipa_freqcounting_predicate): Likewise.
* ipa-predicate.c (predicate::add_clause): Likewise.
(ipa_predicate::add_clause): Likewise.
(predicate::or_with): Likewise.
(ipa_predicate::or_with): Likewise.
(predicate::evaluate): Likewise.
(ipa_predicate::evaluate): Likewise.
(predicate::probability): Likewise.
(ipa_predicate::probability): Likewise.
(dump_condition): Likewise.
(dump_clause): Likewise.
(predicate::dump): Likewise.
(ipa_predicate::dump): Likewise.
(predicate::debug): Likewise.
(ipa_predicate::debug): Likewise.
(predicate::remap_after_duplication): Likewise.
(ipa_predicate::remap_after_duplication): Likewise.
(predicate::remap_after_inlining): Likewise.
(ipa_predicate::remap_after_inlining): Likewise.
(predicate::stream_in): Likewise.
(ipa_predicate::stream_in): Likewise.
(predicate::stream_out): Likewise.
(ipa_predicate::stream_out): Likewise.
(add_condition): Likewise.
* ipa-predicate.h (class predicate): Likewise.
(class ipa_predicate): Likewise.
(add_condition): Likewise.
---
gcc/ipa-fnsummary.c | 234 ++++++++++++++++++++++----------------------
gcc/ipa-fnsummary.h | 11 ++-
gcc/ipa-predicate.c | 101 ++++++++++---------
gcc/ipa-predicate.h | 65 ++++++------
4 files changed, 208 insertions(+), 203 deletions(-)
diff --git a/gcc/ipa-fnsummary.c b/gcc/ipa-fnsummary.c
index ac6eec30af8..2cfa9a6d0e9 100644
--- a/gcc/ipa-fnsummary.c
+++ b/gcc/ipa-fnsummary.c
@@ -94,7 +94,7 @@ fast_function_summary <ipa_size_summary *, va_heap> *ipa_size_summaries;
fast_call_summary <ipa_call_summary *, va_heap> *ipa_call_summaries;
/* Edge predicates goes here. */
-static object_allocator<predicate> edge_predicate_pool ("edge predicates");
+static object_allocator<ipa_predicate> edge_predicate_pool ("edge predicates");
/* Dump IPA hints. */
@@ -162,14 +162,14 @@ ipa_dump_hints (FILE *f, ipa_hints hints)
void
ipa_fn_summary::account_size_time (int size, sreal time,
- const predicate &exec_pred,
- const predicate &nonconst_pred_in,
+ const ipa_predicate &exec_pred,
+ const ipa_predicate &nonconst_pred_in,
bool call)
{
size_time_entry *e;
bool found = false;
int i;
- predicate nonconst_pred;
+ ipa_predicate nonconst_pred;
vec<size_time_entry> *table = call ? &call_size_time_table : &size_time_table;
if (exec_pred == false)
@@ -271,7 +271,7 @@ redirect_to_unreachable (struct cgraph_edge *e)
/* Set predicate for edge E. */
static void
-edge_set_predicate (struct cgraph_edge *e, predicate *predicate)
+edge_set_predicate (struct cgraph_edge *e, ipa_predicate *predicate)
{
/* If the edge is determined to be never executed, redirect it
to BUILTIN_UNREACHABLE to make it clear to IPA passes the call will
@@ -301,7 +301,7 @@ edge_set_predicate (struct cgraph_edge *e, predicate *predicate)
/* Set predicate for hint *P. */
static void
-set_hint_predicate (predicate **p, predicate new_predicate)
+set_hint_predicate (ipa_predicate **p, ipa_predicate new_predicate)
{
if (new_predicate == false || new_predicate == true)
{
@@ -324,7 +324,7 @@ set_hint_predicate (predicate **p, predicate new_predicate)
static void
add_freqcounting_predicate (vec<ipa_freqcounting_predicate, va_gc> **v,
- const predicate &new_predicate, sreal add_freq,
+ const ipa_predicate &new_predicate, sreal add_freq,
unsigned max_num_predicates)
{
if (new_predicate == false || new_predicate == true)
@@ -372,8 +372,8 @@ evaluate_conditions_for_known_args (struct cgraph_node *node,
clause_t *ret_clause,
clause_t *ret_nonspec_clause)
{
- clause_t clause = inline_p ? 0 : 1 << predicate::not_inlined_condition;
- clause_t nonspec_clause = 1 << predicate::not_inlined_condition;
+ clause_t clause = inline_p ? 0 : 1 << ipa_predicate::not_inlined_condition;
+ clause_t nonspec_clause = 1 << ipa_predicate::not_inlined_condition;
class ipa_fn_summary *info = ipa_fn_summaries->get (node);
int i;
struct condition *c;
@@ -396,7 +396,7 @@ evaluate_conditions_for_known_args (struct cgraph_node *node,
if (c->agg_contents)
{
- if (c->code == predicate::changed
+ if (c->code == ipa_predicate::changed
&& !c->by_ref
&& (avals->safe_sval_at(c->operand_num) == error_mark_node))
continue;
@@ -413,27 +413,28 @@ evaluate_conditions_for_known_args (struct cgraph_node *node,
else
{
val = avals->safe_sval_at (c->operand_num);
- if (val && val == error_mark_node && c->code != predicate::changed)
+ if (val && val == error_mark_node
+ && c->code != ipa_predicate::changed)
val = NULL_TREE;
}
if (!val
- && (c->code == predicate::changed
- || c->code == predicate::is_not_constant))
+ && (c->code == ipa_predicate::changed
+ || c->code == ipa_predicate::is_not_constant))
{
- clause |= 1 << (i + predicate::first_dynamic_condition);
- nonspec_clause |= 1 << (i + predicate::first_dynamic_condition);
+ clause |= 1 << (i + ipa_predicate::first_dynamic_condition);
+ nonspec_clause |= 1 << (i + ipa_predicate::first_dynamic_condition);
continue;
}
- if (c->code == predicate::changed)
+ if (c->code == ipa_predicate::changed)
{
- nonspec_clause |= 1 << (i + predicate::first_dynamic_condition);
+ nonspec_clause |= 1 << (i + ipa_predicate::first_dynamic_condition);
continue;
}
- if (c->code == predicate::is_not_constant)
+ if (c->code == ipa_predicate::is_not_constant)
{
- nonspec_clause |= 1 << (i + predicate::first_dynamic_condition);
+ nonspec_clause |= 1 << (i + ipa_predicate::first_dynamic_condition);
continue;
}
@@ -472,8 +473,9 @@ evaluate_conditions_for_known_args (struct cgraph_node *node,
continue;
if (res && integer_onep (res))
{
- clause |= 1 << (i + predicate::first_dynamic_condition);
- nonspec_clause |= 1 << (i + predicate::first_dynamic_condition);
+ clause |= 1 << (i + ipa_predicate::first_dynamic_condition);
+ nonspec_clause
+ |= 1 << (i + ipa_predicate::first_dynamic_condition);
continue;
}
}
@@ -528,8 +530,8 @@ evaluate_conditions_for_known_args (struct cgraph_node *node,
}
}
- clause |= 1 << (i + predicate::first_dynamic_condition);
- nonspec_clause |= 1 << (i + predicate::first_dynamic_condition);
+ clause |= 1 << (i + ipa_predicate::first_dynamic_condition);
+ nonspec_clause |= 1 << (i + ipa_predicate::first_dynamic_condition);
}
*ret_clause = clause;
if (ret_nonspec_clause)
@@ -587,7 +589,7 @@ evaluate_properties_for_edge (struct cgraph_edge *e, bool inline_p,
class ipa_edge_args *args;
if (clause_ptr)
- *clause_ptr = inline_p ? 0 : 1 << predicate::not_inlined_condition;
+ *clause_ptr = inline_p ? 0 : 1 << ipa_predicate::not_inlined_condition;
if (ipa_node_params_sum
&& !e->call_stmt_cannot_inline_p
@@ -785,7 +787,7 @@ remap_freqcounting_preds_after_dup (vec<ipa_freqcounting_predicate, va_gc> *v,
int len = res->length();
for (int i = len - 1; i >= 0; i--)
{
- predicate new_predicate
+ ipa_predicate new_predicate
= (*res)[i].predicate->remap_after_duplication (possible_truths);
/* We do not want to free previous predicate; it is used by node
origin. */
@@ -823,7 +825,7 @@ ipa_fn_summary_t::duplicate (cgraph_node *src,
int count = ipa_get_param_count (parms_info);
int i, j;
clause_t possible_truths;
- predicate true_pred = true;
+ ipa_predicate true_pred = true;
size_time_entry *e;
int optimized_out_size = 0;
bool inlined_to_p = false;
@@ -860,8 +862,8 @@ ipa_fn_summary_t::duplicate (cgraph_node *src,
to be true. */
for (i = 0; src_info->size_time_table.iterate (i, &e); i++)
{
- predicate new_exec_pred;
- predicate new_nonconst_pred;
+ ipa_predicate new_exec_pred;
+ ipa_predicate new_nonconst_pred;
new_exec_pred = e->exec_predicate.remap_after_duplication
(possible_truths);
new_nonconst_pred = e->nonconst_predicate.remap_after_duplication
@@ -877,7 +879,7 @@ ipa_fn_summary_t::duplicate (cgraph_node *src,
Also copy constantness arrays. */
for (edge = dst->callees; edge; edge = next)
{
- predicate new_predicate;
+ ipa_predicate new_predicate;
class ipa_call_summary *es = ipa_call_summaries->get (edge);
next = edge->next_callee;
@@ -896,7 +898,7 @@ ipa_fn_summary_t::duplicate (cgraph_node *src,
Also copy constantness arrays. */
for (edge = dst->indirect_calls; edge; edge = next)
{
- predicate new_predicate;
+ ipa_predicate new_predicate;
class ipa_call_summary *es = ipa_call_summaries->get (edge);
next = edge->next_callee;
@@ -944,13 +946,13 @@ ipa_fn_summary_t::duplicate (cgraph_node *src,
ipa_freqcounting_predicate *f;
for (int i = 0; vec_safe_iterate (info->loop_iterations, i, &f); i++)
{
- predicate p = *f->predicate;
+ ipa_predicate p = *f->predicate;
f->predicate = NULL;
set_hint_predicate (&f->predicate, p);
}
for (int i = 0; vec_safe_iterate (info->loop_strides, i, &f); i++)
{
- predicate p = *f->predicate;
+ ipa_predicate p = *f->predicate;
f->predicate = NULL;
set_hint_predicate (&f->predicate, p);
}
@@ -1609,12 +1611,12 @@ set_cond_stmt_execution_predicate (struct ipa_func_body_info *fbi,
if (this_code != ERROR_MARK
&& !dominated_by_p (CDI_POST_DOMINATORS, bb, e->dest))
{
- predicate p
+ ipa_predicate p
= add_condition (summary, params_summary, index,
param_type, &aggpos,
this_code, gimple_cond_rhs (last), param_ops);
e->aux = edge_predicate_pool.allocate ();
- *(predicate *) e->aux = p;
+ *(ipa_predicate *) e->aux = p;
}
}
vec_free (param_ops);
@@ -1646,11 +1648,11 @@ set_cond_stmt_execution_predicate (struct ipa_func_body_info *fbi,
add_builtin_constant_p_parm (summary, index);
FOR_EACH_EDGE (e, ei, bb->succs) if (e->flags & EDGE_FALSE_VALUE)
{
- predicate p = add_condition (summary, params_summary, index,
+ ipa_predicate p = add_condition (summary, params_summary, index,
param_type, &aggpos,
- predicate::is_not_constant, NULL_TREE);
+ ipa_predicate::is_not_constant, NULL_TREE);
e->aux = edge_predicate_pool.allocate ();
- *(predicate *) e->aux = p;
+ *(ipa_predicate *) e->aux = p;
}
}
@@ -1701,7 +1703,7 @@ set_switch_stmt_execution_predicate (struct ipa_func_body_info *fbi,
FOR_EACH_EDGE (e, ei, bb->succs)
{
e->aux = edge_predicate_pool.allocate ();
- *(predicate *) e->aux = false;
+ *(ipa_predicate *) e->aux = false;
}
e = gimple_switch_edge (cfun, last, 0);
@@ -1718,7 +1720,7 @@ set_switch_stmt_execution_predicate (struct ipa_func_body_info *fbi,
tree cl = gimple_switch_label (last, case_idx);
tree min = CASE_LOW (cl);
tree max = CASE_HIGH (cl);
- predicate p;
+ ipa_predicate p;
e = gimple_switch_edge (cfun, last, case_idx);
@@ -1742,15 +1744,15 @@ set_switch_stmt_execution_predicate (struct ipa_func_body_info *fbi,
&aggpos, EQ_EXPR, min, param_ops);
else
{
- predicate p1, p2;
+ ipa_predicate p1, p2;
p1 = add_condition (summary, params_summary, index, param_type,
&aggpos, GE_EXPR, min, param_ops);
p2 = add_condition (summary, params_summary,index, param_type,
&aggpos, LE_EXPR, max, param_ops);
p = p1 & p2;
}
- *(class predicate *) e->aux
- = p.or_with (summary->conds, *(class predicate *) e->aux);
+ *(ipa_predicate *) e->aux
+ = p.or_with (summary->conds, *(ipa_predicate *) e->aux);
/* If there are too many disjoint case ranges, predicate for default
case might become too complicated. So add a limit here. */
@@ -1796,13 +1798,13 @@ set_switch_stmt_execution_predicate (struct ipa_func_body_info *fbi,
e = gimple_switch_edge (cfun, last, 0);
if (bound_count > bound_limit)
{
- *(class predicate *) e->aux = true;
+ *(ipa_predicate *) e->aux = true;
vec_free (param_ops);
return;
}
- predicate p_seg = true;
- predicate p_all = false;
+ ipa_predicate p_seg = true;
+ ipa_predicate p_all = false;
if (vr_type != VR_RANGE)
{
@@ -1857,8 +1859,8 @@ set_switch_stmt_execution_predicate (struct ipa_func_body_info *fbi,
}
p_all = p_all.or_with (summary->conds, p_seg);
- *(class predicate *) e->aux
- = p_all.or_with (summary->conds, *(class predicate *) e->aux);
+ *(ipa_predicate *) e->aux
+ = p_all.or_with (summary->conds, *(ipa_predicate *) e->aux);
vec_free (param_ops);
}
@@ -1886,7 +1888,7 @@ compute_bb_predicates (struct ipa_func_body_info *fbi,
/* Entry block is always executable. */
ENTRY_BLOCK_PTR_FOR_FN (my_function)->aux
= edge_predicate_pool.allocate ();
- *(predicate *) ENTRY_BLOCK_PTR_FOR_FN (my_function)->aux = true;
+ *(ipa_predicate *) ENTRY_BLOCK_PTR_FOR_FN (my_function)->aux = true;
/* A simple dataflow propagation of predicates forward in the CFG.
TODO: work in reverse postorder. */
@@ -1895,17 +1897,17 @@ compute_bb_predicates (struct ipa_func_body_info *fbi,
done = true;
FOR_EACH_BB_FN (bb, my_function)
{
- predicate p = false;
+ ipa_predicate p = false;
edge e;
edge_iterator ei;
FOR_EACH_EDGE (e, ei, bb->preds)
{
if (e->src->aux)
{
- predicate this_bb_predicate
- = *(predicate *) e->src->aux;
+ ipa_predicate this_bb_predicate
+ = *(ipa_predicate *) e->src->aux;
if (e->aux)
- this_bb_predicate &= (*(class predicate *) e->aux);
+ this_bb_predicate &= (*(ipa_predicate *) e->aux);
p = p.or_with (summary->conds, this_bb_predicate);
if (p == true)
break;
@@ -1919,18 +1921,18 @@ compute_bb_predicates (struct ipa_func_body_info *fbi,
{
done = false;
bb->aux = edge_predicate_pool.allocate ();
- *((predicate *) bb->aux) = p;
+ *((ipa_predicate *) bb->aux) = p;
}
- else if (p != *(predicate *) bb->aux)
+ else if (p != *(ipa_predicate *) bb->aux)
{
/* This OR operation is needed to ensure monotonous data flow
in the case we hit the limit on number of clauses and the
and/or operations above give approximate answers. */
- p = p.or_with (summary->conds, *(predicate *)bb->aux);
- if (p != *(predicate *) bb->aux)
+ p = p.or_with (summary->conds, *(ipa_predicate *)bb->aux);
+ if (p != *(ipa_predicate *)bb->aux)
{
done = false;
- *((predicate *) bb->aux) = p;
+ *((ipa_predicate *)bb->aux) = p;
}
}
@@ -1950,15 +1952,16 @@ compute_bb_predicates (struct ipa_func_body_info *fbi,
{
done = false;
pdom_bb->aux = edge_predicate_pool.allocate ();
- *((predicate *) pdom_bb->aux) = p;
+ *((ipa_predicate *)pdom_bb->aux) = p;
}
- else if (p != *(predicate *) pdom_bb->aux)
+ else if (p != *(ipa_predicate *)pdom_bb->aux)
{
- p = p.or_with (summary->conds, *(predicate *)pdom_bb->aux);
- if (p != *(predicate *) pdom_bb->aux)
+ p = p.or_with (summary->conds,
+ *(ipa_predicate *)pdom_bb->aux);
+ if (p != *(ipa_predicate *)pdom_bb->aux)
{
done = false;
- *((predicate *) pdom_bb->aux) = p;
+ *((ipa_predicate *)pdom_bb->aux) = p;
}
}
}
@@ -1970,12 +1973,12 @@ compute_bb_predicates (struct ipa_func_body_info *fbi,
/* Return predicate specifying when the STMT might have result that is not
a compile time constant. */
-static predicate
+static ipa_predicate
will_be_nonconstant_expr_predicate (ipa_func_body_info *fbi,
class ipa_fn_summary *summary,
class ipa_node_params *params_summary,
tree expr,
- vec<predicate> nonconstant_names)
+ vec<ipa_predicate> nonconstant_names)
{
tree parm;
int index;
@@ -1986,14 +1989,14 @@ will_be_nonconstant_expr_predicate (ipa_func_body_info *fbi,
parm = unmodified_parm (fbi, NULL, expr, NULL);
if (parm && (index = ipa_get_param_decl_index (fbi->info, parm)) >= 0)
return add_condition (summary, params_summary, index, TREE_TYPE (parm), NULL,
- predicate::changed, NULL_TREE);
+ ipa_predicate::changed, NULL_TREE);
if (is_gimple_min_invariant (expr))
return false;
if (TREE_CODE (expr) == SSA_NAME)
return nonconstant_names[SSA_NAME_VERSION (expr)];
if (BINARY_CLASS_P (expr) || COMPARISON_CLASS_P (expr))
{
- predicate p1
+ ipa_predicate p1
= will_be_nonconstant_expr_predicate (fbi, summary,
params_summary,
TREE_OPERAND (expr, 0),
@@ -2001,7 +2004,7 @@ will_be_nonconstant_expr_predicate (ipa_func_body_info *fbi,
if (p1 == true)
return p1;
- predicate p2
+ ipa_predicate p2
= will_be_nonconstant_expr_predicate (fbi, summary,
params_summary,
TREE_OPERAND (expr, 1),
@@ -2010,7 +2013,7 @@ will_be_nonconstant_expr_predicate (ipa_func_body_info *fbi,
}
else if (TREE_CODE (expr) == COND_EXPR)
{
- predicate p1
+ ipa_predicate p1
= will_be_nonconstant_expr_predicate (fbi, summary,
params_summary,
TREE_OPERAND (expr, 0),
@@ -2018,7 +2021,7 @@ will_be_nonconstant_expr_predicate (ipa_func_body_info *fbi,
if (p1 == true)
return p1;
- predicate p2
+ ipa_predicate p2
= will_be_nonconstant_expr_predicate (fbi, summary,
params_summary,
TREE_OPERAND (expr, 1),
@@ -2046,18 +2049,18 @@ will_be_nonconstant_expr_predicate (ipa_func_body_info *fbi,
/* Return predicate specifying when the STMT might have result that is not
a compile time constant. */
-static predicate
+static ipa_predicate
will_be_nonconstant_predicate (struct ipa_func_body_info *fbi,
class ipa_fn_summary *summary,
class ipa_node_params *params_summary,
gimple *stmt,
- vec<predicate> nonconstant_names)
+ vec<ipa_predicate> nonconstant_names)
{
- predicate p = true;
+ ipa_predicate p = true;
ssa_op_iter iter;
tree use;
tree param_type = NULL_TREE;
- predicate op_non_const;
+ ipa_predicate op_non_const;
bool is_load;
int base_index;
struct agg_position_info aggpos;
@@ -2109,7 +2112,7 @@ will_be_nonconstant_predicate (struct ipa_func_body_info *fbi,
op_non_const =
add_condition (summary, params_summary,
base_index, param_type, &aggpos,
- predicate::changed, NULL_TREE);
+ ipa_predicate::changed, NULL_TREE);
else
op_non_const = false;
FOR_EACH_SSA_TREE_OPERAND (use, stmt, iter, SSA_OP_USE)
@@ -2122,7 +2125,7 @@ will_be_nonconstant_predicate (struct ipa_func_body_info *fbi,
if (index != base_index)
p = add_condition (summary, params_summary, index,
TREE_TYPE (parm), NULL,
- predicate::changed, NULL_TREE);
+ ipa_predicate::changed, NULL_TREE);
else
continue;
}
@@ -2315,8 +2318,8 @@ phi_result_unknown_predicate (ipa_func_body_info *fbi,
ipa_fn_summary *summary,
class ipa_node_params *params_summary,
basic_block bb,
- predicate *p,
- vec<predicate> nonconstant_names)
+ ipa_predicate *p,
+ vec<ipa_predicate> nonconstant_names)
{
edge e;
edge_iterator ei;
@@ -2374,8 +2377,8 @@ phi_result_unknown_predicate (ipa_func_body_info *fbi,
static void
predicate_for_phi_result (class ipa_fn_summary *summary, gphi *phi,
- predicate *p,
- vec<predicate> nonconstant_names)
+ ipa_predicate *p,
+ vec<ipa_predicate> nonconstant_names)
{
unsigned i;
@@ -2607,9 +2610,9 @@ analyze_function_body (struct cgraph_node *node, bool early)
class ipa_fn_summary *info = ipa_fn_summaries->get_create (node);
ipa_node_params *params_summary
= early ? NULL : ipa_node_params_sum->get (node);
- predicate bb_predicate;
+ ipa_predicate bb_predicate;
struct ipa_func_body_info fbi;
- vec<predicate> nonconstant_names = vNULL;
+ vec<ipa_predicate> nonconstant_names = vNULL;
int nblocks, n;
int *order;
gimple *fix_builtin_expect_stmt;
@@ -2664,7 +2667,7 @@ analyze_function_body (struct cgraph_node *node, bool early)
bb_predicate = true;
info->account_size_time (0, 0, bb_predicate, bb_predicate);
- bb_predicate = predicate::not_inlined ();
+ bb_predicate = ipa_predicate::not_inlined ();
info->account_size_time (opt_for_fn (node->decl,
param_uninlined_function_insns)
* ipa_fn_summary::size_scale,
@@ -2695,7 +2698,7 @@ analyze_function_body (struct cgraph_node *node, bool early)
if (fbi.info)
{
if (bb->aux)
- bb_predicate = *(predicate *) bb->aux;
+ bb_predicate = *(ipa_predicate *)bb->aux;
else
bb_predicate = false;
}
@@ -2710,7 +2713,7 @@ analyze_function_body (struct cgraph_node *node, bool early)
if (fbi.info && nonconstant_names.exists ())
{
- predicate phi_predicate;
+ ipa_predicate phi_predicate;
bool first_phi = true;
for (gphi_iterator bsi = gsi_start_phis (bb); !gsi_end_p (bsi);
@@ -2743,7 +2746,7 @@ analyze_function_body (struct cgraph_node *node, bool early)
int this_size = estimate_num_insns (stmt, &eni_size_weights);
int this_time = estimate_num_insns (stmt, &eni_time_weights);
int prob;
- predicate will_be_nonconstant;
+ ipa_predicate will_be_nonconstant;
/* This relation stmt should be folded after we remove
__builtin_expect call. Adjust the cost here. */
@@ -2776,7 +2779,7 @@ analyze_function_body (struct cgraph_node *node, bool early)
&& gimple_call_lhs (stmt)
&& TREE_CODE (gimple_call_lhs (stmt)) == SSA_NAME)
{
- predicate false_p = false;
+ ipa_predicate false_p = false;
nonconstant_names[SSA_NAME_VERSION (gimple_call_lhs (stmt))]
= false_p;
}
@@ -2853,7 +2856,7 @@ analyze_function_body (struct cgraph_node *node, bool early)
if (prob == 2 && dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, "\t\tWill be eliminated by inlining\n");
- class predicate p = bb_predicate & will_be_nonconstant;
+ ipa_predicate p = bb_predicate & will_be_nonconstant;
/* We can ignore statement when we proved it is never going
to happen, but we cannot do that for call statements
@@ -2872,7 +2875,8 @@ analyze_function_body (struct cgraph_node *node, bool early)
{
if (prob)
{
- predicate ip = bb_predicate & predicate::not_inlined ();
+ ipa_predicate ip
+ = bb_predicate & ipa_predicate::not_inlined ();
info->account_size_time (this_size * prob,
(final_time * prob) / 2, ip,
p);
@@ -2902,7 +2906,7 @@ analyze_function_body (struct cgraph_node *node, bool early)
|| TREE_CODE (op) == ARRAY_RANGE_REF)
&& TREE_CODE (TREE_OPERAND (op, 1)) == SSA_NAME)
{
- predicate p = bb_predicate;
+ ipa_predicate p = bb_predicate;
if (fbi.info)
p = p & will_be_nonconstant_expr_predicate
(&fbi, info, params_summary,
@@ -2939,7 +2943,7 @@ analyze_function_body (struct cgraph_node *node, bool early)
scev_initialize ();
for (auto loop : loops_list (cfun, 0))
{
- predicate loop_iterations = true;
+ ipa_predicate loop_iterations = true;
sreal header_freq;
edge ex;
unsigned int j;
@@ -2950,13 +2954,13 @@ analyze_function_body (struct cgraph_node *node, bool early)
profile_count phdr_count = loop_preheader_edge (loop)->count ();
sreal phdr_freq = phdr_count.to_sreal_scale (entry_count);
- bb_predicate = *(predicate *) loop->header->aux;
+ bb_predicate = *(ipa_predicate *)loop->header->aux;
auto_vec<edge> exits = get_loop_exit_edges (loop);
FOR_EACH_VEC_ELT (exits, j, ex)
if (number_of_iterations_exit (loop, ex, &niter_desc, false)
&& !is_gimple_min_invariant (niter_desc.niter))
{
- predicate will_be_nonconstant
+ ipa_predicate will_be_nonconstant
= will_be_nonconstant_expr_predicate (&fbi, info,
params_summary,
niter_desc.niter,
@@ -2977,7 +2981,7 @@ analyze_function_body (struct cgraph_node *node, bool early)
for (loop = loops_for_fn (cfun)->tree_root->inner;
loop != NULL; loop = loop->next)
{
- predicate loop_stride = true;
+ ipa_predicate loop_stride = true;
basic_block *body = get_loop_body (loop);
profile_count phdr_count = loop_preheader_edge (loop)->count ();
sreal phdr_freq = phdr_count.to_sreal_scale (entry_count);
@@ -2987,7 +2991,7 @@ analyze_function_body (struct cgraph_node *node, bool early)
if (!body[i]->aux)
continue;
- bb_predicate = *(predicate *) body[i]->aux;
+ bb_predicate = *(ipa_predicate *)body[i]->aux;
for (gsi = gsi_start_bb (body[i]); !gsi_end_p (gsi);
gsi_next (&gsi))
{
@@ -3007,7 +3011,7 @@ analyze_function_body (struct cgraph_node *node, bool early)
|| is_gimple_min_invariant (iv.step))
continue;
- predicate will_be_nonconstant
+ ipa_predicate will_be_nonconstant
= will_be_nonconstant_expr_predicate (&fbi, info,
params_summary,
iv.step,
@@ -3031,12 +3035,12 @@ analyze_function_body (struct cgraph_node *node, bool early)
edge_iterator ei;
if (bb->aux)
- edge_predicate_pool.remove ((predicate *)bb->aux);
+ edge_predicate_pool.remove ((ipa_predicate *)bb->aux);
bb->aux = NULL;
FOR_EACH_EDGE (e, ei, bb->succs)
{
if (e->aux)
- edge_predicate_pool.remove ((predicate *) e->aux);
+ edge_predicate_pool.remove ((ipa_predicate *)e->aux);
e->aux = NULL;
}
}
@@ -3092,7 +3096,7 @@ compute_fn_summary (struct cgraph_node *node, bool early)
if (node->thunk)
{
ipa_call_summary *es = ipa_call_summaries->get_create (node->callees);
- predicate t = true;
+ ipa_predicate t = true;
node->can_change_signature = false;
es->call_stmt_size = eni_size_weights.call_cost;
@@ -3102,7 +3106,7 @@ compute_fn_summary (struct cgraph_node *node, bool early)
param_uninlined_function_thunk_insns),
opt_for_fn (node->decl,
param_uninlined_function_thunk_time), t, t);
- t = predicate::not_inlined ();
+ t = ipa_predicate::not_inlined ();
info->account_size_time (2 * ipa_fn_summary::size_scale, 0, t, t);
ipa_update_overall_fn_summary (node);
size_info->self_size = size_info->size;
@@ -3335,7 +3339,7 @@ summarize_calls_size_and_time (struct cgraph_node *node,
estimate_edge_size_and_time (e, &size, NULL, &time, NULL, NULL);
- struct predicate pred = true;
+ ipa_predicate pred = true;
class ipa_call_summary *es = ipa_call_summaries->get (e);
if (es->predicate)
@@ -3348,7 +3352,7 @@ summarize_calls_size_and_time (struct cgraph_node *node,
sreal time = 0;
estimate_edge_size_and_time (e, &size, NULL, &time, NULL, NULL);
- struct predicate pred = true;
+ ipa_predicate pred = true;
class ipa_call_summary *es = ipa_call_summaries->get (e);
if (es->predicate)
@@ -3414,7 +3418,7 @@ estimate_calls_size_and_time (struct cgraph_node *node, int *size,
/* Build summary if it is absent. */
if (!sum->call_size_time_table.length ())
{
- predicate true_pred = true;
+ ipa_predicate true_pred = true;
sum->account_size_time (0, 0, true_pred, true_pred, true);
summarize_calls_size_and_time (node, sum);
}
@@ -3712,8 +3716,8 @@ ipa_call_context::estimate_size_and_time (ipa_call_estimates *estimates,
fprintf (dump_file, " Estimating body: %s\n"
" Known to be false: ", m_node->dump_name ());
- for (i = predicate::not_inlined_condition;
- i < (predicate::first_dynamic_condition
+ for (i = ipa_predicate::not_inlined_condition;
+ i < (ipa_predicate::first_dynamic_condition
+ (int) vec_safe_length (info->conds)); i++)
if (!(m_possible_truths & (1 << i)))
{
@@ -3984,12 +3988,12 @@ remap_edge_summaries (struct cgraph_edge *inlined_edge,
const vec<int> &operand_map,
const vec<HOST_WIDE_INT> &offset_map,
clause_t possible_truths,
- predicate *toplev_predicate)
+ ipa_predicate *toplev_predicate)
{
struct cgraph_edge *e, *next;
for (e = node->callees; e; e = next)
{
- predicate p;
+ ipa_predicate p;
next = e->next_callee;
if (e->inline_failed)
@@ -4018,7 +4022,7 @@ remap_edge_summaries (struct cgraph_edge *inlined_edge,
for (e = node->indirect_calls; e; e = next)
{
class ipa_call_summary *es = ipa_call_summaries->get (e);
- predicate p;
+ ipa_predicate p;
next = e->next_callee;
remap_edge_params (inlined_edge, e);
@@ -4045,13 +4049,13 @@ remap_freqcounting_predicate (class ipa_fn_summary *info,
const vec<int> &operand_map,
const vec<HOST_WIDE_INT> &offset_map,
clause_t possible_truths,
- predicate *toplev_predicate)
+ ipa_predicate *toplev_predicate)
{
ipa_freqcounting_predicate *fcp;
for (int i = 0; vec_safe_iterate (v, i, &fcp); i++)
{
- predicate p
+ ipa_predicate p
= fcp->predicate->remap_after_inlining (info, params_summary,
callee_info, operand_map,
offset_map, possible_truths,
@@ -4075,7 +4079,7 @@ ipa_merge_fn_summary_after_inlining (struct cgraph_edge *edge)
auto_vec<int, 8> operand_map;
auto_vec<HOST_WIDE_INT, 8> offset_map;
int i;
- predicate toplev_predicate;
+ ipa_predicate toplev_predicate;
class ipa_call_summary *es = ipa_call_summaries->get (edge);
ipa_node_params *params_summary = (ipa_node_params_sum
? ipa_node_params_sum->get (to) : NULL);
@@ -4139,13 +4143,13 @@ ipa_merge_fn_summary_after_inlining (struct cgraph_edge *edge)
sreal freq = edge->sreal_frequency ();
for (i = 0; callee_info->size_time_table.iterate (i, &e); i++)
{
- predicate p;
+ ipa_predicate p;
p = e->exec_predicate.remap_after_inlining
(info, params_summary,
callee_info, operand_map,
offset_map, clause,
toplev_predicate);
- predicate nonconstp;
+ ipa_predicate nonconstp;
nonconstp = e->nonconst_predicate.remap_after_inlining
(info, params_summary,
callee_info, operand_map,
@@ -4230,7 +4234,7 @@ ipa_update_overall_fn_summary (struct cgraph_node *node, bool reset)
if (node->callees || node->indirect_calls)
estimate_calls_size_and_time (node, &size_info->size, &info->min_size,
&info->time, NULL,
- ~(clause_t) (1 << predicate::false_condition),
+ ~(clause_t) (1 << ipa_predicate::false_condition),
NULL);
size_info->size = RDIV (size_info->size, ipa_fn_summary::size_scale);
info->min_size = RDIV (info->min_size, ipa_fn_summary::size_scale);
@@ -4318,7 +4322,7 @@ read_ipa_call_summary (class lto_input_block *ib, struct cgraph_edge *e,
{
class ipa_call_summary *es = prevails
? ipa_call_summaries->get_create (e) : NULL;
- predicate p;
+ ipa_predicate p;
int length, i;
int size = streamer_read_uhwi (ib);
@@ -4399,7 +4403,7 @@ inline_read_section (struct lto_file_decl_data *file_data, const char *data,
lto_symtab_encoder_t encoder;
struct bitpack_d bp;
struct cgraph_edge *e;
- predicate p;
+ ipa_predicate p;
index = streamer_read_uhwi (&ib);
encoder = file_data->symtab_node_encoder;
diff --git a/gcc/ipa-fnsummary.h b/gcc/ipa-fnsummary.h
index 78399b0b9bb..fdfbd660e70 100644
--- a/gcc/ipa-fnsummary.h
+++ b/gcc/ipa-fnsummary.h
@@ -76,11 +76,11 @@ class size_time_entry
{
public:
/* Predicate for code to be executed. */
- predicate exec_predicate;
+ ipa_predicate exec_predicate;
/* Predicate for value to be constant and optimized out in a specialized copy.
When deciding on specialization this makes it possible to see how much
the executed code paths will simplify. */
- predicate nonconst_predicate;
+ ipa_predicate nonconst_predicate;
int size;
sreal time;
};
@@ -114,7 +114,7 @@ struct GTY(()) ipa_freqcounting_predicate
/* The described event happens with this frequency... */
sreal freq;
/* ...when this predicate evaluates to false. */
- class predicate * GTY((skip)) predicate;
+ ipa_predicate * GTY((skip)) predicate;
};
/* Function inlining information. */
@@ -203,7 +203,8 @@ public:
int scc_no;
/* Record time and size under given predicates. */
- void account_size_time (int, sreal, const predicate &, const predicate &,
+ void account_size_time (int, sreal, const ipa_predicate &,
+ const ipa_predicate &,
bool call = false);
/* We keep values scaled up, so fractional sizes can be accounted. */
@@ -286,7 +287,7 @@ public:
/* Default destructor. */
~ipa_call_summary ();
- class predicate *predicate;
+ ipa_predicate *predicate;
/* Vector indexed by parameters. */
vec<inline_param_summary> param;
/* Estimated size and time of the call statement. */
diff --git a/gcc/ipa-predicate.c b/gcc/ipa-predicate.c
index e4b11ec3ae3..48318cc6091 100644
--- a/gcc/ipa-predicate.c
+++ b/gcc/ipa-predicate.c
@@ -69,7 +69,7 @@ expr_eval_ops_equal_p (expr_eval_ops ops1, expr_eval_ops ops2)
sane. */
void
-predicate::add_clause (conditions conditions, clause_t new_clause)
+ipa_predicate::add_clause (conditions conditions, clause_t new_clause)
{
int i;
int i2;
@@ -81,7 +81,7 @@ predicate::add_clause (conditions conditions, clause_t new_clause)
return;
/* False clause makes the whole predicate false. Kill the other variants. */
- if (new_clause == (1 << predicate::false_condition))
+ if (new_clause == (1 << ipa_predicate::false_condition))
{
*this = false;
return;
@@ -90,7 +90,7 @@ predicate::add_clause (conditions conditions, clause_t new_clause)
return;
/* No one should be silly enough to add false into nontrivial clauses. */
- gcc_checking_assert (!(new_clause & (1 << predicate::false_condition)));
+ gcc_checking_assert (!(new_clause & (1 << ipa_predicate::false_condition)));
/* Look where to insert the new_clause. At the same time prune out
new_clauses of P that are implied by the new new_clause and thus
@@ -123,13 +123,13 @@ predicate::add_clause (conditions conditions, clause_t new_clause)
/* Look for clauses that are obviously true. I.e.
op0 == 5 || op0 != 5. */
if (conditions)
- for (c1 = predicate::first_dynamic_condition;
+ for (c1 = ipa_predicate::first_dynamic_condition;
c1 < num_conditions; c1++)
{
condition *cc1;
if (!(new_clause & (1 << c1)))
continue;
- cc1 = &(*conditions)[c1 - predicate::first_dynamic_condition];
+ cc1 = &(*conditions)[c1 - ipa_predicate::first_dynamic_condition];
/* We have no way to represent !changed and !is_not_constant
and thus there is no point for looking for them. */
if (cc1->code == changed || cc1->code == is_not_constant)
@@ -138,7 +138,7 @@ predicate::add_clause (conditions conditions, clause_t new_clause)
if (new_clause & (1 << c2))
{
condition *cc2 =
- &(*conditions)[c2 - predicate::first_dynamic_condition];
+ &(*conditions)[c2 - ipa_predicate::first_dynamic_condition];
if (cc1->operand_num == cc2->operand_num
&& vrp_operand_equal_p (cc1->val, cc2->val)
&& cc2->code != is_not_constant
@@ -170,8 +170,8 @@ predicate::add_clause (conditions conditions, clause_t new_clause)
/* Do THIS &= P. */
-predicate &
-predicate::operator &= (const predicate &p)
+ipa_predicate &
+ipa_predicate::operator &= (const ipa_predicate &p)
{
/* Avoid busy work. */
if (p == false || *this == true)
@@ -184,13 +184,13 @@ predicate::operator &= (const predicate &p)
int i;
- /* See how far predicates match. */
+ /* See how far ipa_predicates match. */
for (i = 0; m_clause[i] && m_clause[i] == p.m_clause[i]; i++)
{
gcc_checking_assert (i < max_clauses);
}
- /* Combine the predicates rest. */
+ /* Combine the ipa_predicates rest. */
for (; p.m_clause[i]; i++)
{
gcc_checking_assert (i < max_clauses);
@@ -203,9 +203,9 @@ predicate::operator &= (const predicate &p)
/* Return THIS | P2. */
-predicate
-predicate::or_with (conditions conditions,
- const predicate &p) const
+ipa_predicate
+ipa_predicate::or_with (conditions conditions,
+ const ipa_predicate &p) const
{
/* Avoid busy work. */
if (p == false || *this == true || *this == p)
@@ -214,7 +214,7 @@ predicate::or_with (conditions conditions,
return p;
/* OK, combine the predicates. */
- predicate out = true;
+ ipa_predicate out = true;
for (int i = 0; m_clause[i]; i++)
for (int j = 0; p.m_clause[j]; j++)
@@ -230,7 +230,7 @@ predicate::or_with (conditions conditions,
if predicate P is known to be false. */
bool
-predicate::evaluate (clause_t possible_truths) const
+ipa_predicate::evaluate (clause_t possible_truths) const
{
int i;
@@ -238,7 +238,7 @@ predicate::evaluate (clause_t possible_truths) const
if (*this == true)
return true;
- gcc_assert (!(possible_truths & (1 << predicate::false_condition)));
+ gcc_assert (!(possible_truths & (1 << ipa_predicate::false_condition)));
/* See if we can find clause we can disprove. */
for (i = 0; m_clause[i]; i++)
@@ -254,7 +254,7 @@ predicate::evaluate (clause_t possible_truths) const
instruction will be recomputed per invocation of the inlined call. */
int
-predicate::probability (conditions conds,
+ipa_predicate::probability (conditions conds,
clause_t possible_truths,
vec<inline_param_summary> inline_param_summary) const
{
@@ -268,7 +268,7 @@ predicate::probability (conditions conds,
if (*this == false)
return 0;
- gcc_assert (!(possible_truths & (1 << predicate::false_condition)));
+ gcc_assert (!(possible_truths & (1 << ipa_predicate::false_condition)));
/* See if we can find clause we can disprove. */
for (i = 0; m_clause[i]; i++)
@@ -285,11 +285,11 @@ predicate::probability (conditions conds,
for (i2 = 0; i2 < num_conditions; i2++)
if ((m_clause[i] & possible_truths) & (1 << i2))
{
- if (i2 >= predicate::first_dynamic_condition)
+ if (i2 >= ipa_predicate::first_dynamic_condition)
{
condition *c =
- &(*conds)[i2 - predicate::first_dynamic_condition];
- if (c->code == predicate::changed
+ &(*conds)[i2 - ipa_predicate::first_dynamic_condition];
+ if (c->code == ipa_predicate::changed
&& (c->operand_num <
(int) inline_param_summary.length ()))
{
@@ -318,13 +318,13 @@ void
dump_condition (FILE *f, conditions conditions, int cond)
{
condition *c;
- if (cond == predicate::false_condition)
+ if (cond == ipa_predicate::false_condition)
fprintf (f, "false");
- else if (cond == predicate::not_inlined_condition)
+ else if (cond == ipa_predicate::not_inlined_condition)
fprintf (f, "not inlined");
else
{
- c = &(*conditions)[cond - predicate::first_dynamic_condition];
+ c = &(*conditions)[cond - ipa_predicate::first_dynamic_condition];
fprintf (f, "op%i", c->operand_num);
if (c->agg_contents)
fprintf (f, "[%soffset: " HOST_WIDE_INT_PRINT_DEC "]",
@@ -406,12 +406,12 @@ dump_condition (FILE *f, conditions conditions, int cond)
fprintf (f, ")");
}
- if (c->code == predicate::is_not_constant)
+ if (c->code == ipa_predicate::is_not_constant)
{
fprintf (f, " not constant");
return;
}
- if (c->code == predicate::changed)
+ if (c->code == ipa_predicate::changed)
{
fprintf (f, " changed");
return;
@@ -432,7 +432,7 @@ dump_clause (FILE *f, conditions conds, clause_t clause)
fprintf (f, "(");
if (!clause)
fprintf (f, "true");
- for (i = 0; i < predicate::num_conditions; i++)
+ for (i = 0; i < ipa_predicate::num_conditions; i++)
if (clause & (1 << i))
{
if (found)
@@ -445,10 +445,10 @@ dump_clause (FILE *f, conditions conds, clause_t clause)
/* Dump THIS to F. CONDS a vector of conditions used when evaluating
- predicates. When NL is true new line is output at the end of dump. */
+ ipa_predicates. When NL is true new line is output at the end of dump. */
void
-predicate::dump (FILE *f, conditions conds, bool nl) const
+ipa_predicate::dump (FILE *f, conditions conds, bool nl) const
{
int i;
if (*this == true)
@@ -466,7 +466,7 @@ predicate::dump (FILE *f, conditions conds, bool nl) const
void
-predicate::debug (conditions conds) const
+ipa_predicate::debug (conditions conds) const
{
dump (stderr, conds);
}
@@ -476,11 +476,11 @@ predicate::debug (conditions conds) const
POSSIBLE_TRUTHS is clause of possible truths in the duplicated node,
INFO is inline summary of the duplicated node. */
-predicate
-predicate::remap_after_duplication (clause_t possible_truths)
+ipa_predicate
+ipa_predicate::remap_after_duplication (clause_t possible_truths)
{
int j;
- predicate out = true;
+ ipa_predicate out = true;
for (j = 0; m_clause[j]; j++)
if (!(possible_truths & m_clause[j]))
return false;
@@ -503,26 +503,26 @@ predicate::remap_after_duplication (clause_t possible_truths)
because they might not be preserved (and should be considered offset zero
for other purposes). */
-predicate
-predicate::remap_after_inlining (class ipa_fn_summary *info,
+ipa_predicate
+ipa_predicate::remap_after_inlining (class ipa_fn_summary *info,
class ipa_node_params *params_summary,
class ipa_fn_summary *callee_info,
const vec<int> &operand_map,
const vec<HOST_WIDE_INT> &offset_map,
clause_t possible_truths,
- const predicate &toplev_predicate)
+ const ipa_predicate &toplev_predicate)
{
int i;
- predicate out = true;
+ ipa_predicate out = true;
- /* True predicate is easy. */
+ /* True ipa_predicate is easy. */
if (*this == true)
return toplev_predicate;
for (i = 0; m_clause[i]; i++)
{
clause_t clause = m_clause[i];
int cond;
- predicate clause_predicate = false;
+ ipa_predicate clause_predicate = false;
gcc_assert (i < max_clauses);
@@ -530,16 +530,15 @@ predicate::remap_after_inlining (class ipa_fn_summary *info,
/* Do we have condition we can't disprove? */
if (clause & possible_truths & (1 << cond))
{
- predicate cond_predicate;
+ ipa_predicate cond_predicate;
/* Work out if the condition can translate to predicate in the
inlined function. */
- if (cond >= predicate::first_dynamic_condition)
+ if (cond >= ipa_predicate::first_dynamic_condition)
{
struct condition *c;
- c = &(*callee_info->conds)[cond
- -
- predicate::first_dynamic_condition];
+ int index = cond - ipa_predicate::first_dynamic_condition;
+ c = &(*callee_info->conds)[index];
/* See if we can remap condition operand to caller's operand.
Otherwise give up. */
if (!operand_map.exists ()
@@ -576,7 +575,7 @@ predicate::remap_after_inlining (class ipa_fn_summary *info,
/* Fixed conditions remains same, construct single
condition predicate. */
else
- cond_predicate = predicate::predicate_testing_cond (cond);
+ cond_predicate = ipa_predicate::predicate_testing_cond (cond);
clause_predicate = clause_predicate.or_with (info->conds,
cond_predicate);
}
@@ -590,7 +589,7 @@ predicate::remap_after_inlining (class ipa_fn_summary *info,
/* Read predicate from IB. */
void
-predicate::stream_in (class lto_input_block *ib)
+ipa_predicate::stream_in (class lto_input_block *ib)
{
clause_t clause;
int k = 0;
@@ -611,7 +610,7 @@ predicate::stream_in (class lto_input_block *ib)
/* Write predicate P to OB. */
void
-predicate::stream_out (struct output_block *ob)
+ipa_predicate::stream_out (struct output_block *ob)
{
int j;
for (j = 0; m_clause[j]; j++)
@@ -629,7 +628,7 @@ predicate::stream_out (struct output_block *ob)
aggregate it is. It can be NULL, which means this not a load from an
aggregate. */
-predicate
+ipa_predicate
add_condition (class ipa_fn_summary *summary,
class ipa_node_params *params_summary,
int operand_num,
@@ -669,10 +668,10 @@ add_condition (class ipa_fn_summary *summary,
&& c->agg_contents == agg_contents
&& expr_eval_ops_equal_p (c->param_ops, param_ops)
&& (!agg_contents || (c->offset == offset && c->by_ref == by_ref)))
- return predicate::predicate_testing_cond (i);
+ return ipa_predicate::predicate_testing_cond (i);
}
/* Too many conditions. Give up and return constant true. */
- if (i == predicate::num_conditions - predicate::first_dynamic_condition)
+ if (i == ipa_predicate::num_conditions - ipa_predicate::first_dynamic_condition)
return true;
new_cond.operand_num = operand_num;
@@ -694,5 +693,5 @@ add_condition (class ipa_fn_summary *summary,
vec_safe_push (summary->conds, new_cond);
- return predicate::predicate_testing_cond (i);
+ return ipa_predicate::predicate_testing_cond (i);
}
diff --git a/gcc/ipa-predicate.h b/gcc/ipa-predicate.h
index ac52b54aa36..190dcedc93f 100644
--- a/gcc/ipa-predicate.h
+++ b/gcc/ipa-predicate.h
@@ -111,7 +111,7 @@ typedef vec<condition, va_gc> *conditions;
is not. */
typedef uint32_t clause_t;
-class predicate
+class ipa_predicate
{
public:
enum predicate_conditions
@@ -138,7 +138,7 @@ public:
/* Initialize predicate either to true of false depending on P. */
- inline predicate (bool p = true)
+ inline ipa_predicate (bool p = true)
{
if (p)
/* True predicate. */
@@ -149,42 +149,42 @@ public:
}
/* Sanity check that we do not mix pointers to predicates with predicates. */
- inline predicate (predicate *)
+ inline ipa_predicate (ipa_predicate *)
{
gcc_unreachable ();
}
/* Return predicate testing condition I. */
- static inline predicate predicate_testing_cond (int i)
+ static inline ipa_predicate predicate_testing_cond (int i)
{
- class predicate p;
+ ipa_predicate p;
p.set_to_cond (i + first_dynamic_condition);
return p;
}
/* Return predicate testing that function was not inlined. */
- static predicate not_inlined (void)
+ static ipa_predicate not_inlined (void)
{
- class predicate p;
+ ipa_predicate p;
p.set_to_cond (not_inlined_condition);
return p;
}
- /* Compute logical and of predicates. */
- predicate & operator &= (const predicate &);
- inline predicate operator &(const predicate &p) const
+ /* Compute logical and of ipa_predicates. */
+ ipa_predicate & operator &= (const ipa_predicate &);
+ inline ipa_predicate operator &(const ipa_predicate &p) const
{
- predicate ret = *this;
+ ipa_predicate ret = *this;
ret &= p;
return ret;
}
- /* Compute logical or of predicates. This is not operator because
+ /* Compute logical or of ipa_predicates. This is not operator because
extra parameter CONDITIONS is needed */
- predicate or_with (conditions, const predicate &) const;
+ ipa_predicate or_with (conditions, const ipa_predicate &) const;
- /* Return true if predicates are known to be equal. */
- inline bool operator==(const predicate &p2) const
+ /* Return true if ipa_predicates are known to be equal. */
+ inline bool operator==(const ipa_predicate &p2) const
{
int i;
for (i = 0; m_clause[i]; i++)
@@ -215,7 +215,7 @@ public:
return false;
}
- inline bool operator!=(const predicate &p2) const
+ inline bool operator!=(const ipa_predicate &p2) const
{
return !(*this == p2);
}
@@ -236,18 +236,19 @@ public:
void dump (FILE *f, conditions, bool nl=true) const;
void DEBUG_FUNCTION debug (conditions) const;
- /* Return predicate equal to THIS after duplication. */
- predicate remap_after_duplication (clause_t);
+ /* Return ipa_predicate equal to THIS after duplication. */
+ ipa_predicate remap_after_duplication (clause_t);
- /* Return predicate equal to THIS after inlining. */
- predicate remap_after_inlining (class ipa_fn_summary *,
- class ipa_node_params *params_summary,
- class ipa_fn_summary *,
- const vec<int> &, const vec<HOST_WIDE_INT> &,
- clause_t, const predicate &);
+ /* Return ipa_predicate equal to THIS after inlining. */
+ ipa_predicate remap_after_inlining (class ipa_fn_summary *,
+ ipa_node_params *params_summary,
+ ipa_fn_summary *,
+ const vec<int> &,
+ const vec<HOST_WIDE_INT> &,
+ clause_t, const ipa_predicate &);
- void stream_in (class lto_input_block *);
- void stream_out (struct output_block *);
+ void stream_in (lto_input_block *);
+ void stream_out (output_block *);
private:
static const int max_clauses = 8;
@@ -264,9 +265,9 @@ private:
};
void dump_condition (FILE *f, conditions conditions, int cond);
-predicate add_condition (class ipa_fn_summary *summary,
- class ipa_node_params *params_summary,
- int operand_num,
- tree type, struct agg_position_info *aggpos,
- enum tree_code code, tree val,
- expr_eval_ops param_ops = NULL);
+ipa_predicate add_condition (ipa_fn_summary *summary,
+ ipa_node_params *params_summary,
+ int operand_num,
+ tree type, struct agg_position_info *aggpos,
+ enum tree_code code, tree val,
+ expr_eval_ops param_ops = NULL);
--
2.33.1
More information about the Gcc-patches
mailing list