{
bool inlinable = true;
enum availability avail;
- struct cgraph_node *callee = cgraph_function_or_thunk_node (e->callee, &avail);
+ struct cgraph_node *callee
+ = cgraph_function_or_thunk_node (e->callee, &avail);
tree caller_tree = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (e->caller->decl);
- tree callee_tree = callee ? DECL_FUNCTION_SPECIFIC_OPTIMIZATION (callee->decl) : NULL;
+ tree callee_tree
+ = callee ? DECL_FUNCTION_SPECIFIC_OPTIMIZATION (callee->decl) : NULL;
+ struct function *caller_cfun = DECL_STRUCT_FUNCTION (e->caller->decl);
+ struct function *callee_cfun
+ = callee ? DECL_STRUCT_FUNCTION (callee->decl) : NULL;
+
+ if (!caller_cfun && e->caller->clone_of)
+ caller_cfun = DECL_STRUCT_FUNCTION (e->caller->clone_of->decl);
+
+ if (!callee_cfun && callee && callee->clone_of)
+ callee_cfun = DECL_STRUCT_FUNCTION (callee->clone_of->decl);
gcc_assert (e->inline_failed);
caller cannot.
FIXME: this is obviously wrong for LTO where STRUCT_FUNCTION is missing.
Move the flag into cgraph node or mirror it in the inline summary. */
- else if (DECL_STRUCT_FUNCTION (callee->decl)
- && DECL_STRUCT_FUNCTION
- (callee->decl)->can_throw_non_call_exceptions
- && !(DECL_STRUCT_FUNCTION (e->caller->decl)
- && DECL_STRUCT_FUNCTION
- (e->caller->decl)->can_throw_non_call_exceptions))
+ else if (callee_cfun && callee_cfun->can_throw_non_call_exceptions
+ && !(caller_cfun && caller_cfun->can_throw_non_call_exceptions))
{
e->inline_failed = CIF_NON_CALL_EXCEPTIONS;
inlinable = false;
? callee_tree
: optimization_default_node);
- if ((caller_opt->x_optimize > callee_opt->x_optimize)
- || (caller_opt->x_optimize_size != callee_opt->x_optimize_size))
+ if (((caller_opt->x_optimize > callee_opt->x_optimize)
+ || (caller_opt->x_optimize_size != callee_opt->x_optimize_size))
+ /* gcc.dg/pr43564.c. Look at forced inline even in -O0. */
+ && !DECL_DISREGARD_INLINE_LIMITS (e->callee->decl))
{
- e->inline_failed = CIF_TARGET_OPTIMIZATION_MISMATCH;
+ e->inline_failed = CIF_OPTIMIZATION_MISMATCH;
inlinable = false;
}
}
uninlined_call_time =
((gcov_type)
(callee_info->time
- + inline_edge_summary (edge)->call_stmt_time
- + CGRAPH_FREQ_BASE / 2) * edge->frequency
- / CGRAPH_FREQ_BASE);
+ + inline_edge_summary (edge)->call_stmt_time) * edge->frequency
+ + CGRAPH_FREQ_BASE / 2) / CGRAPH_FREQ_BASE;
/* Compute relative time benefit, i.e. how much the call becomes faster.
??? perhaps computing how much the caller+calle together become faster
would lead to more realistic results. */
/* Result must be integer in range 0...INT_MAX.
Set the base of fixed point calculation so we don't lose much of
precision for small bandesses (those are interesting) yet we don't
- overflow for growths that are still in interesting range. */
- badness = ((gcov_type)growth) * (1<<18);
+ overflow for growths that are still in interesting range.
+
+ Fixed point arithmetic with point at 8th bit. */
+ badness = ((gcov_type)growth) * (1<<(19+8));
badness = (badness + div / 2) / div;
/* Overall growth of inlining all calls of function matters: we want to
We might mix the valud into the fraction by taking into account
relative growth of the unit, but for now just add the number
into resulting fraction. */
+ if (badness > INT_MAX / 2)
+ {
+ badness = INT_MAX / 2;
+ if (dump)
+ fprintf (dump_file, "Badness overflow\n");
+ }
growth_for_all = estimate_growth (callee);
badness += growth_for_all;
- if (badness > INT_MAX - 1)
- badness = INT_MAX - 1;
if (dump)
{
fprintf (dump_file,
depth = 1;
for (cnode = curr->caller;
cnode->global.inlined_to; cnode = cnode->callers->caller)
- if (node->decl == curr->callee->decl)
- depth++;
+ if (node->decl
+ == cgraph_function_or_thunk_node (curr->callee, NULL)->decl)
+ depth++;
if (!want_inline_self_recursive_call_p (curr, node, false, depth))
continue;
struct cgraph_node *where, *callee;
int badness = fibheap_min_key (heap);
int current_badness;
+ int cached_badness;
int growth;
edge = (struct cgraph_edge *) fibheap_extract_min (heap);
if (!edge->inline_failed)
continue;
- /* Be sure that caches are maintained consistent. */
-#ifdef ENABLE_CHECKING
+ /* Be sure that caches are maintained consistent.
+ We can not make this ENABLE_CHECKING only because it cause differnt
+ updates of the fibheap queue. */
+ cached_badness = edge_badness (edge, false);
reset_edge_growth_cache (edge);
reset_node_growth_cache (edge->callee);
-#endif
/* When updating the edge costs, we only decrease badness in the keys.
Increases of badness are handled lazilly; when we see key with out
of date value on it, we re-insert it now. */
current_badness = edge_badness (edge, false);
+ gcc_assert (cached_badness == current_badness);
gcc_assert (current_badness >= badness);
if (current_badness != badness)
{
/* We inlined last offline copy to the body. This might lead
to callees of function having fewer call sites and thus they
- may need updating. */
- if (callee->global.inlined_to)
+ may need updating.
+
+ FIXME: the callee size could also shrink because more information
+ is propagated from caller. We don't track when this happen and
+ thus we need to recompute everything all the time. Once this is
+ solved, "|| 1" should go away. */
+ if (callee->global.inlined_to || 1)
update_all_callee_keys (heap, callee, updated_nodes);
else
update_callee_keys (heap, edge->callee, updated_nodes);
XCNEWVEC (struct cgraph_node *, cgraph_n_nodes);
int i;
- if (in_lto_p && flag_indirect_inlining)
+ if (in_lto_p && optimize)
ipa_update_after_lto_read ();
- if (flag_indirect_inlining)
- ipa_create_all_structures_for_iinln ();
if (dump_file)
dump_inline_summaries (dump_file);
}
/* Free ipa-prop structures if they are no longer needed. */
- if (flag_indirect_inlining)
+ if (optimize)
ipa_free_all_structures_after_iinln ();
if (dump_file)
/* When to run IPA inlining. Inlining of always-inline functions
- happens during early inlining. */
+ happens during early inlining.
+
+ Enable inlining unconditoinally at -flto. We need size estimates to
+ drive partitioning. */
static bool
gate_ipa_inline (void)
{
- /* ??? We'd like to skip this if not optimizing or not inlining as
- all always-inline functions have been processed by early
- inlining already. But this at least breaks EH with C++ as
- we need to unconditionally run fixup_cfg even at -O0.
- So leave it on unconditionally for now. */
- return 1;
+ return optimize || flag_lto || flag_wpa;
}
struct ipa_opt_pass_d pass_ipa_inline =