"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
"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",
+ "If -ftree-vectorize is used, the minimal loop bound of a loop to be considered for vectorization",
+ 0, 0, 0)
+
/* 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
"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)",
- 50, 0, 0)
+ 60, 0, 0)
DEFPARAM(PARAM_INLINE_CALL_COST,
"inline-call-cost",
"expense of call operation relative to ordinary arithmetic operations",
16, 0, 0)
+DEFPARAM(PARAM_LARGE_STACK_FRAME,
+ "large-stack-frame",
+ "The size of stack frame to be considered large",
+ 256, 0, 0)
+DEFPARAM(PARAM_STACK_FRAME_GROWTH,
+ "large-stack-frame-growth",
+ "Maximal stack frame growth due to inlining (in percent)",
+ 1000, 0, 0)
/* The GCSE optimization will be disabled if it would require
significantly more memory than this value. */
"max-iterations-to-track",
"Bound on the number of iterations the brute force # of iterations analysis algorithm evaluates",
1000, 0, 0)
+/* A cutoff to avoid costly computations of the number of iterations in
+ the doloop transformation. */
+DEFPARAM(PARAM_MAX_ITERATIONS_COMPUTATION_COST,
+ "max-iterations-computation-cost",
+ "Bound on the cost of an expression to compute the number of iterations",
+ 10, 0, 0)
DEFPARAM(PARAM_MAX_SMS_LOOP_NUMBER,
"max-sms-loop-number",
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 enought iterations
+ 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. */
"The maximum length of path considered in cse",
10, 0, 0)
DEFPARAM(PARAM_MAX_CSE_INSNS,
- "max-flow-memory-locations",
+ "max-cse-insns",
"The maximum instructions CSE process before flushing",
1000, 0, 0)
"Bound on number of runtime checks inserted by the vectorizer's loop versioning",
6, 0, 0)
-/* 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, 0, 0)
-
DEFPARAM(PARAM_MAX_CSELIB_MEMORY_LOCATIONS,
"max-cselib-memory-locations",
"The maximum memory locations recorded by cselib",
DEFPARAM(PARAM_MAX_ALIASED_VOPS,
"max-aliased-vops",
- "The maximum number of virtual operands allowed to represent aliases before triggering alias grouping",
- 500, 0, 0)
+ "The maximum number of virtual operators per statement allowed to represent aliases before triggering alias grouping",
+ 10, 0, 0)
DEFPARAM(PARAM_MAX_SCHED_REGION_BLOCKS,
"max-sched-region-blocks",
"The minimum probability of reaching a source block for interblock speculative scheduling",
40, 0, 0)
+DEFPARAM(PARAM_MAX_SCHED_EXTEND_REGIONS_ITERS,
+ "max-sched-extend-regions-iters",
+ "The maximum number of iterations through CFG to extend regions",
+ 0, 0, 0)
+
+DEFPARAM(PARAM_MAX_SCHED_INSN_CONFLICT_DELAY,
+ "max-sched-insn-conflict-delay",
+ "The maximum conflict delay for an insn to be considered for speculative motion",
+ 3, 1, 10)
+
+DEFPARAM(PARAM_SCHED_SPEC_PROB_CUTOFF,
+ "sched-spec-prob-cutoff",
+ "The minimal probability of speculation success (in percents), so that speculative insn will be scheduled.",
+ 40, 0, 100)
+
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",
"max-jump-thread-duplication-stmts",
"Maximum number of statements allowed in a block that needs to be duplicated when threading jumps",
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.
+ 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,
+ "max-fields-for-field-sensitive",
+ "Maximum number of fields in a structure before pointer analysis treats the structure as a single variable",
+ 100, 0, 0)
+
+DEFPARAM(PARAM_MAX_SCHED_READY_INSNS,
+ "max-sched-ready-insns",
+ "The maximum number of instructions ready to be issued to be considered by the scheduler during the first scheduling pass",
+ 100, 0, 0)
+
+/* Prefetching and cache-optimizations related parameters. Default values are
+ usually set by machine description. */
+
+/* The number of insns executed before prefetch is completed. */
+
+DEFPARAM (PARAM_PREFETCH_LATENCY,
+ "prefetch-latency",
+ "The number of insns executed before prefetch is completed",
+ 200, 0, 0)
+
+/* The number of prefetches that can run at the same time. */
+
+DEFPARAM (PARAM_SIMULTANEOUS_PREFETCHES,
+ "simultaneous-prefetches",
+ "The number of prefetches that can run at the same time",
+ 3, 0, 0)
+
+/* The size of L1 cache in number of cache lines. */
+
+DEFPARAM (PARAM_L1_CACHE_SIZE,
+ "l1-cache-size",
+ "The size of L1 cache",
+ 1024, 0, 0)
+
+/* The size of L1 cache line in bytes. */
+
+DEFPARAM (PARAM_L1_CACHE_LINE_SIZE,
+ "l1-cache-line-size",
+ "The size of L1 cache line",
+ 32, 0, 0)
+
+#ifdef ENABLE_CHECKING
+# define GCC_CANONICAL_TYPES_DEFAULT 1
+#else
+# define GCC_CANONICAL_TYPES_DEFAULT 0
+#endif
+
+/* Whether we should verify that the canonical types in the system are
+ consistent with the "structural" typing. */
+
+DEFPARAM (PARAM_VERIFY_CANONICAL_TYPES,
+ "verify-canonical-types",
+ "Whether to verify canonical types",
+ GCC_CANONICAL_TYPES_DEFAULT, 0, 1)
/*
Local variables:
mode:c
OSDN Git Service
