Skip to content

R
riscv-gcc-1
Commit 42d57399 by Jan Hubicka Committed by Jan Hubicka
Options

* ipa-inline-analysis.c: Fix formatting. 

From-SVN: r194769
parent 2a5195d9
Showing with 541 additions and 542 deletions
gcc/ChangeLog
2013-01-01 Jan Hubicka <jh@suse.cz>
* ipa-inline-analysis.c: Fix formatting.
2013-01-01 Jakub Jelinek <jakub@redhat.com>
PR tree-optimization/55831
gcc/ipa-inline-analysis.c
/* 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
......@@ -127,8 +127,7 @@ static void inline_node_duplication_hook (struct cgraph_node *,
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. */
......@@ -200,6 +199,7 @@ false_predicate_p (struct predicate *p)
/* Return predicate that is set true when function is not inlined. */
static inline struct predicate
not_inlined_predicate (void)
{
......@@ -254,7 +254,7 @@ add_condition (struct inline_summary *summary, int operand_num,
&& 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)
......@@ -321,7 +321,7 @@ add_clause (conditions conditions, struct predicate *p, clause_t clause)
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++;
}
......@@ -335,26 +335,27 @@ add_clause (conditions conditions, struct predicate *p, clause_t clause)
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)
......@@ -362,7 +363,7 @@ add_clause (conditions conditions, struct predicate *p, clause_t clause)
/* 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;
......@@ -390,7 +391,7 @@ and_predicates (conditions conditions,
{
gcc_checking_assert (i < MAX_CLAUSES);
}
/* Combine the predicates rest. */
for (; p2->clause[i]; i++)
{
......@@ -410,11 +411,11 @@ predicates_equal_p (struct predicate *p, struct predicate *p2)
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];
}
......@@ -423,10 +424,11 @@ predicates_equal_p (struct predicate *p, struct predicate *p2)
/* 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))
......@@ -440,8 +442,8 @@ or_predicates (conditions conditions, struct predicate *p, struct predicate *p2)
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;
}
......@@ -466,7 +468,7 @@ evaluate_predicate (struct predicate *p, clause_t possible_truths)
{
gcc_checking_assert (i < MAX_CLAUSES);
if (!(p->clause[i] & possible_truths))
return false;
return false;
}
return true;
}
......@@ -508,23 +510,25 @@ predicate_probability (conditions conds,
{
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;
......@@ -580,7 +584,7 @@ dump_clause (FILE *f, conditions conds, clause_t clause)
if (found)
fprintf (f, " || ");
found = true;
dump_condition (f, conds, i);
dump_condition (f, conds, i);
}
fprintf (f, ")");
}
......@@ -599,7 +603,7 @@ dump_predicate (FILE *f, conditions conds, struct predicate *pred)
{
if (i)
fprintf (f, " && ");
dump_clause (f, conds, pred->clause[i]);
dump_clause (f, conds, pred->clause[i]);
}
fprintf (f, "\n");
}
......@@ -683,7 +687,7 @@ account_size_time (struct inline_summary *summary, int size, int time,
if (predicates_equal_p (&e->predicate, pred))
{
found = true;
break;
break;
}
if (i == 256)
{
......@@ -692,14 +696,16 @@ account_size_time (struct inline_summary *summary, int size, int time,
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)
......@@ -728,13 +734,13 @@ edge_set_predicate (struct cgraph_edge *e, struct predicate *predicate)
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;
}
}
......@@ -744,8 +750,7 @@ edge_set_predicate (struct cgraph_edge *e, struct predicate *predicate)
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);
......@@ -754,7 +759,7 @@ set_hint_predicate (struct predicate **p, struct predicate new_predicate)
else
{
if (!*p)
*p = (struct predicate *)pool_alloc (edge_predicate_pool);
*p = (struct predicate *) pool_alloc (edge_predicate_pool);
**p = new_predicate;
}
}
......@@ -769,9 +774,10 @@ set_hint_predicate (struct predicate **p, struct predicate 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);
......@@ -784,9 +790,9 @@ evaluate_conditions_for_known_args (struct cgraph_node *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 ())
......@@ -801,8 +807,7 @@ evaluate_conditions_for_known_args (struct cgraph_node *node,
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 ())
......@@ -828,8 +833,7 @@ evaluate_conditions_for_known_args (struct cgraph_node *node,
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);
}
......@@ -841,12 +845,13 @@ evaluate_conditions_for_known_args (struct cgraph_node *node,
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;
......@@ -860,8 +865,7 @@ evaluate_properties_for_edge (struct cgraph_edge *e, bool inline_p,
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);
......@@ -869,9 +873,9 @@ evaluate_properties_for_edge (struct cgraph_edge *e, bool inline_p,
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);
......@@ -888,7 +892,8 @@ evaluate_properties_for_edge (struct cgraph_edge *e, bool inline_p,
{
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)
......@@ -940,8 +945,7 @@ inline_summary_alloc (void)
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
......@@ -950,7 +954,7 @@ inline_summary_alloc (void)
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);
......@@ -1005,10 +1009,11 @@ reset_inline_summary (struct cgraph_node *node)
/* 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);
......@@ -1054,8 +1059,7 @@ remap_hint_predicate_after_duplication (struct predicate **p,
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);
......@@ -1065,29 +1069,28 @@ remap_hint_predicate_after_duplication (struct predicate **p,
/* 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;
......@@ -1098,15 +1101,13 @@ inline_node_duplication_hook (struct cgraph_node *src, struct cgraph_node *dst,
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;
......@@ -1114,16 +1115,17 @@ inline_node_duplication_hook (struct cgraph_node *src, struct cgraph_node *dst,
}
}
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;
......@@ -1137,7 +1139,7 @@ inline_node_duplication_hook (struct cgraph_node *src, struct cgraph_node *dst,
}
/* 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;
......@@ -1160,7 +1162,7 @@ inline_node_duplication_hook (struct cgraph_node *src, struct cgraph_node *dst,
}
/* 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;
......@@ -1181,21 +1183,17 @@ inline_node_duplication_hook (struct cgraph_node *src, struct cgraph_node *dst,
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
{
......@@ -1226,7 +1224,8 @@ inline_node_duplication_hook (struct cgraph_node *src, struct cgraph_node *dst,
/* 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;
......@@ -1234,8 +1233,7 @@ inline_edge_duplication_hook (struct cgraph_edge *src, struct cgraph_edge *dst,
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 ();
......@@ -1245,7 +1243,8 @@ inline_edge_duplication_hook (struct cgraph_edge *src, struct cgraph_edge *dst,
/* 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);
......@@ -1279,28 +1278,27 @@ free_growth_caches (void)
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)
{
......@@ -1308,9 +1306,9 @@ dump_inline_edge_summary (FILE * f, int indent, struct cgraph_node *node,
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;
......@@ -1323,13 +1321,13 @@ dump_inline_edge_summary (FILE * f, int indent, struct cgraph_node *node,
}
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)
......@@ -1338,10 +1336,8 @@ dump_inline_edge_summary (FILE * f, int indent, struct cgraph_node *node,
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: ");
......@@ -1354,7 +1350,7 @@ dump_inline_edge_summary (FILE * f, int indent, struct cgraph_node *node,
void
dump_inline_summary (FILE * f, struct cgraph_node *node)
dump_inline_summary (FILE *f, struct cgraph_node *node)
{
if (node->analyzed)
{
......@@ -1367,22 +1363,17 @@ dump_inline_summary (FILE * f, struct cgraph_node *node)
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:",
......@@ -1452,7 +1443,7 @@ initialize_inline_failed (struct cgraph_edge *e)
static bool
mark_modified (ao_ref *ao ATTRIBUTE_UNUSED, tree vdef ATTRIBUTE_UNUSED,
void *data)
void *data)
{
bool *b = (bool *) data;
*b = true;
......@@ -1563,116 +1554,117 @@ eliminated_by_inlining_prob (gimple stmt)
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;
}
}
......@@ -1682,8 +1674,8 @@ eliminated_by_inlining_prob (gimple stmt)
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;
......@@ -1696,8 +1688,7 @@ set_cond_stmt_execution_predicate (struct ipa_node_params *info,
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;
......@@ -1709,8 +1700,8 @@ set_cond_stmt_execution_predicate (struct ipa_node_params *info,
{
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)
{
......@@ -1719,7 +1710,7 @@ set_cond_stmt_execution_predicate (struct ipa_node_params *info,
? code : inverted_code,
gimple_cond_rhs (last));
e->aux = pool_alloc (edge_predicate_pool);
*(struct predicate *)e->aux = p;
*(struct predicate *) e->aux = p;
}
}
......@@ -1727,9 +1718,9 @@ set_cond_stmt_execution_predicate (struct ipa_node_params *info,
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
......@@ -1743,16 +1734,16 @@ set_cond_stmt_execution_predicate (struct ipa_node_params *info,
|| 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;
}
}
......@@ -1761,8 +1752,8 @@ set_cond_stmt_execution_predicate (struct ipa_node_params *info,
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;
......@@ -1774,8 +1765,7 @@ set_switch_stmt_execution_predicate (struct ipa_node_params *info,
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))
......@@ -1784,9 +1774,9 @@ set_switch_stmt_execution_predicate (struct ipa_node_params *info,
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);
......@@ -1798,8 +1788,8 @@ set_switch_stmt_execution_predicate (struct ipa_node_params *info,
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)
......@@ -1811,8 +1801,8 @@ set_switch_stmt_execution_predicate (struct ipa_node_params *info,
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);
}
}
......@@ -1838,7 +1828,7 @@ compute_bb_predicates (struct cgraph_node *node,
/* 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.
......@@ -1848,19 +1838,19 @@ compute_bb_predicates (struct cgraph_node *node,
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;
......@@ -1874,12 +1864,12 @@ compute_bb_predicates (struct cgraph_node *node,
{
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;
}
}
}
......@@ -1895,9 +1885,9 @@ typedef struct predicate predicate_t;
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;
......@@ -1906,19 +1896,17 @@ will_be_nonconstant_expr_predicate (struct ipa_node_params *info,
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;
......@@ -1930,8 +1918,8 @@ will_be_nonconstant_expr_predicate (struct ipa_node_params *info,
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;
......@@ -2018,7 +2006,8 @@ will_be_nonconstant_predicate (struct ipa_node_params *info,
}
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)
......@@ -2026,8 +2015,7 @@ will_be_nonconstant_predicate (struct ipa_node_params *info,
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);
......@@ -2041,7 +2029,7 @@ will_be_nonconstant_predicate (struct ipa_node_params *info,
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;
}
......@@ -2055,15 +2043,16 @@ struct record_modified_bb_info
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;
}
......@@ -2081,6 +2070,7 @@ param_change_prob (gimple stmt, int i)
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
......@@ -2104,10 +2094,10 @@ param_change_prob (gimple stmt, int i)
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);
......@@ -2130,13 +2120,13 @@ param_change_prob (gimple stmt, int i)
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
......@@ -2144,13 +2134,13 @@ param_change_prob (gimple stmt, int i)
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;
}
......@@ -2251,19 +2241,18 @@ predicate_for_phi_result (struct inline_summary *summary, gimple phi,
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;
......@@ -2304,7 +2293,8 @@ estimate_function_body_sizes (struct cgraph_node *node, bool early)
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 ());
}
}
......@@ -2335,7 +2325,7 @@ estimate_function_body_sizes (struct cgraph_node *node, bool early)
if (parms_info)
{
if (bb->aux)
bb_predicate = *(struct predicate *)bb->aux;
bb_predicate = *(struct predicate *) bb->aux;
else
bb_predicate = false_predicate ();
}
......@@ -2384,26 +2374,33 @@ estimate_function_body_sizes (struct cgraph_node *node, bool early)
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))
{
......@@ -2411,8 +2408,8 @@ estimate_function_body_sizes (struct cgraph_node *node, bool early)
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)
......@@ -2420,11 +2417,11 @@ estimate_function_body_sizes (struct cgraph_node *node, bool early)
{
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)
......@@ -2444,12 +2441,12 @@ estimate_function_body_sizes (struct cgraph_node *node, bool early)
}
/* 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;
......@@ -2458,7 +2455,8 @@ estimate_function_body_sizes (struct cgraph_node *node, bool early)
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");
......@@ -2477,8 +2475,8 @@ estimate_function_body_sizes (struct cgraph_node *node, bool early)
}
/* 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)
......@@ -2516,38 +2514,42 @@ estimate_function_body_sizes (struct cgraph_node *node, bool early)
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;
......@@ -2555,30 +2557,36 @@ estimate_function_body_sizes (struct cgraph_node *node, bool early)
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 ();
}
......@@ -2691,8 +2699,7 @@ compute_inline_parameters (struct cgraph_node *node, bool early)
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 ();
......@@ -2709,24 +2716,24 @@ compute_inline_parameters_for_current (void)
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 */
}
};
......@@ -2776,7 +2783,6 @@ estimate_edge_size_and_time (struct cgraph_edge *e, int *size, int *time,
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;
......@@ -2784,12 +2790,11 @@ estimate_edge_size_and_time (struct cgraph_edge *e, int *size, int *time,
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;
}
......@@ -2812,26 +2817,29 @@ estimate_calls_size_and_time (struct cgraph_node *node, int *size, int *time,
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);
......@@ -2849,10 +2857,10 @@ estimate_node_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,
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;
......@@ -2861,24 +2869,21 @@ estimate_node_size_and_time (struct cgraph_node *node,
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);
}
}
......@@ -2887,7 +2892,7 @@ estimate_node_size_and_time (struct cgraph_node *node,
{
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
......@@ -2898,25 +2903,25 @@ estimate_node_size_and_time (struct cgraph_node *node,
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))
......@@ -2929,9 +2934,8 @@ estimate_node_size_and_time (struct cgraph_node *node,
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)
......@@ -2949,11 +2953,11 @@ estimate_node_size_and_time (struct cgraph_node *node,
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;
......@@ -2982,8 +2986,7 @@ remap_predicate (struct inline_summary *info,
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 ();
......@@ -2999,7 +3002,7 @@ remap_predicate (struct inline_summary *info,
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))
{
......@@ -3008,42 +3011,42 @@ remap_predicate (struct inline_summary *info,
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. */
......@@ -3065,8 +3068,7 @@ remap_predicate (struct inline_summary *info,
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);
......@@ -3075,12 +3077,11 @@ inline_update_callee_summaries (struct cgraph_node *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)
{
......@@ -3108,7 +3109,7 @@ remap_edge_change_prob (struct cgraph_edge *inlined_edge,
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++)
{
......@@ -3129,7 +3130,7 @@ remap_edge_change_prob (struct cgraph_edge *inlined_edge,
es->param[i].change_prob = prob;
}
}
}
}
}
/* Update edge summaries of NODE after INLINED_EDGE has been inlined.
......@@ -3140,14 +3141,14 @@ remap_edge_change_prob (struct cgraph_edge *inlined_edge,
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)
......@@ -3163,12 +3164,11 @@ remap_edge_summaries (struct cgraph_edge *inlined_edge,
{
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;
......@@ -3227,17 +3227,13 @@ remap_hint_predicate (struct inline_summary *info,
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);
}
}
......@@ -3312,19 +3308,19 @@ inline_merge_summary (struct cgraph_edge *edge)
&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);
}
......@@ -3333,16 +3329,13 @@ inline_merge_summary (struct cgraph_edge *edge)
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);
......@@ -3371,10 +3364,10 @@ inline_update_overall_summary (struct cgraph_node *node)
{
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;
......@@ -3386,8 +3379,7 @@ simple_edge_hints (struct cgraph_edge *edge)
{
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))
......@@ -3437,7 +3429,7 @@ do_estimate_edge_time (struct cgraph_edge *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);
......@@ -3537,7 +3529,8 @@ estimate_time_after_inlining (struct cgraph_node *node,
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)
......@@ -3588,7 +3581,7 @@ do_estimate_growth_1 (struct cgraph_node *node, void *data)
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;
......@@ -3600,7 +3593,7 @@ do_estimate_growth_1 (struct cgraph_node *node, void *data)
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);
......@@ -3618,10 +3611,10 @@ do_estimate_growth (struct cgraph_node *node)
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;
......@@ -3629,7 +3622,7 @@ do_estimate_growth (struct cgraph_node *node)
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);
}
......@@ -3687,7 +3680,7 @@ inline_generate_summary (void)
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 ();
......@@ -3707,7 +3700,7 @@ read_predicate (struct lto_input_block *ib)
clause_t clause;
int k = 0;
do
do
{
gcc_assert (k <= MAX_CLAUSES);
clause = out.clause[k++] = streamer_read_uhwi (ib);
......@@ -3741,8 +3734,7 @@ read_inline_edge_summary (struct lto_input_block *ib, struct cgraph_edge *e)
{
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);
}
}
......@@ -3820,7 +3812,7 @@ inline_read_section (struct lto_file_decl_data *file_data, const char *data,
vec_safe_push (info->entry, e);
}
p = read_predicate (&ib);
set_hint_predicate (&info->loop_iterations, p);
p = read_predicate (&ib);
......@@ -3859,7 +3851,7 @@ inline_read_summary (void)
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
......@@ -3870,10 +3862,10 @@ inline_read_summary (void)
{
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);
}
......@@ -3886,8 +3878,8 @@ write_predicate (struct output_block *ob, struct predicate *p)
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);
}
......@@ -3906,7 +3898,7 @@ write_inline_edge_summary (struct output_block *ob, struct cgraph_edge *e)
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);
}
......@@ -3945,8 +3937,11 @@ inline_write_summary (void)
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);
......@@ -3964,7 +3959,7 @@ inline_write_summary (void)
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++)
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment