src/share/vm/c1/c1_globals.hpp
Index Unified diffs Context diffs Sdiffs Patch New Old Previous File Next File 8078554 Sdiff src/share/vm/c1

src/share/vm/c1/c1_globals.hpp

Print this page




 135           "stress loop invariant code motion")                              \
 136                                                                             \
 137   develop(bool, TraceRangeCheckElimination, false,                          \
 138           "Trace Range Check Elimination")                                  \
 139                                                                             \
 140   develop(bool, AssertRangeCheckElimination, false,                         \
 141           "Assert Range Check Elimination")                                 \
 142                                                                             \
 143   develop(bool, StressRangeCheckElimination, false,                         \
 144           "stress Range Check Elimination")                                 \
 145                                                                             \
 146   develop(bool, PrintValueNumbering, false,                                 \
 147           "Print Value Numbering")                                          \
 148                                                                             \
 149   product(intx, ValueMapInitialSize, 11,                                    \
 150           "Initial size of a value map")                                    \
 151           range(1, NOT_LP64(1*K) LP64_ONLY(32*K))                           \
 152                                                                             \
 153   product(intx, ValueMapMaxLoopSize, 8,                                     \
 154           "maximum size of a loop optimized by global value numbering")     \

 155                                                                             \
 156   develop(bool, EliminateBlocks, true,                                      \
 157           "Eliminate unneccessary basic blocks")                            \
 158                                                                             \
 159   develop(bool, PrintBlockElimination, false,                               \
 160           "Print basic block elimination")                                  \
 161                                                                             \
 162   develop(bool, EliminateNullChecks, true,                                  \
 163           "Eliminate unneccessary null checks")                             \
 164                                                                             \
 165   develop(bool, PrintNullCheckElimination, false,                           \
 166           "Print null check elimination")                                   \
 167                                                                             \
 168   develop(bool, EliminateFieldAccess, true,                                 \
 169           "Optimize field loads and stores")                                \
 170                                                                             \
 171   develop(bool, InlineMethodsWithExceptionHandlers, true,                   \
 172           "Inline methods containing exception handlers "                   \
 173           "(NOTE: does not work with current backend)")                     \
 174                                                                             \


 203   develop(bool, CommentedAssembly, trueInDebug,                             \
 204           "Show extra info in PrintNMethods output")                        \
 205                                                                             \
 206   develop(bool, LIRTracePeephole, false,                                    \
 207           "Trace peephole optimizer")                                       \
 208                                                                             \
 209   develop(bool, LIRTraceExecution, false,                                   \
 210           "add LIR code which logs the execution of blocks")                \
 211                                                                             \
 212   product_pd(bool, LIRFillDelaySlots,                                       \
 213              "fill delays on on SPARC with LIR")                            \
 214                                                                             \
 215   develop_pd(bool, CSEArrayLength,                                          \
 216           "Create separate nodes for length in array accesses")             \
 217                                                                             \
 218   develop_pd(bool, TwoOperandLIRForm,                                       \
 219           "true if LIR requires src1 and dst to match in binary LIR ops")   \
 220                                                                             \
 221   develop(intx, TraceLinearScanLevel, 0,                                    \
 222           "Debug levels for the linear scan allocator")                     \

 223                                                                             \
 224   develop(bool, StressLinearScan, false,                                    \
 225           "scramble block order used by LinearScan (stress test)")          \
 226                                                                             \
 227   product(bool, TimeLinearScan, false,                                      \
 228           "detailed timing of LinearScan phases")                           \
 229                                                                             \
 230   develop(bool, TimeEachLinearScan, false,                                  \
 231           "print detailed timing of each LinearScan run")                   \
 232                                                                             \
 233   develop(bool, CountLinearScan, false,                                     \
 234           "collect statistic counters during LinearScan")                   \
 235                                                                             \
 236   /* C1 variable */                                                         \
 237                                                                             \
 238   develop(bool, C1Breakpoint, false,                                        \
 239           "Sets a breakpoint at entry of each compiled method")             \
 240                                                                             \
 241   develop(bool, ImplicitDiv0Checks, true,                                   \
 242           "Use implicit division by zero checks")                           \


 277   develop(bool, PrintNotLoaded, false,                                      \
 278           "Prints where classes are not loaded during code generation")     \
 279                                                                             \
 280   develop(bool, PrintLIR, false,                                            \
 281           "print low-level IR")                                             \
 282                                                                             \
 283   develop(bool, BailoutAfterHIR, false,                                     \
 284           "bailout of compilation after building of HIR")                   \
 285                                                                             \
 286   develop(bool, BailoutAfterLIR, false,                                     \
 287           "bailout of compilation after building of LIR")                   \
 288                                                                             \
 289   develop(bool, BailoutOnExceptionHandlers, false,                          \
 290           "bailout of compilation for methods with exception handlers")     \
 291                                                                             \
 292   develop(bool, InstallMethods, true,                                       \
 293           "Install methods at the end of successful compilations")          \
 294                                                                             \
 295   develop(intx, NMethodSizeLimit, (64*K)*wordSize,                          \
 296           "Maximum size of a compiled method.")                             \

 297                                                                             \
 298   develop(bool, TraceFPUStack, false,                                       \
 299           "Trace emulation of the FPU stack (intel only)")                  \
 300                                                                             \
 301   develop(bool, TraceFPURegisterUsage, false,                               \
 302           "Trace usage of FPU registers at start of blocks (intel only)")   \
 303                                                                             \
 304   develop(bool, OptimizeUnsafes, true,                                      \
 305           "Optimize raw unsafe ops")                                        \
 306                                                                             \
 307   develop(bool, PrintUnsafeOptimization, false,                             \
 308           "Print optimization of raw unsafe ops")                           \
 309                                                                             \
 310   develop(intx, InstructionCountCutoff, 37000,                              \
 311           "If GraphBuilder adds this many instructions, bails out")         \

 312                                                                             \
 313   develop(bool, ComputeExactFPURegisterUsage, true,                         \
 314           "Compute additional live set for fpu registers to simplify fpu stack merge (Intel only)") \
 315                                                                             \
 316   product(bool, C1ProfileCalls, true,                                       \
 317           "Profile calls when generating code for updating MDOs")           \
 318                                                                             \
 319   product(bool, C1ProfileVirtualCalls, true,                                \
 320           "Profile virtual calls when generating code for updating MDOs")   \
 321                                                                             \
 322   product(bool, C1ProfileInlinedCalls, true,                                \
 323           "Profile inlined calls when generating code for updating MDOs")   \
 324                                                                             \
 325   product(bool, C1ProfileBranches, true,                                    \
 326           "Profile branches when generating code for updating MDOs")        \
 327                                                                             \
 328   product(bool, C1ProfileCheckcasts, true,                                  \
 329           "Profile checkcasts when generating code for updating MDOs")      \
 330                                                                             \
 331   product(bool, C1OptimizeVirtualCallProfiling, true,                       \




 135           "stress loop invariant code motion")                              \
 136                                                                             \
 137   develop(bool, TraceRangeCheckElimination, false,                          \
 138           "Trace Range Check Elimination")                                  \
 139                                                                             \
 140   develop(bool, AssertRangeCheckElimination, false,                         \
 141           "Assert Range Check Elimination")                                 \
 142                                                                             \
 143   develop(bool, StressRangeCheckElimination, false,                         \
 144           "stress Range Check Elimination")                                 \
 145                                                                             \
 146   develop(bool, PrintValueNumbering, false,                                 \
 147           "Print Value Numbering")                                          \
 148                                                                             \
 149   product(intx, ValueMapInitialSize, 11,                                    \
 150           "Initial size of a value map")                                    \
 151           range(1, NOT_LP64(1*K) LP64_ONLY(32*K))                           \
 152                                                                             \
 153   product(intx, ValueMapMaxLoopSize, 8,                                     \
 154           "maximum size of a loop optimized by global value numbering")     \
 155           range(0, 128)                                                     \
 156                                                                             \
 157   develop(bool, EliminateBlocks, true,                                      \
 158           "Eliminate unneccessary basic blocks")                            \
 159                                                                             \
 160   develop(bool, PrintBlockElimination, false,                               \
 161           "Print basic block elimination")                                  \
 162                                                                             \
 163   develop(bool, EliminateNullChecks, true,                                  \
 164           "Eliminate unneccessary null checks")                             \
 165                                                                             \
 166   develop(bool, PrintNullCheckElimination, false,                           \
 167           "Print null check elimination")                                   \
 168                                                                             \
 169   develop(bool, EliminateFieldAccess, true,                                 \
 170           "Optimize field loads and stores")                                \
 171                                                                             \
 172   develop(bool, InlineMethodsWithExceptionHandlers, true,                   \
 173           "Inline methods containing exception handlers "                   \
 174           "(NOTE: does not work with current backend)")                     \
 175                                                                             \


 204   develop(bool, CommentedAssembly, trueInDebug,                             \
 205           "Show extra info in PrintNMethods output")                        \
 206                                                                             \
 207   develop(bool, LIRTracePeephole, false,                                    \
 208           "Trace peephole optimizer")                                       \
 209                                                                             \
 210   develop(bool, LIRTraceExecution, false,                                   \
 211           "add LIR code which logs the execution of blocks")                \
 212                                                                             \
 213   product_pd(bool, LIRFillDelaySlots,                                       \
 214              "fill delays on on SPARC with LIR")                            \
 215                                                                             \
 216   develop_pd(bool, CSEArrayLength,                                          \
 217           "Create separate nodes for length in array accesses")             \
 218                                                                             \
 219   develop_pd(bool, TwoOperandLIRForm,                                       \
 220           "true if LIR requires src1 and dst to match in binary LIR ops")   \
 221                                                                             \
 222   develop(intx, TraceLinearScanLevel, 0,                                    \
 223           "Debug levels for the linear scan allocator")                     \
 224           range(0, 4)                                                       \
 225                                                                             \
 226   develop(bool, StressLinearScan, false,                                    \
 227           "scramble block order used by LinearScan (stress test)")          \
 228                                                                             \
 229   product(bool, TimeLinearScan, false,                                      \
 230           "detailed timing of LinearScan phases")                           \
 231                                                                             \
 232   develop(bool, TimeEachLinearScan, false,                                  \
 233           "print detailed timing of each LinearScan run")                   \
 234                                                                             \
 235   develop(bool, CountLinearScan, false,                                     \
 236           "collect statistic counters during LinearScan")                   \
 237                                                                             \
 238   /* C1 variable */                                                         \
 239                                                                             \
 240   develop(bool, C1Breakpoint, false,                                        \
 241           "Sets a breakpoint at entry of each compiled method")             \
 242                                                                             \
 243   develop(bool, ImplicitDiv0Checks, true,                                   \
 244           "Use implicit division by zero checks")                           \


 279   develop(bool, PrintNotLoaded, false,                                      \
 280           "Prints where classes are not loaded during code generation")     \
 281                                                                             \
 282   develop(bool, PrintLIR, false,                                            \
 283           "print low-level IR")                                             \
 284                                                                             \
 285   develop(bool, BailoutAfterHIR, false,                                     \
 286           "bailout of compilation after building of HIR")                   \
 287                                                                             \
 288   develop(bool, BailoutAfterLIR, false,                                     \
 289           "bailout of compilation after building of LIR")                   \
 290                                                                             \
 291   develop(bool, BailoutOnExceptionHandlers, false,                          \
 292           "bailout of compilation for methods with exception handlers")     \
 293                                                                             \
 294   develop(bool, InstallMethods, true,                                       \
 295           "Install methods at the end of successful compilations")          \
 296                                                                             \
 297   develop(intx, NMethodSizeLimit, (64*K)*wordSize,                          \
 298           "Maximum size of a compiled method.")                             \
 299           range(0, max_jint)                                                \
 300                                                                             \
 301   develop(bool, TraceFPUStack, false,                                       \
 302           "Trace emulation of the FPU stack (intel only)")                  \
 303                                                                             \
 304   develop(bool, TraceFPURegisterUsage, false,                               \
 305           "Trace usage of FPU registers at start of blocks (intel only)")   \
 306                                                                             \
 307   develop(bool, OptimizeUnsafes, true,                                      \
 308           "Optimize raw unsafe ops")                                        \
 309                                                                             \
 310   develop(bool, PrintUnsafeOptimization, false,                             \
 311           "Print optimization of raw unsafe ops")                           \
 312                                                                             \
 313   develop(intx, InstructionCountCutoff, 37000,                              \
 314           "If GraphBuilder adds this many instructions, bails out")         \
 315           range(0, max_jint)                                                \
 316                                                                             \
 317   develop(bool, ComputeExactFPURegisterUsage, true,                         \
 318           "Compute additional live set for fpu registers to simplify fpu stack merge (Intel only)") \
 319                                                                             \
 320   product(bool, C1ProfileCalls, true,                                       \
 321           "Profile calls when generating code for updating MDOs")           \
 322                                                                             \
 323   product(bool, C1ProfileVirtualCalls, true,                                \
 324           "Profile virtual calls when generating code for updating MDOs")   \
 325                                                                             \
 326   product(bool, C1ProfileInlinedCalls, true,                                \
 327           "Profile inlined calls when generating code for updating MDOs")   \
 328                                                                             \
 329   product(bool, C1ProfileBranches, true,                                    \
 330           "Profile branches when generating code for updating MDOs")        \
 331                                                                             \
 332   product(bool, C1ProfileCheckcasts, true,                                  \
 333           "Profile checkcasts when generating code for updating MDOs")      \
 334                                                                             \
 335   product(bool, C1OptimizeVirtualCallProfiling, true,                       \


src/share/vm/c1/c1_globals.hpp
Index Unified diffs Context diffs Sdiffs Patch New Old Previous File Next File