Daily bump.

[pf3gnuchains/gcc-fork.git] / gcc / params.def

diff --git a/gcc/params.def b/gcc/params.def
index f0740a9..e8d8615 100644 (file)
--- a/gcc/params.def
+++ b/gcc/params.def
@@ -47,7 +47,14 @@ DEFPARAM (PARAM_SALIAS_MAX_IMPLICIT_FIELDS,
          "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
@@ -179,6 +186,10 @@ DEFPARAM(PARAM_LARGE_FUNCTION_GROWTH,
         "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)",
@@ -309,6 +320,22 @@ 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)
+
+/* 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",
@@ -363,6 +390,10 @@ DEFPARAM(PARAM_MAX_CSE_PATH_LENGTH,
         "max-cse-path-length",
         "The maximum length of path considered in cse",
         10, 0, 0)
+DEFPARAM(PARAM_MAX_CSE_INSNS,
+        "max-cse-insns",
+        "The maximum instructions CSE process before flushing",
+        1000, 0, 0)
 
 /* The cost of expression in loop invariant motion that is considered
    expensive.  */
@@ -417,6 +448,10 @@ DEFPARAM(PARAM_MAX_CSELIB_MEMORY_LOCATIONS,
         "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
@@ -464,6 +499,21 @@ DEFPARAM(PARAM_MIN_SPEC_PROB,
          "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",
+         2, 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",
@@ -523,7 +573,21 @@ 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)
+
 /*
 Local variables:
 mode:c