< prev index next >

src/hotspot/share/c1/c1_globals.hpp

Print this page

@@ -30,295 +30,288 @@
 
 #include CPU_HEADER(c1_globals)
 #include OS_HEADER(c1_globals)
 
 //
-// Defines all global flags used by the client compiler.
+// Declare all global flags used by the client compiler.
 //
-#define C1_FLAGS(develop, \
-                 develop_pd, \
-                 product, \
-                 product_pd, \
-                 diagnostic, \
-                 diagnostic_pd, \
-                 notproduct, \
-                 range, \
-                 constraint) \
-                                                                            \
-  /* Printing */                                                            \
-  notproduct(bool, PrintC1Statistics, false,                                \
-          "Print Compiler1 statistics" )                                    \
-                                                                            \
-  notproduct(bool, PrintInitialBlockList, false,                            \
-          "Print block list of BlockListBuilder")                           \
-                                                                            \
-  notproduct(bool, PrintCFG, false,                                         \
-          "Print control flow graph after each change")                     \
-                                                                            \
-  notproduct(bool, PrintCFG0, false,                                        \
-          "Print control flow graph after construction")                    \
-                                                                            \
-  notproduct(bool, PrintCFG1, false,                                        \
-          "Print control flow graph after optimizations")                   \
-                                                                            \
-  notproduct(bool, PrintCFG2, false,                                        \
-          "Print control flow graph before code generation")                \
-                                                                            \
-  notproduct(bool, PrintIRDuringConstruction, false,                        \
-          "Print IR as it's being constructed (helpful for debugging frontend)")\
-                                                                            \
-  notproduct(bool, PrintPhiFunctions, false,                                \
-          "Print phi functions when they are created and simplified")       \
-                                                                            \
-  notproduct(bool, PrintIR, false,                                          \
-          "Print full intermediate representation after each change")       \
-                                                                            \
-  notproduct(bool, PrintIR0, false,                                         \
-          "Print full intermediate representation after construction")      \
-                                                                            \
-  notproduct(bool, PrintIR1, false,                                         \
-          "Print full intermediate representation after optimizations")     \
-                                                                            \
-  notproduct(bool, PrintIR2, false,                                         \
-          "Print full intermediate representation before code generation")  \
-                                                                            \
-  notproduct(bool, PrintSimpleStubs, false,                                 \
-          "Print SimpleStubs")                                              \
-                                                                            \
-  /* C1 optimizations */                                                    \
-                                                                            \
-  develop(bool, UseC1Optimizations, true,                                   \
-          "Turn on C1 optimizations")                                       \
-                                                                            \
-  develop(bool, SelectivePhiFunctions, true,                                \
-          "create phi functions at loop headers only when necessary")       \
-                                                                            \
-  develop(bool, OptimizeIfOps, true,                                        \
-          "Optimize multiple IfOps")                                        \
-                                                                            \
-  develop(bool, DoCEE, true,                                                \
-          "Do Conditional Expression Elimination to simplify CFG")          \
-                                                                            \
-  develop(bool, PrintCEE, false,                                            \
-          "Print Conditional Expression Elimination")                       \
-                                                                            \
-  develop(bool, UseLocalValueNumbering, true,                               \
-          "Use Local Value Numbering (embedded in GraphBuilder)")           \
-                                                                            \
-  develop(bool, UseGlobalValueNumbering, true,                              \
-          "Use Global Value Numbering (separate phase)")                    \
-                                                                            \
-  product(bool, UseLoopInvariantCodeMotion, true,                           \
-          "Simple loop invariant code motion for short loops during GVN")   \
-                                                                            \
-  develop(bool, TracePredicateFailedTraps, false,                           \
-          "trace runtime traps caused by predicate failure")                \
-                                                                            \
-  develop(bool, StressLoopInvariantCodeMotion, false,                       \
-          "stress loop invariant code motion")                              \
-                                                                            \
-  develop(bool, TraceRangeCheckElimination, false,                          \
-          "Trace Range Check Elimination")                                  \
-                                                                            \
-  develop(bool, AssertRangeCheckElimination, false,                         \
-          "Assert Range Check Elimination")                                 \
-                                                                            \
-  develop(bool, StressRangeCheckElimination, false,                         \
-          "stress Range Check Elimination")                                 \
-                                                                            \
-  develop(bool, PrintValueNumbering, false,                                 \
-          "Print Value Numbering")                                          \
-                                                                            \
-  product(intx, ValueMapInitialSize, 11,                                    \
-          "Initial size of a value map")                                    \
-          range(1, NOT_LP64(1*K) LP64_ONLY(32*K))                           \
-                                                                            \
-  product(intx, ValueMapMaxLoopSize, 8,                                     \
-          "maximum size of a loop optimized by global value numbering")     \
-          range(0, 128)                                                     \
-                                                                            \
-  develop(bool, EliminateBlocks, true,                                      \
-          "Eliminate unneccessary basic blocks")                            \
-                                                                            \
-  develop(bool, PrintBlockElimination, false,                               \
-          "Print basic block elimination")                                  \
-                                                                            \
-  develop(bool, EliminateNullChecks, true,                                  \
-          "Eliminate unneccessary null checks")                             \
-                                                                            \
-  develop(bool, PrintNullCheckElimination, false,                           \
-          "Print null check elimination")                                   \
-                                                                            \
-  develop(bool, EliminateFieldAccess, true,                                 \
-          "Optimize field loads and stores")                                \
-                                                                            \
-  develop(bool, InlineMethodsWithExceptionHandlers, true,                   \
-          "Inline methods containing exception handlers "                   \
-          "(NOTE: does not work with current backend)")                     \
-                                                                            \
-  product(bool, InlineSynchronizedMethods, true,                            \
-          "Inline synchronized methods")                                    \
-                                                                            \
-  diagnostic(bool, InlineNIOCheckIndex, true,                               \
-          "Intrinsify java.nio.Buffer.checkIndex")                          \
-                                                                            \
-  develop(bool, CanonicalizeNodes, true,                                    \
-          "Canonicalize graph nodes")                                       \
-                                                                            \
-  develop(bool, PrintCanonicalization, false,                               \
-          "Print graph node canonicalization")                              \
-                                                                            \
-  develop(bool, UseTableRanges, true,                                       \
-          "Faster versions of lookup table using ranges")                   \
-                                                                            \
-  develop(intx, NestedInliningSizeRatio, 90,                                \
-          "Percentage of prev. allowed inline size in recursive inlining")  \
-          range(0, 100)                                                     \
-                                                                            \
-  notproduct(bool, PrintIRWithLIR, false,                                   \
-          "Print IR instructions with generated LIR")                       \
-                                                                            \
-  notproduct(bool, PrintLIRWithAssembly, false,                             \
-          "Show LIR instruction with generated assembly")                   \
-                                                                            \
-  develop(bool, CommentedAssembly, trueInDebug,                             \
-          "Show extra info in PrintNMethods output")                        \
-                                                                            \
-  develop(bool, LIRTracePeephole, false,                                    \
-          "Trace peephole optimizer")                                       \
-                                                                            \
-  develop(bool, LIRTraceExecution, false,                                   \
-          "add LIR code which logs the execution of blocks")                \
-                                                                            \
-  product_pd(bool, LIRFillDelaySlots,                                       \
-             "fill delays on on SPARC with LIR")                            \
-                                                                            \
-  develop_pd(bool, CSEArrayLength,                                          \
-          "Create separate nodes for length in array accesses")             \
-                                                                            \
-  develop_pd(bool, TwoOperandLIRForm,                                       \
-          "true if LIR requires src1 and dst to match in binary LIR ops")   \
-                                                                            \
-  develop(intx, TraceLinearScanLevel, 0,                                    \
-          "Debug levels for the linear scan allocator")                     \
-          range(0, 4)                                                       \
-                                                                            \
-  develop(bool, StressLinearScan, false,                                    \
-          "scramble block order used by LinearScan (stress test)")          \
-                                                                            \
-  product(bool, TimeLinearScan, false,                                      \
-          "detailed timing of LinearScan phases")                           \
-                                                                            \
-  develop(bool, TimeEachLinearScan, false,                                  \
-          "print detailed timing of each LinearScan run")                   \
-                                                                            \
-  develop(bool, CountLinearScan, false,                                     \
-          "collect statistic counters during LinearScan")                   \
-                                                                            \
-  /* C1 variable */                                                         \
-                                                                            \
-  develop(bool, C1Breakpoint, false,                                        \
-          "Sets a breakpoint at entry of each compiled method")             \
-                                                                            \
-  develop(bool, ImplicitDiv0Checks, true,                                   \
-          "Use implicit division by zero checks")                           \
-                                                                            \
-  develop(bool, PinAllInstructions, false,                                  \
-          "All instructions are pinned")                                    \
-                                                                            \
-  develop(bool, UseFastNewInstance, true,                                   \
-          "Use fast inlined instance allocation")                           \
-                                                                            \
-  develop(bool, UseFastNewTypeArray, true,                                  \
-          "Use fast inlined type array allocation")                         \
-                                                                            \
-  develop(bool, UseFastNewObjectArray, true,                                \
-          "Use fast inlined object array allocation")                       \
-                                                                            \
-  develop(bool, UseFastLocking, true,                                       \
-          "Use fast inlined locking code")                                  \
-                                                                            \
-  develop(bool, UseSlowPath, false,                                         \
-          "For debugging: test slow cases by always using them")            \
-                                                                            \
-  develop(bool, GenerateArrayStoreCheck, true,                              \
-          "Generates code for array store checks")                          \
-                                                                            \
-  develop(bool, DeoptC1, true,                                              \
-          "Use deoptimization in C1")                                       \
-                                                                            \
-  develop(bool, PrintBailouts, false,                                       \
-          "Print bailout and its reason")                                   \
-                                                                            \
-  develop(bool, TracePatching, false,                                       \
-         "Trace patching of field access on uninitialized classes")         \
-                                                                            \
-  develop(bool, PatchALot, false,                                           \
-          "Marks all fields as having unloaded classes")                    \
-                                                                            \
-  develop(bool, PrintNotLoaded, false,                                      \
-          "Prints where classes are not loaded during code generation")     \
-                                                                            \
-  develop(bool, PrintLIR, false,                                            \
-          "print low-level IR")                                             \
-                                                                            \
-  develop(bool, BailoutAfterHIR, false,                                     \
-          "bailout of compilation after building of HIR")                   \
-                                                                            \
-  develop(bool, BailoutAfterLIR, false,                                     \
-          "bailout of compilation after building of LIR")                   \
-                                                                            \
-  develop(bool, BailoutOnExceptionHandlers, false,                          \
-          "bailout of compilation for methods with exception handlers")     \
-                                                                            \
-  develop(bool, InstallMethods, true,                                       \
-          "Install methods at the end of successful compilations")          \
-                                                                            \
-  develop(intx, NMethodSizeLimit, (64*K)*wordSize,                          \
-          "Maximum size of a compiled method.")                             \
-          range(0, max_jint)                                                \
-                                                                            \
-  develop(bool, TraceFPUStack, false,                                       \
-          "Trace emulation of the FPU stack (intel only)")                  \
-                                                                            \
-  develop(bool, TraceFPURegisterUsage, false,                               \
-          "Trace usage of FPU registers at start of blocks (intel only)")   \
-                                                                            \
-  develop(bool, OptimizeUnsafes, true,                                      \
-          "Optimize raw unsafe ops")                                        \
-                                                                            \
-  develop(bool, PrintUnsafeOptimization, false,                             \
-          "Print optimization of raw unsafe ops")                           \
-                                                                            \
-  develop(intx, InstructionCountCutoff, 37000,                              \
-          "If GraphBuilder adds this many instructions, bails out")         \
-          range(0, max_jint)                                                \
-                                                                            \
-  develop(bool, ComputeExactFPURegisterUsage, true,                         \
-          "Compute additional live set for fpu registers to simplify fpu stack merge (Intel only)") \
-                                                                            \
-  product(bool, C1ProfileCalls, true,                                       \
-          "Profile calls when generating code for updating MDOs")           \
-                                                                            \
-  product(bool, C1ProfileVirtualCalls, true,                                \
-          "Profile virtual calls when generating code for updating MDOs")   \
-                                                                            \
-  product(bool, C1ProfileInlinedCalls, true,                                \
-          "Profile inlined calls when generating code for updating MDOs")   \
-                                                                            \
-  product(bool, C1ProfileBranches, true,                                    \
-          "Profile branches when generating code for updating MDOs")        \
-                                                                            \
-  product(bool, C1ProfileCheckcasts, true,                                  \
-          "Profile checkcasts when generating code for updating MDOs")      \
-                                                                            \
-  product(bool, C1OptimizeVirtualCallProfiling, true,                       \
-          "Use CHA and exact type results at call sites when updating MDOs")\
-                                                                            \
-  product(bool, C1UpdateMethodData, trueInTiered,                           \
-          "Update MethodData*s in Tier1-generated code")                    \
-                                                                            \
-  develop(bool, PrintCFGToFile, false,                                      \
-          "print control flow graph to a separate file during compilation") \
-                                                                            \
+#include "utilities/macros.hpp"
+#if COMPILER1
+#include "runtime/flags/jvmFlag.hpp"
 
