+/* 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)
+
+DEFPARAM (PARAM_SSP_BUFFER_SIZE,
+ "ssp-buffer-size",
+ "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)
+
+/* 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)