From 38a8aecfb882072900434499696b5c32a2274515 Mon Sep 17 00:00:00 2001
From: Rong Xu <xur@google.com>
Date: Mon, 21 Jul 2014 16:47:22 -0700
Subject: [4.9] Switch gcc-4.9 to use google/gcc-4_9 branch. This source drop
 uses svn version r212828 of google/gcc-4.9 branch. We also cherry-picked
 r213062, r213063 and r213064 to fix windows build issues. All gcc-4.9 patches
 before July 3rd are ported to google/gcc-4.9. The following prior commits has
 not been merged to google branch yet. (They are included in this commit).
 e7af147f979e657fe2df00808e5b4319b0e088c6,
 baf87df3cb2683649ba7e9872362a7e721117c23, and
 c231900e5dcc14d8296bd9f62b45997a49d4d5e7.

Change-Id: I4bea3ea470387ff751c2be4cb0d4a12059b9299b
---
 gcc-4.9/gcc/params.def | 262 +++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 262 insertions(+)

(limited to 'gcc-4.9/gcc/params.def')

diff --git a/gcc-4.9/gcc/params.def b/gcc-4.9/gcc/params.def
index dd2e2cd1a..fd38e8fed 100644
--- a/gcc-4.9/gcc/params.def
+++ b/gcc-4.9/gcc/params.def
@@ -103,6 +103,33 @@ DEFPARAM (PARAM_MIN_INLINE_RECURSIVE_PROBABILITY,
 	  "Inline recursively only when the probability of call being executed exceeds the parameter",
 	  10, 0, 0)
 
+DEFPARAM (PARAM_INLINE_FUNCTION_OVERHEAD_SIZE,
+	  "inline-function-overhead-size",
+	  "Size estimate of function overhead (prologue/epilogue) for inlining purposes",
+	  7, 0, 0)
+
+/* Knob to control hot-caller heuristic. 0 means it is turned off, 1 means
+   it is always applied, and 2 means it is applied only if the footprint is
+   smaller than PARAM_HOT_CALLER_CODESIZE_THRESHOLD.  */
+DEFPARAM (PARAM_INLINE_HOT_CALLER,
+	  "inline-hot-caller",
+	  "Consider cold callsites for inlining if caller contains hot code",
+	  2, 0, 2)
+
+/* The maximum code size estimate under which hot caller heuristic is
+   applied.  */
+DEFPARAM(PARAM_HOT_CALLER_CODESIZE_THRESHOLD,
+	"hot-caller-codesize-threshold",
+	"Maximum profile-based code size footprint estimate for "
+	"hot caller heuristic  ",
+	10000, 0, 0)
+
+DEFPARAM (PARAM_INLINE_USEFUL_COLD_CALLEE,
+	  "inline-useful-cold-callee",
+	  "Only consider cold callsites for inlining if analysis estimates "
+	  "downstream optimization opportunities",
+	  1, 0, 1)
+
 /* Limit of iterations of early inliner.  This basically bounds number of
    nested indirect calls early inliner can resolve.  Deeper chains are still
    handled by late inlining.  */
@@ -199,6 +226,14 @@ DEFPARAM(PARAM_EARLY_INLINING_INSNS,
 	 "early-inlining-insns",
 	 "Maximal estimated growth of function body caused by early inlining of single call",
 	 11, 0, 0)
