From patchwork Sat Nov 23 13:12:20 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jan Hubicka X-Patchwork-Id: 1199824 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Authentication-Results: ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=gcc.gnu.org (client-ip=209.132.180.131; helo=sourceware.org; envelope-from=gcc-patches-return-514461-incoming=patchwork.ozlabs.org@gcc.gnu.org; receiver=) Authentication-Results: ozlabs.org; dmarc=none (p=none dis=none) header.from=ucw.cz Authentication-Results: ozlabs.org; dkim=pass (1024-bit key; unprotected) header.d=gcc.gnu.org header.i=@gcc.gnu.org header.b="BwaDiKsr"; dkim-atps=neutral Received: from sourceware.org (server1.sourceware.org [209.132.180.131]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id 47Kty05hh7z9sPT for ; Sun, 24 Nov 2019 00:12:38 +1100 (AEDT) DomainKey-Signature: a=rsa-sha1; c=nofws; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender:date :from:to:subject:message-id:mime-version:content-type; q=dns; s= default; b=hUYpEjBiD7HiKNLWuDFyIoSLwxduyPgefLbZdW1b5F2aJGno/ZDyq EzGTAlDf3W/y4WZO1MTIbC07vlZCV3FuI/PvyieTLV6cVrt4rinixbzfOeEj3AKo NkGsTzL4hEZREw+/QpOYFuOhOYyv57LVGx64iAxezFK23G9vcQuuK4= DKIM-Signature: v=1; a=rsa-sha1; c=relaxed; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender:date :from:to:subject:message-id:mime-version:content-type; s= default; bh=HkiBCVEgru4w8rmC+KY6vnttZoI=; b=BwaDiKsrtatZucHp0igT JPoSm11Stpho9VVhBygTlCLuItilKB9AQH5XR6bUKGSAd93Vq1ePlbqn83feik5O KVKuPmnlmO5Gms8VXpiQMzwRsp5Xsfv1v+pWt81cUSpyLZalYyo2YsgBcO63WfEO EhfwiWg42UfgKcfJcihAGXw= Received: (qmail 122716 invoked by alias); 23 Nov 2019 13:12:29 -0000 Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Delivered-To: mailing list gcc-patches@gcc.gnu.org Received: (qmail 122703 invoked by uid 89); 23 Nov 2019 13:12:29 -0000 Authentication-Results: sourceware.org; auth=none X-Spam-SWARE-Status: No, score=-10.1 required=5.0 tests=AWL, BAYES_00, GIT_PATCH_2, GIT_PATCH_3, KAM_ASCII_DIVIDERS autolearn=ham version=3.3.1 spammy=2700, eligible, ffastmath, sk:want_in X-HELO: nikam.ms.mff.cuni.cz Received: from nikam.ms.mff.cuni.cz (HELO nikam.ms.mff.cuni.cz) (195.113.20.16) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Sat, 23 Nov 2019 13:12:24 +0000 Received: by nikam.ms.mff.cuni.cz (Postfix, from userid 16202) id 9492A28909A; Sat, 23 Nov 2019 14:12:20 +0100 (CET) Date: Sat, 23 Nov 2019 14:12:20 +0100 From: Jan Hubicka To: gcc-patches@gcc.gnu.org, mliska@suse.cz Subject: Convert inliner to new param infrastructure Message-ID: <20191123131220.ivtblcgtwstd6gyr@kam.mff.cuni.cz> MIME-Version: 1.0 Content-Disposition: inline User-Agent: NeoMutt/20170113 (1.7.2) Hi, This patch adds opt_for_fn for all cross module params used by inliner so they can be modified at function granuality. With inlining almost always there are three functions to consider (callee and caller of the inlined edge and the outer function caller is inlined to). I always use the outer function params since that is how local parameters behave. I hope it is kind of what is also expected in most case: it is better to inline agressively into -O3 compiled code rather than inline agressively -O3 functions into their callers. New params infrastructure is nice. One drawback is that is very hard to search for individual param uses since they all occupy global namespace. With C++ world we had chance to do something like params.param_flag_name or params::param_flag_name instead... Bootstrapped/regtested x86_64-linux, comitted. * cif-code.def (MAX_INLINE_INSNS_SINGLE_O2_LIMIT): Remove. * doc/invoke.texi (max-inline-insns-single-O2, inline-heuristics-hint-percent-O2, inline-min-speedup-O2, early-inlining-insns-O2): Remove documentation. * ipa-fnsummary.c (analyze_function_body, compute_fn_summary): Use opt_for_fn when accessing parameters. * ipa-inline.c (caller_growth_limits, can_inline_edge_p, inline_insns_auto, can_inline_edge_by_limits_p, want_early_inline_function_p, big_speedup_p, want_inline_small_function_p, want_inline_self_recursive_call_p, recursive_inlining, compute_max_insns, inline_small_functions): Likewise. * opts.c (default_options): Add -O3 defaults for OPT__param_early_inlining_insns_, OPT__param_inline_heuristics_hint_percent_, OPT__param_inline_min_speedup_, OPT__param_max_inline_insns_single_. * params.opt (-param=early-inlining-insns-O2=, -param=inline-heuristics-hint-percent-O2=, -param=inline-min-speedup-O2=, -param=max-inline-insns-single-O2= -param=early-inlining-insns=, -param=inline-heuristics-hint-percent=, -param=inline-min-speedup=, -param=inline-unit-growth=, -param=large-function-growth=, -param=large-stack-frame=, -param=large-stack-frame-growth=, -param=large-unit-insns=, -param=max-inline-insns-recursive=, -param=max-inline-insns-recursive-auto=, -param=max-inline-insns-single=, -param=max-inline-insns-size=, -param=max-inline-insns-small=, -param=max-inline-recursive-depth=, -param=max-inline-recursive-depth-auto=, -param=min-inline-recursive-probability=, -param=partial-inlining-entry-probability=, -param=uninlined-function-insns=, -param=uninlined-function-time=, -param=uninlined-thunk-insns=, -param=uninlined-thunk-time=): Add Optimization. * g++.dg/tree-ssa/pr53844.C: Drop -O2 from param name. * g++.dg/tree-ssa/pr61034.C: Likewise. * g++.dg/tree-ssa/pr8781.C: Likewise. * g++.dg/warn/Wstringop-truncation-1.C: Likewise. * gcc.dg/ipa/pr63416.c: Likewise. * gcc.dg/tree-ssa/ssa-thread-12.c: Likewise. * gcc.dg/vect/pr66142.c: Likewise. * gcc.dg/winline-3.c: Likewise. * gcc.target/powerpc/pr72804.c: Likewise. Index: cif-code.def =================================================================== --- cif-code.def (revision 278629) +++ cif-code.def (working copy) @@ -70,8 +70,6 @@ DEFCIFCODE(LARGE_STACK_FRAME_GROWTH_LIMI N_("--param large-stack-frame-growth limit reached")) DEFCIFCODE(MAX_INLINE_INSNS_SINGLE_LIMIT, CIF_FINAL_NORMAL, N_("--param max-inline-insns-single limit reached")) -DEFCIFCODE(MAX_INLINE_INSNS_SINGLE_O2_LIMIT, CIF_FINAL_NORMAL, - N_("--param max-inline-insns-single-O2 limit reached")) DEFCIFCODE(MAX_INLINE_INSNS_AUTO_LIMIT, CIF_FINAL_NORMAL, N_("--param max-inline-insns-auto limit reached")) DEFCIFCODE(INLINE_UNIT_GROWTH_LIMIT, CIF_FINAL_NORMAL, Index: doc/invoke.texi =================================================================== --- doc/invoke.texi (revision 278629) +++ doc/invoke.texi (working copy) @@ -11281,17 +11281,12 @@ when modulo scheduling a loop. Larger v compilation time. @item max-inline-insns-single -@item max-inline-insns-single-O2 Several parameters control the tree inliner used in GCC@. This number sets the maximum number of instructions (counted in GCC's internal representation) in a single function that the tree inliner considers for inlining. This only affects functions declared inline and methods implemented in a class declaration (C++). -For functions compiled with optimization levels -@option{-O3} and @option{-Ofast} parameter @option{max-inline-insns-single} is -applied. In other cases @option{max-inline-insns-single-O2} is applied. - @item max-inline-insns-auto When you use @option{-finline-functions} (included in @option{-O3}), @@ -11317,33 +11312,22 @@ Extra time accounted by inliner for func execute function prologue and epilogue @item inline-heuristics-hint-percent -@item inline-heuristics-hint-percent-O2 The scale (in percents) applied to @option{inline-insns-single}, @option{inline-insns-single-O2}, @option{inline-insns-auto} when inline heuristics hints that inlining is very profitable (will enable later optimizations). -For functions compiled with optimization levels -@option{-O3} and @option{-Ofast} parameter -@option{inline-heuristics-hint-percent} is applied. In other cases -@option{inline-heuristics-hint-percent-O2} is applied. - @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 -@item inline-min-speedup-O2 When estimated performance improvement of caller + callee runtime exceeds this threshold (in percent), the function can be inlined regardless of the limit on @option{--param max-inline-insns-single} and @option{--param max-inline-insns-auto}. -For functions compiled with optimization levels -@option{-O3} and @option{-Ofast} parameter @option{inline-min-speedup} is -applied. In other cases @option{inline-min-speedup-O2} is applied. - @item large-function-insns The limit specifying really large functions. For functions larger than this limit after inlining, inlining is constrained by @@ -11421,14 +11405,9 @@ via a given call expression. This param expressions whose probability exceeds the given threshold (in percents). @item early-inlining-insns -@item early-inlining-insns-O2 Specify growth that the early inliner can make. In effect it increases the amount of inlining for code having a large abstraction penalty. -For functions compiled with optimization levels -@option{-O3} and @option{-Ofast} parameter @option{early-inlining-insns} is -applied. In other cases @option{early-inlining-insns-O2} is applied. - @item max-early-inliner-iterations Limit of iterations of the early inliner. This basically bounds the number of nested indirect calls the early inliner can resolve. Index: ipa-fnsummary.c =================================================================== --- ipa-fnsummary.c (revision 278629) +++ ipa-fnsummary.c (working copy) @@ -2397,9 +2397,9 @@ fp_expression_p (gimple *stmt) static void analyze_function_body (struct cgraph_node *node, bool early) { - sreal time = param_uninlined_function_time; + sreal time = opt_for_fn (node->decl, param_uninlined_function_time); /* Estimate static overhead for function prologue/epilogue and alignment. */ - int size = param_uninlined_function_insns; + int size = opt_for_fn (node->decl, param_uninlined_function_insns); /* Benefits are scaled by probability of elimination that is in range <0,2>. */ basic_block bb; @@ -2465,9 +2465,11 @@ analyze_function_body (struct cgraph_nod info->account_size_time (0, 0, bb_predicate, bb_predicate); bb_predicate = predicate::not_inlined (); - info->account_size_time (param_uninlined_function_insns + info->account_size_time (opt_for_fn (node->decl, + param_uninlined_function_insns) * ipa_fn_summary::size_scale, - param_uninlined_function_time, + opt_for_fn (node->decl, + param_uninlined_function_time), bb_predicate, bb_predicate); @@ -2865,8 +2867,10 @@ compute_fn_summary (struct cgraph_node * 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 - * param_uninlined_function_thunk_insns, - param_uninlined_function_thunk_time, t, t); + * opt_for_fn (node->decl, + param_uninlined_function_thunk_insns), + opt_for_fn (node->decl, + 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); Index: ipa-inline.c =================================================================== --- ipa-inline.c (revision 278629) +++ ipa-inline.c (working copy) @@ -178,13 +178,13 @@ caller_growth_limits (struct cgraph_edge if (limit < what_size_info->self_size) limit = what_size_info->self_size; - limit += limit * param_large_function_growth / 100; + limit += limit * opt_for_fn (to->decl, param_large_function_growth) / 100; /* Check the size after inlining against the function limits. But allow the function to shrink if it went over the limits by forced inlining. */ newsize = estimate_size_after_inlining (to, e); if (newsize >= ipa_size_summaries->get (what)->size - && newsize > param_large_function_insns + && newsize > opt_for_fn (to->decl, param_large_function_insns) && newsize > limit) { e->inline_failed = CIF_LARGE_FUNCTION_GROWTH_LIMIT; @@ -200,7 +200,8 @@ caller_growth_limits (struct cgraph_edge on every invocation of the caller (i.e. its call statement dominates exit block). We do not track this information, yet. */ stack_size_limit += ((gcov_type)stack_size_limit - * param_stack_frame_growth / 100); + * opt_for_fn (to->decl, param_stack_frame_growth) + / 100); inlined_stack = (ipa_get_stack_frame_offset (to) + outer_info->estimated_self_stack_size @@ -213,7 +214,7 @@ caller_growth_limits (struct cgraph_edge This bit overoptimistically assume that we are good at stack packing. */ && inlined_stack > ipa_fn_summaries->get (to)->estimated_stack_size - && inlined_stack > param_large_stack_frame) + && inlined_stack > opt_for_fn (to->decl, param_large_stack_frame)) { e->inline_failed = CIF_LARGE_STACK_FRAME_GROWTH_LIMIT; return false; @@ -395,20 +396,10 @@ can_inline_edge_p (struct cgraph_edge *e static int inline_insns_single (cgraph_node *n, bool hint) { - if (opt_for_fn (n->decl, optimize) >= 3) - { - if (hint) - return param_max_inline_insns_single - * param_inline_heuristics_hint_percent / 100; - return param_max_inline_insns_single; - } - else - { - if (hint) - return param_max_inline_insns_single_o2 - * param_inline_heuristics_hint_percent_o2 / 100; - return param_max_inline_insns_single_o2; - } + if (hint) + return opt_for_fn (n->decl, param_max_inline_insns_single) + * opt_for_fn (n->decl, param_inline_heuristics_hint_percent) / 100; + return opt_for_fn (n->decl, param_max_inline_insns_single); } /* Return inlining_insns_auto limit for function N. If HINT is true @@ -419,7 +410,8 @@ inline_insns_auto (cgraph_node *n, bool { int max_inline_insns_auto = opt_for_fn (n->decl, param_max_inline_insns_auto); if (hint) - return max_inline_insns_auto * param_inline_heuristics_hint_percent / 100; + return max_inline_insns_auto + * opt_for_fn (n->decl, param_inline_heuristics_hint_percent) / 100; return max_inline_insns_auto; } @@ -563,7 +555,7 @@ can_inline_edge_by_limits_p (struct cgra > opt_for_fn (caller->decl, optimize_size)) { int growth = estimate_edge_growth (e); - if (growth > param_max_inline_insns_size + if (growth > opt_for_fn (caller->decl, param_max_inline_insns_size) && (!DECL_DECLARED_INLINE_P (callee->decl) && growth >= MAX (inline_insns_single (caller, false), inline_insns_auto (caller, false)))) @@ -675,9 +667,7 @@ want_early_inline_function_p (struct cgr /* First take care of very large functions. */ int min_growth = estimate_min_edge_growth (e), growth = 0; int n; - int early_inlining_insns = opt_for_fn (e->caller->decl, optimize) >= 3 - ? param_early_inlining_insns - : param_early_inlining_insns_o2; + int early_inlining_insns = param_early_inlining_insns; if (min_growth > early_inlining_insns) { @@ -824,9 +814,7 @@ big_speedup_p (struct cgraph_edge *e) cgraph_node *caller = (e->caller->inlined_to ? e->caller->inlined_to : e->caller); - int limit = opt_for_fn (caller->decl, optimize) >= 3 - ? param_inline_min_speedup - : param_inline_min_speedup_o2; + int limit = opt_for_fn (caller->decl, param_inline_min_speedup); if ((time - inlined_time) * 100 > time * limit) return true; @@ -841,6 +829,8 @@ want_inline_small_function_p (struct cgr { bool want_inline = true; struct cgraph_node *callee = e->callee->ultimate_alias_target (); + cgraph_node *to = (e->caller->inlined_to + ? e->caller->inlined_to : e->caller); /* Allow this function to be called before can_inline_edge_p, since it's usually cheaper. */ @@ -876,9 +866,7 @@ want_inline_small_function_p (struct cgr ? CIF_MAX_INLINE_INSNS_SINGLE_LIMIT : CIF_MAX_INLINE_INSNS_AUTO_LIMIT); else - e->inline_failed = (DECL_DECLARED_INLINE_P (callee->decl) - ? CIF_MAX_INLINE_INSNS_SINGLE_O2_LIMIT - : CIF_MAX_INLINE_INSNS_AUTO_LIMIT); + e->inline_failed = CIF_MAX_INLINE_INSNS_AUTO_LIMIT; want_inline = false; } else @@ -890,7 +878,8 @@ want_inline_small_function_p (struct cgr | INLINE_HINT_loop_iterations | INLINE_HINT_loop_stride)); - if (growth <= param_max_inline_insns_size) + if (growth <= opt_for_fn (to->decl, + param_max_inline_insns_size)) ; /* Apply param_max_inline_insns_single limit. Do not do so when hints suggests that inlining given function is very profitable. @@ -902,15 +891,13 @@ want_inline_small_function_p (struct cgr || growth >= inline_insns_single (e->caller, true) || !big_speedup_p (e))) { - if (opt_for_fn (e->caller->decl, optimize) >= 3) - e->inline_failed = CIF_MAX_INLINE_INSNS_SINGLE_LIMIT; - else - e->inline_failed = CIF_MAX_INLINE_INSNS_SINGLE_O2_LIMIT; + e->inline_failed = CIF_MAX_INLINE_INSNS_SINGLE_LIMIT; want_inline = false; } else if (!DECL_DECLARED_INLINE_P (callee->decl) && !opt_for_fn (e->caller->decl, flag_inline_functions) - && growth >= param_max_inline_insns_small) + && growth >= opt_for_fn (to->decl, + param_max_inline_insns_small)) { /* growth_positive_p is expensive, always test it last. */ if (growth >= inline_insns_single (e->caller, false) @@ -951,7 +938,7 @@ want_inline_small_function_p (struct cgr } /* EDGE is self recursive edge. - We hand two cases - when function A is inlining into itself + We handle two cases - when function A is inlining into itself or when function A is being inlined into another inliner copy of function A within function B. @@ -970,10 +957,12 @@ want_inline_self_recursive_call_p (struc char const *reason = NULL; bool want_inline = true; sreal caller_freq = 1; - int max_depth = param_max_inline_recursive_depth_auto; + int max_depth = opt_for_fn (outer_node->decl, + param_max_inline_recursive_depth_auto); if (DECL_DECLARED_INLINE_P (edge->caller->decl)) - max_depth = param_max_inline_recursive_depth; + max_depth = opt_for_fn (outer_node->decl, + param_max_inline_recursive_depth); if (!edge->maybe_hot_p ()) { @@ -1035,7 +1024,8 @@ want_inline_self_recursive_call_p (struc { if (edge->sreal_frequency () * 100 <= caller_freq - * param_min_inline_recursive_probability) + * opt_for_fn (outer_node->decl, + param_min_inline_recursive_probability)) { reason = "frequency of recursive call is too small"; want_inline = false; @@ -1241,7 +1231,9 @@ edge_badness (struct cgraph_edge *edge, /* ... or when early optimizers decided to split and edge frequency still indicates splitting is a win ... */ || (callee->split_part && !caller->split_part - && freq * 100 < param_partial_inlining_entry_probability + && freq * 100 + < opt_for_fn (caller->decl, + param_partial_inlining_entry_probability) /* ... and do not overwrite user specified hints. */ && (!DECL_DECLARED_INLINE_P (edge->callee->decl) || DECL_DECLARED_INLINE_P (caller->decl))))) @@ -1599,7 +1591,10 @@ static bool recursive_inlining (struct cgraph_edge *edge, vec *new_edges) { - int limit = param_max_inline_insns_recursive_auto; + cgraph_node *to = (edge->caller->inlined_to + ? edge->caller->inlined_to : edge->caller); + int limit = opt_for_fn (to->decl, + param_max_inline_insns_recursive_auto); edge_heap_t heap (sreal::min ()); struct cgraph_node *node; struct cgraph_edge *e; @@ -1612,7 +1607,7 @@ recursive_inlining (struct cgraph_edge * node = node->inlined_to; if (DECL_DECLARED_INLINE_P (node->decl)) - limit = param_max_inline_insns_recursive; + limit = opt_for_fn (to->decl, param_max_inline_insns_recursive); /* Make sure that function is small enough to be considered for inlining. */ if (estimate_size_after_inlining (node, edge) >= limit) @@ -1735,14 +1730,14 @@ recursive_inlining (struct cgraph_edge * allow the unit to grow. */ static int -compute_max_insns (int insns) +compute_max_insns (cgraph_node *node, int insns) { int max_insns = insns; - if (max_insns < param_large_unit_insns) - max_insns = param_large_unit_insns; + if (max_insns < opt_for_fn (node->decl, param_large_unit_insns)) + max_insns = opt_for_fn (node->decl, param_large_unit_insns); return ((int64_t) max_insns - * (100 + param_inline_unit_growth) / 100); + * (100 + opt_for_fn (node->decl, param_inline_unit_growth)) / 100); } @@ -1906,7 +1901,7 @@ inline_small_functions (void) struct cgraph_edge *edge; edge_heap_t edge_heap (sreal::min ()); auto_bitmap updated_nodes; - int min_size, max_size; + int min_size; auto_vec new_indirect_edges; int initial_size = 0; struct cgraph_node **order = XCNEWVEC (cgraph_node *, symtab->cgraph_count); @@ -1973,7 +1968,6 @@ inline_small_functions (void) initial_size); overall_size = initial_size; - max_size = compute_max_insns (overall_size); min_size = overall_size; /* Populate the heap with all edges we might inline. */ @@ -2141,7 +2135,9 @@ inline_small_functions (void) edge_badness (edge, true); } - if (overall_size + growth > max_size + where = edge->caller; + + if (overall_size + growth > compute_max_insns (where, min_size) && !DECL_DISREGARD_INLINE_LIMITS (callee->decl)) { edge->inline_failed = CIF_INLINE_UNIT_GROWTH_LIMIT; @@ -2164,7 +2160,6 @@ inline_small_functions (void) specific inliner. */ if (edge->recursive_p ()) { - where = edge->caller; if (where->inlined_to) where = where->inlined_to; if (!recursive_inlining (edge, @@ -2278,7 +2273,6 @@ inline_small_functions (void) if (min_size > overall_size) { min_size = overall_size; - max_size = compute_max_insns (min_size); if (dump_file) fprintf (dump_file, "New minimal size reached: %i\n", min_size); Index: opts.c =================================================================== --- opts.c (revision 278629) +++ opts.c (working copy) @@ -544,6 +544,10 @@ static const struct default_options defa /* -O3 parameters. */ { OPT_LEVELS_3_PLUS, OPT__param_max_inline_insns_auto_, NULL, 30 }, + { OPT_LEVELS_3_PLUS, OPT__param_early_inlining_insns_, NULL, 14 }, + { OPT_LEVELS_3_PLUS, OPT__param_inline_heuristics_hint_percent_, NULL, 600 }, + { OPT_LEVELS_3_PLUS, OPT__param_inline_min_speedup_, NULL, 15 }, + { OPT_LEVELS_3_PLUS, OPT__param_max_inline_insns_single_, NULL, 200 }, /* -Ofast adds optimizations to -O3. */ { OPT_LEVELS_FAST, OPT_ffast_math, NULL, 1 }, Index: params.opt =================================================================== --- params.opt (revision 278629) +++ params.opt (working copy) @@ -99,12 +99,8 @@ Common Joined UInteger Var(param_dse_max Maximum size (in bytes) of objects tracked bytewise by dead store elimination. -param=early-inlining-insns= -Common Joined UInteger Var(param_early_inlining_insns) Init(14) Param -Maximal estimated growth of function body caused by early inlining of single call with -O3 and -Ofast. - --param=early-inlining-insns-O2= -Common Joined UInteger Var(param_early_inlining_insns_o2) Init(6) Param -Maximal estimated growth of function body caused by early inlining of single call with -O1 and -O2. +Common Joined UInteger Var(param_early_inlining_insns) Init(6) Optimization Param +Maximal estimated growth of function body caused by early inlining of single call. -param=fsm-maximum-phi-arguments= Common Joined UInteger Var(param_fsm_maximum_phi_arguments) Init(100) IntegerRange(1, 999999) Param @@ -179,23 +175,15 @@ Common Joined UInteger Var(param_hsa_gen Level of hsa debug stores verbosity. -param=inline-heuristics-hint-percent= -Common Joined UInteger Var(param_inline_heuristics_hint_percent) Init(600) IntegerRange(100, 1000000) Param -The scale (in percents) applied to inline-insns-single and auto limits when heuristics hints that inlining is very profitable with -O3 and -Ofast. - --param=inline-heuristics-hint-percent-O2= -Common Joined UInteger Var(param_inline_heuristics_hint_percent_o2) Init(200) IntegerRange(100, 1000000) Param +Common Joined UInteger Var(param_inline_heuristics_hint_percent) Init(200) Optimization IntegerRange(100, 1000000) Param The scale (in percents) applied to inline-insns-single and auto limits when heuristics hints that inlining is very profitable. -param=inline-min-speedup= -Common Joined UInteger Var(param_inline_min_speedup) Init(15) IntegerRange(0, 100) Param -The minimal estimated speedup allowing inliner to ignore inline-insns-single and inline-insns-auto with -O3 and -Ofast. - --param=inline-min-speedup-O2= -Common Joined UInteger Var(param_inline_min_speedup_o2) Init(30) IntegerRange(0, 100) Param +Common Joined UInteger Var(param_inline_min_speedup) Init(30) Optimization IntegerRange(0, 100) Param The minimal estimated speedup allowing inliner to ignore inline-insns-single and inline-insns-auto. -param=inline-unit-growth= -Common Joined UInteger Var(param_inline_unit_growth) Init(40) Param +Common Joined UInteger Var(param_inline_unit_growth) Init(40) Optimization Param How much can given compilation unit grow because of the inlining (in percent). -param=integer-share-limit= @@ -295,23 +283,23 @@ Common Joined UInteger Var(param_l2_cach The size of L2 cache. -param=large-function-growth= -Common Joined UInteger Var(param_large_function_growth) Init(100) Param +Common Joined UInteger Var(param_large_function_growth) Optimization Init(100) Param Maximal growth due to inlining of large function (in percent). -param=large-function-insns= -Common Joined UInteger Var(param_large_function_insns) Init(2700) Param +Common Joined UInteger Var(param_large_function_insns) Optimization Init(2700) Param The size of function body to be considered large. -param=large-stack-frame= -Common Joined UInteger Var(param_large_stack_frame) Init(256) Param +Common Joined UInteger Var(param_large_stack_frame) Init(256) Optimization Param The size of stack frame to be considered large. -param=large-stack-frame-growth= -Common Joined UInteger Var(param_stack_frame_growth) Init(1000) Param +Common Joined UInteger Var(param_stack_frame_growth) Optimization Init(1000) Param Maximal stack frame growth due to inlining (in percent). -param=large-unit-insns= -Common Joined UInteger Var(param_large_unit_insns) Init(10000) Param +Common Joined UInteger Var(param_large_unit_insns) Optimization Init(10000) Param The size of translation unit to be considered large. -param=lim-expensive= @@ -471,35 +459,31 @@ Common Joined UInteger Var(param_max_inl The maximum number of instructions when automatically inlining. -param=max-inline-insns-recursive= -Common Joined UInteger Var(param_max_inline_insns_recursive) Init(450) Param +Common Joined UInteger Var(param_max_inline_insns_recursive) Optimization Init(450) Param The maximum number of instructions inline function can grow to via recursive inlining. -param=max-inline-insns-recursive-auto= -Common Joined UInteger Var(param_max_inline_insns_recursive_auto) Init(450) Param +Common Joined UInteger Var(param_max_inline_insns_recursive_auto) Optimization Init(450) Param The maximum number of instructions non-inline function can grow to via recursive inlining. -param=max-inline-insns-single= -Common Joined UInteger Var(param_max_inline_insns_single) Init(200) Param -The maximum number of instructions in a single function eligible for inlining with -O3 and -Ofast. - --param=max-inline-insns-single-O2= -Common Joined UInteger Var(param_max_inline_insns_single_o2) Init(70) Param +Common Joined UInteger Var(param_max_inline_insns_single) Optimization Init(70) Param The maximum number of instructions in a single function eligible for inlining. -param=max-inline-insns-size= -Common Joined UInteger Var(param_max_inline_insns_size) Param +Common Joined UInteger Var(param_max_inline_insns_size) Optimization Param The maximum number of instructions when inlining for size. -param=max-inline-insns-small= -Common Joined UInteger Var(param_max_inline_insns_small) Param +Common Joined UInteger Var(param_max_inline_insns_small) Optimization Param The maximum number of instructions when automatically inlining small functions. -param=max-inline-recursive-depth= -Common Joined UInteger Var(param_max_inline_recursive_depth) Init(8) Param +Common Joined UInteger Var(param_max_inline_recursive_depth) Optimization Init(8) Param The maximum depth of recursive inlining for inline functions. -param=max-inline-recursive-depth-auto= -Common Joined UInteger Var(param_max_inline_recursive_depth_auto) Init(8) Param +Common Joined UInteger Var(param_max_inline_recursive_depth_auto) Optimization Init(8) Param The maximum depth of recursive inlining for non-inline functions. -param=max-isl-operations= @@ -679,7 +663,7 @@ Common Joined UInteger Var(param_min_cro The minimum number of matching instructions to consider for crossjumping. -param=min-inline-recursive-probability= -Common Joined UInteger Var(param_min_inline_recursive_probability) Init(10) Param +Common Joined UInteger Var(param_min_inline_recursive_probability) Init(10) Optimization Param Inline recursively only when the probability of call being executed exceeds the parameter. -param=min-insn-to-prefetch-ratio= @@ -737,7 +721,7 @@ EnumValue Enum(parloops_schedule_type) String(runtime) Value(PARLOOPS_SCHEDULE_RUNTIME) -param=partial-inlining-entry-probability= -Common Joined UInteger Var(param_partial_inlining_entry_probability) Init(70) IntegerRange(0, 100) Param +Common Joined UInteger Var(param_partial_inlining_entry_probability) Init(70) Optimization IntegerRange(0, 100) Param Maximum probability of the entry BB of split region (in percent relative to entry BB of the function) to make partial inlining happen. -param=predictable-branch-outcome= @@ -913,19 +897,19 @@ Common Joined UInteger Var(param_uninit_ Maximum number of nested calls to search for control dependencies during uninitialized variable analysis. -param=uninlined-function-insns= -Common Joined UInteger Var(param_uninlined_function_insns) Init(2) IntegerRange(0, 1000000) Param +Common Joined UInteger Var(param_uninlined_function_insns) Init(2) Optimization IntegerRange(0, 1000000) Param Instruction accounted for function prologue, epilogue and other overhead. -param=uninlined-function-time= -Common Joined UInteger Var(param_uninlined_function_time) IntegerRange(0, 1000000) Param +Common Joined UInteger Var(param_uninlined_function_time) Optimization IntegerRange(0, 1000000) Param Time accounted for function prologue, epilogue and other overhead. -param=uninlined-thunk-insns= -Common Joined UInteger Var(param_uninlined_function_thunk_insns) Init(2) IntegerRange(0, 1000000) Param +Common Joined UInteger Var(param_uninlined_function_thunk_insns) Optimization Init(2) IntegerRange(0, 1000000) Param Instruction accounted for function thunk overhead. -param=uninlined-thunk-time= -Common Joined UInteger Var(param_uninlined_function_thunk_time) Init(2) IntegerRange(0, 1000000) Param +Common Joined UInteger Var(param_uninlined_function_thunk_time) Optimization Init(2) IntegerRange(0, 1000000) Param Time accounted for function thunk overhead. -param=unlikely-bb-count-fraction= Index: testsuite/g++.dg/tree-ssa/pr53844.C =================================================================== --- testsuite/g++.dg/tree-ssa/pr53844.C (revision 278629) +++ testsuite/g++.dg/tree-ssa/pr53844.C (working copy) @@ -1,5 +1,5 @@ // { dg-do compile } -// { dg-options "-O2 -fdump-tree-optimized-vops -fno-inline-functions --param max-inline-insns-single-O2=200" } +// { dg-options "-O2 -fdump-tree-optimized-vops -fno-inline-functions --param max-inline-insns-single=200" } struct VBase; Index: testsuite/g++.dg/tree-ssa/pr61034.C =================================================================== --- testsuite/g++.dg/tree-ssa/pr61034.C (revision 278629) +++ testsuite/g++.dg/tree-ssa/pr61034.C (working copy) @@ -1,5 +1,5 @@ // { dg-do compile } -// { dg-options "-O2 -fdump-tree-fre3 -fdump-tree-optimized -fdelete-null-pointer-checks --param early-inlining-insns-O2=14 --param max-inline-insns-single-O2=200" } +// { dg-options "-O2 -fdump-tree-fre3 -fdump-tree-optimized -fdelete-null-pointer-checks --param early-inlining-insns=14 --param max-inline-insns-single=200" } #define assume(x) if(!(x))__builtin_unreachable() Index: testsuite/g++.dg/tree-ssa/pr8781.C =================================================================== --- testsuite/g++.dg/tree-ssa/pr8781.C (revision 278629) +++ testsuite/g++.dg/tree-ssa/pr8781.C (working copy) @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-O -fno-tree-sra -fdump-tree-fre1 --param early-inlining-insns-O2=14" } */ +/* { dg-options "-O -fno-tree-sra -fdump-tree-fre1 --param early-inlining-insns=14" } */ int f(); Index: testsuite/g++.dg/warn/Wstringop-truncation-1.C =================================================================== --- testsuite/g++.dg/warn/Wstringop-truncation-1.C (revision 278629) +++ testsuite/g++.dg/warn/Wstringop-truncation-1.C (working copy) @@ -1,7 +1,7 @@ /* PR/tree-optimization/84480 - bogus -Wstringop-truncation despite assignment with an inlined string literal { dg-do compile } - { dg-options "-O2 -Wstringop-truncation --param early-inlining-insns-O2=14" } */ + { dg-options "-O2 -Wstringop-truncation --param early-inlining-insns=14" } */ #include Index: testsuite/gcc.dg/ipa/pr63416.c =================================================================== --- testsuite/gcc.dg/ipa/pr63416.c (revision 278629) +++ testsuite/gcc.dg/ipa/pr63416.c (working copy) @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-O2 -fdump-tree-optimized --param early-inlining-insns-O2=14" } */ +/* { dg-options "-O2 -fdump-tree-optimized --param early-inlining-insns=14" } */ #define _UNUSED_ __attribute__((__unused__)) typedef int TEST_F30 (int *v); Index: testsuite/gcc.dg/tree-ssa/ssa-thread-12.c =================================================================== --- testsuite/gcc.dg/tree-ssa/ssa-thread-12.c (revision 278629) +++ testsuite/gcc.dg/tree-ssa/ssa-thread-12.c (working copy) @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-O2 -fdump-tree-thread2-details -fdump-tree-thread3-details -fdump-tree-thread4-details -fno-finite-loops --param early-inlining-insns-O2=14 -fno-inline-functions" } */ +/* { dg-options "-O2 -fdump-tree-thread2-details -fdump-tree-thread3-details -fdump-tree-thread4-details -fno-finite-loops --param early-inlining-insns=14 -fno-inline-functions" } */ /* { dg-final { scan-tree-dump "FSM" "thread2" } } */ /* { dg-final { scan-tree-dump "FSM" "thread3" } } */ /* { dg-final { scan-tree-dump "FSM" "thread4" { xfail *-*-* } } } */ Index: testsuite/gcc.dg/vect/pr66142.c =================================================================== --- testsuite/gcc.dg/vect/pr66142.c (revision 278629) +++ testsuite/gcc.dg/vect/pr66142.c (working copy) @@ -1,6 +1,6 @@ /* PR middle-end/66142 */ /* { dg-do compile } */ -/* { dg-additional-options "-ffast-math -fopenmp-simd --param early-inlining-insns-O2=14" } */ +/* { dg-additional-options "-ffast-math -fopenmp-simd --param early-inlining-insns=14" } */ /* { dg-additional-options "-mavx" { target avx_runtime } } */ struct A { float x, y; }; Index: testsuite/gcc.dg/winline-3.c =================================================================== --- testsuite/gcc.dg/winline-3.c (revision 278629) +++ testsuite/gcc.dg/winline-3.c (working copy) @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-Winline -O2 --param max-inline-insns-single-O2=1 --param inline-min-speedup-O2=100 -fgnu89-inline" } */ +/* { dg-options "-Winline -O2 --param max-inline-insns-single=1 --param inline-min-speedup=100 -fgnu89-inline" } */ void big (void); inline int q(void) /* { dg-warning "max-inline-insns-single" } */ Index: testsuite/gcc.target/powerpc/pr72804.c =================================================================== --- testsuite/gcc.target/powerpc/pr72804.c (revision 278629) +++ testsuite/gcc.target/powerpc/pr72804.c (working copy) @@ -1,7 +1,7 @@ /* { dg-do compile { target { lp64 } } } */ /* { dg-skip-if "" { powerpc*-*-darwin* } } */ /* { dg-require-effective-target powerpc_vsx_ok } */ -/* { dg-options "-O2 -mvsx -fno-inline-functions --param max-inline-insns-single-O2=200" } */ +/* { dg-options "-O2 -mvsx -fno-inline-functions --param max-inline-insns-single=200" } */ __int128_t foo (__int128_t *src)