/* params.def - Run-time parameters.
- Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
- Free Software Foundation, Inc.
+ Copyright (C) 2001-2015 Free Software Foundation, Inc.
Written by Mark Mitchell <mark@codesourcery.com>.
This file is part of GCC.
- The enumeral corresponding to this parameter.
- - The name that can be used to set this parameter using the
+ - The name that can be used to set this parameter using the
command-line option `--param <name>=<value>'.
- A help string explaining how the parameter is used.
Be sure to add an entry to invoke.texi summarizing the parameter. */
-/* The threshold ratio between current and hottest structure counts.
- We say that if the ratio of the current structure count,
- calculated by profiling, to the hottest structure count
- in the program is less than this parameter, then structure
- reorganization is not applied. The default is 10%. */
-DEFPARAM (PARAM_STRUCT_REORG_COLD_STRUCT_RATIO,
- "struct-reorg-cold-struct-ratio",
- "The threshold ratio between current and hottest structure counts",
- 10, 0, 100)
-
/* When branch is predicted to be taken with probability lower than this
threshold (in percent), then it is considered well predictable. */
DEFPARAM (PARAM_PREDICTABLE_BRANCH_OUTCOME,
"predictable-branch-outcome",
- "Maximal esitmated outcome of branch considered predictable",
+ "Maximal estimated outcome of branch considered predictable",
2, 0, 50)
+DEFPARAM (PARAM_INLINE_MIN_SPEEDUP,
+ "inline-min-speedup",
+ "The minimal estimated speedup allowing inliner to ignore inline-insns-single and inline-isnsns-auto",
+ 10, 0, 0)
+
/* 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
definition for C++) are affected by this.
There are more restrictions to inlining: If inlined functions
call other functions, the already inlined instructions are
- counted and once the recursive inline limit (see
+ counted and once the recursive inline limit (see
"max-inline-insns" parameter) is exceeded, the acceptable size
gets decreased. */
DEFPARAM (PARAM_MAX_INLINE_INSNS_SINGLE,
that is applied to functions marked inlined (or defined in the
class declaration in C++) given by the "max-inline-insns-single"
parameter.
- The default value is 90. */
+ The default value is 40. */
DEFPARAM (PARAM_MAX_INLINE_INSNS_AUTO,
"max-inline-insns-auto",
"The maximum number of instructions when automatically inlining",
- 50, 0, 0)
+ 40, 0, 0)
DEFPARAM (PARAM_MAX_INLINE_INSNS_RECURSIVE,
"max-inline-insns-recursive",
DEFPARAM (PARAM_EARLY_INLINER_MAX_ITERATIONS,
"max-early-inliner-iterations",
"The maximum number of nested indirect inlining performed by early inliner",
- 10, 0, 0)
+ 1, 0, 0)
+
+/* Limit on probability of entry BB. */
+DEFPARAM (PARAM_COMDAT_SHARING_PROBABILITY,
+ "comdat-sharing-probability",
+ "Probability that COMDAT function will be shared with different compilation unit",
+ 20, 0, 0)
+
+/* Limit on probability of entry BB. */
+DEFPARAM (PARAM_PARTIAL_INLINING_ENTRY_PROBABILITY,
+ "partial-inlining-entry-probability",
+ "Maximum probability of the entry BB of split region (in percent relative to entry BB of the function) to make partial inlining happen",
+ 70, 0, 0)
/* Limit the number of expansions created by the variable expansion
optimization to avoid register pressure. */
"max-variable-expansions-in-unroller",
"If -fvariable-expansion-in-unroller is used, the maximum number of times that an individual variable will be expanded during loop unrolling",
1, 0, 0)
-
+
/* Limit loop autovectorization to loops with large enough iteration count. */
DEFPARAM (PARAM_MIN_VECT_LOOP_BOUND,
"min-vect-loop-bound",
"The maximum number of instructions to consider to find accurate live register information",
333, 0, 0)
-/* This parameter limits the number of branch elements that the
+/* This parameter limits the number of branch elements that the
scheduler will track anti-dependencies through without resetting
- the tracking mechanism. Large functions with few calls or barriers
- can generate lists containing many 1000's of dependencies. Generally
+ the tracking mechanism. Large functions with few calls or barriers
+ can generate lists containing many 1000's of dependencies. Generally
the compiler either uses all available memory, or runs for far too long. */
DEFPARAM(PARAM_MAX_PENDING_LIST_LENGTH,
"max-pending-list-length",
"The maximum length of scheduling's pending operations list",
32, 0, 0)
+/* This parameter limits the number of backtracking attempts when using the
+ haifa scheduler for modulo scheduling. */
+DEFPARAM(PARAM_MAX_MODULO_BACKTRACK_ATTEMPTS,
+ "max-modulo-backtrack-attempts",
+ "The maximum number of backtrack attempts the scheduler should make when modulo scheduling a loop",
+ 40, 0, 0)
+
DEFPARAM(PARAM_LARGE_FUNCTION_INSNS,
"large-function-insns",
"The size of function body to be considered large",
DEFPARAM(PARAM_INLINE_UNIT_GROWTH,
"inline-unit-growth",
"How much can given compilation unit grow because of the inlining (in percent)",
- 30, 0, 0)
+ 20, 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)",
DEFPARAM(PARAM_EARLY_INLINING_INSNS,
"early-inlining-insns",
"Maximal estimated growth of function body caused by early inlining of single call",
- 8, 0, 0)
+ 14, 0, 0)
DEFPARAM(PARAM_LARGE_STACK_FRAME,
"large-stack-frame",
"The size of stack frame to be considered large",
"The maximum amount of memory to be allocated by GCSE",
50 * 1024 * 1024, 0, 0)
+/* The GCSE optimization of an expression will avoided if the ratio of
+ insertions to deletions is greater than this value. */
+DEFPARAM(PARAM_MAX_GCSE_INSERTION_RATIO,
+ "max-gcse-insertion-ratio",
+ "The maximum ratio of insertions to deletions of expressions in GCSE",
+ 20, 0, 0)
+
/* This is the threshold ratio when to perform partial redundancy
elimination after reload. We perform partial redundancy elimination
when the following holds:
"gcse-after-reload-critical-fraction",
"The threshold ratio of critical edges execution count that permit performing redundancy elimination after reload",
10, 0, 0)
+
+/* GCSE will use GCSE_COST_DISTANCE_RATION as a scaling factor
+ to calculate maximum distance for which an expression is allowed to move
+ from its rtx_cost. */
+DEFPARAM(PARAM_GCSE_COST_DISTANCE_RATIO,
+ "gcse-cost-distance-ratio",
+ "Scaling factor in calculation of maximum distance an expression can be moved by GCSE optimizations",
+ 10, 0, 0)
+/* GCSE won't restrict distance for which an expression with rtx_cost greater
+ than COSTS_N_INSN(GCSE_UNRESTRICTED_COST) is allowed to move. */
+DEFPARAM(PARAM_GCSE_UNRESTRICTED_COST,
+ "gcse-unrestricted-cost",
+ "Cost at which GCSE optimizations will not constraint the distance an expression can travel",
+ 3, 0, 0)
+
+/* How deep from a given basic block the dominator tree should be searched
+ for expressions to hoist to the block. The value of 0 will avoid limiting
+ the search. */
+DEFPARAM(PARAM_MAX_HOIST_DEPTH,
+ "max-hoist-depth",
+ "Maximum depth of search in the dominator tree for expressions to hoist",
+ 30, 0, 0)
+
+
+/* When synthesizing expnonentiation by a real constant operations using square
+ roots, this controls how deep sqrt chains we are willing to generate. */
+DEFPARAM(PARAM_MAX_POW_SQRT_DEPTH,
+ "max-pow-sqrt-depth",
+ "Maximum depth of sqrt chains to use when synthesizing exponentiation by a real constant",
+ 5, 1, 32)
+
/* This parameter limits the number of insns in a loop that will be unrolled,
and by how much the loop is unrolled.
-
+
This limit should be at most half of the peeling limits: loop unroller
decides to not unroll loops that iterate fewer than 2*number of allowed
unrollings and thus we would have loops that are neither peeled or unrolled
DEFPARAM(PARAM_MAX_PEELED_INSNS,
"max-peeled-insns",
"The maximum number of insns of a peeled loop",
- 400, 0, 0)
+ 100, 0, 0)
/* The maximum number of peelings of a single loop. */
DEFPARAM(PARAM_MAX_PEEL_TIMES,
"max-peel-times",
"The maximum number of peelings of a single loop",
16, 0, 0)
+/* The maximum number of peelings of a single loop that is peeled completely. */
+DEFPARAM(PARAM_MAX_PEEL_BRANCHES,
+ "max-peel-branches",
+ "The maximum number of branches on the path through the peeled sequence",
+ 32, 0, 0)
/* The maximum number of insns of a peeled loop. */
DEFPARAM(PARAM_MAX_COMPLETELY_PEELED_INSNS,
"max-completely-peeled-insns",
"The maximum number of insns of a completely peeled loop",
- 400, 0, 0)
+ 200, 0, 0)
/* The maximum number of peelings of a single loop that is peeled completely. */
DEFPARAM(PARAM_MAX_COMPLETELY_PEEL_TIMES,
"max-completely-peel-times",
"max-once-peeled-insns",
"The maximum number of insns of a peeled loop that rolls only once",
400, 0, 0)
+/* The maximum depth of a loop nest we completely peel. */
+DEFPARAM(PARAM_MAX_UNROLL_ITERATIONS,
+ "max-completely-peel-loop-nest-depth",
+ "The maximum depth of a loop nest we completely peel",
+ 8, 0, 0)
/* The maximum number of insns of an unswitched loop. */
DEFPARAM(PARAM_MAX_UNSWITCH_INSNS,
"sms-max-ii-factor",
"A factor for tuning the upper bound that swing modulo scheduler uses for scheduling a loop",
100, 0, 0)
+/* The minimum value of stage count that swing modulo scheduler will generate. */
+DEFPARAM(PARAM_SMS_MIN_SC,
+ "sms-min-sc",
+ "The minimum value of stage count that swing modulo scheduler will generate.",
+ 2, 1, 1)
DEFPARAM(PARAM_SMS_DFA_HISTORY,
"sms-dfa-history",
"The number of cycles the swing modulo scheduler considers when checking conflicts using DFA",
"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",
- "Select fraction of the maximal count of repetitions of basic block in program given basic block needs to have to be considered hot",
- 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)
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",
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)
+
DEFPARAM (PARAM_ALIGN_THRESHOLD,
"align-threshold",
"Select fraction of the maximal frequency of executions of basic block in function given basic block get alignment",
- 100, 0, 0)
+ 100, 1, 0)
DEFPARAM (PARAM_ALIGN_LOOP_ITERATIONS,
"align-loop-iterations",
For functions containing one loop with large known number of iterations
and other loops having unbounded loops we would end up predicting all
the other loops cold that is not usually the case. So we need to artificially
- flatten the profile.
+ flatten the profile.
We need to cut the maximal predicted iterations to large enough iterations
- so the loop appears important, but safely within HOT_BB_COUNT_FRACTION
+ so the loop appears important, but safely within maximum hotness
range. */
DEFPARAM(PARAM_MAX_PREDICTED_ITERATIONS,
"max-predicted-iterations",
"The maximum number of loop iterations we predict statically",
100, 0, 0)
+
+/* This parameter controls the probability of builtin_expect. The default
+ value is 90%. This empirical value is obtained through the weighted
+ probability of FDO counters (with the FDO count value as the weight)
+ in some real world programs:
+ (1) Google performance test benchmarks: the probability is 0.9081.
+ (2) Linux 3.3 kernel running Google search workload: the probability
+ is 0.8717. */
+
+DEFPARAM(BUILTIN_EXPECT_PROBABILITY,
+ "builtin-expect-probability",
+ "Set the estimated probability in percentage for builtin expect. The default value is 90% probability.",
+ 90, 0, 100)
DEFPARAM(TRACER_DYNAMIC_COVERAGE_FEEDBACK,
"tracer-dynamic-coverage-feedback",
"The percentage of function, weighted by execution frequency, that must be covered by trace formation. Used when profile feedback is available",
DEFPARAM(PARAM_MIN_CROSSJUMP_INSNS,
"min-crossjump-insns",
"The minimum number of matching instructions to consider for crossjumping",
- 5, 0, 0)
+ 5, 1, 0)
/* The maximum number expansion factor when copying basic blocks. */
DEFPARAM(PARAM_MAX_GROW_COPY_BB_INSNS,
DEFPARAM(PARAM_MAX_CSE_PATH_LENGTH,
"max-cse-path-length",
"The maximum length of path considered in cse",
- 10, 0, 0)
+ 10, 1, 0)
DEFPARAM(PARAM_MAX_CSE_INSNS,
"max-cse-insns",
"The maximum instructions CSE process before flushing",
DEFPARAM(PARAM_SCEV_MAX_EXPR_SIZE,
"scev-max-expr-size",
"Bound on size of expressions used in the scalar evolutions analyzer",
- 20, 0, 0)
+ 100, 0, 0)
+
+DEFPARAM(PARAM_SCEV_MAX_EXPR_COMPLEXITY,
+ "scev-max-expr-complexity",
+ "Bound on the complexity of the expressions in the scalar evolutions analyzer",
+ 10, 0, 0)
DEFPARAM(PARAM_OMEGA_MAX_VARS,
"omega-max-vars",
"Bound on number of runtime checks inserted by the vectorizer's loop versioning for alias check",
10, 0, 0)
+DEFPARAM(PARAM_VECT_MAX_PEELING_FOR_ALIGNMENT,
+ "vect-max-peeling-for-alignment",
+ "Max number of loop peels to enhancement alignment of data references in a loop",
+ -1, -1, 64)
+
DEFPARAM(PARAM_MAX_CSELIB_MEMORY_LOCATIONS,
"max-cselib-memory-locations",
"The maximum memory locations recorded by cselib",
"The maximum number of instructions to search backward when looking for equivalent reload",
100, 0, 0)
+DEFPARAM(PARAM_SINK_FREQUENCY_THRESHOLD,
+ "sink-frequency-threshold",
+ "Target block's relative execution frequency (as a percentage) required to sink a statement",
+ 75, 0, 100)
+
DEFPARAM(PARAM_MAX_SCHED_REGION_BLOCKS,
"max-sched-region-blocks",
"The maximum number of blocks in a region to be considered for interblock scheduling",
"The minimal probability of speculation success (in percents), so that speculative insn will be scheduled.",
40, 0, 100)
+DEFPARAM(PARAM_SCHED_STATE_EDGE_PROB_CUTOFF,
+ "sched-state-edge-prob-cutoff",
+ "The minimum probability an edge must have for the scheduler to save its state across it.",
+ 10, 0, 100)
+
DEFPARAM(PARAM_SELSCHED_MAX_LOOKAHEAD,
"selsched-max-lookahead",
"The maximum size of the lookahead window of selective scheduling",
"Minimal distance between possibly conflicting store and load",
1, 0, 0)
+DEFPARAM (PARAM_SCHED_AUTOPREF_QUEUE_DEPTH,
+ "sched-autopref-queue-depth",
+ "Hardware autoprefetcher scheduler model control flag. Number of lookahead cycles the model looks into; at '0' only enable instruction sorting heuristic. Disabled by default.",
+ -1, 0, 0)
+
DEFPARAM(PARAM_MAX_LAST_VALUE_RTL,
"max-last-value-rtl",
"The maximum number of RTL nodes that can be recorded as combiner's last value",
10000, 0, 0)
+DEFPARAM(PARAM_MAX_COMBINE_INSNS,
+ "max-combine-insns",
+ "The maximum number of insns combine tries to combine",
+ 4, 2, 4)
+
/* INTEGER_CST nodes are shared for values [{-1,0} .. N) for
{signed,unsigned} integral types. This determines N.
- Experimentation shows 256 to be a good value. */
+ Experimentation shows 251 to be a good value that generates the
+ least amount of garbage for allocating the TREE_VEC storage. */
DEFPARAM (PARAM_INTEGER_SHARE_LIMIT,
"integer-share-limit",
"The upper bound for sharing integer constants",
- 256, 2, 2)
-
-/* Incremental SSA updates for virtual operands may be very slow if
- there is a large number of mappings to process. In those cases, it
- is faster to rewrite the virtual symbols from scratch as if they
- had been recently introduced. This heuristic cannot be applied to
- SSA mappings for real SSA names, only symbols kept in FUD chains.
-
- PARAM_MIN_VIRTUAL_MAPPINGS specifies the minimum number of virtual
- mappings that should be registered to trigger the heuristic.
-
- PARAM_VIRTUAL_MAPPINGS_TO_SYMS_RATIO specifies the ratio between
- mappings and symbols. If the number of virtual mappings is
- PARAM_VIRTUAL_MAPPINGS_TO_SYMS_RATIO bigger than the number of
- virtual symbols to be updated, then the updater switches to a full
- update for those symbols. */
-DEFPARAM (PARAM_MIN_VIRTUAL_MAPPINGS,
- "min-virtual-mappings",
- "Minimum number of virtual mappings to consider switching to full virtual renames",
- 100, 0, 0)
-
-DEFPARAM (PARAM_VIRTUAL_MAPPINGS_TO_SYMS_RATIO,
- "virtual-mappings-ratio",
- "Ratio between virtual mappings and virtual symbols to do full virtual renames",
- 3, 0, 0)
+ 251, 2, 2)
DEFPARAM (PARAM_SSP_BUFFER_SIZE,
"ssp-buffer-size",
"The lower bound for a buffer to be considered for stack smashing protection",
8, 1, 0)
+DEFPARAM (PARAM_MIN_SIZE_FOR_STACK_SHARING,
+ "min-size-for-stack-sharing",
+ "The minimum size of variables taking part in stack slot sharing "
+ "when not optimizing",
+ 32, 0, 0)
+
/* When we thread through a block we have to make copies of the
statements within the block. Clearly for large blocks the code
duplication is bad.
15, 0, 0)
/* This is the maximum number of fields a variable may have before the pointer analysis machinery
- will stop trying to treat it in a field-sensitive manner.
+ will stop trying to treat it in a field-sensitive manner.
There are programs out there with thousands of fields per structure, and handling them
field-sensitively is not worth the cost. */
DEFPARAM (PARAM_MAX_FIELDS_FOR_FIELD_SENSITIVE,
"The maximum number of instructions ready to be issued to be considered by the scheduler during the first scheduling pass",
100, 0, 0)
+/* This is the maximum number of active local stores RTL DSE will consider. */
+DEFPARAM (PARAM_MAX_DSE_ACTIVE_LOCAL_STORES,
+ "max-dse-active-local-stores",
+ "Maximum number of active local stores in RTL dead store elimination",
+ 5000, 0, 0)
+
/* Prefetching and cache-optimizations related parameters. Default values are
usually set by machine description. */
"Maximum size of a SCC before SCCVN stops processing a function",
10000, 10, 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
+ alias-queries we do for finding common subexpressions for memory loads and
+ stores. The number of alias-queries is otherwise limited by the number of
+ stores on paths to function entry. */
+
+DEFPARAM (PARAM_SCCVN_MAX_ALIAS_QUERIES_PER_ACCESS,
+ "sccvn-max-alias-queries-per-access",
+ "Maximum number of disambiguations to perform per memory access",
+ 1000, 0, 0)
+
DEFPARAM (PARAM_IRA_MAX_LOOPS_NUM,
"ira-max-loops-num",
"Max loops number for regional RA",
"The number of registers in each class kept unused by loop invariant motion",
2, 0, 0)
+DEFPARAM (PARAM_LRA_MAX_CONSIDERED_RELOAD_PSEUDOS,
+ "lra-max-considered-reload-pseudos",
+ "The max number of reload pseudos which are considered during spilling a non-reload pseudo",
+ 500, 0, 0)
+
+DEFPARAM (PARAM_LRA_INHERITANCE_EBB_PROBABILITY_CUTOFF,
+ "lra-inheritance-ebb-probability-cutoff",
+ "Minimal fall-through edge probability in percentage used to add BB to inheritance EBB in LRA",
+ 40, 0, 100)
+
/* Switch initialization conversion will refuse to create arrays that are
bigger than this parameter times the number of switch branches. */
"a switch conversion to take place",
8, 1, 0)
+/* Size of tiles when doing loop blocking. */
+
+DEFPARAM (PARAM_LOOP_BLOCK_TILE_SIZE,
+ "loop-block-tile-size",
+ "size of tiles for loop blocking",
+ 51, 0, 0)
+
+/* Size of unrolling factor for unroll-and-jam. */
+
+DEFPARAM (PARAM_LOOP_UNROLL_JAM_SIZE,
+ "loop-unroll-jam-size",
+ "size of unrolling factor for unroll-and-jam",
+ 4, 0, 0)
+
+/* Size of the band formed by the strip mined dimension and the most inner one for unroll-and-jam. */
+
+DEFPARAM (PARAM_LOOP_UNROLL_JAM_DEPTH,
+ "loop-unroll-jam-depth",
+ "depth of unrolled loop for unroll-and-jam",
+ 2, 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",
+ 10, 0, 0)
+
+/* Maximal number of basic blocks in the functions analyzed by Graphite. */
+
+DEFPARAM (PARAM_GRAPHITE_MAX_BBS_PER_FUNCTION,
+ "graphite-max-bbs-per-function",
+ "maximum number of basic blocks per function to be analyzed by Graphite",
+ 100, 0, 0)
+
+/* Avoid data dependence analysis on very large loops. */
+DEFPARAM (PARAM_LOOP_MAX_DATAREFS_FOR_DATADEPS,
+ "loop-max-datarefs-for-datadeps",
+ "Maximum number of datarefs in loop for building loop data dependencies",
+ 1000, 0, 0)
+
/* Avoid doing loop invariant motion on very large loops. */
DEFPARAM (PARAM_LOOP_INVARIANT_MAX_BBS_IN_LOOP,
"Max basic blocks number in loop for loop invariant motion",
10000, 0, 0)
+/* When the parameter is 1, use the internal function id
+ 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)
+
/* Avoid SLP vectorization of large basic blocks. */
DEFPARAM (PARAM_SLP_MAX_INSNS_IN_BB,
"slp-max-insns-in-bb",
"min-insn-to-prefetch-ratio",
"Min. ratio of insns to prefetches to enable prefetching for "
"a loop with an unknown trip count",
- 10, 0, 0)
+ 9, 0, 0)
DEFPARAM (PARAM_PREFETCH_MIN_INSN_TO_MEM_RATIO,
"prefetch-min-insn-to-mem-ratio",
"Min. ratio of insns to mem ops to enable prefetching in a loop",
3, 0, 0)
+/* Set maximum hash table size for var tracking. */
+
+DEFPARAM (PARAM_MAX_VARTRACK_SIZE,
+ "max-vartrack-size",
+ "Max. size of var tracking hash tables",
+ 50000000, 0, 0)
+
+/* Set maximum recursion depth for var tracking expression expansion
+ and resolution. */
+
+DEFPARAM (PARAM_MAX_VARTRACK_EXPR_DEPTH,
+ "max-vartrack-expr-depth",
+ "Max. recursion depth for expanding var tracking expressions",
+ 12, 0, 0)
+
+/* Set maximum length of value location list for which var tracking
+ should add reverse operations. */
+
+DEFPARAM (PARAM_MAX_VARTRACK_REVERSE_OP_SIZE,
+ "max-vartrack-reverse-op-size",
+ "Max. size of loc list for which reverse ops should be added",
+ 50, 0, 0)
+
/* Set minimum insn uid for non-debug insns. */
DEFPARAM (PARAM_MIN_NONDEBUG_INSN_UID,
"a pointer to an aggregate with",
2, 0, 0)
+DEFPARAM (PARAM_TM_MAX_AGGREGATE_SIZE,
+ "tm-max-aggregate-size",
+ "Size in bytes after which thread-local aggregates should be "
+ "instrumented with the logging functions instead of save/restore "
+ "pairs",
+ 9, 0, 0)
+
+DEFPARAM (PARAM_SRA_MAX_SCALARIZATION_SIZE_SPEED,
+ "sra-max-scalarization-size-Ospeed",
+ "Maximum size, in storage units, of an aggregate which should be "
+ "considered for scalarization when compiling for speed",
+ 0, 0, 0)
+
+DEFPARAM (PARAM_SRA_MAX_SCALARIZATION_SIZE_SIZE,
+ "sra-max-scalarization-size-Osize",
+ "Maximum size, in storage units, of an aggregate which should be "
+ "considered for scalarization when compiling for size",
+ 0, 0, 0)
+
+DEFPARAM (PARAM_IPA_CP_VALUE_LIST_SIZE,
+ "ipa-cp-value-list-size",
+ "Maximum size of a list of values associated with each parameter for "
+ "interprocedural constant propagation",
+ 8, 0, 0)
+
+DEFPARAM (PARAM_IPA_CP_EVAL_THRESHOLD,
+ "ipa-cp-eval-threshold",
+ "Threshold ipa-cp opportunity evaluation that is still considered "
+ "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.",
+ 40, 0, 100)
+
+DEFPARAM (PARAM_IPA_CP_SINGLE_CALL_PENALTY,
+ "ipa-cp-single-call-penalty",
+ "Percentage penalty functions containg a single call to another "
+ "function will receive when they are evaluated for cloning.",
+ 15, 0, 100)
+
+DEFPARAM (PARAM_IPA_MAX_AGG_ITEMS,
+ "ipa-max-agg-items",
+ "Maximum number of aggregate content items for a parameter in "
+ "jump functions and lattices",
+ 16, 0, 0)
+
+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.",
+ 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)
+
+/* WHOPR partitioning configuration. */
+
+DEFPARAM (PARAM_LTO_PARTITIONS,
+ "lto-partitions",
+ "Number of partitions the program should be split to",
+ 32, 1, 0)
+
+DEFPARAM (MIN_PARTITION_SIZE,
+ "lto-min-partition",
+ "Minimal size of a partition for LTO (in estimated instructions)",
+ 1000, 0, 0)
+
+/* Diagnostic parameters. */
+
+DEFPARAM (CXX_MAX_NAMESPACES_FOR_DIAGNOSTIC_HELP,
+ "cxx-max-namespaces-for-diagnostic-help",
+ "Maximum number of namespaces to search for alternatives when "
+ "name lookup fails",
+ 1000, 0, 0)
+
+/* Maximum number of conditional store pairs that can be sunk. */
+DEFPARAM (PARAM_MAX_STORES_TO_SINK,
+ "max-stores-to-sink",
+ "Maximum number of conditional store pairs that can be sunk",
+ 2, 0, 0)
+
+/* Override CASE_VALUES_THRESHOLD of when to switch from doing switch
+ statements via if statements to using a table jump operation. If the value
+ is 0, the default CASE_VALUES_THRESHOLD will be used. */
+DEFPARAM (PARAM_CASE_VALUES_THRESHOLD,
+ "case-values-threshold",
+ "The smallest number of different values for which it is best to "
+ "use a jump-table instead of a tree of conditional branches, "
+ "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)
+
+/* 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.",
+ 0, 0, 0)
+
+DEFPARAM (PARAM_MAX_TAIL_MERGE_COMPARISONS,
+ "max-tail-merge-comparisons",
+ "Maximum amount of similar bbs to compare a bb with",
+ 10, 0, 0)
+
+DEFPARAM (PARAM_MAX_TAIL_MERGE_ITERATIONS,
+ "max-tail-merge-iterations",
+ "Maximum amount of iterations of the pass over a function",
+ 2, 0, 0)
+
+/* Maximum number of strings for which strlen optimization pass will
+ track string lenths. */
+DEFPARAM (PARAM_MAX_TRACKED_STRLENS,
+ "max-tracked-strlens",
+ "Maximum number of strings for which strlen optimization pass will "
+ "track string lengths",
+ 10000, 0, 0)
+
+/* Keep this in sync with the sched_pressure_algorithm enum. */
+DEFPARAM (PARAM_SCHED_PRESSURE_ALGORITHM,
+ "sched-pressure-algorithm",
+ "Which -fsched-pressure algorithm to apply",
+ 1, 1, 2)
+
+/* Maximum length of candidate scans in straight-line strength reduction. */
+DEFPARAM (PARAM_MAX_SLSR_CANDIDATE_SCAN,
+ "max-slsr-cand-scan",
+ "Maximum length of candidate scans for straight-line "
+ "strength reduction",
+ 50, 1, 999999)
+
+DEFPARAM (PARAM_ASAN_STACK,
+ "asan-stack",
+ "Enable asan stack protection",
+ 1, 0, 1)
+
+DEFPARAM (PARAM_ASAN_GLOBALS,
+ "asan-globals",
+ "Enable asan globals protection",
+ 1, 0, 1)
+
+DEFPARAM (PARAM_ASAN_INSTRUMENT_WRITES,
+ "asan-instrument-writes",
+ "Enable asan store operations protection",
+ 1, 0, 1)
+
+DEFPARAM (PARAM_ASAN_INSTRUMENT_READS,
+ "asan-instrument-reads",
+ "Enable asan load operations protection",
+ 1, 0, 1)
+
+DEFPARAM (PARAM_ASAN_MEMINTRIN,
+ "asan-memintrin",
+ "Enable asan builtin functions protection",
+ 1, 0, 1)
+
+DEFPARAM (PARAM_ASAN_USE_AFTER_RETURN,
+ "asan-use-after-return",
+ "Enable asan detection of use-after-return bugs",
+ 1, 0, 1)
+
+DEFPARAM (PARAM_ASAN_INSTRUMENTATION_WITH_CALL_THRESHOLD,
+ "asan-instrumentation-with-call-threshold",
+ "Use callbacks instead of inline code if number of accesses "
+ "in function becomes greater or equal to this number",
+ 7000, 0, INT_MAX)
+
+DEFPARAM (PARAM_UNINIT_CONTROL_DEP_ATTEMPTS,
+ "uninit-control-dep-attempts",
+ "Maximum number of nested calls to search for control dependencies "
+ "during uninitialized variable analysis",
+ 1000, 1, 0)
+
+DEFPARAM (PARAM_CHKP_MAX_CTOR_SIZE,
+ "chkp-max-ctor-size",
+ "Maximum number of statements to be included into a single static "
+ "constructor generated by Pointer Bounds Checker",
+ 5000, 100, 0)
+
+DEFPARAM (PARAM_MAX_FSM_THREAD_PATH_INSNS,
+ "max-fsm-thread-path-insns",
+ "Maximum number of instructions to copy when duplicating blocks on a finite state automaton jump thread path",
+ 100, 1, 999999)
+
+DEFPARAM (PARAM_MAX_FSM_THREAD_LENGTH,
+ "max-fsm-thread-length",
+ "Maximum number of basic blocks on a finite state automaton jump thread path",
+ 10, 1, 999999)
+
+DEFPARAM (PARAM_MAX_FSM_THREAD_PATHS,
+ "max-fsm-thread-paths",
+ "Maximum number of new jump thread paths to create for a finite state automaton",
+ 50, 1, 999999)
/*
+
Local variables:
mode:c
End: