Be sure to add an entry to invoke.texi summarizing the parameter. */
+/* The maximum structure size at which the scalar replacement of
+ aggregates (SRA) pass will perform block copies. The default
+ value, 0, implies that GCC will select the most appropriate size
+ itself. */
+DEFPARAM (PARAM_SRA_MAX_STRUCTURE_SIZE,
+ "sra-max-structure-size",
+ "The maximum structure size (in bytes) at which GCC will do block copies.",
+ 0)
+
+/* The ratio between instantiated fields and the complete structure
+ size. We say that if the ratio of the number of bytes in
+ instantiated fields to the number of bytes in the complete
+ structure exceeds this parameter, then block copies are not used.
+ The default is 75%. */
+DEFPARAM (PARAM_SRA_FIELD_STRUCTURE_RATIO,
+ "sra-field-structure-ratio",
+ "The threshold ratio between instantiated fields and the total structure size.",
+ 75)
+
/* 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
"The maximum number of instructions when automatically inlining",
120)
+DEFPARAM (PARAM_MAX_INLINE_INSNS_RECURSIVE,
+ "max-inline-insns-recursive",
+ "The maximum number of instructions inline function can grow to via recursive inlining",
+ 500)
+
+DEFPARAM (PARAM_MAX_INLINE_INSNS_RECURSIVE_AUTO,
+ "max-inline-insns-recursive-auto",
+ "The maximum number of instructions non-inline function can grow to via recursive inlining",
+ 500)
+
+DEFPARAM (PARAM_MAX_INLINE_RECURSIVE_DEPTH,
+ "max-inline-recursive-depth",
+ "The maximum depth of recursive inlining for inline functions",
+ 8)
+
+DEFPARAM (PARAM_MAX_INLINE_RECURSIVE_DEPTH_AUTO,
+ "max-inline-recursive-depth-auto",
+ "The maximum depth of recursive inlining for non-inline functions",
+ 8)
+
/* For languages that (still) use the RTL inliner, we can specify
limits for the RTL inliner separately.
The parameter here defines the maximum number of RTL instructions
"The maximum number of instructions for the RTL inliner",
600)
+/* Limit the number of expansions created by the variable expansion
+ optimization to avoid register pressure. */
+DEFPARAM (PARAM_MAX_VARIABLE_EXPANSIONS,
+ "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)
+
/* The maximum number of instructions to consider when looking for an
instruction to fill a delay slot. If more than this arbitrary
number of instructions is searched, the time savings from filling
"max-gcse-passes",
"The maximum number of passes to make when doing GCSE",
1)
-
+/* This is the threshold ratio when to perform partial redundancy
+ elimination after reload. We perform partial redundancy elimination
+ when the following holds:
+ (Redundant load execution count)
+ ------------------------------- >= GCSE_AFTER_RELOAD_PARTIAL_FRACTION
+ (Added loads execution count) */
+DEFPARAM(PARAM_GCSE_AFTER_RELOAD_PARTIAL_FRACTION,
+ "gcse-after-reload-partial-fraction",
+ "The threshold ratio for performing partial redundancy elimination \
+ after reload.",
+ 3)
+/* This is the threshold ratio of the critical edges execution count compared to
+ the redundant loads execution count that permits performing the load
+ redundancy elimination in gcse after reload. */
+DEFPARAM(PARAM_GCSE_AFTER_RELOAD_CRITICAL_FRACTION,
+ "gcse-after-reload-critical-fraction",
+ "The threshold ratio of critical edges execution count that permit \
+ performing redundancy elimination after reload.",
+ 10)
/* This parameter limits the number of insns in a loop that will be unrolled,
- and by how much the loop is 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
+ otherwise. */
DEFPARAM(PARAM_MAX_UNROLLED_INSNS,
"max-unrolled-insns",
"The maximum number of instructions to consider to unroll in a loop",
DEFPARAM(PARAM_MAX_PEELED_INSNS,
"max-peeled-insns",
"The maximum number of insns of a peeled loop",
- 120)
+ 400)
/* The maximum number of peelings of a single loop. */
DEFPARAM(PARAM_MAX_PEEL_TIMES,
"max-peel-times",
DEFPARAM(PARAM_MAX_COMPLETELY_PEELED_INSNS,
"max-completely-peeled-insns",
"The maximum number of insns of a completely peeled loop",
- 120)
+ 400)
/* The maximum number of peelings of a single loop that is peeled completely. */
DEFPARAM(PARAM_MAX_COMPLETELY_PEEL_TIMES,
"max-completely-peel-times",
DEFPARAM(PARAM_MAX_ONCE_PEELED_INSNS,
"max-once-peeled-insns",
"The maximum number of insns of a peeled loop that rolls only once",
- 200)
+ 400)
/* The maximum number of insns of an unswitched loop. */
DEFPARAM(PARAM_MAX_UNSWITCH_INSNS,
"The maximum number of unswitchings in a single loop",
3)
+/* The maximum number of iterations of a loop the brute force algorithm
+ for analysis of # of iterations of the loop tries to evaluate. */
+DEFPARAM(PARAM_MAX_ITERATIONS_TO_TRACK,
+ "max-iterations-to-track",
+ "Bound on the number of iterations the brute force # of iterations \
+ analysis algorithm evaluates",
+ 1000)
+
+DEFPARAM(PARAM_MAX_SMS_LOOP_NUMBER,
+ "max-sms-loop-number",
+ "Maximum number of loops to perform swing modulo scheduling on \
+ (mainly for debugging)",
+ -1)
+
+/* This parameter is used to tune SMS MAX II calculations. */
+DEFPARAM(PARAM_SMS_MAX_II_FACTOR,
+ "sms-max-ii-factor",
+ "A factor for tuning the upper bound that swing modulo scheduler uses \
+ for scheduling a loop",
+ 100)
+DEFPARAM(PARAM_SMS_DFA_HISTORY,
+ "sms-dfa-history",
+ "The number of cycles the swing modulo scheduler considers when \
+ checking conflicts using DFA",
+ 0)
+DEFPARAM(PARAM_SMS_LOOP_AVERAGE_COUNT_THRESHOLD,
+ "sms-loop-average-count-threshold",
+ "A threshold on the average loop count considered by the swing modulo \
+ scheduler",
+ 0)
+
DEFPARAM(HOT_BB_COUNT_FRACTION,
"hot-bb-count-fraction",
"Select fraction of the maximal count of repetitions of basic block in \
"The maximum number of incoming edges to consider for crossjumping",
100)
+/* The minimum number of matching instructions to consider for crossjumping. */
+DEFPARAM(PARAM_MIN_CROSSJUMP_INSNS,
+ "min-crossjump-insns",
+ "The minimum number of matching instructions to consider for crossjumping",
+ 5)
+
/* The maximum length of path considered in cse. */
DEFPARAM(PARAM_MAX_CSE_PATH_LENGTH,
"max-cse-path-length",
"The maximum length of path considered in cse",
10)
+/* The cost of expression in loop invariant motion that is considered
+ expensive. */
+DEFPARAM(PARAM_LIM_EXPENSIVE,
+ "lim-expensive",
+ "The minimum cost of an expensive expression in the loop invariant motion",
+ 20)
+
+/* Bound on number of candidates for induction variables below that
+ all candidates are considered for each use in induction variable
+ optimizations. */
+
+DEFPARAM(PARAM_IV_CONSIDER_ALL_CANDIDATES_BOUND,
+ "iv-consider-all-candidates-bound",
+ "Bound on number of candidates below that all candidates are considered in iv optimizations",
+ 30)
+
+/* The induction variable optimizations give up on loops that contain more
+ induction variable uses. */
+
+DEFPARAM(PARAM_IV_MAX_CONSIDERED_USES,
+ "iv-max-considered-uses",
+ "Bound on number of iv uses in loop optimized in iv optimizations",
+ 250)
+
+/* The product of the next two is used to decide whether or not to
+ use .GLOBAL_VAR. See tree-dfa.c. */
+DEFPARAM(PARAM_GLOBAL_VAR_THRESHOLD,
+ "global-var-threshold",
+ "Given N calls and V call-clobbered vars in a function. Use .GLOBAL_VAR if NxV is larger than this limit",
+ 500000)
+
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)
+DEFPARAM(PARAM_MAX_ALIASED_VOPS,
+ "max-aliased-vops",
+ "The maximum number of virtual operands allowed to represent aliases before triggering alias grouping.",
+ 500)
+
+DEFPARAM(PARAM_MAX_SCHED_REGION_BLOCKS,
+ "max-sched-region-blocks",
+ "The maximum number of blocks in a region to be considered for interblock scheduling",
+ 10)
+
+DEFPARAM(PARAM_MAX_SCHED_REGION_INSNS,
+ "max-sched-region-insns",
+ "The maximum number of insns in a region to be considered for interblock scheduling",
+ 100)
+
+/* 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. */
+DEFPARAM (PARAM_INTEGER_SHARE_LIMIT,
+ "integer-share-limit",
+ "The upper bound for sharing integer constants",
+ 256)
+
/*
Local variables:
mode:c
OSDN Git Service
