/* params.def - Run-time parameters.
- Copyright (C) 2001-2018 Free Software Foundation, Inc.
+ Copyright (C) 2001-2019 Free Software Foundation, Inc.
Written by Mark Mitchell <mark@codesourcery.com>.
This file is part of GCC.
DEFPARAM (PARAM_INLINE_MIN_SPEEDUP,
"inline-min-speedup",
+ "The minimal estimated speedup allowing inliner to ignore inline-insns-single and inline-insns-auto with -O3 and -Ofast.",
+ 15, 0, 100)
+
+DEFPARAM (PARAM_INLINE_MIN_SPEEDUP_O2,
+ "inline-min-speedup-O2",
"The minimal estimated speedup allowing inliner to ignore inline-insns-single and inline-insns-auto.",
- 15, 0, 0)
+ 30, 0, 100)
/* The single function inlining limit. This is the maximum size
of a function counted in internal gcc instructions (not in
real machine instructions) that is eligible for inlining
by the tree inliner.
- The default value is 400.
Only functions marked inline (or methods defined in the class
definition for C++) are affected by this.
There are more restrictions to inlining: If inlined functions
gets decreased. */
DEFPARAM (PARAM_MAX_INLINE_INSNS_SINGLE,
"max-inline-insns-single",
+ "The maximum number of instructions in a single function eligible for inlining with -O3 and -Ofast.",
+ 200, 0, 0)
+
+DEFPARAM (PARAM_MAX_INLINE_INSNS_SINGLE_O2,
+ "max-inline-insns-single-O2",
"The maximum number of instructions in a single function eligible for inlining.",
- 400, 0, 0)
+ 30, 0, 0)
/* The single function inlining limit for functions that are
inlined by virtue of -finline-functions (-O3).
The default value is 30. */
DEFPARAM (PARAM_MAX_INLINE_INSNS_AUTO,
"max-inline-insns-auto",
- "The maximum number of instructions when automatically inlining.",
+ "The maximum number of instructions when automatically inlining with -O3 and -Ofast.",
30, 0, 0)
+DEFPARAM (PARAM_MAX_INLINE_INSNS_AUTO_O2,
+ "max-inline-insns-auto-O2",
+ "The maximum number of instructions when automatically inlining.",
+ 15, 0, 0)
+
+DEFPARAM (PARAM_MAX_INLINE_INSNS_SMALL,
+ "max-inline-insns-small",
+ "The maximum number of instructions when automatically inlining small functions.",
+ 0, 0, 0)
+
+DEFPARAM (PARAM_INLINE_HEURISTICS_HINT_PERCENT,
+ "inline-heuristics-hint-percent",
+ "The scale (in percents) applied to inline-insns-single and auto limits when heuristics hints that inlining is very profitable with -O3 and -Ofast.",
+ 1600, 100, 1000000)
+
+DEFPARAM (PARAM_INLINE_HEURISTICS_HINT_PERCENT_O2,
+ "inline-heuristics-hint-percent-O2",
+ "The scale (in percents) applied to inline-insns-single and auto limits when heuristics hints that inlining is very profitable.",
+ 200, 100, 1000000)
+
+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, 1000000)
+
+DEFPARAM (PARAM_UNINLINED_FUNCTION_TIME,
+ "uninlined-function-time",
+ "Time accounted for function prologue, epilogue and other"
+ " overhead.",
+ 0, 0, 1000000)
+
+DEFPARAM (PARAM_UNINLINED_FUNCTION_THUNK_INSNS,
+ "uninlined-thunk-insns",
+ "Instruction accounted for function thunk overhead.",
+ 2, 0, 1000000)
+
+DEFPARAM (PARAM_UNINLINED_FUNCTION_THUNK_TIME,
+ "uninlined-thunk-time",
+ "Time accounted for function thunk overhead.",
+ 2, 0, 1000000)
+
DEFPARAM (PARAM_MAX_INLINE_INSNS_RECURSIVE,
"max-inline-insns-recursive",
"The maximum number of instructions inline function can grow to via recursive inlining.",
DEFPARAM(PARAM_INLINE_UNIT_GROWTH,
"inline-unit-growth",
"How much can given compilation unit grow because of the inlining (in percent).",
- 20, 0, 0)
+ 40, 0, 0)
DEFPARAM(PARAM_IPCP_UNIT_GROWTH,
"ipcp-unit-growth",
"How much can given compilation unit grow because of the interprocedural constant propagation (in percent).",
10, 0, 0)
DEFPARAM(PARAM_EARLY_INLINING_INSNS,
"early-inlining-insns",
- "Maximal estimated growth of function body caused by early inlining of single call.",
+ "Maximal estimated growth of function body caused by early inlining of single call with -O3 and -Ofast.",
14, 0, 0)
+DEFPARAM(PARAM_EARLY_INLINING_INSNS_O2,
+ "early-inlining-insns-O2",
+ "Maximal estimated growth of function body caused by early inlining of single call with -O1 and -O2.",
+ 6, 0, 0)
DEFPARAM(PARAM_LARGE_STACK_FRAME,
"large-stack-frame",
"The size of stack frame to be considered large.",
"Maximal stack frame growth due to inlining (in percent).",
1000, 0, 0)
+/* Keep these up to date with those in configure.ac. */
DEFPARAM(PARAM_STACK_CLASH_PROTECTION_GUARD_SIZE,
"stack-clash-protection-guard-size",
- "Size of the stack guard expressed as a power of two.",
+ "Size of the stack guard expressed as a power of two in bytes.",
12, 12, 30)
DEFPARAM(PARAM_STACK_CLASH_PROTECTION_PROBE_INTERVAL,
"stack-clash-protection-probe-interval",
- "Interval in which to probe the stack expressed as a power of two.",
+ "Interval in which to probe the stack expressed as a power of two in bytes.",
12, 10, 16)
/* The GCSE optimization will be disabled if it would require
"A threshold on the average loop count considered by the swing modulo scheduler.",
0, 0, 0)
+DEFPARAM(HOT_BB_COUNT_FRACTION,
+ "hot-bb-count-fraction",
+ "The denominator n of fraction 1/n of the maximal execution count of "
+ "a basic block in the entire program that a basic block needs to at "
+ "least have in order to be considered hot (used in non-LTO mode).",
+ 10000, 0, 0)
+
DEFPARAM(HOT_BB_COUNT_WS_PERMILLE,
"hot-bb-count-ws-permille",
- "A basic block profile count is considered hot if it contributes to "
- "the given permillage of the entire profiled execution.",
- 999, 0, 1000)
+ "The number of most executed permilles of the profiled execution of "
+ "the entire program to which the execution count of a basic block "
+ "must be part of in order to be considered hot (used in LTO mode).",
+ 990, 0, 1000)
+
DEFPARAM(HOT_BB_FREQUENCY_FRACTION,
"hot-bb-frequency-fraction",
- "Select fraction of the maximal frequency of executions of basic block in function given basic block needs to have to be considered hot.",
+ "The denominator n of fraction 1/n of the execution frequency of the "
+ "entry block of a function that a basic block of this function needs "
+ "to at least have in order to be considered hot.",
1000, 0, 0)
DEFPARAM(UNLIKELY_BB_COUNT_FRACTION,
"unlikely-bb-count-fraction",
- "The minimum fraction of profile runs a given basic block execution count must be not to be considered unlikely.",
- 20, 1, 10000)
+ "The denominator n of fraction 1/n of the number of profiled runs of "
+ "the entire program below which the execution count of a basic block "
+ "must be in order for the basic block to be considered unlikely.",
+ 20, 0, 0)
DEFPARAM (PARAM_ALIGN_THRESHOLD,
"align-threshold",
DEFPARAM (PARAM_ALIGN_LOOP_ITERATIONS,
"align-loop-iterations",
- "Loops iterating at least selected number of iterations will get loop alignment..",
- 4, 0, 0)
+ "Loops iterating at least selected number of iterations will get "
+ "loop alignment.", 4, 0, 0)
/* For guessed profiles, the loops having unknown number of iterations
are predicted to iterate relatively few (10) times at average.
DEFPARAM (PARAM_LOOP_INTERCHANGE_STRIDE_RATIO,
"loop-interchange-stride-ratio",
- "The minimum stride ratio for loop interchange to be profitable",
+ "The minimum stride ratio for loop interchange to be profitable.",
2, 0, 0)
/* Whether we should use canonical types rather than deep "structural"
"Maximum length of partial antic set when performing tree pre optimization.",
100, 0, 0)
-/* The following is used as a stop-gap limit for cases where really huge
- SCCs blow up memory and compile-time use too much. If we hit this limit,
- SCCVN and such FRE and PRE will be not done at all for the current
- function. */
+/* The following is used as a stop-gap limit for cases where really deep
+ loop nests cause compile-time to blow up. If we hit this limit,
+ FRE and PRE will value-number outer loops (but the outermost) in a
+ loop nest non-optimistically. */
-DEFPARAM (PARAM_SCCVN_MAX_SCC_SIZE,
- "sccvn-max-scc-size",
- "Maximum size of a SCC before SCCVN stops processing a function.",
- 10000, 10, 0)
+DEFPARAM (PARAM_RPO_VN_MAX_LOOP_DEPTH,
+ "rpo-vn-max-loop-depth",
+ "Maximum depth of a loop nest to fully value-number optimistically.",
+ 7, 2, 0)
/* The following is used as a stop-gap limit for cases where really huge
functions blow up compile-time use too much. It limits the number of
DEFPARAM (PARAM_LOOP_BLOCK_TILE_SIZE,
"loop-block-tile-size",
- "size of tiles for loop blocking.",
+ "Size of tiles for loop blocking.",
51, 0, 0)
/* Maximal number of parameters that we allow in a SCoP. */
DEFPARAM (PARAM_GRAPHITE_MAX_NB_SCOP_PARAMS,
"graphite-max-nb-scop-params",
- "maximum number of parameters in a SCoP.",
+ "Maximum number of parameters in a SCoP.",
10, 0, 0)
/* Maximal number of array references in a scop. */
DEFPARAM (PARAM_GRAPHITE_MAX_ARRAYS_PER_SCOP,
"graphite-max-arrays-per-scop",
- "maximum number of arrays per scop.",
+ "Maximum number of arrays per SCoP.",
100, 0, 0)
DEFPARAM (PARAM_MAX_ISL_OPERATIONS,
"max-isl-operations",
- "maximum number of isl operations, 0 means unlimited",
+ "Maximum number of isl operations, 0 means unlimited.",
350000, 0, 0)
/* For testsuite purposes allow to check for codegen error handling. */
DEFPARAM (PARAM_GRAPHITE_ALLOW_CODEGEN_ERRORS,
"graphite-allow-codegen-errors",
- "whether codegen errors should be ICEs when -fchecking.",
+ "Whether codegen errors should be ICEs when -fchecking.",
0, 0, 1)
/* Avoid data dependence analysis on very large loops. */
to look up for profile data. Otherwise, use a more stable
external id based on assembler name and source location. */
DEFPARAM (PARAM_PROFILE_FUNC_INTERNAL_ID,
- "profile-func-internal-id",
- "use internal function id in profile lookup.",
- 0, 0, 1)
-
-/* When the parameter is 1, track the most frequent N target
- addresses in indirect-call profile. This disables
- indirect_call_profiler_v2 which tracks single target. */
-DEFPARAM (PARAM_INDIR_CALL_TOPN_PROFILE,
- "indir-call-topn-profile",
- "track topn target addresses in indirect-call profile.",
- 0, 0, 1)
+ "profile-func-internal-id",
+ "Use internal function id in profile lookup.",
+ 0, 0, 1)
/* Avoid SLP vectorization of large basic blocks. */
DEFPARAM (PARAM_SLP_MAX_INSNS_IN_BB,
- "slp-max-insns-in-bb",
- "Maximum number of instructions in basic block to be considered for SLP vectorization.",
- 1000, 0, 0)
+ "slp-max-insns-in-bb",
+ "Maximum number of instructions in basic block to be considered for "
+ "SLP vectorization.", 1000, 0, 0)
DEFPARAM (PARAM_MIN_INSN_TO_PREFETCH_RATIO,
"min-insn-to-prefetch-ratio",
"that ipa-sra replaces a pointer to an aggregate with.",
2, 0, 0)
+DEFPARAM (PARAM_IPA_SRA_MAX_REPLACEMENTS,
+ "ipa-sra-max-replacements",
+ "Maximum pieces that IPA-SRA tracks per formal parameter, as "
+ "a consequence, also the maximum number of replacements of a formal "
+ "parameter.",
+ 8, 0, 16)
+
DEFPARAM (PARAM_TM_MAX_AGGREGATE_SIZE,
"tm-max-aggregate-size",
"Size in bytes after which thread-local aggregates should be "
DEFPARAM (PARAM_IPA_CP_EVAL_THRESHOLD,
"ipa-cp-eval-threshold",
"Threshold ipa-cp opportunity evaluation that is still considered "
- "beneficial to clone..",
+ "beneficial to clone.",
500, 0, 0)
DEFPARAM (PARAM_IPA_CP_RECURSION_PENALTY,
"ipa-cp-recursion-penalty",
"Percentage penalty the recursive functions will receive when they "
- "are evaluated for cloning..",
+ "are evaluated for cloning.",
40, 0, 100)
DEFPARAM (PARAM_IPA_CP_SINGLE_CALL_PENALTY,
"ipa-cp-single-call-penalty",
"Percentage penalty functions containing a single call to another "
- "function will receive when they are evaluated for cloning..",
+ "function will receive when they are evaluated for cloning.",
15, 0, 100)
DEFPARAM (PARAM_IPA_MAX_AGG_ITEMS,
DEFPARAM (PARAM_IPA_CP_LOOP_HINT_BONUS,
"ipa-cp-loop-hint-bonus",
"Compile-time bonus IPA-CP assigns to candidates which make loop "
- "bounds or strides known..",
+ "bounds or strides known.",
64, 0, 0)
-DEFPARAM (PARAM_IPA_CP_ARRAY_INDEX_HINT_BONUS,
- "ipa-cp-array-index-hint-bonus",
- "Compile-time bonus IPA-CP assigns to candidates which make an array "
- "index known..",
- 48, 0, 0)
-
DEFPARAM (PARAM_IPA_MAX_AA_STEPS,
"ipa-max-aa-steps",
"Maximum number of statements that will be visited by IPA formal "
"parameter analysis based on alias analysis in any given function.",
25000, 0, 0)
+DEFPARAM (PARAM_IPA_MAX_SWITCH_PREDICATE_BOUNDS,
+ "ipa-max-switch-predicate-bounds",
+ "Maximal number of boundary endpoints of case ranges of switch "
+ "statement used during IPA functoin summary generation.",
+ 5, 0, 0)
+
+DEFPARAM (PARAM_IPA_MAX_PARAM_EXPR_OPS,
+ "ipa-max-param-expr-ops",
+ "Maximum number of operations in a parameter expression that can "
+ "be handled by IPA analysis.",
+ 10, 0, 0)
+
/* WHOPR partitioning configuration. */
DEFPARAM (PARAM_LTO_PARTITIONS,
"lto-partitions",
"Number of partitions the program should be split to.",
- 32, 1, 0)
+ 128, 1, 0)
DEFPARAM (MIN_PARTITION_SIZE,
"lto-min-partition",
"Maximal size of a partition for LTO (in estimated instructions).",
1000000, 0, INT_MAX)
+DEFPARAM (PARAM_MAX_LTO_STREAMING_PARALLELISM,
+ "lto-max-streaming-parallelism",
+ "maximal number of LTO partitions streamed in parallel.",
+ 32, 1, 0)
+
/* Diagnostic parameters. */
DEFPARAM (CXX_MAX_NAMESPACES_FOR_DIAGNOSTIC_HELP,
"if 0, use the default for the machine.",
0, 0, 0)
-/* Data race flags for C++0x memory model compliance. */
-DEFPARAM (PARAM_ALLOW_STORE_DATA_RACES,
- "allow-store-data-races",
- "Allow new data races on stores to be introduced.",
- 0, 0, 1)
+DEFPARAM (PARAM_JUMP_TABLE_MAX_GROWTH_RATIO_FOR_SIZE,
+ "jump-table-max-growth-ratio-for-size",
+ "The maximum code size growth ratio when expanding "
+ "into a jump table (in percent). The parameter is used when "
+ "optimizing for size.",
+ 300, 0, 0)
+
+DEFPARAM (PARAM_JUMP_TABLE_MAX_GROWTH_RATIO_FOR_SPEED,
+ "jump-table-max-growth-ratio-for-speed",
+ "The maximum code size growth ratio when expanding "
+ "into a jump table (in percent). The parameter is used when "
+ "optimizing for speed.",
+ 800, 0, 0)
/* Reassociation width to be used by tree reassoc optimization. */
DEFPARAM (PARAM_TREE_REASSOC_WIDTH,
"tree-reassoc-width",
"Set the maximum number of instructions executed in parallel in "
- "reassociated tree. If 0, use the target dependent heuristic..",
+ "reassociated tree. If 0, use the target dependent heuristic.",
0, 0, 0)
DEFPARAM (PARAM_MAX_TAIL_MERGE_COMPARISONS,
"store merging pass.",
64, 2, 0)
+DEFPARAM (PARAM_STORE_MERGING_MAX_SIZE,
+ "store-merging-max-size",
+ "Maximum size of a single store merging region in bytes.",
+ 65536, 1, 1)
+
DEFPARAM (PARAM_MAX_TAIL_MERGE_ITERATIONS,
"max-tail-merge-iterations",
"Maximum amount of iterations of the pass over a function.",
DEFPARAM (PARAM_HSA_GEN_DEBUG_STORES,
"hsa-gen-debug-stores",
- "Level of hsa debug stores verbosity",
+ "Level of hsa debug stores verbosity.",
0, 0, 1)
DEFPARAM (PARAM_MAX_SPECULATIVE_DEVIRT_MAYDEFS,
"max-speculative-devirt-maydefs",
"Maximum number of may-defs visited when devirtualizing "
- "speculatively", 50, 0, 0)
+ "speculatively.", 50, 0, 0)
DEFPARAM (PARAM_MAX_VRP_SWITCH_ASSERTIONS,
"max-vrp-switch-assertions",
"Maximum number of assertions to add along the default "
- "edge of a switch statement during VRP",
+ "edge of a switch statement during VRP.",
10, 0, 0)
DEFPARAM (PARAM_VECT_EPILOGUES_NOMASK,
"Maximum number of bits for which we avoid creating FMAs.",
0, 0, 512)
+DEFPARAM(PARAM_LOGICAL_OP_NON_SHORT_CIRCUIT,
+ "logical-op-non-short-circuit",
+ "True if a non-short-circuit operation is optimal.",
+ -1, -1, 1)
+
+DEFPARAM(PARAM_LOOP_VERSIONING_MAX_INNER_INSNS,
+ "loop-versioning-max-inner-insns",
+ "The maximum number of instructions in an inner loop that is being"
+ " considered for versioning.",
+ 200, 0, 0)
+
+DEFPARAM(PARAM_LOOP_VERSIONING_MAX_OUTER_INSNS,
+ "loop-versioning-max-outer-insns",
+ "The maximum number of instructions in an outer loop that is being"
+ " considered for versioning, on top of the instructions in inner"
+ " loops.",
+ 100, 0, 0)
+
+DEFPARAM(PARAM_GIMPLE_FE_COMPUTED_HOT_BB_THRESHOLD,
+ "gimple-fe-computed-hot-bb-threshold",
+ "The number of executions of a basic block which is considered hot."
+ " The parameter is used only in GIMPLE FE.",
+ 0, 0, 0)
+
+DEFPARAM(PARAM_HASH_TABLE_VERIFICATION_LIMIT,
+ "hash-table-verification-limit",
+ "The number of elements for which hash table verification is done for "
+ "each searched element.",
+ 10, 0, 0)
+
+DEFPARAM(PARAM_SSA_NAME_DEF_CHAIN_LIMIT,
+ "ssa-name-def-chain-limit",
+ "The maximum number of SSA_NAME assignments to follow in determining "
+ "a value.",
+ 512, 0, 0)
+
/*
Local variables:
projects / thirdparty / gcc.git / blobdiff