< prev index next >

src/hotspot/share/opto/c2_globals.hpp

Print this page

@@ -23,735 +23,734 @@
  */
 
 #ifndef SHARE_OPTO_C2_GLOBALS_HPP
 #define SHARE_OPTO_C2_GLOBALS_HPP
 
+#include "runtime/flags/jvmFlagConstraintsCompiler.hpp"
 #include "runtime/globals_shared.hpp"
 #include "utilities/macros.hpp"
 
 #include CPU_HEADER(c2_globals)
 #include OS_HEADER(c2_globals)
 
+extern "C" intx OptoLoopAlignment; // declared in globals.hpp
+
 //
-// Defines all globals flags used by the server compiler.
+// Declare all globals flags used by the server compiler.
 //
 
-#define C2_FLAGS(develop, \
-                 develop_pd, \
-                 product, \
-                 product_pd, \
-                 diagnostic, \
-                 diagnostic_pd, \
-                 experimental, \
-                 notproduct, \
-                 range, \
-                 constraint) \
-                                                                            \
-  diagnostic(bool, StressLCM, false,                                        \
-          "Randomize instruction scheduling in LCM")                        \
-                                                                            \
-  diagnostic(bool, StressGCM, false,                                        \
-          "Randomize instruction scheduling in GCM")                        \
-                                                                            \
-  develop(bool, StressMethodHandleLinkerInlining, false,                    \
-          "Stress inlining through method handle linkers")                  \
-                                                                            \
-  develop(intx, OptoPrologueNops, 0,                                        \
-          "Insert this many extra nop instructions "                        \
-          "in the prologue of every nmethod")                               \
-          range(0, 128)                                                     \
-                                                                            \
-  product_pd(intx, InteriorEntryAlignment,                                  \
-          "Code alignment for interior entry points "                       \
-          "in generated code (in bytes)")                                   \
-          constraint(InteriorEntryAlignmentConstraintFunc, AfterErgo)       \
-                                                                            \
-  product(intx, MaxLoopPad, (OptoLoopAlignment-1),                          \
-          "Align a loop if padding size in bytes is less or equal to this " \
-          "value")                                                          \
-          range(0, max_jint)                                                \
-                                                                            \
-  product(intx, MaxVectorSize, 64,                                          \
-          "Max vector size in bytes, "                                      \
-          "actual size could be less depending on elements type")           \
-          range(0, max_jint)                                                \
-                                                                            \
-  product(bool, AlignVector, true,                                          \
-          "Perform vector store/load alignment in loop")                    \
-                                                                            \
-  product(intx, NumberOfLoopInstrToAlign, 4,                                \
-          "Number of first instructions in a loop to align")                \
-          range(0, max_jint)                                                \
-                                                                            \
-  notproduct(intx, IndexSetWatch, 0,                                        \
-          "Trace all operations on this IndexSet (-1 means all, 0 none)")   \
-          range(-1, 0)                                                      \
-                                                                            \
-  develop(intx, OptoNodeListSize, 4,                                        \
-          "Starting allocation size of Node_List data structures")          \
-          range(0, max_jint)                                                \
-                                                                            \
-  develop(intx, OptoBlockListSize, 8,                                       \
-          "Starting allocation size of Block_List data structures")         \
-          range(0, max_jint)                                                \
-                                                                            \
-  develop(intx, OptoPeepholeAt, -1,                                         \
-          "Apply peephole optimizations to this peephole rule")             \
-                                                                            \
-  notproduct(bool, PrintIdeal, false,                                       \
-          "Print ideal graph before code generation")                       \
-                                                                            \
-  notproduct(bool, PrintOpto, false,                                        \
-          "Print compiler2 attempts")                                       \
-                                                                            \
-  notproduct(bool, PrintOptoInlining, false,                                \
-          "Print compiler2 inlining decisions")                             \
-                                                                            \
-  notproduct(bool, VerifyIdealNodeCount, false,                             \
-          "Verify that tracked dead ideal node count is accurate")          \
-                                                                            \
-  notproduct(bool, PrintIdealNodeCount, false,                              \
-          "Print liveness counts of ideal nodes")                           \
-                                                                            \
-  notproduct(bool, VerifyOptoOopOffsets, false,                             \
-          "Check types of base addresses in field references")              \
-                                                                            \
-  develop(bool, IdealizedNumerics, false,                                   \
-          "Check performance difference allowing FP "                       \
-          "associativity and commutativity...")                             \
-                                                                            \
-  diagnostic_pd(bool, IdealizeClearArrayNode,                               \
-          "Replace ClearArrayNode by subgraph of basic operations.")        \
-                                                                            \
-  develop(bool, OptoBreakpoint, false,                                      \
-          "insert breakpoint at method entry")                              \
-                                                                            \
-  notproduct(bool, OptoBreakpointOSR, false,                                \
-          "insert breakpoint at osr method entry")                          \
-                                                                            \
-  notproduct(intx, BreakAtNode, 0,                                          \
-          "Break at construction of this Node (either _idx or _debug_idx)") \
-                                                                            \
-  notproduct(bool, OptoBreakpointC2R, false,                                \
-          "insert breakpoint at runtime stub entry")                        \
-                                                                            \
-  notproduct(bool, OptoNoExecute, false,                                    \
-          "Attempt to parse and compile but do not execute generated code") \
-                                                                            \
-  notproduct(bool, PrintOptoStatistics, false,                              \
-          "Print New compiler statistics")                                  \
-                                                                            \
-  diagnostic(bool, PrintOptoAssembly, false,                                \
-          "Print New compiler assembly output")                             \
-                                                                            \
-  develop_pd(bool, OptoPeephole,                                            \
-          "Apply peephole optimizations after register allocation")         \
-                                                                            \
-  develop(bool, OptoRemoveUseless, true,                                    \
-          "Remove useless nodes after parsing")                             \
-                                                                            \
-  notproduct(bool, PrintFrameConverterAssembly, false,                      \
-          "Print New compiler assembly output for frame converters")        \
-                                                                            \
-  notproduct(bool, PrintParseStatistics, false,                             \
-          "Print nodes, transforms and new values made per bytecode parsed")\
-                                                                            \
-  notproduct(bool, PrintOptoPeephole, false,                                \
-          "Print New compiler peephole replacements")                       \
-                                                                            \
-  develop(bool, PrintCFGBlockFreq, false,                                   \
-          "Print CFG block freqencies")                                     \
-                                                                            \
-  develop(bool, TraceOptoParse, false,                                      \
-          "Trace bytecode parse and control-flow merge")                    \
-                                                                            \
-  product_pd(intx,  LoopUnrollLimit,                                        \
-          "Unroll loop bodies with node count less than this")              \
-          range(0, max_jint / 4)                                            \
-                                                                            \
-  product_pd(intx, LoopPercentProfileLimit,                                 \
-             "Unroll loop bodies with % node count of profile limit")       \
-             range(10, 100)                                                 \
-                                                                            \
-  product(intx,  LoopMaxUnroll, 16,                                         \
-          "Maximum number of unrolls for main loop")                        \
-          range(0, max_jint)                                                \
-                                                                            \
-  product_pd(bool,  SuperWordLoopUnrollAnalysis,                            \
-           "Map number of unrolls for main loop via "                       \
-           "Superword Level Parallelism analysis")                          \
-                                                                            \
-  experimental(bool, PostLoopMultiversioning, false,                        \
-           "Multi versioned post loops to eliminate range checks")          \
-                                                                            \
-  notproduct(bool, TraceSuperWordLoopUnrollAnalysis, false,                 \
-          "Trace what Superword Level Parallelism analysis applies")        \
-                                                                            \
-  diagnostic(bool, UseVectorMacroLogic, true,                               \
-          "Use ternary macro logic instructions")                           \
-                                                                            \
-  product(intx,  LoopUnrollMin, 4,                                          \
-          "Minimum number of unroll loop bodies before checking progress"   \
-          "of rounds of unroll,optimize,..")                                \
-          range(0, max_jint)                                                \
-                                                                            \
-  product(bool, UseSubwordForMaxVector, true,                               \
-          "Use Subword Analysis to set maximum vector size")                \
-                                                                            \
-  product(bool, UseVectorCmov, false,                                       \
-          "Use Vectorized Cmov")                                            \
-                                                                            \
-  develop(intx, UnrollLimitForProfileCheck, 1,                              \
-          "Don't use profile_trip_cnt() to restrict unrolling until "       \
-          "unrolling would push the number of unrolled iterations above "   \
-          "UnrollLimitForProfileCheck. A higher value allows more "         \
-          "unrolling. Zero acts as a very large value." )                   \
-          range(0, max_intx)                                                \
-                                                                            \
-  product(intx, MultiArrayExpandLimit, 6,                                   \
-          "Maximum number of individual allocations in an inline-expanded " \
-          "multianewarray instruction")                                     \
-          range(0, max_jint)                                                \
-                                                                            \
-  notproduct(bool, TraceProfileTripCount, false,                            \
-          "Trace profile loop trip count information")                      \
-                                                                            \
-  product(bool, UseCountedLoopSafepoints, false,                            \
-          "Force counted loops to keep a safepoint")                        \
-                                                                            \
-  product(bool, UseLoopPredicate, true,                                     \
-          "Generate a predicate to select fast/slow loop versions")         \
-                                                                            \
-  develop(bool, TraceLoopPredicate, false,                                  \
-          "Trace generation of loop predicates")                            \
-                                                                            \
-  develop(bool, TraceLoopOpts, false,                                       \
-          "Trace executed loop optimizations")                              \
-                                                                            \
-  develop(bool, TraceLoopLimitCheck, false,                                 \
-          "Trace generation of loop limits checks")                         \
-                                                                            \
-  develop(bool, TraceRangeLimitCheck, false,                                \
-          "Trace additional overflow checks in RCE")                        \
-                                                                            \
-  /* OptimizeFill not yet supported on PowerPC. */                          \
-  product(bool, OptimizeFill, true PPC64_ONLY(&& false),                    \
-          "convert fill/copy loops into intrinsic")                         \
-                                                                            \
-  develop(bool, TraceOptimizeFill, false,                                   \
-          "print detailed information about fill conversion")               \
-                                                                            \
-  develop(bool, OptoCoalesce, true,                                         \
-          "Use Conservative Copy Coalescing in the Register Allocator")     \
-                                                                            \
-  develop(bool, UseUniqueSubclasses, true,                                  \
-          "Narrow an abstract reference to the unique concrete subclass")   \
-                                                                            \
-  develop(bool, UseExactTypes, true,                                        \
-          "Use exact types to eliminate array store checks and v-calls")    \
-                                                                            \
-  product(intx, TrackedInitializationLimit, 50,                             \
-          "When initializing fields, track up to this many words")          \
-          range(0, 65535)                                                   \
-                                                                            \
-  product(bool, ReduceFieldZeroing, true,                                   \
-          "When initializing fields, try to avoid needless zeroing")        \
-                                                                            \
-  product(bool, ReduceInitialCardMarks, true,                               \
-          "When initializing fields, try to avoid needless card marks")     \
-                                                                            \
-  product(bool, ReduceBulkZeroing, true,                                    \
-          "When bulk-initializing, try to avoid needless zeroing")          \
-                                                                            \
-  product(bool, UseFPUForSpilling, false,                                   \
-          "Spill integer registers to FPU instead of stack when possible")  \
-                                                                            \
-  develop_pd(intx, RegisterCostAreaRatio,                                   \
-          "Spill selection in reg allocator: scale area by (X/64K) before " \
-          "adding cost")                                                    \
-                                                                            \
-  develop_pd(bool, UseCISCSpill,                                            \
-          "Use ADLC supplied cisc instructions during allocation")          \
-                                                                            \
-  notproduct(bool, VerifyGraphEdges , false,                                \
-          "Verify Bi-directional Edges")                                    \
-                                                                            \
-  notproduct(bool, VerifyDUIterators, true,                                 \
-          "Verify the safety of all iterations of Bi-directional Edges")    \
-                                                                            \
-  notproduct(bool, VerifyHashTableKeys, true,                               \
-          "Verify the immutability of keys in the VN hash tables")          \
-                                                                            \
-  notproduct(bool, VerifyRegisterAllocator , false,                         \
-          "Verify Register Allocator")                                      \
-                                                                            \
-  develop_pd(intx, FLOATPRESSURE,                                           \
-          "Number of float LRG's that constitute high register pressure")   \
-          range(0, max_jint)                                                \
-                                                                            \
-  develop_pd(intx, INTPRESSURE,                                             \
-          "Number of integer LRG's that constitute high register pressure") \
-          range(0, max_jint)                                                \
-                                                                            \
-  notproduct(bool, TraceOptoPipelining, false,                              \
-          "Trace pipelining information")                                   \
-                                                                            \
-  notproduct(bool, TraceOptoOutput, false,                                  \
-          "Trace pipelining information")                                   \
-                                                                            \
-  product_pd(bool, OptoScheduling,                                          \
-          "Instruction Scheduling after register allocation")               \
-                                                                            \
-  product_pd(bool, OptoRegScheduling,                                       \
-          "Instruction Scheduling before register allocation for pressure") \
-                                                                            \
-  product(bool, PartialPeelLoop, true,                                      \
-          "Partial peel (rotate) loops")                                    \
-                                                                            \
-  product(intx, PartialPeelNewPhiDelta, 0,                                  \
-          "Additional phis that can be created by partial peeling")         \
-          range(0, max_jint)                                                \
-                                                                            \
-  notproduct(bool, TracePartialPeeling, false,                              \
-          "Trace partial peeling (loop rotation) information")              \
-                                                                            \
-  product(bool, PartialPeelAtUnsignedTests, true,                           \
-          "Partial peel at unsigned tests if no signed test exists")        \
-                                                                            \
-  product(bool, ReassociateInvariants, true,                                \
-          "Enable reassociation of expressions with loop invariants.")      \
-                                                                            \
-  product(bool, LoopUnswitching, true,                                      \
-          "Enable loop unswitching (a form of invariant test hoisting)")    \
-                                                                            \
-  notproduct(bool, TraceLoopUnswitching, false,                             \
-          "Trace loop unswitching")                                         \
-                                                                            \
-  product(bool, AllowVectorizeOnDemand, true,                               \
-          "Globally supress vectorization set in VectorizeMethod")          \
-                                                                            \
-  product(bool, UseSuperWord, true,                                         \
-          "Transform scalar operations into superword operations")          \
-                                                                            \
-  develop(bool, SuperWordRTDepCheck, false,                                 \
-          "Enable runtime dependency checks.")                              \
-                                                                            \
-  product(bool, SuperWordReductions, true,                                  \
-          "Enable reductions support in superword.")                        \
-                                                                            \
-  product(bool, UseCMoveUnconditionally, false,                             \
-          "Use CMove (scalar and vector) ignoring profitability test.")     \
-                                                                            \
-  product(bool, DoReserveCopyInSuperWord, true,                             \
-          "Create reserve copy of graph in SuperWord.")                     \
-                                                                            \
-  notproduct(bool, TraceSuperWord, false,                                   \
-          "Trace superword transforms")                                     \
-                                                                            \
-  notproduct(bool, TraceNewVectors, false,                                  \
-          "Trace creation of Vector nodes")                                 \
-                                                                            \
-  product_pd(bool, OptoBundling,                                            \
-          "Generate nops to fill i-cache lines")                            \
-                                                                            \
-  product_pd(intx, ConditionalMoveLimit,                                    \
-          "Limit of ops to make speculative when using CMOVE")              \
-          range(0, max_jint)                                                \
-                                                                            \
-  /* Set BranchOnRegister == false. See 4965987. */                         \
-  product(bool, BranchOnRegister, false,                                    \
-          "Use Sparc V9 branch-on-register opcodes")                        \
-                                                                            \
-  develop(bool, SparcV9RegsHiBitsZero, true,                                \
-          "Assume Sparc V9 I&L registers on V8+ systems are zero-extended") \
-                                                                            \
-  product(bool, UseRDPCForConstantTableBase, false,                         \
-          "Use Sparc RDPC instruction for the constant table base.")        \
-                                                                            \
-  notproduct(bool, PrintIdealGraph, false,                                  \
-          "Print ideal graph to XML file / network interface. "             \
-          "By default attempts to connect to the visualizer on a socket.")  \
-                                                                            \
-  notproduct(intx, PrintIdealGraphLevel, 0,                                 \
-          "Level of detail of the ideal graph printout. "                   \
-          "System-wide value, 0=nothing is printed, 4=all details printed. "\
-          "Level of detail of printouts can be set on a per-method level "  \
-          "as well by using CompileCommand=option.")                        \
-          range(0, 4)                                                       \
-                                                                            \
-  notproduct(intx, PrintIdealGraphPort, 4444,                               \
-          "Ideal graph printer to network port")                            \
-          range(0, SHRT_MAX)                                                \
-                                                                            \
-  notproduct(ccstr, PrintIdealGraphAddress, "127.0.0.1",                    \
-          "IP address to connect to visualizer")                            \
-                                                                            \
-  notproduct(ccstr, PrintIdealGraphFile, NULL,                              \
-          "File to dump ideal graph to.  If set overrides the "             \
-          "use of the network")                                             \
-                                                                            \
-  product(bool, UseBimorphicInlining, true,                                 \
-          "Profiling based inlining for two receivers")                     \
-                                                                            \
-  product(bool, UseOnlyInlinedBimorphic, true,                              \
-          "Don't use BimorphicInlining if can't inline a second method")    \
-                                                                            \
-  product(bool, InsertMemBarAfterArraycopy, true,                           \
-          "Insert memory barrier after arraycopy call")                     \
-                                                                            \
-  develop(bool, SubsumeLoads, true,                                         \
-          "Attempt to compile while subsuming loads into machine "          \
-          "instructions.")                                                  \
-                                                                            \
-  develop(bool, StressRecompilation, false,                                 \
-          "Recompile each compiled method without subsuming loads "         \
-          "or escape analysis.")                                            \
-                                                                            \
-  develop(intx, ImplicitNullCheckThreshold, 3,                              \
-          "Don't do implicit null checks if NPE's in a method exceeds "     \
-          "limit")                                                          \
-          range(0, max_jint)                                                \
-                                                                            \
-  product(intx, LoopOptsCount, 43,                                          \
-          "Set level of loop optimization for tier 1 compiles")             \
-          range(5, 43)                                                      \
-                                                                            \
-  /* controls for heat-based inlining */                                    \
-                                                                            \
-  develop(intx, NodeCountInliningCutoff, 18000,                             \
-          "If parser node generation exceeds limit stop inlining")          \
-          range(0, max_jint)                                                \
-                                                                            \
-  develop(intx, NodeCountInliningStep, 1000,                                \
-          "Target size of warm calls inlined between optimization passes")  \
-          range(0, max_jint)                                                \
-                                                                            \
-  develop(bool, InlineWarmCalls, false,                                     \
-          "Use a heat-based priority queue to govern inlining")             \
-                                                                            \
-  /* Max values must not exceed WarmCallInfo::MAX_VALUE(). */               \
-  develop(intx, HotCallCountThreshold, 999999,                              \
-          "large numbers of calls (per method invocation) force hotness")   \
-          range(0, ((intx)MIN2((int64_t)max_intx,(int64_t)(+1.0e10))))      \
-                                                                            \
-  develop(intx, HotCallProfitThreshold, 999999,                             \
-          "highly profitable inlining opportunities force hotness")         \
-          range(0, ((intx)MIN2((int64_t)max_intx,(int64_t)(+1.0e10))))      \
-                                                                            \
-  develop(intx, HotCallTrivialWork, -1,                                     \
-          "trivial execution time (no larger than this) forces hotness")    \
-          range(-1, ((intx)MIN2((int64_t)max_intx,(int64_t)(+1.0e10))))     \
-                                                                            \
-  develop(intx, HotCallTrivialSize, -1,                                     \
-          "trivial methods (no larger than this) force calls to be hot")    \
-          range(-1, ((intx)MIN2((int64_t)max_intx,(int64_t)(+1.0e10))))     \
-                                                                            \
-  develop(intx, WarmCallMinCount, -1,                                       \
-          "number of calls (per method invocation) to enable inlining")     \
-          range(-1, ((intx)MIN2((int64_t)max_intx,(int64_t)(+1.0e10))))     \
-                                                                            \
-  develop(intx, WarmCallMinProfit, -1,                                      \
-          "number of calls (per method invocation) to enable inlining")     \
-          range(-1, ((intx)MIN2((int64_t)max_intx,(int64_t)(+1.0e10))))     \
-                                                                            \
-  develop(intx, WarmCallMaxWork, 999999,                                    \
-          "execution time of the largest inlinable method")                 \
-          range(0, ((intx)MIN2((int64_t)max_intx,(int64_t)(+1.0e10))))      \
-                                                                            \
-  develop(intx, WarmCallMaxSize, 999999,                                    \
-          "size of the largest inlinable method")                           \
-          range(0, ((intx)MIN2((int64_t)max_intx,(int64_t)(+1.0e10))))      \
-                                                                            \
-  product(intx, MaxNodeLimit, 80000,                                        \
-          "Maximum number of nodes")                                        \
-          range(1000, max_jint / 3)                                         \
-                                                                            \
-  product(intx, NodeLimitFudgeFactor, 2000,                                 \
-          "Fudge Factor for certain optimizations")                         \
-          constraint(NodeLimitFudgeFactorConstraintFunc, AfterErgo)         \
-                                                                            \
-  product(bool, UseJumpTables, true,                                        \
-          "Use JumpTables instead of a binary search tree for switches")    \
-                                                                            \
-  product(bool, UseDivMod, true,                                            \
-          "Use combined DivMod instruction if available")                   \
-                                                                            \
-  product_pd(intx, MinJumpTableSize,                                        \
-          "Minimum number of targets in a generated jump table")            \
-          range(0, max_intx)                                                \
-                                                                            \
-  product(intx, MaxJumpTableSize, 65000,                                    \
-          "Maximum number of targets in a generated jump table")            \
-          range(0, max_intx)                                                \
-                                                                            \
-  product(intx, MaxJumpTableSparseness, 5,                                  \
-          "Maximum sparseness for jumptables")                              \
-          range(0, max_intx / 4)                                            \
-                                                                            \
-  product(bool, EliminateLocks, true,                                       \
-          "Coarsen locks when possible")                                    \
-                                                                            \
-  product(bool, EliminateNestedLocks, true,                                 \
-          "Eliminate nested locks of the same object when possible")        \
-                                                                            \
-  notproduct(bool, PrintLockStatistics, false,                              \
-          "Print precise statistics on the dynamic lock usage")             \
-                                                                            \
-  diagnostic(bool, PrintPreciseBiasedLockingStatistics, false,              \
-          "Print per-lock-site statistics of biased locking in JVM")        \
-                                                                            \
-  diagnostic(bool, PrintPreciseRTMLockingStatistics, false,                 \
-          "Print per-lock-site statistics of rtm locking in JVM")           \
-                                                                            \
-  notproduct(bool, PrintEliminateLocks, false,                              \
-          "Print out when locks are eliminated")                            \
-                                                                            \
-  product(bool, EliminateAutoBox, true,                                     \
-          "Control optimizations for autobox elimination")                  \
-                                                                            \
-  product(intx, AutoBoxCacheMax, 128,                                       \
-          "Sets max value cached by the java.lang.Integer autobox cache")   \
-          range(0, max_jint)                                                \
-                                                                            \
-  diagnostic(bool, AggressiveUnboxing, true,                                \
-          "Control optimizations for aggressive boxing elimination")        \
-                                                                            \
-  develop(bool, TracePostallocExpand, false, "Trace expanding nodes after"  \
-          " register allocation.")                                          \
-                                                                            \
-  product(bool, DoEscapeAnalysis, true,                                     \
-          "Perform escape analysis")                                        \
-                                                                            \
-  product(double, EscapeAnalysisTimeout, 20. DEBUG_ONLY(+40.),              \
-          "Abort EA when it reaches time limit (in sec)")                   \
-          range(0, DBL_MAX)                                                 \
-                                                                            \
-  develop(bool, ExitEscapeAnalysisOnTimeout, true,                          \
-          "Exit or throw assert in EA when it reaches time limit")          \
-                                                                            \
-  notproduct(bool, PrintEscapeAnalysis, false,                              \
-          "Print the results of escape analysis")                           \
-                                                                            \
-  product(bool, EliminateAllocations, true,                                 \
-          "Use escape analysis to eliminate allocations")                   \
-                                                                            \
-  notproduct(bool, PrintEliminateAllocations, false,                        \
-          "Print out when allocations are eliminated")                      \
-                                                                            \
-  product(intx, EliminateAllocationArraySizeLimit, 64,                      \
-          "Array size (number of elements) limit for scalar replacement")   \
-          range(0, max_jint)                                                \
-                                                                            \
-  product(bool, OptimizePtrCompare, true,                                   \
-          "Use escape analysis to optimize pointers compare")               \
-                                                                            \
-  notproduct(bool, PrintOptimizePtrCompare, false,                          \
-          "Print information about optimized pointers compare")             \
-                                                                            \
-  notproduct(bool, VerifyConnectionGraph , true,                            \
-          "Verify Connection Graph construction in Escape Analysis")        \
-                                                                            \
-  product(bool, UseOptoBiasInlining, true,                                  \
-          "Generate biased locking code in C2 ideal graph")                 \
-                                                                            \
-  product(bool, OptimizeStringConcat, true,                                 \
-          "Optimize the construction of Strings by StringBuilder")          \
-                                                                            \
-  notproduct(bool, PrintOptimizeStringConcat, false,                        \
-          "Print information about transformations performed on Strings")   \
-                                                                            \
-  product(intx, ValueSearchLimit, 1000,                                     \
-          "Recursion limit in PhaseMacroExpand::value_from_mem_phi")        \
-          range(0, max_jint)                                                \
-                                                                            \
-  product(intx, MaxLabelRootDepth, 1100,                                    \
-          "Maximum times call Label_Root to prevent stack overflow")        \
-          range(100, max_jint)                                              \
-                                                                            \
-  diagnostic(intx, DominatorSearchLimit, 1000,                              \
-          "Iterations limit in Node::dominates")                            \
-          range(0, max_jint)                                                \
-                                                                            \
-  product(bool, BlockLayoutByFrequency, true,                               \
-          "Use edge frequencies to drive block ordering")                   \
-                                                                            \
-  product(intx, BlockLayoutMinDiamondPercentage, 20,                        \
-          "Miniumum %% of a successor (predecessor) for which block "       \
-          "layout a will allow a fork (join) in a single chain")            \
-          range(0, 100)                                                     \
-                                                                            \
-  product(bool, BlockLayoutRotateLoops, true,                               \
-          "Allow back branches to be fall throughs in the block layout")    \
-                                                                            \
-  diagnostic(bool, InlineReflectionGetCallerClass, true,                    \
-          "inline sun.reflect.Reflection.getCallerClass(), known to be "    \
-          "part of base library DLL")                                       \
-                                                                            \
-  diagnostic(bool, InlineObjectCopy, true,                                  \
-          "inline Object.clone and Arrays.copyOf[Range] intrinsics")        \
-                                                                            \
-  diagnostic(bool, SpecialStringCompareTo, true,                            \
-          "special version of string compareTo")                            \
-                                                                            \
-  diagnostic(bool, SpecialStringIndexOf, true,                              \
-          "special version of string indexOf")                              \
-                                                                            \
-  diagnostic(bool, SpecialStringEquals, true,                               \
-          "special version of string equals")                               \
-                                                                            \
-  diagnostic(bool, SpecialArraysEquals, true,                               \
-          "special version of Arrays.equals(char[],char[])")                \
-                                                                            \
-  diagnostic(bool, SpecialEncodeISOArray, true,                             \
-          "special version of ISO_8859_1$Encoder.encodeISOArray")           \
-                                                                            \
-  develop(bool, BailoutToInterpreterForThrows, false,                       \
-          "Compiled methods which throws/catches exceptions will be "       \
-          "deopt and intp.")                                                \
-                                                                            \
-  develop(bool, ConvertCmpD2CmpF, true,                                     \
-          "Convert cmpD to cmpF when one input is constant in float range") \
-                                                                            \
-  develop(bool, ConvertFloat2IntClipping, true,                             \
-          "Convert float2int clipping idiom to integer clipping")           \
-                                                                            \
-  develop(bool, MonomorphicArrayCheck, true,                                \
-          "Uncommon-trap array store checks that require full type check")  \
-                                                                            \
-  notproduct(bool, TracePhaseCCP, false,                                    \
-          "Print progress during Conditional Constant Propagation")         \
-                                                                            \
-  develop(bool, PrintDominators, false,                                     \
-          "Print out dominator trees for GVN")                              \
-                                                                            \
-  diagnostic(bool, TraceSpilling, false,                                    \
-          "Trace spilling")                                                 \
-                                                                            \
-  diagnostic(bool, TraceTypeProfile, false,                                 \
-          "Trace type profile")                                             \
-                                                                            \
-  develop(bool, PoisonOSREntry, true,                                       \
-           "Detect abnormal calls to OSR code")                             \
-                                                                            \
-  develop(bool, SoftMatchFailure, trueInProduct,                            \
-          "If the DFA fails to match a node, print a message and bail out") \
-                                                                            \
-  develop(bool, InlineAccessors, true,                                      \
-          "inline accessor methods (get/set)")                              \
-                                                                            \
-  product(intx, TypeProfileMajorReceiverPercent, 90,                        \
-          "% of major receiver type to all profiled receivers")             \
-          range(0, 100)                                                     \
-                                                                            \
-  diagnostic(bool, PrintIntrinsics, false,                                  \
-          "prints attempted and successful inlining of intrinsics")         \
-                                                                            \
-  develop(bool, StressReflectiveCode, false,                                \
-          "Use inexact types at allocations, etc., to test reflection")     \
-                                                                            \
-  diagnostic(bool, DebugInlinedCalls, true,                                 \
-         "If false, restricts profiled locations to the root method only")  \
-                                                                            \
-  notproduct(bool, VerifyLoopOptimizations, false,                          \
-          "verify major loop optimizations")                                \
-                                                                            \
-  diagnostic(bool, ProfileDynamicTypes, true,                               \
-          "do extra type profiling and use it more aggressively")           \
-                                                                            \
-  develop(bool, TraceIterativeGVN, false,                                   \
-          "Print progress during Iterative Global Value Numbering")         \
-                                                                            \
-  develop(bool, VerifyIterativeGVN, false,                                  \
-          "Verify Def-Use modifications during sparse Iterative Global "    \
-          "Value Numbering")                                                \
-                                                                            \
-  notproduct(bool, TraceCISCSpill, false,                                   \
-          "Trace allocators use of cisc spillable instructions")            \
-                                                                            \
-  product(bool, SplitIfBlocks, true,                                        \
-          "Clone compares and control flow through merge points to fold "   \
-          "some branches")                                                  \
-                                                                            \
-  develop(intx, FreqCountInvocations,  1,                                   \
-          "Scaling factor for branch frequencies (deprecated)")             \
-          range(1, max_intx)                                                \
-                                                                            \
-  product(intx, AliasLevel,     3,                                          \
-          "0 for no aliasing, 1 for oop/field/static/array split, "         \
-          "2 for class split, 3 for unique instances")                      \
-          range(0, 3)                                                       \
-          constraint(AliasLevelConstraintFunc,AfterErgo)                    \
-                                                                            \
-  develop(bool, VerifyAliases, false,                                       \
-          "perform extra checks on the results of alias analysis")          \
-                                                                            \
-  product(bool, IncrementalInline, true,                                    \
-          "do post parse inlining")                                         \
-                                                                            \
-  develop(bool, AlwaysIncrementalInline, false,                             \
-          "do all inlining incrementally")                                  \
-                                                                            \
-  product(intx, LiveNodeCountInliningCutoff, 40000,                         \
-          "max number of live nodes in a method")                           \
-          range(0, max_juint / 8)                                           \
-                                                                            \
-  diagnostic(bool, OptimizeExpensiveOps, true,                              \
-          "Find best control for expensive operations")                     \
-                                                                            \
-  diagnostic(bool, UseMathExactIntrinsics, true,                            \
-          "Enables intrinsification of various java.lang.Math functions")   \
-                                                                            \
-  diagnostic(bool, UseCharacterCompareIntrinsics, false,                    \
-          "Enables intrinsification of java.lang.Character functions")      \
-                                                                            \
-  diagnostic(bool, UseMultiplyToLenIntrinsic, false,                        \
-          "Enables intrinsification of BigInteger.multiplyToLen()")         \
-                                                                            \
-  diagnostic(bool, UseSquareToLenIntrinsic, false,                          \
-          "Enables intrinsification of BigInteger.squareToLen()")           \
-                                                                            \
-  diagnostic(bool, UseMulAddIntrinsic, false,                               \
-          "Enables intrinsification of BigInteger.mulAdd()")                \
-                                                                            \
-  diagnostic(bool, UseMontgomeryMultiplyIntrinsic, false,                   \
-          "Enables intrinsification of BigInteger.montgomeryMultiply()")    \
-                                                                            \
-  diagnostic(bool, UseMontgomerySquareIntrinsic, false,                     \
-          "Enables intrinsification of BigInteger.montgomerySquare()")      \
-                                                                            \
-  product(bool, UseTypeSpeculation, true,                                   \
-          "Speculatively propagate types from profiles")                    \
-                                                                            \
-  diagnostic(bool, UseInlineDepthForSpeculativeTypes, true,                 \
-          "Carry inline depth of profile point with speculative type "      \
-          "and give priority to profiling from lower inline depth")         \
-                                                                            \
-  product_pd(bool, TrapBasedRangeChecks,                                    \
-          "Generate code for range checks that uses a cmp and trap "        \
-          "instruction raising SIGTRAP. Used on PPC64.")                    \
-                                                                            \
-  product(intx, ArrayCopyLoadStoreMaxElem, 8,                               \
-          "Maximum number of arraycopy elements inlined as a sequence of"   \
-          "loads/stores")                                                   \
-          range(0, max_intx)                                                \
-                                                                            \
-  develop(bool, StressArrayCopyMacroNode, false,                            \
-          "Perform ArrayCopy load/store replacement during IGVN only")      \
-                                                                            \
-  develop(bool, RenumberLiveNodes, true,                                    \
-          "Renumber live nodes")                                            \
-                                                                            \
-  product(uintx, LoopStripMiningIter, 0,                                    \
-          "Number of iterations in strip mined loop")                       \
-          range(0, max_juint)                                               \
-                                                                            \
-  product(uintx, LoopStripMiningIterShortLoop, 0,                           \
-          "Loop with fewer iterations are not strip mined")                 \
-          range(0, max_juint)                                               \
-                                                                            \
-  product(bool, UseProfiledLoopPredicate, true,                             \
-          "Move predicates out of loops based on profiling data")           \
-                                                                            \
-  diagnostic(bool, ExpandSubTypeCheckAtParseTime, false,                    \
-          "Do not use subtype check macro node")                            \
+#include "utilities/macros.hpp"
+#if COMPILER2
+#include "runtime/flags/jvmFlag.hpp"
+PRODUCT_FLAG(bool,     StressLCM, false, JVMFlag::DIAGNOSTIC,
+                       "Randomize instruction scheduling in LCM");
+
+PRODUCT_FLAG(bool,     StressGCM, false, JVMFlag::DIAGNOSTIC,
+                       "Randomize instruction scheduling in GCM");
+
+DEVELOP_FLAG(bool,     StressMethodHandleLinkerInlining, false, JVMFlag::DEFAULT,
+                       "Stress inlining through method handle linkers");
+
+DEVELOP_FLAG(intx,     OptoPrologueNops, 0, JVMFlag::RANGE,
+                       "Insert this many extra nop instructions "
+                       "in the prologue of every nmethod");
+   FLAG_RANGE(         OptoPrologueNops, 0, 128);
+
+PRODUCT_FLAG_PD(intx,  InteriorEntryAlignment, JVMFlag::CONSTRAINT,
+                       "Code alignment for interior entry points "
+                       "in generated code (in bytes)");
+   FLAG_CONSTRAINT(    InteriorEntryAlignment, (void*)InteriorEntryAlignmentConstraintFunc, JVMFlag::AfterErgo);
+
+PRODUCT_FLAG(intx,     MaxLoopPad, (OptoLoopAlignment-1), JVMFlag::RANGE,
+                       "Align a loop if padding size in bytes is less or equal to this "
+                       "value");
+   FLAG_RANGE(         MaxLoopPad, 0, max_jint);
+
+PRODUCT_FLAG(intx,     MaxVectorSize, 64, JVMFlag::RANGE,
+                       "Max vector size in bytes, "
+                       "actual size could be less depending on elements type");
+   FLAG_RANGE(         MaxVectorSize, 0, max_jint);
+
+PRODUCT_FLAG(bool,     AlignVector, true, JVMFlag::DEFAULT,
+                       "Perform vector store/load alignment in loop");
+
+PRODUCT_FLAG(intx,     NumberOfLoopInstrToAlign, 4, JVMFlag::RANGE,
+                       "Number of first instructions in a loop to align");
+   FLAG_RANGE(         NumberOfLoopInstrToAlign, 0, max_jint);
+
+NOTPROD_FLAG(intx,     IndexSetWatch, 0, JVMFlag::RANGE,
+                       "Trace all operations on this IndexSet (-1 means all, 0 none)");
+   FLAG_RANGE(         IndexSetWatch, -1, 0);
+
+DEVELOP_FLAG(intx,     OptoNodeListSize, 4, JVMFlag::RANGE,
+                       "Starting allocation size of Node_List data structures");
+   FLAG_RANGE(         OptoNodeListSize, 0, max_jint);
+
+DEVELOP_FLAG(intx,     OptoBlockListSize, 8, JVMFlag::RANGE,
+                       "Starting allocation size of Block_List data structures");
+   FLAG_RANGE(         OptoBlockListSize, 0, max_jint);
+
+DEVELOP_FLAG(intx,     OptoPeepholeAt, -1, JVMFlag::DEFAULT,
+                       "Apply peephole optimizations to this peephole rule");
+
+NOTPROD_FLAG(bool,     PrintIdeal, false, JVMFlag::DEFAULT,
+                       "Print ideal graph before code generation");
+
+DEVELOP_FLAG(bool,     PrintOpto, false, JVMFlag::DEFAULT,
+                       "Print compiler2 attempts");
+
+DEVELOP_FLAG(bool,     PrintOptoInlining, false, JVMFlag::DEFAULT,
+                       "Print compiler2 inlining decisions");
+
+NOTPROD_FLAG(bool,     VerifyIdealNodeCount, false, JVMFlag::DEFAULT,
+                       "Verify that tracked dead ideal node count is accurate");
+
+NOTPROD_FLAG(bool,     PrintIdealNodeCount, false, JVMFlag::DEFAULT,
+                       "Print liveness counts of ideal nodes");
+
+NOTPROD_FLAG(bool,     VerifyOptoOopOffsets, false, JVMFlag::DEFAULT,
+                       "Check types of base addresses in field references");
+
+DEVELOP_FLAG(bool,     IdealizedNumerics, false, JVMFlag::DEFAULT,
+                       "Check performance difference allowing FP "
+                       "associativity and commutativity...");
+
+PRODUCT_FLAG_PD(bool,  IdealizeClearArrayNode, JVMFlag::DIAGNOSTIC,
+                       "Replace ClearArrayNode by subgraph of basic operations.");
+
+DEVELOP_FLAG(bool,     OptoBreakpoint, false, JVMFlag::DEFAULT,
+                       "insert breakpoint at method entry");
+
+DEVELOP_FLAG(bool,     OptoBreakpointOSR, false, JVMFlag::DEFAULT,
+                       "insert breakpoint at osr method entry");
+
+NOTPROD_FLAG(intx,     BreakAtNode, 0, JVMFlag::DEFAULT,
+                       "Break at construction of this Node (either _idx or _debug_idx)");
+
+DEVELOP_FLAG(bool,     OptoBreakpointC2R, false, JVMFlag::DEFAULT,
+                       "insert breakpoint at runtime stub entry");
+
+NOTPROD_FLAG(bool,     OptoNoExecute, false, JVMFlag::DEFAULT,
+                       "Attempt to parse and compile but do not execute generated code");
+
+NOTPROD_FLAG(bool,     PrintOptoStatistics, false, JVMFlag::DEFAULT,
+                       "Print New compiler statistics");
+
+PRODUCT_FLAG(bool,     PrintOptoAssembly, false, JVMFlag::DIAGNOSTIC,
+                       "Print New compiler assembly output");
+
+DEVELOP_FLAG_PD(bool,  OptoPeephole, JVMFlag::DEFAULT,
+                       "Apply peephole optimizations after register allocation");
+
+DEVELOP_FLAG(bool,     OptoRemoveUseless, true, JVMFlag::DEFAULT,
+                       "Remove useless nodes after parsing");
+
+NOTPROD_FLAG(bool,     PrintFrameConverterAssembly, false, JVMFlag::DEFAULT,
+                       "Print New compiler assembly output for frame converters");
+
+NOTPROD_FLAG(bool,     PrintParseStatistics, false, JVMFlag::DEFAULT,
+                       "Print nodes, transforms and new values made per bytecode parsed");
+
+NOTPROD_FLAG(bool,     PrintOptoPeephole, false, JVMFlag::DEFAULT,
+                       "Print New compiler peephole replacements");
+
+DEVELOP_FLAG(bool,     PrintCFGBlockFreq, false, JVMFlag::DEFAULT,
+                       "Print CFG block freqencies");
+
+DEVELOP_FLAG(bool,     TraceOptoParse, false, JVMFlag::DEFAULT,
+                       "Trace bytecode parse and control-flow merge");
+
+PRODUCT_FLAG_PD(intx,  LoopUnrollLimit, JVMFlag::RANGE,
+                       "Unroll loop bodies with node count less than this");
+   FLAG_RANGE(         LoopUnrollLimit, 0, max_jint / 4);
+
+PRODUCT_FLAG_PD(intx,  LoopPercentProfileLimit, JVMFlag::RANGE,
+                       "Unroll loop bodies with % node count of profile limit");
+   FLAG_RANGE(         LoopPercentProfileLimit, 10, 100);
+
+PRODUCT_FLAG(intx,     LoopMaxUnroll, 16, JVMFlag::RANGE,
+                       "Maximum number of unrolls for main loop");
+   FLAG_RANGE(         LoopMaxUnroll, 0, max_jint);
+
+PRODUCT_FLAG_PD(bool,  SuperWordLoopUnrollAnalysis, JVMFlag::DEFAULT,
+                       "Map number of unrolls for main loop via "
+                       "Superword Level Parallelism analysis");
+
+PRODUCT_FLAG(bool,     PostLoopMultiversioning, false, JVMFlag::EXPERIMENTAL,
+                       "Multi versioned post loops to eliminate range checks");
+
+DEVELOP_FLAG(bool,     TraceSuperWordLoopUnrollAnalysis, false, JVMFlag::DEFAULT,
+                       "Trace what Superword Level Parallelism analysis applies");
+
+PRODUCT_FLAG(bool,     UseVectorMacroLogic, true, JVMFlag::DIAGNOSTIC,
+                       "Use ternary macro logic instructions");
+
+PRODUCT_FLAG(intx,     LoopUnrollMin, 4, JVMFlag::RANGE,
+                       "Minimum number of unroll loop bodies before checking progress"
+                       "of rounds of unroll,optimize,..");
+   FLAG_RANGE(         LoopUnrollMin, 0, max_jint);
+
+PRODUCT_FLAG(bool,     UseSubwordForMaxVector, true, JVMFlag::DEFAULT,
+                       "Use Subword Analysis to set maximum vector size");
+
+PRODUCT_FLAG(bool,     UseVectorCmov, false, JVMFlag::DEFAULT,
+                       "Use Vectorized Cmov");
+
+DEVELOP_FLAG(intx,     UnrollLimitForProfileCheck, 1, JVMFlag::RANGE,
+                       "Don't use profile_trip_cnt() to restrict unrolling until "
+                       "unrolling would push the number of unrolled iterations above "
+                       "UnrollLimitForProfileCheck. A higher value allows more "
+                       "unrolling. Zero acts as a very large value.");
+   FLAG_RANGE(         UnrollLimitForProfileCheck, 0, max_intx);
+
+PRODUCT_FLAG(intx,     MultiArrayExpandLimit, 6, JVMFlag::RANGE,
+                       "Maximum number of individual allocations in an inline-expanded "
+                       "multianewarray instruction");
+   FLAG_RANGE(         MultiArrayExpandLimit, 0, max_jint);
+
+NOTPROD_FLAG(bool,     TraceProfileTripCount, false, JVMFlag::DEFAULT,
+                       "Trace profile loop trip count information");
+
+PRODUCT_FLAG(bool,     UseCountedLoopSafepoints, false, JVMFlag::DEFAULT,
+                       "Force counted loops to keep a safepoint");
+
+PRODUCT_FLAG(bool,     UseLoopPredicate, true, JVMFlag::DEFAULT,
+                       "Generate a predicate to select fast/slow loop versions");
+
+DEVELOP_FLAG(bool,     TraceLoopPredicate, false, JVMFlag::DEFAULT,
+                       "Trace generation of loop predicates");
+
+DEVELOP_FLAG(bool,     TraceLoopOpts, false, JVMFlag::DEFAULT,
+                       "Trace executed loop optimizations");
+
+DEVELOP_FLAG(bool,     TraceLoopLimitCheck, false, JVMFlag::DEFAULT,
+                       "Trace generation of loop limits checks");
+
+DEVELOP_FLAG(bool,     TraceRangeLimitCheck, false, JVMFlag::DEFAULT,
+                       "Trace additional overflow checks in RCE");
+
+
+    //  OptimizeFill not yet supported on PowerPC. 
+PRODUCT_FLAG(bool,     OptimizeFill, true PPC64_ONLY(&& false), JVMFlag::DEFAULT,
+                       "convert fill/copy loops into intrinsic");
+
+DEVELOP_FLAG(bool,     TraceOptimizeFill, false, JVMFlag::DEFAULT,
+                       "print detailed information about fill conversion");
+
+DEVELOP_FLAG(bool,     OptoCoalesce, true, JVMFlag::DEFAULT,
+                       "Use Conservative Copy Coalescing in the Register Allocator");
+
+DEVELOP_FLAG(bool,     UseUniqueSubclasses, true, JVMFlag::DEFAULT,
+                       "Narrow an abstract reference to the unique concrete subclass");
+
+DEVELOP_FLAG(bool,     UseExactTypes, true, JVMFlag::DEFAULT,
+                       "Use exact types to eliminate array store checks and v-calls");
+
+PRODUCT_FLAG(intx,     TrackedInitializationLimit, 50, JVMFlag::RANGE,
+                       "When initializing fields, track up to this many words");
+   FLAG_RANGE(         TrackedInitializationLimit, 0, 65535);
+
+PRODUCT_FLAG(bool,     ReduceFieldZeroing, true, JVMFlag::DEFAULT,
+                       "When initializing fields, try to avoid needless zeroing");
+
+PRODUCT_FLAG(bool,     ReduceInitialCardMarks, true, JVMFlag::DEFAULT,
+                       "When initializing fields, try to avoid needless card marks");
+
+PRODUCT_FLAG(bool,     ReduceBulkZeroing, true, JVMFlag::DEFAULT,
+                       "When bulk-initializing, try to avoid needless zeroing");
+
+PRODUCT_FLAG(bool,     UseFPUForSpilling, false, JVMFlag::DEFAULT,
+                       "Spill integer registers to FPU instead of stack when possible");
+
+DEVELOP_FLAG_PD(intx,  RegisterCostAreaRatio, JVMFlag::DEFAULT,
+                       "Spill selection in reg allocator: scale area by (X/64K) before "
+                       "adding cost");
+
+DEVELOP_FLAG_PD(bool,  UseCISCSpill, JVMFlag::DEFAULT,
+                       "Use ADLC supplied cisc instructions during allocation");
+
+NOTPROD_FLAG(bool,     VerifyGraphEdges, false, JVMFlag::DEFAULT,
+                       "Verify Bi-directional Edges");
+
+NOTPROD_FLAG(bool,     VerifyDUIterators, true, JVMFlag::DEFAULT,
+                       "Verify the safety of all iterations of Bi-directional Edges");
+
+NOTPROD_FLAG(bool,     VerifyHashTableKeys, true, JVMFlag::DEFAULT,
+                       "Verify the immutability of keys in the VN hash tables");
+
+NOTPROD_FLAG(bool,     VerifyRegisterAllocator, false, JVMFlag::DEFAULT,
+                       "Verify Register Allocator");
+
+DEVELOP_FLAG_PD(intx,  FLOATPRESSURE, JVMFlag::RANGE,
+                       "Number of float LRG's that constitute high register pressure");
+   FLAG_RANGE(         FLOATPRESSURE, 0, max_jint);
+
+DEVELOP_FLAG_PD(intx,  INTPRESSURE, JVMFlag::RANGE,
+                       "Number of integer LRG's that constitute high register pressure");
+   FLAG_RANGE(         INTPRESSURE, 0, max_jint);
+
+NOTPROD_FLAG(bool,     TraceOptoPipelining, false, JVMFlag::DEFAULT,
+                       "Trace pipelining information");
+
+NOTPROD_FLAG(bool,     TraceOptoOutput, false, JVMFlag::DEFAULT,
+                       "Trace pipelining information");
+
+PRODUCT_FLAG_PD(bool,  OptoScheduling, JVMFlag::DEFAULT,
+                       "Instruction Scheduling after register allocation");
+
+PRODUCT_FLAG_PD(bool,  OptoRegScheduling, JVMFlag::DEFAULT,
+                       "Instruction Scheduling before register allocation for pressure");
+
+PRODUCT_FLAG(bool,     PartialPeelLoop, true, JVMFlag::DEFAULT,
+                       "Partial peel (rotate) loops");
+
+PRODUCT_FLAG(intx,     PartialPeelNewPhiDelta, 0, JVMFlag::RANGE,
+                       "Additional phis that can be created by partial peeling");
+   FLAG_RANGE(         PartialPeelNewPhiDelta, 0, max_jint);
+
+NOTPROD_FLAG(bool,     TracePartialPeeling, false, JVMFlag::DEFAULT,
+                       "Trace partial peeling (loop rotation) information");
+
+PRODUCT_FLAG(bool,     PartialPeelAtUnsignedTests, true, JVMFlag::DEFAULT,
+                       "Partial peel at unsigned tests if no signed test exists");
+
+PRODUCT_FLAG(bool,     ReassociateInvariants, true, JVMFlag::DEFAULT,
+                       "Enable reassociation of expressions with loop invariants.");
+
+PRODUCT_FLAG(bool,     LoopUnswitching, true, JVMFlag::DEFAULT,
+                       "Enable loop unswitching (a form of invariant test hoisting)");
+
+NOTPROD_FLAG(bool,     TraceLoopUnswitching, false, JVMFlag::DEFAULT,
+                       "Trace loop unswitching");
+
+PRODUCT_FLAG(bool,     AllowVectorizeOnDemand, true, JVMFlag::DEFAULT,
+                       "Globally supress vectorization set in VectorizeMethod");
+
+PRODUCT_FLAG(bool,     UseSuperWord, true, JVMFlag::DEFAULT,
+                       "Transform scalar operations into superword operations");
+
+DEVELOP_FLAG(bool,     SuperWordRTDepCheck, false, JVMFlag::DEFAULT,
+                       "Enable runtime dependency checks.");
+
+PRODUCT_FLAG(bool,     SuperWordReductions, true, JVMFlag::DEFAULT,
+                       "Enable reductions support in superword.");
+
+PRODUCT_FLAG(bool,     UseCMoveUnconditionally, false, JVMFlag::DEFAULT,
+                       "Use CMove (scalar and vector) ignoring profitability test.");
+
+PRODUCT_FLAG(bool,     DoReserveCopyInSuperWord, true, JVMFlag::DEFAULT,
+                       "Create reserve copy of graph in SuperWord.");
+
+DEVELOP_FLAG(bool,     TraceSuperWord, false, JVMFlag::DEFAULT,
+                       "Trace superword transforms");
+
+NOTPROD_FLAG(bool,     TraceNewVectors, false, JVMFlag::DEFAULT,
+                       "Trace creation of Vector nodes");
+
+PRODUCT_FLAG_PD(bool,  OptoBundling, JVMFlag::DEFAULT,
+                       "Generate nops to fill i-cache lines");
+
+PRODUCT_FLAG_PD(intx,  ConditionalMoveLimit, JVMFlag::RANGE,
+                       "Limit of ops to make speculative when using CMOVE");
+   FLAG_RANGE(         ConditionalMoveLimit, 0, max_jint);
+
+
+    //  Set BranchOnRegister == false. See 4965987. 
+PRODUCT_FLAG(bool,     BranchOnRegister, false, JVMFlag::DEFAULT,
+                       "Use Sparc V9 branch-on-register opcodes");
+
+DEVELOP_FLAG(bool,     SparcV9RegsHiBitsZero, true, JVMFlag::DEFAULT,
+                       "Assume Sparc V9 I&L registers on V8+ systems are zero-extended");
+
+PRODUCT_FLAG(bool,     UseRDPCForConstantTableBase, false, JVMFlag::DEFAULT,
+                       "Use Sparc RDPC instruction for the constant table base.");
+
+NOTPROD_FLAG(bool,     PrintIdealGraph, false, JVMFlag::DEFAULT,
+                       "Print ideal graph to XML file / network interface. "
+                       "By default attempts to connect to the visualizer on a socket.");
+
+NOTPROD_FLAG(intx,     PrintIdealGraphLevel, 0, JVMFlag::RANGE,
+                       "Level of detail of the ideal graph printout. "
+                       "System-wide value, 0=nothing is printed, 4=all details printed. "
+                       "Level of detail of printouts can be set on a per-method level "
+                       "as well by using CompileCommand=option.");
+   FLAG_RANGE(         PrintIdealGraphLevel, 0, 4);
+
+NOTPROD_FLAG(intx,     PrintIdealGraphPort, 4444, JVMFlag::RANGE,
+                       "Ideal graph printer to network port");
+   FLAG_RANGE(         PrintIdealGraphPort, 0, SHRT_MAX);
+
+NOTPROD_FLAG(ccstr,    PrintIdealGraphAddress, "127.0.0.1", JVMFlag::DEFAULT,
+                       "IP address to connect to visualizer");
+
+NOTPROD_FLAG(ccstr,    PrintIdealGraphFile, NULL, JVMFlag::DEFAULT,
+                       "File to dump ideal graph to.  If set overrides the "
+                       "use of the network");
+
+PRODUCT_FLAG(bool,     UseBimorphicInlining, true, JVMFlag::DEFAULT,
+                       "Profiling based inlining for two receivers");
+
+PRODUCT_FLAG(bool,     UseOnlyInlinedBimorphic, true, JVMFlag::DEFAULT,
+                       "Don't use BimorphicInlining if can't inline a second method");
+
+PRODUCT_FLAG(bool,     InsertMemBarAfterArraycopy, true, JVMFlag::DEFAULT,
+                       "Insert memory barrier after arraycopy call");
+
+DEVELOP_FLAG(bool,     SubsumeLoads, true, JVMFlag::DEFAULT,
+                       "Attempt to compile while subsuming loads into machine "
+                       "instructions.");
+
+DEVELOP_FLAG(bool,     StressRecompilation, false, JVMFlag::DEFAULT,
+                       "Recompile each compiled method without subsuming loads "
+                       "or escape analysis.");
+
+DEVELOP_FLAG(intx,     ImplicitNullCheckThreshold, 3, JVMFlag::RANGE,
+                       "Don't do implicit null checks if NPE's in a method exceeds "
+                       "limit");
+   FLAG_RANGE(         ImplicitNullCheckThreshold, 0, max_jint);
+
+PRODUCT_FLAG(intx,     LoopOptsCount, 43, JVMFlag::RANGE,
+                       "Set level of loop optimization for tier 1 compiles");
+   FLAG_RANGE(         LoopOptsCount, 5, 43);
+
+
+    //  controls for heat-based inlining 
+DEVELOP_FLAG(intx,     NodeCountInliningCutoff, 18000, JVMFlag::RANGE,
+                       "If parser node generation exceeds limit stop inlining");
+   FLAG_RANGE(         NodeCountInliningCutoff, 0, max_jint);
+
+DEVELOP_FLAG(intx,     NodeCountInliningStep, 1000, JVMFlag::RANGE,
+                       "Target size of warm calls inlined between optimization passes");
+   FLAG_RANGE(         NodeCountInliningStep, 0, max_jint);
+
+DEVELOP_FLAG(bool,     InlineWarmCalls, false, JVMFlag::DEFAULT,
+                       "Use a heat-based priority queue to govern inlining");
+
+
+    //  Max values must not exceed WarmCallInfo::MAX_VALUE(). 
+DEVELOP_FLAG(intx,     HotCallCountThreshold, 999999, JVMFlag::RANGE,
+                       "large numbers of calls (per method invocation) force hotness");
+   FLAG_RANGE(         HotCallCountThreshold, 0, ((intx)MIN2((int64_t)max_intx,(int64_t)(+1.0e10))));
+
+DEVELOP_FLAG(intx,     HotCallProfitThreshold, 999999, JVMFlag::RANGE,
+                       "highly profitable inlining opportunities force hotness");
+   FLAG_RANGE(         HotCallProfitThreshold, 0, ((intx)MIN2((int64_t)max_intx,(int64_t)(+1.0e10))));
+
+DEVELOP_FLAG(intx,     HotCallTrivialWork, -1, JVMFlag::RANGE,
+                       "trivial execution time (no larger than this) forces hotness");
+   FLAG_RANGE(         HotCallTrivialWork, -1, ((intx)MIN2((int64_t)max_intx,(int64_t)(+1.0e10))));
+
+DEVELOP_FLAG(intx,     HotCallTrivialSize, -1, JVMFlag::RANGE,
+                       "trivial methods (no larger than this) force calls to be hot");
+   FLAG_RANGE(         HotCallTrivialSize, -1, ((intx)MIN2((int64_t)max_intx,(int64_t)(+1.0e10))));
+
+DEVELOP_FLAG(intx,     WarmCallMinCount, -1, JVMFlag::RANGE,
+                       "number of calls (per method invocation) to enable inlining");
+   FLAG_RANGE(         WarmCallMinCount, -1, ((intx)MIN2((int64_t)max_intx,(int64_t)(+1.0e10))));
+
+DEVELOP_FLAG(intx,     WarmCallMinProfit, -1, JVMFlag::RANGE,
+                       "number of calls (per method invocation) to enable inlining");
+   FLAG_RANGE(         WarmCallMinProfit, -1, ((intx)MIN2((int64_t)max_intx,(int64_t)(+1.0e10))));
+
+DEVELOP_FLAG(intx,     WarmCallMaxWork, 999999, JVMFlag::RANGE,
+                       "execution time of the largest inlinable method");
+   FLAG_RANGE(         WarmCallMaxWork, 0, ((intx)MIN2((int64_t)max_intx,(int64_t)(+1.0e10))));
+
+DEVELOP_FLAG(intx,     WarmCallMaxSize, 999999, JVMFlag::RANGE,
+                       "size of the largest inlinable method");
+   FLAG_RANGE(         WarmCallMaxSize, 0, ((intx)MIN2((int64_t)max_intx,(int64_t)(+1.0e10))));
+
+PRODUCT_FLAG(intx,     MaxNodeLimit, 80000, JVMFlag::RANGE,
+                       "Maximum number of nodes");
+   FLAG_RANGE(         MaxNodeLimit, 1000, max_jint / 3);
+
+PRODUCT_FLAG(intx,     NodeLimitFudgeFactor, 2000, JVMFlag::CONSTRAINT,
+                       "Fudge Factor for certain optimizations");
+   FLAG_CONSTRAINT(    NodeLimitFudgeFactor, (void*)NodeLimitFudgeFactorConstraintFunc, JVMFlag::AfterErgo);
+
+PRODUCT_FLAG(bool,     UseJumpTables, true, JVMFlag::DEFAULT,
+                       "Use JumpTables instead of a binary search tree for switches");
+
+PRODUCT_FLAG(bool,     UseDivMod, true, JVMFlag::DEFAULT,
+                       "Use combined DivMod instruction if available");
+
+PRODUCT_FLAG_PD(intx,  MinJumpTableSize, JVMFlag::RANGE,
+                       "Minimum number of targets in a generated jump table");
+   FLAG_RANGE(         MinJumpTableSize, 0, max_intx);
+
+PRODUCT_FLAG(intx,     MaxJumpTableSize, 65000, JVMFlag::RANGE,
+                       "Maximum number of targets in a generated jump table");
+   FLAG_RANGE(         MaxJumpTableSize, 0, max_intx);
+
+PRODUCT_FLAG(intx,     MaxJumpTableSparseness, 5, JVMFlag::RANGE,
+                       "Maximum sparseness for jumptables");
+   FLAG_RANGE(         MaxJumpTableSparseness, 0, max_intx / 4);
+
+PRODUCT_FLAG(bool,     EliminateLocks, true, JVMFlag::DEFAULT,
+                       "Coarsen locks when possible");
+
+PRODUCT_FLAG(bool,     EliminateNestedLocks, true, JVMFlag::DEFAULT,
+                       "Eliminate nested locks of the same object when possible");
+
+NOTPROD_FLAG(bool,     PrintLockStatistics, false, JVMFlag::DEFAULT,
+                       "Print precise statistics on the dynamic lock usage");
+
+PRODUCT_FLAG(bool,     PrintPreciseBiasedLockingStatistics, false, JVMFlag::DIAGNOSTIC,
+                       "Print per-lock-site statistics of biased locking in JVM");
+
+PRODUCT_FLAG(bool,     PrintPreciseRTMLockingStatistics, false, JVMFlag::DIAGNOSTIC,
+                       "Print per-lock-site statistics of rtm locking in JVM");
+
+NOTPROD_FLAG(bool,     PrintEliminateLocks, false, JVMFlag::DEFAULT,
+                       "Print out when locks are eliminated");
+
+PRODUCT_FLAG(bool,     EliminateAutoBox, true, JVMFlag::DEFAULT,
+                       "Control optimizations for autobox elimination");
+
+PRODUCT_FLAG(intx,     AutoBoxCacheMax, 128, JVMFlag::RANGE,
+                       "Sets max value cached by the java.lang.Integer autobox cache");
+   FLAG_RANGE(         AutoBoxCacheMax, 0, max_jint);
+
+PRODUCT_FLAG(bool,     AggressiveUnboxing, true, JVMFlag::DIAGNOSTIC,
+                       "Control optimizations for aggressive boxing elimination");
+
+DEVELOP_FLAG(bool,     TracePostallocExpand, false, JVMFlag::DEFAULT,
+                       "Trace expanding nodes after"
+                       " register allocation.");
+
+PRODUCT_FLAG(bool,     DoEscapeAnalysis, true, JVMFlag::DEFAULT,
+                       "Perform escape analysis");
+
+PRODUCT_FLAG(double,   EscapeAnalysisTimeout, 20. DEBUG_ONLY(+40.), JVMFlag::RANGE,
+                       "Abort EA when it reaches time limit (in sec)");
+   FLAG_RANGE(         EscapeAnalysisTimeout, 0, DBL_MAX);
+
+DEVELOP_FLAG(bool,     ExitEscapeAnalysisOnTimeout, true, JVMFlag::DEFAULT,
+                       "Exit or throw assert in EA when it reaches time limit");
+
+NOTPROD_FLAG(bool,     PrintEscapeAnalysis, false, JVMFlag::DEFAULT,
+                       "Print the results of escape analysis");
+
+PRODUCT_FLAG(bool,     EliminateAllocations, true, JVMFlag::DEFAULT,
+                       "Use escape analysis to eliminate allocations");
+
+NOTPROD_FLAG(bool,     PrintEliminateAllocations, false, JVMFlag::DEFAULT,
+                       "Print out when allocations are eliminated");
+
+PRODUCT_FLAG(intx,     EliminateAllocationArraySizeLimit, 64, JVMFlag::RANGE,
+                       "Array size (number of elements) limit for scalar replacement");
+   FLAG_RANGE(         EliminateAllocationArraySizeLimit, 0, max_jint);
+
+PRODUCT_FLAG(bool,     OptimizePtrCompare, true, JVMFlag::DEFAULT,
+                       "Use escape analysis to optimize pointers compare");
+
+NOTPROD_FLAG(bool,     PrintOptimizePtrCompare, false, JVMFlag::DEFAULT,
+                       "Print information about optimized pointers compare");
+
+NOTPROD_FLAG(bool,     VerifyConnectionGraph, true, JVMFlag::DEFAULT,
+                       "Verify Connection Graph construction in Escape Analysis");
+
+PRODUCT_FLAG(bool,     UseOptoBiasInlining, true, JVMFlag::DEFAULT,
+                       "Generate biased locking code in C2 ideal graph");
+
+PRODUCT_FLAG(bool,     OptimizeStringConcat, true, JVMFlag::DEFAULT,
+                       "Optimize the construction of Strings by StringBuilder");
+
+NOTPROD_FLAG(bool,     PrintOptimizeStringConcat, false, JVMFlag::DEFAULT,
+                       "Print information about transformations performed on Strings");
+
+PRODUCT_FLAG(intx,     ValueSearchLimit, 1000, JVMFlag::RANGE,
+                       "Recursion limit in PhaseMacroExpand::value_from_mem_phi");
+   FLAG_RANGE(         ValueSearchLimit, 0, max_jint);
+
+PRODUCT_FLAG(intx,     MaxLabelRootDepth, 1100, JVMFlag::RANGE,
+                       "Maximum times call Label_Root to prevent stack overflow");
+   FLAG_RANGE(         MaxLabelRootDepth, 100, max_jint);
+
+PRODUCT_FLAG(intx,     DominatorSearchLimit, 1000, JVMFlag::DIAGNOSTIC | JVMFlag::RANGE,
+                       "Iterations limit in Node::dominates");
+   FLAG_RANGE(         DominatorSearchLimit, 0, max_jint);
+
+PRODUCT_FLAG(bool,     BlockLayoutByFrequency, true, JVMFlag::DEFAULT,
+                       "Use edge frequencies to drive block ordering");
+
+PRODUCT_FLAG(intx,     BlockLayoutMinDiamondPercentage, 20, JVMFlag::RANGE,
+                       "Miniumum %% of a successor (predecessor) for which block "
+                       "layout a will allow a fork (join) in a single chain");
+   FLAG_RANGE(         BlockLayoutMinDiamondPercentage, 0, 100);
+
+PRODUCT_FLAG(bool,     BlockLayoutRotateLoops, true, JVMFlag::DEFAULT,
+                       "Allow back branches to be fall throughs in the block layout");
+
+PRODUCT_FLAG(bool,     InlineReflectionGetCallerClass, true, JVMFlag::DIAGNOSTIC,
+                       "inline sun.reflect.Reflection.getCallerClass(), known to be "
+                       "part of base library DLL");
+
+PRODUCT_FLAG(bool,     InlineObjectCopy, true, JVMFlag::DIAGNOSTIC,
+                       "inline Object.clone and Arrays.copyOf[Range] intrinsics");
+
+PRODUCT_FLAG(bool,     SpecialStringCompareTo, true, JVMFlag::DIAGNOSTIC,
+                       "special version of string compareTo");
+
+PRODUCT_FLAG(bool,     SpecialStringIndexOf, true, JVMFlag::DIAGNOSTIC,
+                       "special version of string indexOf");
+
+PRODUCT_FLAG(bool,     SpecialStringEquals, true, JVMFlag::DIAGNOSTIC,
+                       "special version of string equals");
+
+PRODUCT_FLAG(bool,     SpecialArraysEquals, true, JVMFlag::DIAGNOSTIC,
+                       "special version of Arrays.equals(char[],char[])");
+
+PRODUCT_FLAG(bool,     SpecialEncodeISOArray, true, JVMFlag::DIAGNOSTIC,
+                       "special version of ISO_8859_1$Encoder.encodeISOArray");
+
+DEVELOP_FLAG(bool,     BailoutToInterpreterForThrows, false, JVMFlag::DEFAULT,
+                       "Compiled methods which throws/catches exceptions will be "
+                       "deopt and intp.");
+
+DEVELOP_FLAG(bool,     ConvertCmpD2CmpF, true, JVMFlag::DEFAULT,
+                       "Convert cmpD to cmpF when one input is constant in float range");
+
+DEVELOP_FLAG(bool,     ConvertFloat2IntClipping, true, JVMFlag::DEFAULT,
+                       "Convert float2int clipping idiom to integer clipping");
+
+DEVELOP_FLAG(bool,     MonomorphicArrayCheck, true, JVMFlag::DEFAULT,
+                       "Uncommon-trap array store checks that require full type check");
+
+NOTPROD_FLAG(bool,     TracePhaseCCP, false, JVMFlag::DEFAULT,
+                       "Print progress during Conditional Constant Propagation");
+
+DEVELOP_FLAG(bool,     PrintDominators, false, JVMFlag::DEFAULT,
+                       "Print out dominator trees for GVN");
+
+PRODUCT_FLAG(bool,     TraceSpilling, false, JVMFlag::DIAGNOSTIC,
+                       "Trace spilling");
+
+PRODUCT_FLAG(bool,     TraceTypeProfile, false, JVMFlag::DIAGNOSTIC,
+                       "Trace type profile");
+
+DEVELOP_FLAG(bool,     PoisonOSREntry, true, JVMFlag::DEFAULT,
+                       "Detect abnormal calls to OSR code");
+
+DEVELOP_FLAG(bool,     SoftMatchFailure, trueInProduct, JVMFlag::DEFAULT,
+                       "If the DFA fails to match a node, print a message and bail out");
+
+DEVELOP_FLAG(bool,     InlineAccessors, true, JVMFlag::DEFAULT,
+                       "inline accessor methods (get/set)");
+
+PRODUCT_FLAG(intx,     TypeProfileMajorReceiverPercent, 90, JVMFlag::RANGE,
+                       "% of major receiver type to all profiled receivers");
+   FLAG_RANGE(         TypeProfileMajorReceiverPercent, 0, 100);
+
+PRODUCT_FLAG(bool,     PrintIntrinsics, false, JVMFlag::DIAGNOSTIC,
+                       "prints attempted and successful inlining of intrinsics");
+
+DEVELOP_FLAG(bool,     StressReflectiveCode, false, JVMFlag::DEFAULT,
+                       "Use inexact types at allocations, etc., to test reflection");
+
+PRODUCT_FLAG(bool,     DebugInlinedCalls, true, JVMFlag::DIAGNOSTIC,
+                       "If false, restricts profiled locations to the root method only");
+
+DEVELOP_FLAG(bool,     VerifyLoopOptimizations, false, JVMFlag::DEFAULT,
+                       "verify major loop optimizations");
+
+PRODUCT_FLAG(bool,     ProfileDynamicTypes, true, JVMFlag::DIAGNOSTIC,
+                       "do extra type profiling and use it more aggressively");
+
+DEVELOP_FLAG(bool,     TraceIterativeGVN, false, JVMFlag::DEFAULT,
+                       "Print progress during Iterative Global Value Numbering");
+
+DEVELOP_FLAG(bool,     VerifyIterativeGVN, false, JVMFlag::DEFAULT,
+                       "Verify Def-Use modifications during sparse Iterative Global "
+                       "Value Numbering");
+
+NOTPROD_FLAG(bool,     TraceCISCSpill, false, JVMFlag::DEFAULT,
+                       "Trace allocators use of cisc spillable instructions");
+
+PRODUCT_FLAG(bool,     SplitIfBlocks, true, JVMFlag::DEFAULT,
+                       "Clone compares and control flow through merge points to fold "
+                       "some branches");
+
+DEVELOP_FLAG(intx,     FreqCountInvocations, 1, JVMFlag::RANGE,
+                       "Scaling factor for branch frequencies (deprecated)");
+   FLAG_RANGE(         FreqCountInvocations, 1, max_intx);
+
+PRODUCT_FLAG(intx,     AliasLevel, 3, JVMFlag::RANGE | JVMFlag::CONSTRAINT,
+                       "0 for no aliasing, 1 for oop/field/static/array split, "
+                       "2 for class split, 3 for unique instances");
+   FLAG_RANGE(         AliasLevel, 0, 3);
+   FLAG_CONSTRAINT(    AliasLevel, (void*)AliasLevelConstraintFunc, JVMFlag::AfterErgo);
+
+DEVELOP_FLAG(bool,     VerifyAliases, false, JVMFlag::DEFAULT,
+                       "perform extra checks on the results of alias analysis");
+
+PRODUCT_FLAG(bool,     IncrementalInline, true, JVMFlag::DEFAULT,
+                       "do post parse inlining");
+
+DEVELOP_FLAG(bool,     AlwaysIncrementalInline, false, JVMFlag::DEFAULT,
+                       "do all inlining incrementally");
+
+PRODUCT_FLAG(intx,     LiveNodeCountInliningCutoff, 40000, JVMFlag::RANGE,
+                       "max number of live nodes in a method");
+   FLAG_RANGE(         LiveNodeCountInliningCutoff, 0, max_juint / 8);
+
+PRODUCT_FLAG(bool,     OptimizeExpensiveOps, true, JVMFlag::DIAGNOSTIC,
+                       "Find best control for expensive operations");
+
+PRODUCT_FLAG(bool,     UseMathExactIntrinsics, true, JVMFlag::DIAGNOSTIC,
+                       "Enables intrinsification of various java.lang.Math functions");
+
+PRODUCT_FLAG(bool,     UseCharacterCompareIntrinsics, false, JVMFlag::DIAGNOSTIC,
+                       "Enables intrinsification of java.lang.Character functions");
+
+PRODUCT_FLAG(bool,     UseMultiplyToLenIntrinsic, false, JVMFlag::DIAGNOSTIC,
+                       "Enables intrinsification of BigInteger.multiplyToLen()");
+
+PRODUCT_FLAG(bool,     UseSquareToLenIntrinsic, false, JVMFlag::DIAGNOSTIC,
+                       "Enables intrinsification of BigInteger.squareToLen()");
+
+PRODUCT_FLAG(bool,     UseMulAddIntrinsic, false, JVMFlag::DIAGNOSTIC,
+                       "Enables intrinsification of BigInteger.mulAdd()");
+
+PRODUCT_FLAG(bool,     UseMontgomeryMultiplyIntrinsic, false, JVMFlag::DIAGNOSTIC,
+                       "Enables intrinsification of BigInteger.montgomeryMultiply()");
+
+PRODUCT_FLAG(bool,     UseMontgomerySquareIntrinsic, false, JVMFlag::DIAGNOSTIC,
+                       "Enables intrinsification of BigInteger.montgomerySquare()");
+
+PRODUCT_FLAG(bool,     UseTypeSpeculation, true, JVMFlag::DEFAULT,
+                       "Speculatively propagate types from profiles");
+
+PRODUCT_FLAG(bool,     UseInlineDepthForSpeculativeTypes, true, JVMFlag::DIAGNOSTIC,
+                       "Carry inline depth of profile point with speculative type "
+                       "and give priority to profiling from lower inline depth");
+
+PRODUCT_FLAG_PD(bool,  TrapBasedRangeChecks, JVMFlag::DEFAULT,
+                       "Generate code for range checks that uses a cmp and trap "
+                       "instruction raising SIGTRAP. Used on PPC64.");
+
+PRODUCT_FLAG(intx,     ArrayCopyLoadStoreMaxElem, 8, JVMFlag::RANGE,
+                       "Maximum number of arraycopy elements inlined as a sequence of"
+                       "loads/stores");
+   FLAG_RANGE(         ArrayCopyLoadStoreMaxElem, 0, max_intx);
+
+DEVELOP_FLAG(bool,     StressArrayCopyMacroNode, false, JVMFlag::DEFAULT,
+                       "Perform ArrayCopy load/store replacement during IGVN only");
+
+DEVELOP_FLAG(bool,     RenumberLiveNodes, true, JVMFlag::DEFAULT,
+                       "Renumber live nodes");
+
+PRODUCT_FLAG(uintx,    LoopStripMiningIter, 0, JVMFlag::RANGE,
+                       "Number of iterations in strip mined loop");
+   FLAG_RANGE(         LoopStripMiningIter, 0, max_juint);
+
+PRODUCT_FLAG(uintx,    LoopStripMiningIterShortLoop, 0, JVMFlag::RANGE,
+                       "Loop with fewer iterations are not strip mined");
+   FLAG_RANGE(         LoopStripMiningIterShortLoop, 0, max_juint);
+
+PRODUCT_FLAG(bool,     UseProfiledLoopPredicate, true, JVMFlag::DEFAULT,
+                       "Move predicates out of loops based on profiling data");
 
+PRODUCT_FLAG(bool,     ExpandSubTypeCheckAtParseTime, false, JVMFlag::DIAGNOSTIC,
+                       "Do not use subtype check macro node");
+#endif // COMPILER2
 #endif // SHARE_OPTO_C2_GLOBALS_HPP
< prev index next >