"salias-max-implicit-fields",
"The maximum number of fields in a structure variable without direct structure accesses that GCC will attempt to track separately",
5, 0, 0)
-
+
+/* The maximum number of array elements structure aliasing will decompose
+ an array for. The default is 4. */
+DEFPARAM (PARAM_SALIAS_MAX_ARRAY_ELEMENTS,
+ "salias-max-array-elements",
+ "The maximum number of elements in an array for wich we track its elements separately",
+ 4, 0, 0)
+
/* 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
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",
+ "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)
/* The maximum number of instructions to consider when looking for an
"large-function-growth",
"Maximal growth due to inlining of large function (in percent)",
100, 0, 0)
+DEFPARAM(PARAM_LARGE_UNIT_INSNS,
+ "large-unit-insns",
+ "The size of translation unit to be considered large",
+ 10000, 0, 0)
DEFPARAM(PARAM_INLINE_UNIT_GROWTH,
"inline-unit-growth",
"how much can given compilation unit grow because of the inlining (in percent)",
100, 0, 0)
DEFPARAM(PARAM_SMS_DFA_HISTORY,
"sms-dfa-history",
- "The number of cycles the swing modulo scheduler considers when \
- checking conflicts using DFA",
+ "The number of cycles the swing modulo scheduler considers when checking conflicts using DFA",
0, 0, 0)
DEFPARAM(PARAM_SMS_LOOP_AVERAGE_COUNT_THRESHOLD,
"sms-loop-average-count-threshold",
"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)
+
+/* For guessed profiles, the loops having unknown number of iterations
+ are predicted to iterate relatively few (10) times at average.
+ 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.
+
+ We need to cut the maximal predicted iterations to large enough iterations
+ so the loop appears important, but safely within HOT_BB_COUNT_FRACTION
+ range. */
+
+DEFPARAM(PARAM_MAX_PREDICTED_ITERATIONS,
+ "max-predicted-iterations",
+ "The maximum number of loop iterations we predict statically",
+ 100, 0, 0)
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",
"The minimum number of matching instructions to consider for crossjumping",
5, 0, 0)
+/* The maximum number expansion factor when copying basic blocks. */
+DEFPARAM(PARAM_MAX_GROW_COPY_BB_INSNS,
+ "max-grow-copy-bb-insns",
+ "The maximum expansion factor when copying basic blocks",
+ 8, 0, 0)
+
/* The maximum number of insns to duplicate when unfactoring computed gotos. */
DEFPARAM(PARAM_MAX_GOTO_DUPLICATION_INSNS,
"max-goto-duplication-insns",
"max-cse-path-length",
"The maximum length of path considered in cse",
10, 0, 0)
+DEFPARAM(PARAM_MAX_CSE_INSNS,
+ "max-flow-memory-locations",
+ "The maximum instructions CSE process before flushing",
+ 1000, 0, 0)
/* The cost of expression in loop invariant motion that is considered
expensive. */
"max-cselib-memory-locations",
"The maximum memory locations recorded by cselib",
500, 0, 0)
+DEFPARAM(PARAM_MAX_FLOW_MEMORY_LOCATIONS,
+ "max-flow-memory-locations",
+ "The maximum memory locations recorded by flow",
+ 100, 0, 0)
#ifdef ENABLE_GC_ALWAYS_COLLECT
# define GGC_MIN_EXPAND_DEFAULT 0
"The lower bound for a buffer to be considered for stack smashing protection",
8, 1, 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.
+
+ PARAM_MAX_JUMP_THREAD_DUPLICATION_STMTS specifies the maximum number
+ of statements and PHI nodes allowed in a block which is going to
+ be duplicated for thread jumping purposes.
+
+ Some simple analysis showed that more than 99% of the jump
+ threading opportunities are for blocks with less than 15
+ statements. So we can get the benefits of jump threading
+ without excessive code bloat for pathological cases with the
+ throttle set at 15 statements. */
+DEFPARAM (PARAM_MAX_JUMP_THREAD_DUPLICATION_STMTS,
+ "max-jump-thread-duplication-stmts",
+ "Maximum number of statements allowed in a block that needs to be duplicated when threading jumps",
+ 15, 0, 0)
+
/*
Local variables:
mode:c