+DEFPARAM(PARAM_EARLY_INLINING_INSNS_ANY,
+	 "early-inlining-insns-any",
+	 "Early inline calls if growth does not exceed this limit",
+	 0, 0, 0)
+DEFPARAM(PARAM_EARLY_INLINING_INSNS_COMDAT,
+	 "early-inlining-insns-comdat",
+	 "Early inline calls to comdate functions if growth does not exceed this limit",
+	 15, 0, 0)
 DEFPARAM(PARAM_LARGE_STACK_FRAME,
 	 "large-stack-frame",
 	 "The size of stack frame to be considered large",
@@ -304,6 +339,11 @@ DEFPARAM(PARAM_MAX_COMPLETELY_PEELED_INSNS,
 	"max-completely-peeled-insns",
 	"The maximum number of insns of a completely peeled loop",
 	100, 0, 0)
+/* The default maximum number of insns of a peeled loop, with -O2.  */
+DEFPARAM(PARAM_MAX_DEFAULT_COMPLETELY_PEELED_INSNS,
+	"max-default-completely-peeled-insns",
+	"The maximum number of insns of a completely peeled loop",
+	200, 0, 0)
 /* The maximum number of peelings of a single loop that is peeled completely.  */
 DEFPARAM(PARAM_MAX_COMPLETELY_PEEL_TIMES,
 	"max-completely-peel-times",
@@ -319,6 +359,32 @@ DEFPARAM(PARAM_MAX_UNROLL_ITERATIONS,
 	 "max-completely-peel-loop-nest-depth",
 	 "The maximum depth of a loop nest we completely peel",
 	 8, 0, 0)
+/* The maximum code size estimate under which loop unrolling and peeling
+ * is allowed in a profile feedback compile. This currently applies to loops
+ * with non-constant iteration counts and no floating point computations.  */
+DEFPARAM(PARAM_UNROLLPEEL_CODESIZE_THRESHOLD,
+	"unrollpeel-codesize-threshold",
+	"Maximum profile-based code size footprint estimate for loop unrolling "
+	"and peeling",
+	15000, 0, 0)
+/* The maximum ratio of total profiled execution counts to loop entry block
+   count that must be exceeded to ignore most code size limits when unrolling
+   and peeling.  */
+DEFPARAM(PARAM_UNROLLPEEL_HOTNESS_THRESHOLD,
+        "unrollpeel-hotness-threshold",
+        "Maximum ratio of total profiled execution count to loop entry "
+        "block count under which most codesize limits for unrolling and "
+        "peeling will be ignored",
+        100, 1, 0)
+
+DEFPARAM(PARAM_MIN_ITER_UNROLL_WITH_BRANCHES,
+	"min-iter-unroll-with-branches",
+	"Minimum iteration count to ignore branch effects when unrolling",
+	50, 0, 0)
+DEFPARAM(PARAM_UNROLL_OUTER_LOOP_BRANCH_BUDGET,
+	"unroll-outer-loop-branch-budget",
+	"Maximum number of branches allowed in hot outer loop region after unroll",
+	25, 0, 0)
 
 /* The maximum number of insns of an unswitched loop.  */
 DEFPARAM(PARAM_MAX_UNSWITCH_INSNS,
@@ -404,6 +470,14 @@ DEFPARAM(PARAM_MAX_PREDICTED_ITERATIONS,
 	 "The maximum number of loop iterations we predict statically",
 	 100, 0, 0)
 
+/* This parameter controls the maximum iterations that AutoFDO profile
+   prpagation algorithm will run for a specific CFG.  */
+
+DEFPARAM(PARAM_AUTOFDO_MAX_PROPAGATE_ITERATIONS,
+         "max-autofdo-max-propagate-iterations",
+         "The maximum number of AutoFDO profile propagation iterations",
+         100, 0, 0)
+
 /* This parameter controls the probability of builtin_expect. The default
    value is 90%. This empirical value is obtained through the weighted
    probability of FDO counters (with the FDO count value as the weight)
@@ -869,6 +943,170 @@ DEFPARAM (PARAM_LOOP_INVARIANT_MAX_BBS_IN_LOOP,
 	  "Max basic blocks number in loop for loop invariant motion",
 	  10000, 0, 0)
 
+/* Promote indirect call to conditional direct call only
+   when the percentage of the target count over the total
+   indirect call count is no smaller than the threshold.  */
+DEFPARAM (PARAM_ICALL_PROMOTE_PERCENT_THRESHOLD,
+	  "icall-promote-target-percent-threshold",
+	  "percentage threshold for direct call promotion"
+          " of a callee target",
+	  33, 0, 100)
+
+DEFPARAM (PARAM_ICALL_PROMOTE_COUNT_THRESHOLD,
+	  "icall-promote-target_count-threshold",
+	  "call count threshold for direct call promotion"
+          " of a callee target",
+	  1, 0, 0)
+
+/* 0: do not always inline icall target:
+   other value: always inline icall target when call count
+   exceeds this value.
+*/
+DEFPARAM (PARAM_ALWAYS_INLINE_ICALL_TARGET,
+	  "always-inline-icall-target",
+	  "force inline indirect call target when promoted",
+          0, 0, 0)
+
+/* When the parameter is 1, use the internal function id
+   to look up for profile data. Otherwise, use a more stable
+   external id based on assembler name and source location. */
+DEFPARAM (PARAM_PROFILE_FUNC_INTERNAL_ID,
+	  "profile-func-internal-id",
+	  "use internal function id in profile lookup",
+          0, 0, 1)
+
+/* Do not check the icall target count distribution, but use
+   hotness info to decide if promotion should be done.  */
+DEFPARAM (PARAM_ICALL_USE_HOTNESS_HEUR,
+	  "icall-use-hotness-heur",
+	  "use hotness based heuristics to match inliner",
+          0, 0, 0)
+
+/* Force the compiler to be in LIPO mode even there is no
+ profile data available. -fripa is also needed. */
+DEFPARAM (PARAM_FORCE_LIPO_MODE, 
+	  "force-lipo",
+	  "force LIPO compilation mode",
+          0, 0, 1)
+
+/* Limit max module group size in LIPO mode.  When the value
+ is set to 0 (which is the default), there is no limit.  */
+DEFPARAM (PARAM_MAX_LIPO_GROUP,
+	  "max-lipo-group",
+	  "maximum module group size.",
+          0, 0, 10000)
+
+/* In LIPO mode, stop processing any further auxiliary modules
+   if current memory consumption exceeds this limit (in kb).  */
+DEFPARAM (PARAM_MAX_LIPO_MEMORY,
+	  "max-lipo-mem",
+	  "don't import aux files if memory consumption exceeds this value",
+	  4000000, 0, 0)
+
+/* In LIPO profile-gen, use this parameter to record the cutoff value used at
+   profile collection runtime.  */
+DEFPARAM (PARAM_LIPO_CUTOFF,
+	  "lipo-cutoff",
+	  "The cutoff value of cumulative profile count. The value is between"
+          "0-99. 100 is reserved as a special value indicating default cutoff" 
+          "which is set at runtime. When the parameter is used and if its value"
+          "is not 100, it overrides the dafault as well as the value set by the"
+          " enviornment variable",
+	  100, 0, 100)
+
+/* In LIPO profile-gen, use this parameter to limit IPA inline.  */
+DEFPARAM (PARAM_LIPO_SKIP_SPECIAL_SECTIONS,
+	  "lipo-skip-special-sections",
+          "In LIPO profile gen compilation, do not generate direct call "
+          "profiling to functions marked with __attribute__((section(...))"
+          "Those functions can not be inlined so there is no point tracking"
+          "them.",
+	  1, 0, 1)
+
+/* In LIPO profile-gen, use this parameter to set random group generation
+   seed value.  */
+DEFPARAM (PARAM_LIPO_RANDOM_SEED,
+	  "lipo-random-seed",
+	  "random seed value used in random group testing",
+	  0, 0, 0)
+
+/* In LIPO profile-gen, use this parmaeter to set random group max size at profile
+   collection runtime.  */
+DEFPARAM (PARAM_LIPO_RANDOM_GROUP_SIZE,
+	  "lipo-random-group-size",
+	  "In LIPO random group testing, this parameter is used to set max group"
+          " size. The default value is 0 which is treated specially and specifies"
+          " no random grouping.",
+	  0, 0, 300)
+
+/* In LIPO profile-gen, use this parameter to specify the scale factor to propagate
+   callee module groups to caller.  */
+DEFPARAM (PARAM_LIPO_PROPAGATE_SCALE,
+	  "lipo-propagate-scale",
+	  "The scale factor to propagate callee module group's weight to the caller.",
+	  100, 0, 100)
+
+/* Choose different module grouping algorithms. This only affects
+   LIPO profile-gen.  */
+DEFPARAM (PARAM_LIPO_GROUPING_ALGORITHM,
+	  "lipo-grouping-algorithm",
+	  "Algorithm 0 uses the eager propagation algorithm."
+	  "Algorithm 1 uses the inclusion_based priority algorithm."
+	  "The default algorithm is 1.",
+	  1, 0, 1)
+
+/* In the inclusion_based_priority grouping algorithm, specify if we combine the
+   the edges b/w modules.  */
+DEFPARAM (PARAM_LIPO_MERGE_MODU_EDGES,
+	  "lipo-merge-modu-edges",
+	  "Default is 0 which not merge."
+	  "If the value is 1, merge the edges.",
+	  0, 0, 1)
+
+/* In the inclusion_based_priority grouping algorithm, specify if we force
+   strict inclusion of modules.  */
+DEFPARAM (PARAM_LIPO_WEAK_INCLUSION,
+	  "lipo-weak-inclusion",
+	  "0: force strict inclusion; 1: weak inclusion."
+	  "Default is 0.",
+	  0, 0, 1)
+
+/* In LIPO profile-use, use this parameter to enable the dumping of module id
+   in inline message.   */
+DEFPARAM (PARAM_INLINE_DUMP_MODULE_ID,
+	  "inline-dump-module-id",
+	  "Default is 1. If the value is 0, dumping is disabled.",
+	  1, 0, 1)
+
+/* In LIPO profile-gen, use this parameter to enable cgraph dumping.   */
+DEFPARAM (PARAM_LIPO_DUMP_CGRAPH,
+	  "lipo-dump-cgraph",
+	  "Default is 0. If the value is 1, text dump is used. If the value "
+	  "is 2, .dot dump is enabled. ", 
+	  0, 0, 2)
+
+DEFPARAM (PARAM_PROFILE_GENERATE_SAMPLING_PERIOD,
+         "profile-generate-sampling-period",
+         "sampling rate with -fprofile-generate-sampling",
+         100, 0, 2000000000)
+
+DEFPARAM (PARAM_COVERAGE_CALLBACK,
+         "coverage-callback",
+         "callback a user-define function when for arc counter increments.",
+         0, 0, 1)
+
+DEFPARAM (PARAM_COVERAGE_EXEC_ONCE,
+         "coverage-exec_once",
+         "Stop incrementing arc counts once they become 1.",
+         0, 0, 1)
+
+/* Used for debugging purpose. Tell the compiler to find
+   the gcda file in the current directory.  */
+DEFPARAM (PARAM_GCOV_DEBUG,
+	  "gcov-debug",
+	  "Looking for gcda file in current dir.",
+	  0, 0, 1)
+
 /* Avoid SLP vectorization of large basic blocks.  */
 DEFPARAM (PARAM_SLP_MAX_INSNS_IN_BB,
           "slp-max-insns-in-bb",
@@ -971,6 +1209,12 @@ DEFPARAM (MIN_PARTITION_SIZE,
 	  "Minimal size of a partition for LTO (in estimated instructions)",
 	  1000, 0, 0)
 
+DEFPARAM (PARAM_MIN_MCF_CANCEL_ITERS,
+	  "min-mcf-cancel-iters",
+	  "the minimum number of iterations of negative cycle cancellation "
+	  "in MCF",
+	  10, 1, 0)
+
 /* Diagnostic parameters.  */
 
 DEFPARAM (CXX_MAX_NAMESPACES_FOR_DIAGNOSTIC_HELP,
@@ -979,6 +1223,15 @@ DEFPARAM (CXX_MAX_NAMESPACES_FOR_DIAGNOSTIC_HELP,
 	  "name lookup fails",
 	  1000, 0, 0)
 
+
+/* Only output those call graph edges in .gnu.callgraph.text sections
+   whose count is greater than this value. */
+DEFPARAM (PARAM_GNU_CGRAPH_SECTION_EDGE_THRESHOLD,
+	  "gnu-cgraph-section-edge-threshold",
+	  "minimum call graph edge count for inclusion in "
+          ".gnu.callgraph.text section",
+	  0, 0, 0)
+
 /* Maximum number of conditional store pairs that can be sunk.  */
 DEFPARAM (PARAM_MAX_STORES_TO_SINK,
           "max-stores-to-sink",
@@ -1054,6 +1307,15 @@ DEFPARAM (PARAM_MAX_SLSR_CANDIDATE_SCAN,
 	  "strength reduction",
 	  50, 1, 999999)
 
+/* Parameters to be used with -mpatch-functions-for-instrumentation.
+   See config/i386/i386.opt  */
+DEFPARAM (PARAM_FUNCTION_PATCH_MIN_INSTRUCTIONS,
+          "function-patch-min-instructions",
+          "Minimum number of instructions in the function without loop before "
+          "the function is qualified for patching for instrumentation (for use "
+          "with -mpatch-functions-for-instrumentation)",
+          200, 0, 0)
+
 DEFPARAM (PARAM_ASAN_STACK,
          "asan-stack",
          "Enable asan stack protection",
-- 
cgit v1.2.3

