diff --git a/gcc/ChangeLog b/gcc/ChangeLog index f8fd7458bef..1cf9aae3781 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,16 @@ +2019-01-05 Jan Hubicka + + * doc/invoke.texi: Document max-inline-insns-size, + uninlined-function-insns, uninlined-function-time, + uninlined-thunk-insns and uninlined-thunk-time. + * params.def: Add max-inline-insns-size, + uninlined-function-insns, uninlined-function-time, + uninlined-thunk-insns and uninlined-thunk-time. + * ipa-fnsummary.c (compute_fn_summary, analyze_function_body): Use + new parameters. + * ipa-inline.c (can_inline_edge_by_limits_p, + want_inline_small_function_p): Use new parameters. + 2019-01-05 Jan Hubicka * ipa-fnsummary.c (analyze_function_body): Fix accounting of time. diff --git a/gcc/doc/invoke.texi b/gcc/doc/invoke.texi index 292227a3fbb..3501a62abb4 100644 --- a/gcc/doc/invoke.texi +++ b/gcc/doc/invoke.texi @@ -11007,6 +11007,23 @@ by the compiler are investigated. To those functions, a different (more restrictive) limit compared to functions declared inline can be applied. +@item max-inline-insns-size +This is bound applied to calls which are optimized for size. Small growth +may be desirable to anticipate optimization oppurtunities exposed by inlining. + +@item uninlined-function-insns +Number of instructions accounted by inliner for function overhead such as +function prologue and epilogue. + +@item uninlined-function-time +Extra time accounted by inliner for function overhead such as time needed to +execute function prologue and epilogue + +@item uninlined-thunk-insns +@item uninlined-thunk-time +Same as @option{--param uninlined-function-insns} and +@option{--param uninlined-function-time} but applied to function thunks + @item inline-min-speedup When estimated performance improvement of caller + callee runtime exceeds this threshold (in percent), the function can be inlined regardless of the limit on diff --git a/gcc/ipa-fnsummary.c b/gcc/ipa-fnsummary.c index affb210e8ef..1f5ff987825 100644 --- a/gcc/ipa-fnsummary.c +++ b/gcc/ipa-fnsummary.c @@ -2034,7 +2034,10 @@ analyze_function_body (struct cgraph_node *node, bool early) info->account_size_time (0, 0, bb_predicate, bb_predicate); bb_predicate = predicate::not_inlined (); - info->account_size_time (2 * ipa_fn_summary::size_scale, 0, bb_predicate, + info->account_size_time (PARAM_VALUE (PARAM_UNINLINED_FUNCTION_INSNS) + * ipa_fn_summary::size_scale, + PARAM_VALUE (PARAM_UNINLINED_FUNCTION_TIME), + bb_predicate, bb_predicate); if (fbi.info) @@ -2418,7 +2421,11 @@ compute_fn_summary (struct cgraph_node *node, bool early) node->local.can_change_signature = false; es->call_stmt_size = eni_size_weights.call_cost; es->call_stmt_time = eni_time_weights.call_cost; - info->account_size_time (ipa_fn_summary::size_scale * 2, 2, t, t); + info->account_size_time (ipa_fn_summary::size_scale + * PARAM_VALUE + (PARAM_UNINLINED_FUNCTION_THUNK_INSNS), + PARAM_VALUE + (PARAM_UNINLINED_FUNCTION_THUNK_TIME), t, t); t = predicate::not_inlined (); info->account_size_time (2 * ipa_fn_summary::size_scale, 0, t, t); ipa_update_overall_fn_summary (node); diff --git a/gcc/ipa-inline.c b/gcc/ipa-inline.c index 623381fd1ec..b51e2282cc7 100644 --- a/gcc/ipa-inline.c +++ b/gcc/ipa-inline.c @@ -523,7 +523,7 @@ can_inline_edge_by_limits_p (struct cgraph_edge *e, bool report, > opt_for_fn (caller->decl, optimize_size)) { int growth = estimate_edge_growth (e); - if (growth > 0 + if (growth > PARAM_VALUE (PARAM_MAX_INLINE_INSNS_SIZE) && (!DECL_DECLARED_INLINE_P (callee->decl) && growth >= MAX (MAX_INLINE_INSNS_SINGLE, MAX_INLINE_INSNS_AUTO))) @@ -635,7 +635,7 @@ want_early_inline_function_p (struct cgraph_edge *e) int growth = estimate_edge_growth (e); int n; - if (growth <= 0) + if (growth <= PARAM_VALUE (PARAM_MAX_INLINE_INSNS_SIZE)) ; else if (!e->maybe_hot_p () && growth > 0) @@ -791,7 +791,7 @@ want_inline_small_function_p (struct cgraph_edge *e, bool report) ipa_hints hints = estimate_edge_hints (e); int big_speedup = -1; /* compute this lazily */ - if (growth <= 0) + if (growth <= PARAM_VALUE (PARAM_VALUE (PARAM_MAX_INLINE_INSNS_SIZE))) ; /* Apply MAX_INLINE_INSNS_SINGLE limit. Do not do so when hints suggests that inlining given function is very profitable. */ @@ -809,6 +809,8 @@ want_inline_small_function_p (struct cgraph_edge *e, bool report) want_inline = false; } else if (!DECL_DECLARED_INLINE_P (callee->decl) + && (in_lto_p + && growth >= PARAM_VALUE (PARAM_EARLY_INLINING_INSNS)) && !opt_for_fn (e->caller->decl, flag_inline_functions)) { /* growth_likely_positive is expensive, always test it last. */ diff --git a/gcc/params.def b/gcc/params.def index 8ca3bbd2621..b89b475ca96 100644 --- a/gcc/params.def +++ b/gcc/params.def @@ -83,6 +83,33 @@ DEFPARAM (PARAM_MAX_INLINE_INSNS_AUTO, "The maximum number of instructions when automatically inlining.", 30, 0, 0) +DEFPARAM (PARAM_MAX_INLINE_INSNS_SIZE, + "max-inline-insns-size", + "The maximum number of instructions when inlining for size.", + 0, 0, 0) + +DEFPARAM (PARAM_UNINLINED_FUNCTION_INSNS, + "uninlined-function-insns", + "Instruction accounted for function prologue, epilogue and other" + " overhead.", + 2, 0, 0) + +DEFPARAM (PARAM_UNINLINED_FUNCTION_TIME, + "uninlined-function-time", + "Time accounted for function prologue, epilogue and other" + " overhead.", + 0, 0, 0) + +DEFPARAM (PARAM_UNINLINED_FUNCTION_THUNK_INSNS, + "uninlined-thunk-insns", + "Instruction accounted for function thunk overhead.", + 2, 0, 0) + +DEFPARAM (PARAM_UNINLINED_FUNCTION_THUNK_TIME, + "uninlined-thunk-time", + "Time accounted for function thunk overhead.", + 2, 0, 0) + DEFPARAM (PARAM_MAX_INLINE_INSNS_RECURSIVE, "max-inline-insns-recursive", "The maximum number of instructions inline function can grow to via recursive inlining.",