/* Inlining decision heuristics.
- Copyright (C) 2003, 2004, 2007, 2008, 2009, 2010, 2011
+ Copyright (C) 2003, 2004, 2007, 2008, 2009, 2010, 2011, 2012, 2013
Free Software Foundation, Inc.
Contributed by Jan Hubicka
struct cgraph_node *, void *);
static void inline_edge_removal_hook (struct cgraph_edge *, void *);
static void inline_edge_duplication_hook (struct cgraph_edge *,
- struct cgraph_edge *,
- void *);
+ struct cgraph_edge *, void *);
/* VECtor holding inline summaries.
In GGC memory because conditions might point to constant trees. */
/* Return predicate that is set true when function is not inlined. */
+
static inline struct predicate
not_inlined_predicate (void)
{
&& c->val == val
&& c->agg_contents == agg_contents
&& (!agg_contents || (c->offset == offset && c->by_ref == by_ref)))
- return single_cond_predicate (i + predicate_first_dynamic_condition);
+ return single_cond_predicate (i + predicate_first_dynamic_condition);
}
/* Too many conditions. Give up and return constant true. */
if (i == NUM_CONDITIONS - predicate_first_dynamic_condition)
insert_here = i2;
/* If clause implies p->clause[i], then p->clause[i] becomes redundant.
- Otherwise the p->clause[i] has to stay. */
+ Otherwise the p->clause[i] has to stay. */
if ((p->clause[i] & clause) != clause)
i2++;
}
continue;
cc1 = &(*conditions)[c1 - 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)
+ and thus there is no point for looking for them. */
+ if (cc1->code == CHANGED || cc1->code == IS_NOT_CONSTANT)
continue;
for (c2 = c1 + 1; c2 <= NUM_CONDITIONS; c2++)
if (clause & (1 << c2))
{
- condition *cc1 = &(*conditions)[c1 - predicate_first_dynamic_condition];
- condition *cc2 = &(*conditions)[c2 - predicate_first_dynamic_condition];
+ condition *cc1 =
+ &(*conditions)[c1 - predicate_first_dynamic_condition];
+ condition *cc2 =
+ &(*conditions)[c2 - predicate_first_dynamic_condition];
if (cc1->operand_num == cc2->operand_num
&& cc1->val == cc2->val
&& cc2->code != IS_NOT_CONSTANT
&& cc2->code != CHANGED
- && cc1->code == invert_tree_comparison
- (cc2->code,
- HONOR_NANS (TYPE_MODE (TREE_TYPE (cc1->val)))))
+ && cc1->code == invert_tree_comparison
+ (cc2->code,
+ HONOR_NANS (TYPE_MODE (TREE_TYPE (cc1->val)))))
return;
}
}
-
+
/* We run out of variants. Be conservative in positive direction. */
if (i2 == MAX_CLAUSES)
/* Keep clauses in decreasing order. This makes equivalence testing easy. */
p->clause[i2 + 1] = 0;
if (insert_here >= 0)
- for (;i2 > insert_here; i2--)
+ for (; i2 > insert_here; i2--)
p->clause[i2] = p->clause[i2 - 1];
else
insert_here = i2;
{
gcc_checking_assert (i < MAX_CLAUSES);
}
-
+
/* Combine the predicates rest. */
for (; p2->clause[i]; i++)
{
for (i = 0; p->clause[i]; i++)
{
gcc_checking_assert (i < MAX_CLAUSES);
- gcc_checking_assert (p->clause [i] > p->clause[i + 1]);
+ gcc_checking_assert (p->clause[i] > p->clause[i + 1]);
gcc_checking_assert (!p2->clause[i]
- || p2->clause [i] > p2->clause[i + 1]);
+ || p2->clause[i] > p2->clause[i + 1]);
if (p->clause[i] != p2->clause[i])
- return false;
+ return false;
}
return !p2->clause[i];
}
/* Return P | P2. */
static struct predicate
-or_predicates (conditions conditions, struct predicate *p, struct predicate *p2)
+or_predicates (conditions conditions,
+ struct predicate *p, struct predicate *p2)
{
struct predicate out = true_predicate ();
- int i,j;
+ int i, j;
/* Avoid busy work. */
if (false_predicate_p (p2) || true_predicate_p (p))
for (i = 0; p->clause[i]; i++)
for (j = 0; p2->clause[j]; j++)
{
- gcc_checking_assert (i < MAX_CLAUSES && j < MAX_CLAUSES);
- add_clause (conditions, &out, p->clause[i] | p2->clause[j]);
+ gcc_checking_assert (i < MAX_CLAUSES && j < MAX_CLAUSES);
+ add_clause (conditions, &out, p->clause[i] | p2->clause[j]);
}
return out;
}
{
gcc_checking_assert (i < MAX_CLAUSES);
if (!(p->clause[i] & possible_truths))
- return false;
+ return false;
}
return true;
}
{
if (i2 >= predicate_first_dynamic_condition)
{
- condition *c = &(*conds)[i2 - predicate_first_dynamic_condition];
+ condition *c =
+ &(*conds)[i2 - predicate_first_dynamic_condition];
if (c->code == CHANGED
- && (c->operand_num
- < (int) inline_param_summary.length ()))
+ && (c->operand_num <
+ (int) inline_param_summary.length ()))
{
- int iprob = inline_param_summary[c->operand_num].change_prob;
+ int iprob =
+ inline_param_summary[c->operand_num].change_prob;
this_prob = MAX (this_prob, iprob);
}
else
this_prob = REG_BR_PROB_BASE;
- }
- else
- this_prob = REG_BR_PROB_BASE;
+ }
+ else
+ this_prob = REG_BR_PROB_BASE;
}
combined_prob = MIN (this_prob, combined_prob);
if (!combined_prob)
- return 0;
+ return 0;
}
}
return combined_prob;
if (found)
fprintf (f, " || ");
found = true;
- dump_condition (f, conds, i);
+ dump_condition (f, conds, i);
}
fprintf (f, ")");
}
{
if (i)
fprintf (f, " && ");
- dump_clause (f, conds, pred->clause[i]);
+ dump_clause (f, conds, pred->clause[i]);
}
fprintf (f, "\n");
}
if (predicates_equal_p (&e->predicate, pred))
{
found = true;
- break;
+ break;
}
if (i == 256)
{
e = &(*summary->entry)[0];
gcc_assert (!e->predicate.clause[0]);
if (dump_file && (dump_flags & TDF_DETAILS))
- fprintf (dump_file, "\t\tReached limit on number of entries, ignoring the predicate.");
+ fprintf (dump_file,
+ "\t\tReached limit on number of entries, "
+ "ignoring the predicate.");
}
if (dump_file && (dump_flags & TDF_DETAILS) && (time || size))
{
- fprintf (dump_file, "\t\tAccounting size:%3.2f, time:%3.2f on %spredicate:",
- ((double)size) / INLINE_SIZE_SCALE,
- ((double)time) / INLINE_TIME_SCALE,
- found ? "" : "new ");
+ fprintf (dump_file,
+ "\t\tAccounting size:%3.2f, time:%3.2f on %spredicate:",
+ ((double) size) / INLINE_SIZE_SCALE,
+ ((double) time) / INLINE_TIME_SCALE, found ? "" : "new ");
dump_predicate (dump_file, summary->conds, pred);
}
if (!found)
if (predicate && !true_predicate_p (predicate))
{
if (!es->predicate)
- es->predicate = (struct predicate *)pool_alloc (edge_predicate_pool);
+ es->predicate = (struct predicate *) pool_alloc (edge_predicate_pool);
*es->predicate = *predicate;
}
else
{
if (es->predicate)
- pool_free (edge_predicate_pool, es->predicate);
+ pool_free (edge_predicate_pool, es->predicate);
es->predicate = NULL;
}
}
static void
set_hint_predicate (struct predicate **p, struct predicate new_predicate)
{
- if (false_predicate_p (&new_predicate)
- || true_predicate_p (&new_predicate))
+ if (false_predicate_p (&new_predicate) || true_predicate_p (&new_predicate))
{
if (*p)
pool_free (edge_predicate_pool, *p);
else
{
if (!*p)
- *p = (struct predicate *)pool_alloc (edge_predicate_pool);
+ *p = (struct predicate *) pool_alloc (edge_predicate_pool);
**p = new_predicate;
}
}
static clause_t
evaluate_conditions_for_known_args (struct cgraph_node *node,
- bool inline_p,
- vec<tree> known_vals,
- vec<ipa_agg_jump_function_p> known_aggs)
+ bool inline_p,
+ vec<tree> known_vals,
+ vec<ipa_agg_jump_function_p>
+ known_aggs)
{
clause_t clause = inline_p ? 0 : 1 << predicate_not_inlined_condition;
struct inline_summary *info = inline_summary (node);
tree res;
/* We allow call stmt to have fewer arguments than the callee function
- (especially for K&R style programs). So bound check here (we assume
- known_aggs vector, if non-NULL, has the same length as
- known_vals). */
+ (especially for K&R style programs). So bound check here (we assume
+ known_aggs vector, if non-NULL, has the same length as
+ known_vals). */
gcc_checking_assert (!known_aggs.exists ()
|| (known_vals.length () == known_aggs.length ()));
if (c->operand_num >= (int) known_vals.length ())
if (c->code == CHANGED
&& !c->by_ref
- && (known_vals[c->operand_num]
- == error_mark_node))
+ && (known_vals[c->operand_num] == error_mark_node))
continue;
if (known_aggs.exists ())
if (c->code == IS_NOT_CONSTANT || c->code == CHANGED)
continue;
res = fold_binary_to_constant (c->code, boolean_type_node, val, c->val);
- if (res
- && integer_zerop (res))
+ if (res && integer_zerop (res))
continue;
clause |= 1 << (i + predicate_first_dynamic_condition);
}
static void
evaluate_properties_for_edge (struct cgraph_edge *e, bool inline_p,
- clause_t *clause_ptr,
- vec<tree> *known_vals_ptr,
- vec<tree> *known_binfos_ptr,
- vec<ipa_agg_jump_function_p> *known_aggs_ptr)
+ clause_t *clause_ptr,
+ vec<tree> *known_vals_ptr,
+ vec<tree> *known_binfos_ptr,
+ vec<ipa_agg_jump_function_p> *known_aggs_ptr)
{
- struct cgraph_node *callee = cgraph_function_or_thunk_node (e->callee, NULL);
+ struct cgraph_node *callee =
+ cgraph_function_or_thunk_node (e->callee, NULL);
struct inline_summary *info = inline_summary (callee);
vec<tree> known_vals = vNULL;
vec<ipa_agg_jump_function_p> known_aggs = vNULL;
if (ipa_node_params_vector.exists ()
&& !e->call_stmt_cannot_inline_p
- && ((clause_ptr && info->conds)
- || known_vals_ptr || known_binfos_ptr))
+ && ((clause_ptr && info->conds) || known_vals_ptr || known_binfos_ptr))
{
struct ipa_node_params *parms_info;
struct ipa_edge_args *args = IPA_EDGE_REF (e);
int i, count = ipa_get_cs_argument_count (args);
if (e->caller->global.inlined_to)
- parms_info = IPA_NODE_REF (e->caller->global.inlined_to);
+ parms_info = IPA_NODE_REF (e->caller->global.inlined_to);
else
- parms_info = IPA_NODE_REF (e->caller);
+ parms_info = IPA_NODE_REF (e->caller);
if (count && (info->conds || known_vals_ptr))
known_vals.safe_grow_cleared (count);
{
if (known_vals.exists () && TREE_CODE (cst) != TREE_BINFO)
known_vals[i] = cst;
- else if (known_binfos_ptr != NULL && TREE_CODE (cst) == TREE_BINFO)
+ else if (known_binfos_ptr != NULL
+ && TREE_CODE (cst) == TREE_BINFO)
(*known_binfos_ptr)[i] = cst;
}
else if (inline_p && !es->param[i].change_prob)
inline_edge_summary_vec.safe_grow_cleared (cgraph_edge_max_uid + 1);
if (!edge_predicate_pool)
edge_predicate_pool = create_alloc_pool ("edge predicates",
- sizeof (struct predicate),
- 10);
+ sizeof (struct predicate), 10);
}
/* We are called multiple time for given function; clear
static void
reset_inline_edge_summary (struct cgraph_edge *e)
{
- if (e->uid < (int)inline_edge_summary_vec.length ())
+ if (e->uid < (int) inline_edge_summary_vec.length ())
{
struct inline_edge_summary *es = inline_edge_summary (e);
/* Hook that is called by cgraph.c when a node is removed. */
static void
-inline_node_removal_hook (struct cgraph_node *node, void *data ATTRIBUTE_UNUSED)
+inline_node_removal_hook (struct cgraph_node *node,
+ void *data ATTRIBUTE_UNUSED)
{
struct inline_summary *info;
- if (vec_safe_length (inline_summary_vec) <= (unsigned)node->uid)
+ if (vec_safe_length (inline_summary_vec) <= (unsigned) node->uid)
return;
info = inline_summary (node);
reset_inline_summary (node);
return;
new_predicate = remap_predicate_after_duplication (*p,
- possible_truths,
- info);
+ possible_truths, info);
/* We do not want to free previous predicate; it is used by node origin. */
*p = NULL;
set_hint_predicate (p, new_predicate);
/* Hook that is called by cgraph.c when a node is duplicated. */
static void
-inline_node_duplication_hook (struct cgraph_node *src, struct cgraph_node *dst,
+inline_node_duplication_hook (struct cgraph_node *src,
+ struct cgraph_node *dst,
ATTRIBUTE_UNUSED void *data)
{
struct inline_summary *info;
inline_summary_alloc ();
info = inline_summary (dst);
- memcpy (info, inline_summary (src),
- sizeof (struct inline_summary));
+ memcpy (info, inline_summary (src), sizeof (struct inline_summary));
/* TODO: as an optimization, we may avoid copying conditions
that are known to be false or true. */
info->conds = vec_safe_copy (info->conds);
/* When there are any replacements in the function body, see if we can figure
out that something was optimized out. */
- if (ipa_node_params_vector.exists ()
- && dst->clone.tree_map)
+ if (ipa_node_params_vector.exists () && dst->clone.tree_map)
{
vec<size_time_entry, va_gc> *entry = info->entry;
/* Use SRC parm info since it may not be copied yet. */
struct ipa_node_params *parms_info = IPA_NODE_REF (src);
vec<tree> known_vals = vNULL;
int count = ipa_get_param_count (parms_info);
- int i,j;
+ int i, j;
clause_t possible_truths;
struct predicate true_pred = true_predicate ();
size_time_entry *e;
info->entry = 0;
known_vals.safe_grow_cleared (count);
for (i = 0; i < count; i++)
- {
+ {
tree t = ipa_get_param (parms_info, i);
struct ipa_replace_map *r;
for (j = 0; vec_safe_iterate (dst->clone.tree_map, j, &r); j++)
{
- if (r->old_tree == t
- && r->replace_p
- && !r->ref_p)
+ if (r->old_tree == t && r->replace_p && !r->ref_p)
{
known_vals[i] = r->new_tree;
break;
}
}
possible_truths = evaluate_conditions_for_known_args (dst, false,
- known_vals, vNULL);
+ known_vals,
+ vNULL);
known_vals.release ();
account_size_time (info, 0, 0, &true_pred);
/* Remap size_time vectors.
- Simplify the predicate by prunning out alternatives that are known
- to be false.
- TODO: as on optimization, we can also eliminate conditions known
- to be true. */
+ Simplify the predicate by prunning out alternatives that are known
+ to be false.
+ TODO: as on optimization, we can also eliminate conditions known
+ to be true. */
for (i = 0; vec_safe_iterate (entry, i, &e); i++)
{
struct predicate new_predicate;
}
/* Remap edge predicates with the same simplification as above.
- Also copy constantness arrays. */
+ Also copy constantness arrays. */
for (edge = dst->callees; edge; edge = edge->next_callee)
{
struct predicate new_predicate;
}
/* Remap indirect edge predicates with the same simplificaiton as above.
- Also copy constantness arrays. */
+ Also copy constantness arrays. */
for (edge = dst->indirect_calls; edge; edge = edge->next_callee)
{
struct predicate new_predicate;
edge_set_predicate (edge, &new_predicate);
}
remap_hint_predicate_after_duplication (&info->loop_iterations,
- possible_truths,
- info);
+ possible_truths, info);
remap_hint_predicate_after_duplication (&info->loop_stride,
- possible_truths,
- info);
+ possible_truths, info);
remap_hint_predicate_after_duplication (&info->array_index,
- possible_truths,
- info);
+ possible_truths, info);
/* If inliner or someone after inliner will ever start producing
- non-trivial clones, we will get trouble with lack of information
- about updating self sizes, because size vectors already contains
- sizes of the calees. */
- gcc_assert (!inlined_to_p
- || !optimized_out_size);
+ non-trivial clones, we will get trouble with lack of information
+ about updating self sizes, because size vectors already contains
+ sizes of the calees. */
+ gcc_assert (!inlined_to_p || !optimized_out_size);
}
else
{
/* Hook that is called by cgraph.c when a node is duplicated. */
static void
-inline_edge_duplication_hook (struct cgraph_edge *src, struct cgraph_edge *dst,
+inline_edge_duplication_hook (struct cgraph_edge *src,
+ struct cgraph_edge *dst,
ATTRIBUTE_UNUSED void *data)
{
struct inline_edge_summary *info;
inline_summary_alloc ();
info = inline_edge_summary (dst);
srcinfo = inline_edge_summary (src);
- memcpy (info, srcinfo,
- sizeof (struct inline_edge_summary));
+ memcpy (info, srcinfo, sizeof (struct inline_edge_summary));
info->predicate = NULL;
edge_set_predicate (dst, srcinfo->predicate);
info->param = srcinfo->param.copy ();
/* Keep edge cache consistent across edge removal. */
static void
-inline_edge_removal_hook (struct cgraph_edge *edge, void *data ATTRIBUTE_UNUSED)
+inline_edge_removal_hook (struct cgraph_edge *edge,
+ void *data ATTRIBUTE_UNUSED)
{
if (edge_growth_cache.exists ())
reset_edge_growth_cache (edge);
Indent by INDENT. */
static void
-dump_inline_edge_summary (FILE * f, int indent, struct cgraph_node *node,
+dump_inline_edge_summary (FILE *f, int indent, struct cgraph_node *node,
struct inline_summary *info)
{
struct cgraph_edge *edge;
for (edge = node->callees; edge; edge = edge->next_callee)
{
struct inline_edge_summary *es = inline_edge_summary (edge);
- struct cgraph_node *callee = cgraph_function_or_thunk_node (edge->callee, NULL);
+ struct cgraph_node *callee =
+ cgraph_function_or_thunk_node (edge->callee, NULL);
int i;
- fprintf (f, "%*s%s/%i %s\n%*s loop depth:%2i freq:%4i size:%2i time: %2i callee size:%2i stack:%2i",
- indent, "", cgraph_node_name (callee),
- callee->uid,
- !edge->inline_failed ? "inlined"
- : cgraph_inline_failed_string (edge->inline_failed),
- indent, "",
- es->loop_depth,
- edge->frequency,
- es->call_stmt_size,
- es->call_stmt_time,
- (int)inline_summary (callee)->size / INLINE_SIZE_SCALE,
- (int)inline_summary (callee)->estimated_stack_size);
+ fprintf (f,
+ "%*s%s/%i %s\n%*s loop depth:%2i freq:%4i size:%2i"
+ " time: %2i callee size:%2i stack:%2i",
+ indent, "", cgraph_node_name (callee), callee->uid,
+ !edge->inline_failed
+ ? "inlined" : cgraph_inline_failed_string (edge-> inline_failed),
+ indent, "", es->loop_depth, edge->frequency,
+ es->call_stmt_size, es->call_stmt_time,
+ (int) inline_summary (callee)->size / INLINE_SIZE_SCALE,
+ (int) inline_summary (callee)->estimated_stack_size);
if (es->predicate)
{
dump_predicate (f, info->conds, es->predicate);
}
else
- fprintf (f, "\n");
+ fprintf (f, "\n");
if (es->param.exists ())
- for (i = 0; i < (int)es->param.length (); i++)
+ for (i = 0; i < (int) es->param.length (); i++)
{
int prob = es->param[i].change_prob;
}
if (!edge->inline_failed)
{
- fprintf (f, "%*sStack frame offset %i, callee self size %i,"
+ fprintf (f, "%*sStack frame offset %i, callee self size %i,"
" callee size %i\n",
- indent+2, "",
- (int)inline_summary (callee)->stack_frame_offset,
- (int)inline_summary (callee)->estimated_self_stack_size,
- (int)inline_summary (callee)->estimated_stack_size);
- dump_inline_edge_summary (f, indent+2, callee, info);
+ indent + 2, "",
+ (int) inline_summary (callee)->stack_frame_offset,
+ (int) inline_summary (callee)->estimated_self_stack_size,
+ (int) inline_summary (callee)->estimated_stack_size);
+ dump_inline_edge_summary (f, indent + 2, callee, info);
}
}
for (edge = node->indirect_calls; edge; edge = edge->next_callee)
fprintf (f, "%*sindirect call loop depth:%2i freq:%4i size:%2i"
" time: %2i",
indent, "",
- es->loop_depth,
- edge->frequency,
- es->call_stmt_size,
- es->call_stmt_time);
+ es->loop_depth,
+ edge->frequency, es->call_stmt_size, es->call_stmt_time);
if (es->predicate)
{
fprintf (f, "predicate: ");
void
-dump_inline_summary (FILE * f, struct cgraph_node *node)
+dump_inline_summary (FILE *f, struct cgraph_node *node)
{
if (node->analyzed)
{
fprintf (f, " always_inline");
if (s->inlinable)
fprintf (f, " inlinable");
- fprintf (f, "\n self time: %i\n",
- s->self_time);
+ fprintf (f, "\n self time: %i\n", s->self_time);
fprintf (f, " global time: %i\n", s->time);
- fprintf (f, " self size: %i\n",
- s->self_size);
+ fprintf (f, " self size: %i\n", s->self_size);
fprintf (f, " global size: %i\n", s->size);
fprintf (f, " self stack: %i\n",
(int) s->estimated_self_stack_size);
- fprintf (f, " global stack: %i\n",
- (int) s->estimated_stack_size);
+ fprintf (f, " global stack: %i\n", (int) s->estimated_stack_size);
if (s->growth)
- fprintf (f, " estimated growth:%i\n",
- (int) s->growth);
+ fprintf (f, " estimated growth:%i\n", (int) s->growth);
if (s->scc_no)
- fprintf (f, " In SCC: %i\n",
- (int) s->scc_no);
+ fprintf (f, " In SCC: %i\n", (int) s->scc_no);
for (i = 0; vec_safe_iterate (s->entry, i, &e); i++)
{
fprintf (f, " size:%f, time:%f, predicate:",
static bool
mark_modified (ao_ref *ao ATTRIBUTE_UNUSED, tree vdef ATTRIBUTE_UNUSED,
- void *data)
+ void *data)
{
bool *b = (bool *) data;
*b = true;
switch (code)
{
- case GIMPLE_RETURN:
- return 2;
- case GIMPLE_ASSIGN:
- if (gimple_num_ops (stmt) != 2)
- return 0;
-
- rhs_code = gimple_assign_rhs_code (stmt);
-
- /* Casts of parameters, loads from parameters passed by reference
- and stores to return value or parameters are often free after
- inlining dua to SRA and further combining.
- Assume that half of statements goes away. */
- if (rhs_code == CONVERT_EXPR
- || rhs_code == NOP_EXPR
- || rhs_code == VIEW_CONVERT_EXPR
- || rhs_code == ADDR_EXPR
- || gimple_assign_rhs_class (stmt) == GIMPLE_SINGLE_RHS)
- {
- tree rhs = gimple_assign_rhs1 (stmt);
- tree lhs = gimple_assign_lhs (stmt);
- tree inner_rhs = get_base_address (rhs);
- tree inner_lhs = get_base_address (lhs);
- bool rhs_free = false;
- bool lhs_free = false;
-
- if (!inner_rhs)
- inner_rhs = rhs;
- if (!inner_lhs)
- inner_lhs = lhs;
-
- /* Reads of parameter are expected to be free. */
- if (unmodified_parm (stmt, inner_rhs))
- rhs_free = true;
- /* Match expressions of form &this->field. Those will most likely
- combine with something upstream after inlining. */
- else if (TREE_CODE (inner_rhs) == ADDR_EXPR)
- {
- tree op = get_base_address (TREE_OPERAND (inner_rhs, 0));
- if (TREE_CODE (op) == PARM_DECL)
- rhs_free = true;
- else if (TREE_CODE (op) == MEM_REF
- && unmodified_parm (stmt, TREE_OPERAND (op, 0)))
- rhs_free = true;
- }
-
- /* When parameter is not SSA register because its address is taken
- and it is just copied into one, the statement will be completely
- free after inlining (we will copy propagate backward). */
- if (rhs_free && is_gimple_reg (lhs))
- return 2;
-
- /* Reads of parameters passed by reference
- expected to be free (i.e. optimized out after inlining). */
- if (TREE_CODE(inner_rhs) == MEM_REF
- && unmodified_parm (stmt, TREE_OPERAND (inner_rhs, 0)))
- rhs_free = true;
-
- /* Copying parameter passed by reference into gimple register is
- probably also going to copy propagate, but we can't be quite
- sure. */
- if (rhs_free && is_gimple_reg (lhs))
- lhs_free = true;
-
- /* Writes to parameters, parameters passed by value and return value
- (either dirrectly or passed via invisible reference) are free.
-
- TODO: We ought to handle testcase like
- struct a {int a,b;};
- struct a
- retrurnsturct (void)
- {
- struct a a ={1,2};
- return a;
- }
-
- This translate into:
-
- retrurnsturct ()
- {
- int a$b;
- int a$a;
- struct a a;
- struct a D.2739;
-
- <bb 2>:
- D.2739.a = 1;
- D.2739.b = 2;
- return D.2739;
-
- }
- For that we either need to copy ipa-split logic detecting writes
- to return value. */
- if (TREE_CODE (inner_lhs) == PARM_DECL
- || TREE_CODE (inner_lhs) == RESULT_DECL
- || (TREE_CODE(inner_lhs) == MEM_REF
- && (unmodified_parm (stmt, TREE_OPERAND (inner_lhs, 0))
- || (TREE_CODE (TREE_OPERAND (inner_lhs, 0)) == SSA_NAME
- && SSA_NAME_VAR (TREE_OPERAND (inner_lhs, 0))
- && TREE_CODE (SSA_NAME_VAR (TREE_OPERAND
- (inner_lhs, 0))) == RESULT_DECL))))
- lhs_free = true;
- if (lhs_free
- && (is_gimple_reg (rhs) || is_gimple_min_invariant (rhs)))
- rhs_free = true;
- if (lhs_free && rhs_free)
- return 1;
- }
- return 0;
- default:
+ case GIMPLE_RETURN:
+ return 2;
+ case GIMPLE_ASSIGN:
+ if (gimple_num_ops (stmt) != 2)
return 0;
+
+ rhs_code = gimple_assign_rhs_code (stmt);
+
+ /* Casts of parameters, loads from parameters passed by reference
+ and stores to return value or parameters are often free after
+ inlining dua to SRA and further combining.
+ Assume that half of statements goes away. */
+ if (rhs_code == CONVERT_EXPR
+ || rhs_code == NOP_EXPR
+ || rhs_code == VIEW_CONVERT_EXPR
+ || rhs_code == ADDR_EXPR
+ || gimple_assign_rhs_class (stmt) == GIMPLE_SINGLE_RHS)
+ {
+ tree rhs = gimple_assign_rhs1 (stmt);
+ tree lhs = gimple_assign_lhs (stmt);
+ tree inner_rhs = get_base_address (rhs);
+ tree inner_lhs = get_base_address (lhs);
+ bool rhs_free = false;
+ bool lhs_free = false;
+
+ if (!inner_rhs)
+ inner_rhs = rhs;
+ if (!inner_lhs)
+ inner_lhs = lhs;
+
+ /* Reads of parameter are expected to be free. */
+ if (unmodified_parm (stmt, inner_rhs))
+ rhs_free = true;
+ /* Match expressions of form &this->field. Those will most likely
+ combine with something upstream after inlining. */
+ else if (TREE_CODE (inner_rhs) == ADDR_EXPR)
+ {
+ tree op = get_base_address (TREE_OPERAND (inner_rhs, 0));
+ if (TREE_CODE (op) == PARM_DECL)
+ rhs_free = true;
+ else if (TREE_CODE (op) == MEM_REF
+ && unmodified_parm (stmt, TREE_OPERAND (op, 0)))
+ rhs_free = true;
+ }
+
+ /* When parameter is not SSA register because its address is taken
+ and it is just copied into one, the statement will be completely
+ free after inlining (we will copy propagate backward). */
+ if (rhs_free && is_gimple_reg (lhs))
+ return 2;
+
+ /* Reads of parameters passed by reference
+ expected to be free (i.e. optimized out after inlining). */
+ if (TREE_CODE (inner_rhs) == MEM_REF
+ && unmodified_parm (stmt, TREE_OPERAND (inner_rhs, 0)))
+ rhs_free = true;
+
+ /* Copying parameter passed by reference into gimple register is
+ probably also going to copy propagate, but we can't be quite
+ sure. */
+ if (rhs_free && is_gimple_reg (lhs))
+ lhs_free = true;
+
+ /* Writes to parameters, parameters passed by value and return value
+ (either dirrectly or passed via invisible reference) are free.
+
+ TODO: We ought to handle testcase like
+ struct a {int a,b;};
+ struct a
+ retrurnsturct (void)
+ {
+ struct a a ={1,2};
+ return a;
+ }
+
+ This translate into:
+
+ retrurnsturct ()
+ {
+ int a$b;
+ int a$a;
+ struct a a;
+ struct a D.2739;
+
+ <bb 2>:
+ D.2739.a = 1;
+ D.2739.b = 2;
+ return D.2739;
+
+ }
+ For that we either need to copy ipa-split logic detecting writes
+ to return value. */
+ if (TREE_CODE (inner_lhs) == PARM_DECL
+ || TREE_CODE (inner_lhs) == RESULT_DECL
+ || (TREE_CODE (inner_lhs) == MEM_REF
+ && (unmodified_parm (stmt, TREE_OPERAND (inner_lhs, 0))
+ || (TREE_CODE (TREE_OPERAND (inner_lhs, 0)) == SSA_NAME
+ && SSA_NAME_VAR (TREE_OPERAND (inner_lhs, 0))
+ && TREE_CODE (SSA_NAME_VAR (TREE_OPERAND
+ (inner_lhs,
+ 0))) == RESULT_DECL))))
+ lhs_free = true;
+ if (lhs_free
+ && (is_gimple_reg (rhs) || is_gimple_min_invariant (rhs)))
+ rhs_free = true;
+ if (lhs_free && rhs_free)
+ return 1;
+ }
+ return 0;
+ default:
+ return 0;
}
}
static void
set_cond_stmt_execution_predicate (struct ipa_node_params *info,
- struct inline_summary *summary,
- basic_block bb)
+ struct inline_summary *summary,
+ basic_block bb)
{
gimple last;
tree op;
tree op2;
last = last_stmt (bb);
- if (!last
- || gimple_code (last) != GIMPLE_COND)
+ if (!last || gimple_code (last) != GIMPLE_COND)
return;
if (!is_gimple_ip_invariant (gimple_cond_rhs (last)))
return;
{
code = gimple_cond_code (last);
inverted_code
- = invert_tree_comparison (code,
- HONOR_NANS (TYPE_MODE (TREE_TYPE (op))));
+ = invert_tree_comparison (code,
+ HONOR_NANS (TYPE_MODE (TREE_TYPE (op))));
FOR_EACH_EDGE (e, ei, bb->succs)
{
? code : inverted_code,
gimple_cond_rhs (last));
e->aux = pool_alloc (edge_predicate_pool);
- *(struct predicate *)e->aux = p;
+ *(struct predicate *) e->aux = p;
}
}
return;
/* Special case
if (builtin_constant_p (op))
- constant_code
+ constant_code
else
- nonconstant_code.
+ nonconstant_code.
Here we can predicate nonconstant_code. We can't
really handle constant_code since we have no predicate
for this and also the constant code is not known to be
|| gimple_call_num_args (set_stmt) != 1)
return;
op2 = gimple_call_arg (set_stmt, 0);
- if (!unmodified_parm_or_parm_agg_item (info, set_stmt, op2, &index, &aggpos))
+ if (!unmodified_parm_or_parm_agg_item
+ (info, set_stmt, op2, &index, &aggpos))
return;
- FOR_EACH_EDGE (e, ei, bb->succs)
- if (e->flags & EDGE_FALSE_VALUE)
- {
- struct predicate p = add_condition (summary, index, &aggpos,
- IS_NOT_CONSTANT, NULL_TREE);
- e->aux = pool_alloc (edge_predicate_pool);
- *(struct predicate *)e->aux = p;
- }
+ FOR_EACH_EDGE (e, ei, bb->succs) if (e->flags & EDGE_FALSE_VALUE)
+ {
+ struct predicate p = add_condition (summary, index, &aggpos,
+ IS_NOT_CONSTANT, NULL_TREE);
+ e->aux = pool_alloc (edge_predicate_pool);
+ *(struct predicate *) e->aux = p;
+ }
}
static void
set_switch_stmt_execution_predicate (struct ipa_node_params *info,
- struct inline_summary *summary,
- basic_block bb)
+ struct inline_summary *summary,
+ basic_block bb)
{
gimple last;
tree op;
size_t case_idx;
last = last_stmt (bb);
- if (!last
- || gimple_code (last) != GIMPLE_SWITCH)
+ if (!last || gimple_code (last) != GIMPLE_SWITCH)
return;
op = gimple_switch_index (last);
if (!unmodified_parm_or_parm_agg_item (info, last, op, &index, &aggpos))
FOR_EACH_EDGE (e, ei, bb->succs)
{
e->aux = pool_alloc (edge_predicate_pool);
- *(struct predicate *)e->aux = false_predicate ();
+ *(struct predicate *) e->aux = false_predicate ();
}
- n = gimple_switch_num_labels(last);
+ n = gimple_switch_num_labels (last);
for (case_idx = 0; case_idx < n; ++case_idx)
{
tree cl = gimple_switch_label (last, case_idx);
max = CASE_HIGH (cl);
/* For default we might want to construct predicate that none
- of cases is met, but it is bit hard to do not having negations
- of conditionals handy. */
+ of cases is met, but it is bit hard to do not having negations
+ of conditionals handy. */
if (!min && !max)
p = true_predicate ();
else if (!max)
p2 = add_condition (summary, index, &aggpos, LE_EXPR, max);
p = and_predicates (summary->conds, &p1, &p2);
}
- *(struct predicate *)e->aux
- = or_predicates (summary->conds, &p, (struct predicate *)e->aux);
+ *(struct predicate *) e->aux
+ = or_predicates (summary->conds, &p, (struct predicate *) e->aux);
}
}
/* Entry block is always executable. */
ENTRY_BLOCK_PTR_FOR_FUNCTION (my_function)->aux
= pool_alloc (edge_predicate_pool);
- *(struct predicate *)ENTRY_BLOCK_PTR_FOR_FUNCTION (my_function)->aux
+ *(struct predicate *) ENTRY_BLOCK_PTR_FOR_FUNCTION (my_function)->aux
= true_predicate ();
/* A simple dataflow propagation of predicates forward in the CFG.
done = true;
FOR_EACH_BB_FN (bb, my_function)
{
- struct predicate p = false_predicate ();
- edge e;
- edge_iterator ei;
+ struct predicate p = false_predicate ();
+ edge e;
+ edge_iterator ei;
FOR_EACH_EDGE (e, ei, bb->preds)
{
if (e->src->aux)
{
struct predicate this_bb_predicate
- = *(struct predicate *)e->src->aux;
+ = *(struct predicate *) e->src->aux;
if (e->aux)
this_bb_predicate
- = and_predicates (summary->conds, &this_bb_predicate,
- (struct predicate *)e->aux);
+ = and_predicates (summary->conds, &this_bb_predicate,
+ (struct predicate *) e->aux);
p = or_predicates (summary->conds, &p, &this_bb_predicate);
if (true_predicate_p (&p))
break;
{
done = false;
bb->aux = pool_alloc (edge_predicate_pool);
- *((struct predicate *)bb->aux) = p;
+ *((struct predicate *) bb->aux) = p;
}
- else if (!predicates_equal_p (&p, (struct predicate *)bb->aux))
+ else if (!predicates_equal_p (&p, (struct predicate *) bb->aux))
{
done = false;
- *((struct predicate *)bb->aux) = p;
+ *((struct predicate *) bb->aux) = p;
}
}
}
static struct predicate
will_be_nonconstant_expr_predicate (struct ipa_node_params *info,
- struct inline_summary *summary,
- tree expr,
- vec<predicate_t> nonconstant_names)
+ struct inline_summary *summary,
+ tree expr,
+ vec<predicate_t> nonconstant_names)
{
tree parm;
int index;
expr = TREE_OPERAND (expr, 0);
parm = unmodified_parm (NULL, expr);
- if (parm
- && (index = ipa_get_param_decl_index (info, parm)) >= 0)
+ if (parm && (index = ipa_get_param_decl_index (info, parm)) >= 0)
return add_condition (summary, index, NULL, CHANGED, NULL_TREE);
if (is_gimple_min_invariant (expr))
return false_predicate ();
if (TREE_CODE (expr) == SSA_NAME)
return nonconstant_names[SSA_NAME_VERSION (expr)];
- if (BINARY_CLASS_P (expr)
- || COMPARISON_CLASS_P (expr))
+ if (BINARY_CLASS_P (expr) || COMPARISON_CLASS_P (expr))
{
struct predicate p1 = will_be_nonconstant_expr_predicate
- (info, summary, TREE_OPERAND (expr, 0),
- nonconstant_names);
+ (info, summary, TREE_OPERAND (expr, 0),
+ nonconstant_names);
struct predicate p2;
if (true_predicate_p (&p1))
return p1;
else if (TREE_CODE (expr) == COND_EXPR)
{
struct predicate p1 = will_be_nonconstant_expr_predicate
- (info, summary, TREE_OPERAND (expr, 0),
- nonconstant_names);
+ (info, summary, TREE_OPERAND (expr, 0),
+ nonconstant_names);
struct predicate p2;
if (true_predicate_p (&p1))
return p1;
}
if (is_load)
- op_non_const = add_condition (summary, base_index, &aggpos, CHANGED, NULL);
+ op_non_const =
+ add_condition (summary, base_index, &aggpos, CHANGED, NULL);
else
op_non_const = false_predicate ();
FOR_EACH_SSA_TREE_OPERAND (use, stmt, iter, SSA_OP_USE)
tree parm = unmodified_parm (stmt, use);
int index;
- if (parm
- && (index = ipa_get_param_decl_index (info, parm)) >= 0)
+ if (parm && (index = ipa_get_param_decl_index (info, parm)) >= 0)
{
if (index != base_index)
p = add_condition (summary, index, NULL, CHANGED, NULL_TREE);
if (gimple_code (stmt) == GIMPLE_ASSIGN
&& TREE_CODE (gimple_assign_lhs (stmt)) == SSA_NAME)
nonconstant_names[SSA_NAME_VERSION (gimple_assign_lhs (stmt))]
- = op_non_const;
+ = op_non_const;
return op_non_const;
}
set except for info->stmt. */
static bool
-record_modified (ao_ref *ao ATTRIBUTE_UNUSED, tree vdef,
- void *data)
+record_modified (ao_ref *ao ATTRIBUTE_UNUSED, tree vdef, void *data)
{
- struct record_modified_bb_info *info = (struct record_modified_bb_info *) data;
+ struct record_modified_bb_info *info =
+ (struct record_modified_bb_info *) data;
if (SSA_NAME_DEF_STMT (vdef) == info->stmt)
return false;
bitmap_set_bit (info->bb_set,
SSA_NAME_IS_DEFAULT_DEF (vdef)
- ? ENTRY_BLOCK_PTR->index : gimple_bb (SSA_NAME_DEF_STMT (vdef))->index);
+ ? ENTRY_BLOCK_PTR->index
+ : gimple_bb (SSA_NAME_DEF_STMT (vdef))->index);
return false;
}
basic_block bb = gimple_bb (stmt);
tree base;
+ /* Global invariants neve change. */
if (is_gimple_min_invariant (op))
return 0;
/* We would have to do non-trivial analysis to really work out what
if (!init_freq)
init_freq = 1;
if (init_freq < bb->frequency)
- return MAX ((init_freq * REG_BR_PROB_BASE +
- bb->frequency / 2) / bb->frequency, 1);
+ return MAX ((init_freq * REG_BR_PROB_BASE +
+ bb->frequency / 2) / bb->frequency, 1);
else
- return REG_BR_PROB_BASE;
+ return REG_BR_PROB_BASE;
}
base = get_base_address (op);
NULL);
if (bitmap_bit_p (info.bb_set, bb->index))
{
- BITMAP_FREE (info.bb_set);
+ BITMAP_FREE (info.bb_set);
return REG_BR_PROB_BASE;
}
/* Assume that every memory is initialized at entry.
- TODO: Can we easilly determine if value is always defined
- and thus we may skip entry block? */
+ TODO: Can we easilly determine if value is always defined
+ and thus we may skip entry block? */
if (ENTRY_BLOCK_PTR->frequency)
max = ENTRY_BLOCK_PTR->frequency;
else
EXECUTE_IF_SET_IN_BITMAP (info.bb_set, 0, index, bi)
max = MIN (max, BASIC_BLOCK (index)->frequency);
-
+
BITMAP_FREE (info.bb_set);
if (max < bb->frequency)
- return MAX ((max * REG_BR_PROB_BASE +
+ return MAX ((max * REG_BR_PROB_BASE +
bb->frequency / 2) / bb->frequency, 1);
else
- return REG_BR_PROB_BASE;
+ return REG_BR_PROB_BASE;
}
return REG_BR_PROB_BASE;
}
static struct predicate
array_index_predicate (struct inline_summary *info,
- vec<predicate_t> nonconstant_names, tree op)
+ vec< predicate_t> nonconstant_names, tree op)
{
struct predicate p = false_predicate ();
while (handled_component_p (op))
{
- if (TREE_CODE (op) == ARRAY_REF
- || TREE_CODE (op) == ARRAY_RANGE_REF)
- {
+ if (TREE_CODE (op) == ARRAY_REF || TREE_CODE (op) == ARRAY_RANGE_REF)
+ {
if (TREE_CODE (TREE_OPERAND (op, 1)) == SSA_NAME)
- p = or_predicates (info->conds, &p,
- &nonconstant_names[
- SSA_NAME_VERSION (TREE_OPERAND (op, 1))]);
- }
+ p = or_predicates (info->conds, &p,
+ &nonconstant_names[SSA_NAME_VERSION
+ (TREE_OPERAND (op, 1))]);
+ }
op = TREE_OPERAND (op, 0);
}
return p;
if (ipa_node_params_vector.exists ())
{
parms_info = IPA_NODE_REF (node);
- nonconstant_names.safe_grow_cleared(SSANAMES (my_function)->length());
+ nonconstant_names.safe_grow_cleared
+ (SSANAMES (my_function)->length ());
}
}
if (parms_info)
{
if (bb->aux)
- bb_predicate = *(struct predicate *)bb->aux;
+ bb_predicate = *(struct predicate *) bb->aux;
else
bb_predicate = false_predicate ();
}
fprintf (dump_file, " ");
print_gimple_stmt (dump_file, stmt, 0, 0);
fprintf (dump_file, "\t\tfreq:%3.2f size:%3i time:%3i\n",
- ((double)freq)/CGRAPH_FREQ_BASE, this_size, this_time);
+ ((double) freq) / CGRAPH_FREQ_BASE, this_size,
+ this_time);
}
if (gimple_assign_load_p (stmt) && nonconstant_names.exists ())
{
struct predicate this_array_index;
- this_array_index = array_index_predicate (info, nonconstant_names,
- gimple_assign_rhs1 (stmt));
+ this_array_index =
+ array_index_predicate (info, nonconstant_names,
+ gimple_assign_rhs1 (stmt));
if (!false_predicate_p (&this_array_index))
- array_index = and_predicates (info->conds, &array_index, &this_array_index);
+ array_index =
+ and_predicates (info->conds, &array_index,
+ &this_array_index);
}
if (gimple_store_p (stmt) && nonconstant_names.exists ())
{
struct predicate this_array_index;
- this_array_index = array_index_predicate (info, nonconstant_names,
- gimple_get_lhs (stmt));
+ this_array_index =
+ array_index_predicate (info, nonconstant_names,
+ gimple_get_lhs (stmt));
if (!false_predicate_p (&this_array_index))
- array_index = and_predicates (info->conds, &array_index, &this_array_index);
+ array_index =
+ and_predicates (info->conds, &array_index,
+ &this_array_index);
}
-
+
if (is_gimple_call (stmt))
{
struct inline_edge_summary *es = inline_edge_summary (edge);
/* Special case: results of BUILT_IN_CONSTANT_P will be always
- resolved as constant. We however don't want to optimize
- out the cgraph edges. */
+ resolved as constant. We however don't want to optimize
+ out the cgraph edges. */
if (nonconstant_names.exists ()
&& gimple_call_builtin_p (stmt, BUILT_IN_CONSTANT_P)
&& gimple_call_lhs (stmt)
{
struct predicate false_p = false_predicate ();
nonconstant_names[SSA_NAME_VERSION (gimple_call_lhs (stmt))]
- = false_p;
+ = false_p;
}
if (ipa_node_params_vector.exists ())
{
- int count = gimple_call_num_args (stmt);
+ int count = gimple_call_num_args (stmt);
int i;
if (count)
}
/* TODO: When conditional jump or swithc is known to be constant, but
- we did not translate it into the predicates, we really can account
+ we did not translate it into the predicates, we really can account
just maximum of the possible paths. */
if (parms_info)
will_be_nonconstant
- = will_be_nonconstant_predicate (parms_info, info,
- stmt, nonconstant_names);
+ = will_be_nonconstant_predicate (parms_info, info,
+ stmt, nonconstant_names);
if (this_time || this_size)
{
struct predicate p;
prob = eliminated_by_inlining_prob (stmt);
if (prob == 1 && dump_file && (dump_flags & TDF_DETAILS))
- fprintf (dump_file, "\t\t50%% will be eliminated by inlining\n");
+ fprintf (dump_file,
+ "\t\t50%% will be eliminated by inlining\n");
if (prob == 2 && dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, "\t\tWill be eliminated by inlining\n");
}
/* We account everything but the calls. Calls have their own
- size/time info attached to cgraph edges. This is necessary
- in order to make the cost disappear after inlining. */
+ size/time info attached to cgraph edges. This is necessary
+ in order to make the cost disappear after inlining. */
if (!is_gimple_call (stmt))
{
if (prob)
scev_initialize ();
FOR_EACH_LOOP (li, loop, 0)
{
- vec<edge> exits;
- edge ex;
+ vec<edge> exits;
+ edge ex;
unsigned int j, i;
struct tree_niter_desc niter_desc;
basic_block *body = get_loop_body (loop);
- bb_predicate = *(struct predicate *)loop->header->aux;
+ bb_predicate = *(struct predicate *) loop->header->aux;
exits = get_loop_exit_edges (loop);
- FOR_EACH_VEC_ELT (exits, j, ex)
+ 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
- = will_be_nonconstant_expr_predicate (parms_info, info,
- niter_desc.niter, nonconstant_names);
- if (!true_predicate_p (&will_be_nonconstant))
- will_be_nonconstant = and_predicates (info->conds,
- &bb_predicate,
- &will_be_nonconstant);
- if (!true_predicate_p (&will_be_nonconstant)
- && !false_predicate_p (&will_be_nonconstant))
- /* This is slightly inprecise. We may want to represent each loop with
- independent predicate. */
- loop_iterations = and_predicates (info->conds, &loop_iterations, &will_be_nonconstant);
- }
- exits.release ();
+ {
+ predicate will_be_nonconstant
+ = will_be_nonconstant_expr_predicate (parms_info, info,
+ niter_desc.niter,
+ nonconstant_names);
+ if (!true_predicate_p (&will_be_nonconstant))
+ will_be_nonconstant = and_predicates (info->conds,
+ &bb_predicate,
+ &will_be_nonconstant);
+ if (!true_predicate_p (&will_be_nonconstant)
+ && !false_predicate_p (&will_be_nonconstant))
+ /* This is slightly inprecise. We may want to represent each
+ loop with independent predicate. */
+ loop_iterations =
+ and_predicates (info->conds, &loop_iterations,
+ &will_be_nonconstant);
+ }
+ exits.release ();
- for (i = 0; i < loop->num_nodes; i++)
+ for (i = 0; i < loop->num_nodes; i++)
{
gimple_stmt_iterator gsi;
- bb_predicate = *(struct predicate *)body[i]->aux;
- for (gsi = gsi_start_bb (body[i]); !gsi_end_p (gsi); gsi_next (&gsi))
+ bb_predicate = *(struct predicate *) body[i]->aux;
+ for (gsi = gsi_start_bb (body[i]); !gsi_end_p (gsi);
+ gsi_next (&gsi))
{
gimple stmt = gsi_stmt (gsi);
affine_iv iv;
tree use;
FOR_EACH_SSA_TREE_OPERAND (use, stmt, iter, SSA_OP_USE)
- {
- predicate will_be_nonconstant;
-
- if (!simple_iv (loop, loop_containing_stmt (stmt), use, &iv, true)
- || is_gimple_min_invariant (iv.step))
- continue;
+ {
+ predicate will_be_nonconstant;
+
+ if (!simple_iv
+ (loop, loop_containing_stmt (stmt), use, &iv, true)
+ || is_gimple_min_invariant (iv.step))
+ continue;
+ will_be_nonconstant
+ = will_be_nonconstant_expr_predicate (parms_info, info,
+ iv.step,
+ nonconstant_names);
+ if (!true_predicate_p (&will_be_nonconstant))
will_be_nonconstant
- = will_be_nonconstant_expr_predicate (parms_info, info,
- iv.step, nonconstant_names);
- if (!true_predicate_p (&will_be_nonconstant))
- will_be_nonconstant = and_predicates (info->conds,
- &bb_predicate,
- &will_be_nonconstant);
- if (!true_predicate_p (&will_be_nonconstant)
- && !false_predicate_p (&will_be_nonconstant))
- /* This is slightly inprecise. We may want to represent each loop with
- independent predicate. */
- loop_stride = and_predicates (info->conds, &loop_stride, &will_be_nonconstant);
- }
+ = and_predicates (info->conds,
+ &bb_predicate,
+ &will_be_nonconstant);
+ if (!true_predicate_p (&will_be_nonconstant)
+ && !false_predicate_p (&will_be_nonconstant))
+ /* This is slightly inprecise. We may want to represent
+ each loop with independent predicate. */
+ loop_stride =
+ and_predicates (info->conds, &loop_stride,
+ &will_be_nonconstant);
+ }
}
}
free (body);
}
- set_hint_predicate (&inline_summary (node)->loop_iterations, loop_iterations);
+ set_hint_predicate (&inline_summary (node)->loop_iterations,
+ loop_iterations);
set_hint_predicate (&inline_summary (node)->loop_stride, loop_stride);
scev_finalize ();
}
info->estimated_stack_size = info->estimated_self_stack_size;
#ifdef ENABLE_CHECKING
inline_update_overall_summary (node);
- gcc_assert (info->time == info->self_time
- && info->size == info->self_size);
+ gcc_assert (info->time == info->self_time && info->size == info->self_size);
#endif
pop_cfun ();
return 0;
}
-struct gimple_opt_pass pass_inline_parameters =
+struct gimple_opt_pass pass_inline_parameters =
{
{
GIMPLE_PASS,
- "inline_param", /* name */
- OPTGROUP_INLINE, /* optinfo_flags */
- NULL, /* gate */
- compute_inline_parameters_for_current,/* execute */
- NULL, /* sub */
- NULL, /* next */
- 0, /* static_pass_number */
- TV_INLINE_PARAMETERS, /* tv_id */
- 0, /* properties_required */
- 0, /* properties_provided */
- 0, /* properties_destroyed */
- 0, /* todo_flags_start */
- 0 /* todo_flags_finish */
- }
+ "inline_param", /* name */
+ OPTGROUP_INLINE, /* optinfo_flags */
+ NULL, /* gate */
+ compute_inline_parameters_for_current, /* execute */
+ NULL, /* sub */
+ NULL, /* next */
+ 0, /* static_pass_number */
+ TV_INLINE_PARAMETERS, /* tv_id */
+ 0, /* properties_required */
+ 0, /* properties_provided */
+ 0, /* properties_destroyed */
+ 0, /* todo_flags_start */
+ 0 /* todo_flags_finish */
+ }
};
vec<tree> known_binfos,
vec<ipa_agg_jump_function_p> known_aggs,
inline_hints *hints)
-
{
struct inline_edge_summary *es = inline_edge_summary (e);
int call_size = es->call_stmt_size;
if (!e->callee
&& estimate_edge_devirt_benefit (e, &call_size, &call_time,
known_vals, known_binfos, known_aggs)
- && hints
- && cgraph_maybe_hot_edge_p (e))
+ && hints && cgraph_maybe_hot_edge_p (e))
*hints |= INLINE_HINT_indirect_call;
*size += call_size * INLINE_SIZE_SCALE;
*time += call_time * prob / REG_BR_PROB_BASE
- * e->frequency * (INLINE_TIME_SCALE / CGRAPH_FREQ_BASE);
+ * e->frequency * (INLINE_TIME_SCALE / CGRAPH_FREQ_BASE);
if (*time > MAX_TIME * INLINE_TIME_SCALE)
*time = MAX_TIME * INLINE_TIME_SCALE;
}
for (e = node->callees; e; e = e->next_callee)
{
struct inline_edge_summary *es = inline_edge_summary (e);
- if (!es->predicate || evaluate_predicate (es->predicate, possible_truths))
+ if (!es->predicate
+ || evaluate_predicate (es->predicate, possible_truths))
{
if (e->inline_failed)
{
/* Predicates of calls shall not use NOT_CHANGED codes,
- sowe do not need to compute probabilities. */
+ sowe do not need to compute probabilities. */
estimate_edge_size_and_time (e, size, time, REG_BR_PROB_BASE,
- known_vals, known_binfos, known_aggs,
- hints);
+ known_vals, known_binfos,
+ known_aggs, hints);
}
else
estimate_calls_size_and_time (e->callee, size, time, hints,
possible_truths,
- known_vals, known_binfos, known_aggs);
+ known_vals, known_binfos,
+ known_aggs);
}
}
for (e = node->indirect_calls; e; e = e->next_callee)
{
struct inline_edge_summary *es = inline_edge_summary (e);
- if (!es->predicate || evaluate_predicate (es->predicate, possible_truths))
+ if (!es->predicate
+ || evaluate_predicate (es->predicate, possible_truths))
estimate_edge_size_and_time (e, size, time, REG_BR_PROB_BASE,
known_vals, known_binfos, known_aggs,
hints);
vec<tree> known_vals,
vec<tree> known_binfos,
vec<ipa_agg_jump_function_p> known_aggs,
- int *ret_size, int *ret_time,
+ int *ret_size, int *ret_time,
inline_hints *ret_hints,
vec<inline_param_summary_t>
- inline_param_summary)
+ inline_param_summary)
{
struct inline_summary *info = inline_summary (node);
size_time_entry *e;
inline_hints hints = 0;
int i;
- if (dump_file
- && (dump_flags & TDF_DETAILS))
+ if (dump_file && (dump_flags & TDF_DETAILS))
{
bool found = false;
fprintf (dump_file, " Estimating body: %s/%i\n"
- " Known to be false: ",
- cgraph_node_name (node),
- node->uid);
+ " Known to be false: ", cgraph_node_name (node), node->uid);
for (i = predicate_not_inlined_condition;
i < (predicate_first_dynamic_condition
- + (int)vec_safe_length (info->conds)); i++)
+ + (int) vec_safe_length (info->conds)); i++)
if (!(possible_truths & (1 << i)))
{
if (found)
fprintf (dump_file, ", ");
found = true;
- dump_condition (dump_file, info->conds, i);
+ dump_condition (dump_file, info->conds, i);
}
}
{
size += e->size;
gcc_checking_assert (e->time >= 0);
- gcc_checking_assert (time >= 0);
+ gcc_checking_assert (time >= 0);
if (!inline_param_summary.exists ())
time += e->time;
else
inline_param_summary);
gcc_checking_assert (prob >= 0);
gcc_checking_assert (prob <= REG_BR_PROB_BASE);
- time += ((gcov_type)e->time * prob) / REG_BR_PROB_BASE;
+ time += ((gcov_type) e->time * prob) / REG_BR_PROB_BASE;
}
- if (time > MAX_TIME * INLINE_TIME_SCALE)
- time = MAX_TIME * INLINE_TIME_SCALE;
- gcc_checking_assert (time >= 0);
-
+ if (time > MAX_TIME * INLINE_TIME_SCALE)
+ time = MAX_TIME * INLINE_TIME_SCALE;
+ gcc_checking_assert (time >= 0);
+
}
gcc_checking_assert (size >= 0);
gcc_checking_assert (time >= 0);
if (info->loop_iterations
&& !evaluate_predicate (info->loop_iterations, possible_truths))
- hints |=INLINE_HINT_loop_iterations;
+ hints |= INLINE_HINT_loop_iterations;
if (info->loop_stride
&& !evaluate_predicate (info->loop_stride, possible_truths))
- hints |=INLINE_HINT_loop_stride;
+ hints |= INLINE_HINT_loop_stride;
if (info->array_index
&& !evaluate_predicate (info->array_index, possible_truths))
- hints |=INLINE_HINT_array_index;
+ hints |= INLINE_HINT_array_index;
if (info->scc_no)
hints |= INLINE_HINT_in_scc;
if (DECL_DECLARED_INLINE_P (node->symbol.decl))
time = RDIV (time, INLINE_TIME_SCALE);
size = RDIV (size, INLINE_SIZE_SCALE);
- if (dump_file
- && (dump_flags & TDF_DETAILS))
- fprintf (dump_file, "\n size:%i time:%i\n", (int)size, (int)time);
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ fprintf (dump_file, "\n size:%i time:%i\n", (int) size, (int) time);
if (ret_time)
*ret_time = time;
if (ret_size)
void
estimate_ipcp_clone_size_and_time (struct cgraph_node *node,
- vec<tree> known_vals,
- vec<tree> known_binfos,
- vec<ipa_agg_jump_function_p> known_aggs,
- int *ret_size, int *ret_time,
- inline_hints *hints)
+ vec<tree> known_vals,
+ vec<tree> known_binfos,
+ vec<ipa_agg_jump_function_p> known_aggs,
+ int *ret_size, int *ret_time,
+ inline_hints *hints)
{
clause_t clause;
struct predicate *p,
vec<int> operand_map,
vec<int> offset_map,
- clause_t possible_truths,
- struct predicate *toplev_predicate)
+ clause_t possible_truths, struct predicate *toplev_predicate)
{
int i;
struct predicate out = true_predicate ();
gcc_assert (i < MAX_CLAUSES);
- for (cond = 0; cond < NUM_CONDITIONS; cond ++)
+ for (cond = 0; cond < NUM_CONDITIONS; cond++)
/* Do we have condition we can't disprove? */
if (clause & possible_truths & (1 << cond))
{
inlined function. */
if (cond >= predicate_first_dynamic_condition)
{
- struct condition *c;
-
- c = &(*callee_info->conds)[cond
- - predicate_first_dynamic_condition];
- /* See if we can remap condition operand to caller's operand.
- Otherwise give up. */
- if (!operand_map.exists ()
- || (int)operand_map.length () <= c->operand_num
- || operand_map[c->operand_num] == -1
- /* TODO: For non-aggregate conditions, adding an offset is
- basically an arithmetic jump function processing which
- we should support in future. */
- || ((!c->agg_contents || !c->by_ref)
- && offset_map[c->operand_num] > 0)
- || (c->agg_contents && c->by_ref
- && offset_map[c->operand_num] < 0))
- cond_predicate = true_predicate ();
- else
- {
- struct agg_position_info ap;
- HOST_WIDE_INT offset_delta = offset_map[c->operand_num];
- if (offset_delta < 0)
- {
- gcc_checking_assert (!c->agg_contents || !c->by_ref);
- offset_delta = 0;
- }
- gcc_assert (!c->agg_contents
- || c->by_ref
- || offset_delta == 0);
- ap.offset = c->offset + offset_delta;
- ap.agg_contents = c->agg_contents;
- ap.by_ref = c->by_ref;
- cond_predicate = add_condition (info,
- operand_map[c->operand_num],
- &ap, c->code, c->val);
- }
+ struct condition *c;
+
+ c = &(*callee_info->conds)[cond
+ -
+ predicate_first_dynamic_condition];
+ /* See if we can remap condition operand to caller's operand.
+ Otherwise give up. */
+ if (!operand_map.exists ()
+ || (int) operand_map.length () <= c->operand_num
+ || operand_map[c->operand_num] == -1
+ /* TODO: For non-aggregate conditions, adding an offset is
+ basically an arithmetic jump function processing which
+ we should support in future. */
+ || ((!c->agg_contents || !c->by_ref)
+ && offset_map[c->operand_num] > 0)
+ || (c->agg_contents && c->by_ref
+ && offset_map[c->operand_num] < 0))
+ cond_predicate = true_predicate ();
+ else
+ {
+ struct agg_position_info ap;
+ HOST_WIDE_INT offset_delta = offset_map[c->operand_num];
+ if (offset_delta < 0)
+ {
+ gcc_checking_assert (!c->agg_contents || !c->by_ref);
+ offset_delta = 0;
+ }
+ gcc_assert (!c->agg_contents
+ || c->by_ref || offset_delta == 0);
+ ap.offset = c->offset + offset_delta;
+ ap.agg_contents = c->agg_contents;
+ ap.by_ref = c->by_ref;
+ cond_predicate = add_condition (info,
+ operand_map[c->operand_num],
+ &ap, c->code, c->val);
+ }
}
/* Fixed conditions remains same, construct single
condition predicate. */
Compute peak stack usage. */
static void
-inline_update_callee_summaries (struct cgraph_node *node,
- int depth)
+inline_update_callee_summaries (struct cgraph_node *node, int depth)
{
struct cgraph_edge *e;
struct inline_summary *callee_info = inline_summary (node);
callee_info->stack_frame_offset
= caller_info->stack_frame_offset
- + caller_info->estimated_self_stack_size;
+ + caller_info->estimated_self_stack_size;
peak = callee_info->stack_frame_offset
- + callee_info->estimated_self_stack_size;
- if (inline_summary (node->global.inlined_to)->estimated_stack_size
- < peak)
- inline_summary (node->global.inlined_to)->estimated_stack_size = peak;
+ + callee_info->estimated_self_stack_size;
+ if (inline_summary (node->global.inlined_to)->estimated_stack_size < peak)
+ inline_summary (node->global.inlined_to)->estimated_stack_size = peak;
cgraph_propagate_frequency (node);
for (e = node->callees; e; e = e->next_callee)
{
struct ipa_edge_args *args = IPA_EDGE_REF (edge);
struct inline_edge_summary *es = inline_edge_summary (edge);
struct inline_edge_summary *inlined_es
- = inline_edge_summary (inlined_edge);
+ = inline_edge_summary (inlined_edge);
for (i = 0; i < ipa_get_cs_argument_count (args); i++)
{
es->param[i].change_prob = prob;
}
}
- }
+ }
}
/* Update edge summaries of NODE after INLINED_EDGE has been inlined.
Also update change probabilities. */
static void
-remap_edge_summaries (struct cgraph_edge *inlined_edge,
- struct cgraph_node *node,
- struct inline_summary *info,
- struct inline_summary *callee_info,
- vec<int> operand_map,
- vec<int> offset_map,
- clause_t possible_truths,
- struct predicate *toplev_predicate)
+remap_edge_summaries (struct cgraph_edge *inlined_edge,
+ struct cgraph_node *node,
+ struct inline_summary *info,
+ struct inline_summary *callee_info,
+ vec<int> operand_map,
+ vec<int> offset_map,
+ clause_t possible_truths,
+ struct predicate *toplev_predicate)
{
struct cgraph_edge *e;
for (e = node->callees; e; e = e->next_callee)
{
p = remap_predicate (info, callee_info,
es->predicate, operand_map, offset_map,
- possible_truths,
- toplev_predicate);
+ possible_truths, toplev_predicate);
edge_set_predicate (e, &p);
/* TODO: We should remove the edge for code that will be
- optimized out, but we need to keep verifiers and tree-inline
- happy. Make it cold for now. */
+ optimized out, but we need to keep verifiers and tree-inline
+ happy. Make it cold for now. */
if (false_predicate_p (&p))
{
e->count = 0;
p = remap_predicate (info, callee_info,
*hint,
operand_map, offset_map,
- possible_truths,
- toplev_predicate);
- if (!false_predicate_p (&p)
- && !true_predicate_p (&p))
+ possible_truths, toplev_predicate);
+ if (!false_predicate_p (&p) && !true_predicate_p (&p))
{
if (!*hint)
set_hint_predicate (hint, p);
else
- **hint = and_predicates (info->conds,
- *hint,
- &p);
+ **hint = and_predicates (info->conds, *hint, &p);
}
}
&toplev_predicate);
if (!false_predicate_p (&p))
{
- gcov_type add_time = ((gcov_type)e->time * edge->frequency
+ gcov_type add_time = ((gcov_type) e->time * edge->frequency
+ CGRAPH_FREQ_BASE / 2) / CGRAPH_FREQ_BASE;
int prob = predicate_probability (callee_info->conds,
&e->predicate,
clause, es->param);
- add_time = ((gcov_type)add_time * prob) / REG_BR_PROB_BASE;
+ add_time = ((gcov_type) add_time * prob) / REG_BR_PROB_BASE;
if (add_time > MAX_TIME * INLINE_TIME_SCALE)
add_time = MAX_TIME * INLINE_TIME_SCALE;
if (prob != REG_BR_PROB_BASE
&& dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "\t\tScaling time by probability:%f\n",
- (double)prob / REG_BR_PROB_BASE);
+ (double) prob / REG_BR_PROB_BASE);
}
account_size_time (info, e->size, add_time, &p);
}
offset_map, clause, &toplev_predicate);
remap_hint_predicate (info, callee_info,
&callee_info->loop_iterations,
- operand_map, offset_map,
- clause, &toplev_predicate);
+ operand_map, offset_map, clause, &toplev_predicate);
remap_hint_predicate (info, callee_info,
&callee_info->loop_stride,
- operand_map, offset_map,
- clause, &toplev_predicate);
+ operand_map, offset_map, clause, &toplev_predicate);
remap_hint_predicate (info, callee_info,
&callee_info->array_index,
- operand_map, offset_map,
- clause, &toplev_predicate);
+ operand_map, offset_map, clause, &toplev_predicate);
inline_update_callee_summaries (edge->callee,
inline_edge_summary (edge)->loop_depth);
{
info->size += e->size, info->time += e->time;
if (info->time > MAX_TIME * INLINE_TIME_SCALE)
- info->time = MAX_TIME * INLINE_TIME_SCALE;
+ info->time = MAX_TIME * INLINE_TIME_SCALE;
}
estimate_calls_size_and_time (node, &info->size, &info->time, NULL,
- ~(clause_t)(1 << predicate_false_condition),
+ ~(clause_t) (1 << predicate_false_condition),
vNULL, vNULL, vNULL);
info->time = (info->time + INLINE_TIME_SCALE / 2) / INLINE_TIME_SCALE;
info->size = (info->size + INLINE_SIZE_SCALE / 2) / INLINE_SIZE_SCALE;
{
int hints = 0;
struct cgraph_node *to = (edge->caller->global.inlined_to
- ? edge->caller->global.inlined_to
- : edge->caller);
+ ? edge->caller->global.inlined_to : edge->caller);
if (inline_summary (to)->scc_no
&& inline_summary (to)->scc_no == inline_summary (edge->callee)->scc_no
&& !cgraph_edge_recursive_p (edge))
/* When caching, update the cache entry. */
if (edge_growth_cache.exists ())
{
- if ((int)edge_growth_cache.length () <= edge->uid)
+ if ((int) edge_growth_cache.length () <= edge->uid)
edge_growth_cache.safe_grow_cleared (cgraph_edge_max_uid);
edge_growth_cache[edge->uid].time = time + (time >= 0);
struct inline_edge_summary *es = inline_edge_summary (edge);
if (!es->predicate || !false_predicate_p (es->predicate))
{
- gcov_type time = inline_summary (node)->time + estimate_edge_time (edge);
+ gcov_type time =
+ inline_summary (node)->time + estimate_edge_time (edge);
if (time < 0)
time = 0;
if (time > MAX_TIME)
if (e->caller == node
|| (e->caller->global.inlined_to
&& e->caller->global.inlined_to == node))
- d->self_recursive = true;
+ d->self_recursive = true;
d->growth += estimate_edge_growth (e);
}
return false;
int
do_estimate_growth (struct cgraph_node *node)
{
- struct growth_data d = {0, false};
+ struct growth_data d = { 0, false };
struct inline_summary *info = inline_summary (node);
cgraph_for_node_and_aliases (node, do_estimate_growth_1, &d, true);
if (cgraph_will_be_removed_from_program_if_no_direct_calls (node))
d.growth -= info->size;
/* COMDAT functions are very often not shared across multiple units
- since they come from various template instantiations.
- Take this into account. */
- else if (DECL_COMDAT (node->symbol.decl)
- && cgraph_can_remove_if_no_direct_calls_p (node))
+ since they come from various template instantiations.
+ Take this into account. */
+ else if (DECL_COMDAT (node->symbol.decl)
+ && cgraph_can_remove_if_no_direct_calls_p (node))
d.growth -= (info->size
* (100 - PARAM_VALUE (PARAM_COMDAT_SHARING_PROBABILITY))
+ 50) / 100;
if (node_growth_cache.exists ())
{
- if ((int)node_growth_cache.length () <= node->uid)
+ if ((int) node_growth_cache.length () <= node->uid)
node_growth_cache.safe_grow_cleared (cgraph_max_uid);
node_growth_cache[node->uid] = d.growth + (d.growth >= 0);
}
struct cgraph_node *node;
function_insertion_hook_holder =
- cgraph_add_function_insertion_hook (&add_new_function, NULL);
+ cgraph_add_function_insertion_hook (&add_new_function, NULL);
ipa_register_cgraph_hooks ();
inline_free_summary ();
clause_t clause;
int k = 0;
- do
+ do
{
gcc_assert (k <= MAX_CLAUSES);
clause = out.clause[k++] = streamer_read_uhwi (ib);
{
es->param.safe_grow_cleared (length);
for (i = 0; i < length; i++)
- es->param[i].change_prob
- = streamer_read_uhwi (ib);
+ es->param[i].change_prob = streamer_read_uhwi (ib);
}
}
vec_safe_push (info->entry, e);
}
-
+
p = read_predicate (&ib);
set_hint_predicate (&info->loop_iterations, p);
p = read_predicate (&ib);
LTO_section_inline_summary,
NULL, &len);
if (data)
- inline_read_section (file_data, data, len);
+ inline_read_section (file_data, data, len);
else
/* Fatal error here. We do not want to support compiling ltrans units
with different version of compiler or different flags than the WPA
{
ipa_register_cgraph_hooks ();
if (!flag_ipa_cp)
- ipa_prop_read_jump_functions ();
+ ipa_prop_read_jump_functions ();
}
function_insertion_hook_holder =
- cgraph_add_function_insertion_hook (&add_new_function, NULL);
+ cgraph_add_function_insertion_hook (&add_new_function, NULL);
}
if (p)
for (j = 0; p->clause[j]; j++)
{
- gcc_assert (j < MAX_CLAUSES);
- streamer_write_uhwi (ob, p->clause[j]);
+ gcc_assert (j < MAX_CLAUSES);
+ streamer_write_uhwi (ob, p->clause[j]);
}
streamer_write_uhwi (ob, 0);
}
streamer_write_uhwi (ob, es->loop_depth);
write_predicate (ob, es->predicate);
streamer_write_uhwi (ob, es->param.length ());
- for (i = 0; i < (int)es->param.length (); i++)
+ for (i = 0; i < (int) es->param.length (); i++)
streamer_write_uhwi (ob, es->param[i].change_prob);
}
int i;
size_time_entry *e;
struct condition *c;
-
- streamer_write_uhwi (ob, lto_symtab_encoder_encode (encoder, (symtab_node)node));
+
+ streamer_write_uhwi (ob,
+ lto_symtab_encoder_encode (encoder,
+ (symtab_node)
+ node));
streamer_write_hwi (ob, info->estimated_self_stack_size);
streamer_write_hwi (ob, info->self_size);
streamer_write_hwi (ob, info->self_time);
bp_pack_value (&bp, c->by_ref, 1);
streamer_write_bitpack (&bp);
if (c->agg_contents)
- streamer_write_uhwi (ob, c->offset);
+ streamer_write_uhwi (ob, c->offset);
}
streamer_write_uhwi (ob, vec_safe_length (info->entry));
for (i = 0; vec_safe_iterate (info->entry, i, &e); i++)
projects / gcc.git / commitdiff