+    //  Printing 
+NOTPROD_FLAG(bool,     PrintC1Statistics, false, JVMFlag::DEFAULT,
+                       "Print Compiler1 statistics");
+
+DEVELOP_FLAG(bool,     PrintInitialBlockList, false, JVMFlag::DEFAULT,
+                       "Print block list of BlockListBuilder");
+
+NOTPROD_FLAG(bool,     PrintCFG, false, JVMFlag::DEFAULT,
+                       "Print control flow graph after each change");
+
+NOTPROD_FLAG(bool,     PrintCFG0, false, JVMFlag::DEFAULT,
+                       "Print control flow graph after construction");
+
+NOTPROD_FLAG(bool,     PrintCFG1, false, JVMFlag::DEFAULT,
+                       "Print control flow graph after optimizations");
+
+NOTPROD_FLAG(bool,     PrintCFG2, false, JVMFlag::DEFAULT,
+                       "Print control flow graph before code generation");
+
+NOTPROD_FLAG(bool,     PrintIRDuringConstruction, false, JVMFlag::DEFAULT,
+                       "Print IR as it's being constructed (helpful for debugging frontend)");
+
+NOTPROD_FLAG(bool,     PrintPhiFunctions, false, JVMFlag::DEFAULT,
+                       "Print phi functions when they are created and simplified");
+
+NOTPROD_FLAG(bool,     PrintIR, false, JVMFlag::DEFAULT,
+                       "Print full intermediate representation after each change");
+
+NOTPROD_FLAG(bool,     PrintIR0, false, JVMFlag::DEFAULT,
+                       "Print full intermediate representation after construction");
+
+NOTPROD_FLAG(bool,     PrintIR1, false, JVMFlag::DEFAULT,
+                       "Print full intermediate representation after optimizations");
+
+NOTPROD_FLAG(bool,     PrintIR2, false, JVMFlag::DEFAULT,
+                       "Print full intermediate representation before code generation");
+
+NOTPROD_FLAG(bool,     PrintSimpleStubs, false, JVMFlag::DEFAULT,
+                       "Print SimpleStubs");
+
+
+    //  C1 optimizations 
+DEVELOP_FLAG(bool,     UseC1Optimizations, true, JVMFlag::DEFAULT,
+                       "Turn on C1 optimizations");
+
+DEVELOP_FLAG(bool,     SelectivePhiFunctions, true, JVMFlag::DEFAULT,
+                       "create phi functions at loop headers only when necessary");
+
+DEVELOP_FLAG(bool,     OptimizeIfOps, true, JVMFlag::DEFAULT,
+                       "Optimize multiple IfOps");
+
+DEVELOP_FLAG(bool,     DoCEE, true, JVMFlag::DEFAULT,
+                       "Do Conditional Expression Elimination to simplify CFG");
+
+DEVELOP_FLAG(bool,     PrintCEE, false, JVMFlag::DEFAULT,
+                       "Print Conditional Expression Elimination");
+
+DEVELOP_FLAG(bool,     UseLocalValueNumbering, true, JVMFlag::DEFAULT,
+                       "Use Local Value Numbering (embedded in GraphBuilder)");
+
+DEVELOP_FLAG(bool,     UseGlobalValueNumbering, true, JVMFlag::DEFAULT,
+                       "Use Global Value Numbering (separate phase)");
+
+PRODUCT_FLAG(bool,     UseLoopInvariantCodeMotion, true, JVMFlag::DEFAULT,
+                       "Simple loop invariant code motion for short loops during GVN");
+
+DEVELOP_FLAG(bool,     TracePredicateFailedTraps, false, JVMFlag::DEFAULT,
+                       "trace runtime traps caused by predicate failure");
+
+DEVELOP_FLAG(bool,     StressLoopInvariantCodeMotion, false, JVMFlag::DEFAULT,
+                       "stress loop invariant code motion");
+
+DEVELOP_FLAG(bool,     TraceRangeCheckElimination, false, JVMFlag::DEFAULT,
+                       "Trace Range Check Elimination");
+
+DEVELOP_FLAG(bool,     AssertRangeCheckElimination, false, JVMFlag::DEFAULT,
+                       "Assert Range Check Elimination");
+
+DEVELOP_FLAG(bool,     StressRangeCheckElimination, false, JVMFlag::DEFAULT,
+                       "stress Range Check Elimination");
+
+DEVELOP_FLAG(bool,     PrintValueNumbering, false, JVMFlag::DEFAULT,
+                       "Print Value Numbering");
+
+PRODUCT_FLAG(intx,     ValueMapInitialSize, 11, JVMFlag::RANGE,
+                       "Initial size of a value map");
+   FLAG_RANGE(         ValueMapInitialSize, 1, NOT_LP64(1*K) LP64_ONLY(32*K));
+
+PRODUCT_FLAG(intx,     ValueMapMaxLoopSize, 8, JVMFlag::RANGE,
+                       "maximum size of a loop optimized by global value numbering");
+   FLAG_RANGE(         ValueMapMaxLoopSize, 0, 128);
+
+DEVELOP_FLAG(bool,     EliminateBlocks, true, JVMFlag::DEFAULT,
+                       "Eliminate unneccessary basic blocks");
+
+DEVELOP_FLAG(bool,     PrintBlockElimination, false, JVMFlag::DEFAULT,
+                       "Print basic block elimination");
+
+DEVELOP_FLAG(bool,     EliminateNullChecks, true, JVMFlag::DEFAULT,
+                       "Eliminate unneccessary null checks");
+
+DEVELOP_FLAG(bool,     PrintNullCheckElimination, false, JVMFlag::DEFAULT,
+                       "Print null check elimination");
+
+DEVELOP_FLAG(bool,     EliminateFieldAccess, true, JVMFlag::DEFAULT,
+                       "Optimize field loads and stores");
+
+DEVELOP_FLAG(bool,     InlineMethodsWithExceptionHandlers, true, JVMFlag::DEFAULT,
+                       "Inline methods containing exception handlers "
+                       "(NOTE: does not work with current backend)");
+
+PRODUCT_FLAG(bool,     InlineSynchronizedMethods, true, JVMFlag::DEFAULT,
+                       "Inline synchronized methods");
+
+PRODUCT_FLAG(bool,     InlineNIOCheckIndex, true, JVMFlag::DIAGNOSTIC,
+                       "Intrinsify java.nio.Buffer.checkIndex");
+
+DEVELOP_FLAG(bool,     CanonicalizeNodes, true, JVMFlag::DEFAULT,
+                       "Canonicalize graph nodes");
+
+DEVELOP_FLAG(bool,     PrintCanonicalization, false, JVMFlag::DEFAULT,
+                       "Print graph node canonicalization");
+
+DEVELOP_FLAG(bool,     UseTableRanges, true, JVMFlag::DEFAULT,
+                       "Faster versions of lookup table using ranges");
+
+DEVELOP_FLAG(intx,     NestedInliningSizeRatio, 90, JVMFlag::RANGE,
+                       "Percentage of prev. allowed inline size in recursive inlining");
+   FLAG_RANGE(         NestedInliningSizeRatio, 0, 100);
+
+NOTPROD_FLAG(bool,     PrintIRWithLIR, false, JVMFlag::DEFAULT,
+                       "Print IR instructions with generated LIR");
+
+NOTPROD_FLAG(bool,     PrintLIRWithAssembly, false, JVMFlag::DEFAULT,
+                       "Show LIR instruction with generated assembly");
+
+DEVELOP_FLAG(bool,     CommentedAssembly, trueInDebug, JVMFlag::DEFAULT,
+                       "Show extra info in PrintNMethods output");
+
+DEVELOP_FLAG(bool,     LIRTracePeephole, false, JVMFlag::DEFAULT,
+                       "Trace peephole optimizer");
+
+DEVELOP_FLAG(bool,     LIRTraceExecution, false, JVMFlag::DEFAULT,
+                       "add LIR code which logs the execution of blocks");
+
+PRODUCT_FLAG_PD(bool,  LIRFillDelaySlots, JVMFlag::DEFAULT,
+                       "fill delays on on SPARC with LIR");
+
+DEVELOP_FLAG_PD(bool,  CSEArrayLength, JVMFlag::DEFAULT,
+                       "Create separate nodes for length in array accesses");
+
+DEVELOP_FLAG_PD(bool,  TwoOperandLIRForm, JVMFlag::DEFAULT,
+                       "true if LIR requires src1 and dst to match in binary LIR ops");
+
+DEVELOP_FLAG(intx,     TraceLinearScanLevel, 0, JVMFlag::RANGE,
+                       "Debug levels for the linear scan allocator");
+   FLAG_RANGE(         TraceLinearScanLevel, 0, 4);
+
+DEVELOP_FLAG(bool,     StressLinearScan, false, JVMFlag::DEFAULT,
+                       "scramble block order used by LinearScan (stress test)");
+
+PRODUCT_FLAG(bool,     TimeLinearScan, false, JVMFlag::DEFAULT,
+                       "detailed timing of LinearScan phases");
+
+DEVELOP_FLAG(bool,     TimeEachLinearScan, false, JVMFlag::DEFAULT,
+                       "print detailed timing of each LinearScan run");
+
+DEVELOP_FLAG(bool,     CountLinearScan, false, JVMFlag::DEFAULT,
+                       "collect statistic counters during LinearScan");
+
+
+    //  C1 variable 
+DEVELOP_FLAG(bool,     C1Breakpoint, false, JVMFlag::DEFAULT,
+                       "Sets a breakpoint at entry of each compiled method");
+
+DEVELOP_FLAG(bool,     ImplicitDiv0Checks, true, JVMFlag::DEFAULT,
+                       "Use implicit division by zero checks");
+
+DEVELOP_FLAG(bool,     PinAllInstructions, false, JVMFlag::DEFAULT,
+                       "All instructions are pinned");
+
+DEVELOP_FLAG(bool,     UseFastNewInstance, true, JVMFlag::DEFAULT,
+                       "Use fast inlined instance allocation");
+
+DEVELOP_FLAG(bool,     UseFastNewTypeArray, true, JVMFlag::DEFAULT,
+                       "Use fast inlined type array allocation");
+
+DEVELOP_FLAG(bool,     UseFastNewObjectArray, true, JVMFlag::DEFAULT,
+                       "Use fast inlined object array allocation");
+
+DEVELOP_FLAG(bool,     UseFastLocking, true, JVMFlag::DEFAULT,
+                       "Use fast inlined locking code");
+
+DEVELOP_FLAG(bool,     UseSlowPath, false, JVMFlag::DEFAULT,
+                       "For debugging: test slow cases by always using them");
+
+DEVELOP_FLAG(bool,     GenerateArrayStoreCheck, true, JVMFlag::DEFAULT,
+                       "Generates code for array store checks");
+
+DEVELOP_FLAG(bool,     DeoptC1, true, JVMFlag::DEFAULT,
+                       "Use deoptimization in C1");
+
+DEVELOP_FLAG(bool,     PrintBailouts, false, JVMFlag::DEFAULT,
+                       "Print bailout and its reason");
+
+DEVELOP_FLAG(bool,     TracePatching, false, JVMFlag::DEFAULT,
+                       "Trace patching of field access on uninitialized classes");
+
+DEVELOP_FLAG(bool,     PatchALot, false, JVMFlag::DEFAULT,
+                       "Marks all fields as having unloaded classes");
+
+DEVELOP_FLAG(bool,     PrintNotLoaded, false, JVMFlag::DEFAULT,
+                       "Prints where classes are not loaded during code generation");
+
+DEVELOP_FLAG(bool,     PrintLIR, false, JVMFlag::DEFAULT,
+                       "print low-level IR");
+
+DEVELOP_FLAG(bool,     BailoutAfterHIR, false, JVMFlag::DEFAULT,
+                       "bailout of compilation after building of HIR");
+
+DEVELOP_FLAG(bool,     BailoutAfterLIR, false, JVMFlag::DEFAULT,
+                       "bailout of compilation after building of LIR");
+
+DEVELOP_FLAG(bool,     BailoutOnExceptionHandlers, false, JVMFlag::DEFAULT,
+                       "bailout of compilation for methods with exception handlers");
+
+DEVELOP_FLAG(bool,     InstallMethods, true, JVMFlag::DEFAULT,
+                       "Install methods at the end of successful compilations");
+
+DEVELOP_FLAG(intx,     NMethodSizeLimit, (64*K)*wordSize, JVMFlag::RANGE,
+                       "Maximum size of a compiled method.");
+   FLAG_RANGE(         NMethodSizeLimit, 0, max_jint);
+
+DEVELOP_FLAG(bool,     TraceFPUStack, false, JVMFlag::DEFAULT,
+                       "Trace emulation of the FPU stack (intel only)");
+
+DEVELOP_FLAG(bool,     TraceFPURegisterUsage, false, JVMFlag::DEFAULT,
+                       "Trace usage of FPU registers at start of blocks (intel only)");
+
+DEVELOP_FLAG(bool,     OptimizeUnsafes, true, JVMFlag::DEFAULT,
+                       "Optimize raw unsafe ops");
+
+DEVELOP_FLAG(bool,     PrintUnsafeOptimization, false, JVMFlag::DEFAULT,
+                       "Print optimization of raw unsafe ops");
+
+DEVELOP_FLAG(intx,     InstructionCountCutoff, 37000, JVMFlag::RANGE,
+                       "If GraphBuilder adds this many instructions, bails out");
+   FLAG_RANGE(         InstructionCountCutoff, 0, max_jint);
+
+DEVELOP_FLAG(bool,     ComputeExactFPURegisterUsage, true, JVMFlag::DEFAULT,
+                       "Compute additional live set for fpu registers to simplify fpu stack merge (Intel only)");
+
+PRODUCT_FLAG(bool,     C1ProfileCalls, true, JVMFlag::DEFAULT,
+                       "Profile calls when generating code for updating MDOs");
+
+PRODUCT_FLAG(bool,     C1ProfileVirtualCalls, true, JVMFlag::DEFAULT,
+                       "Profile virtual calls when generating code for updating MDOs");
+
+PRODUCT_FLAG(bool,     C1ProfileInlinedCalls, true, JVMFlag::DEFAULT,
+                       "Profile inlined calls when generating code for updating MDOs");
+
+PRODUCT_FLAG(bool,     C1ProfileBranches, true, JVMFlag::DEFAULT,
+                       "Profile branches when generating code for updating MDOs");
+
+PRODUCT_FLAG(bool,     C1ProfileCheckcasts, true, JVMFlag::DEFAULT,
+                       "Profile checkcasts when generating code for updating MDOs");
+
+PRODUCT_FLAG(bool,     C1OptimizeVirtualCallProfiling, true, JVMFlag::DEFAULT,
+                       "Use CHA and exact type results at call sites when updating MDOs");
+
+PRODUCT_FLAG(bool,     C1UpdateMethodData, trueInTiered, JVMFlag::DEFAULT,
+                       "Update MethodData*s in Tier1-generated code");
+
+DEVELOP_FLAG(bool,     PrintCFGToFile, false, JVMFlag::DEFAULT,
+                       "print control flow graph to a separate file during compilation");
+#endif // COMPILER1
 #endif // SHARE_C1_C1_GLOBALS_HPP
< prev index next >