JVM tiered x86_x64 flags

static Flag flagTable[] = {
 { "bool", "UseCompressedOops", &UseCompressedOops, "Use 32-bit object references in 64-bit VM. " "lp64_product means flag is always constant in 32 bit VM", "{lp64_product}", DEFAULT },
 { "bool", "CheckCompressedOops", &CheckCompressedOops, "generate checks in encoding/decoding code in debug VM", "{notproduct}", DEFAULT },
 { "uintx", "HeapBaseMinAddress", &HeapBaseMinAddress, "OS specific low limit for heap base address", "{pd product}", DEFAULT },
 { "bool", "PrintCompressedOopsMode", &PrintCompressedOopsMode, "Print compressed oops base address and encoding mode", "{diagnostic}", DEFAULT },
 { "intx", "ObjectAlignmentInBytes", &ObjectAlignmentInBytes, "Default object alignment in bytes, 8 is minimum", "{lp64_product}", DEFAULT },
 { "bool", "UseMembar", &UseMembar, "(Unstable) Issues membars on thread state transitions", "{pd product}", DEFAULT },
 { "bool", "UsePPCLWSYNC", &UsePPCLWSYNC, "Use lwsync instruction if true, else use slower sync", "{product}", DEFAULT },
 { "bool", "CleanChunkPoolAsync", &CleanChunkPoolAsync, "Whether to clean the chunk pool asynchronously", "", DEFAULT },
 { "bool", "UseMemSetInBOT", &UseMemSetInBOT, "(Unstable) uses memset in BOT updates in GC code", "{experimental}", DEFAULT },
 { "bool", "UnlockDiagnosticVMOptions", &UnlockDiagnosticVMOptions, "Enable normal processing of flags relating to field diagnostics", "{diagnostic}", DEFAULT },
 { "bool", "UnlockExperimentalVMOptions", &UnlockExperimentalVMOptions, "Enable normal processing of flags relating to experimental features", "{experimental}", DEFAULT },
 { "bool", "JavaMonitorsInStackTrace", &JavaMonitorsInStackTrace, "Print info. about Java monitor locks when the stacks are dumped", "{product}", DEFAULT },
 { "bool", "UseLargePages", &UseLargePages, "Use large page memory", "{pd product}", DEFAULT },
 { "bool", "UseLargePagesIndividualAllocation", &UseLargePagesIndividualAllocation, "Allocate large pages individually for better affinity", "{pd product}", DEFAULT },
 { "bool", "LargePagesIndividualAllocationInjectError", &LargePagesIndividualAllocationInjectError, "Fail large pages individual allocation", "", DEFAULT },
 { "bool", "TracePageSizes", &TracePageSizes, "Trace page size selection and usage.", "", DEFAULT },
 { "bool", "UseNUMA", &UseNUMA, "Use NUMA if available", "{product}", DEFAULT },
 { "bool", "UseNUMAInterleaving", &UseNUMAInterleaving, "Interleave memory across NUMA nodes if available", "{product}", DEFAULT },
 { "uintx", "NUMAInterleaveGranularity", &NUMAInterleaveGranularity, "Granularity to use for NUMA interleaving on Windows OS", "{product}", DEFAULT },
 { "bool", "ForceNUMA", &ForceNUMA, "Force NUMA optimizations on single-node/UMA systems", "{product}", DEFAULT },
 { "intx", "NUMAChunkResizeWeight", &NUMAChunkResizeWeight, "Percentage (0-100) used to weight the current sample when " "computing exponentially decaying average for " "AdaptiveNUMAChunkSizing", "{product}", DEFAULT },
 { "intx", "NUMASpaceResizeRate", &NUMASpaceResizeRate, "Do not reallocate more that this amount per collection", "{product}", DEFAULT },
 { "bool", "UseAdaptiveNUMAChunkSizing", &UseAdaptiveNUMAChunkSizing, "Enable adaptive chunk sizing for NUMA", "{product}", DEFAULT },
 { "bool", "NUMAStats", &NUMAStats, "Print NUMA stats in detailed heap information", "{product}", DEFAULT },
 { "intx", "NUMAPageScanRate", &NUMAPageScanRate, "Maximum number of pages to include in the page scan procedure", "{product}", DEFAULT },
 { "bool", "NeedsDeoptSuspend", &NeedsDeoptSuspend, "True for register window machines (sparc/ia64)", "{pd product}", DEFAULT },
 { "intx", "UseSSE", &UseSSE, "Highest supported SSE instructions set on x86/x64", "{product}", DEFAULT },
 { "bool", "UseAES", &UseAES, "Control whether AES instructions can be used on x86/x64", "{product}", DEFAULT },
 { "uintx", "LargePageSizeInBytes", &LargePageSizeInBytes, "Large page size (0 to let VM choose the page size", "{product}", DEFAULT },
 { "uintx", "LargePageHeapSizeThreshold", &LargePageHeapSizeThreshold, "Use large pages if max heap is at least this big", "{product}", DEFAULT },
 { "bool", "ForceTimeHighResolution", &ForceTimeHighResolution, "Using high time resolution(For Win32 only)", "{product}", DEFAULT },
 { "bool", "TraceItables", &TraceItables, "Trace initialization and use of itables", "", DEFAULT },
 { "bool", "TracePcPatching", &TracePcPatching, "Trace usage of frame::patch_pc", "", DEFAULT },
 { "bool", "TraceJumps", &TraceJumps, "Trace assembly jumps in thread ring buffer", "", DEFAULT },
 { "bool", "TraceRelocator", &TraceRelocator, "Trace the bytecode relocator", "", DEFAULT },
 { "bool", "TraceLongCompiles", &TraceLongCompiles, "Print out every time compilation is longer than " "a given threashold", "", DEFAULT },
 { "bool", "SafepointALot", &SafepointALot, "Generates a lot of safepoints. Works with " "GuaranteedSafepointInterval", "", DEFAULT },
 { "bool", "BackgroundCompilation", &BackgroundCompilation, "A thread requesting compilation is not blocked during " "compilation", "{pd product}", DEFAULT },
 { "bool", "PrintVMQWaitTime", &PrintVMQWaitTime, "Prints out the waiting time in VM operation queue", "{product}", DEFAULT },
 { "bool", "NoYieldsInMicrolock", &NoYieldsInMicrolock, "Disable yields in microlock", "", DEFAULT },
 { "bool", "TraceOopMapGeneration", &TraceOopMapGeneration, "Shows oopmap generation", "", DEFAULT },
 { "bool", "MethodFlushing", &MethodFlushing, "Reclamation of zombie and not-entrant methods", "{product}", DEFAULT },
 { "bool", "VerifyStack", &VerifyStack, "Verify stack of each thread when it is entering a runtime call", "", DEFAULT },
 { "bool", "ForceUnreachable", &ForceUnreachable, "Make all non code cache addresses to be unreachable with forcing use of 64bit literal fixups", "{diagnostic}", DEFAULT },
 { "bool", "StressDerivedPointers", &StressDerivedPointers, "Force scavenge when a derived pointers is detected on stack " "after rtm call", "{notproduct}", DEFAULT },
 { "bool", "TraceDerivedPointers", &TraceDerivedPointers, "Trace traversal of derived pointers on stack", "", DEFAULT },
 { "bool", "TraceCodeBlobStacks", &TraceCodeBlobStacks, "Trace stack-walk of codeblobs", "{notproduct}", DEFAULT },
 { "bool", "PrintJNIResolving", &PrintJNIResolving, "Used to implement -v:jni", "{product}", DEFAULT },
 { "bool", "PrintRewrites", &PrintRewrites, "Print methods that are being rewritten", "{notproduct}", DEFAULT },
 { "bool", "UseInlineCaches", &UseInlineCaches, "Use Inline Caches for virtual calls ", "{product}", DEFAULT },
 { "bool", "InlineArrayCopy", &InlineArrayCopy, "inline arraycopy native that is known to be part of " "base library DLL", "", DEFAULT },
 { "bool", "InlineObjectHash", &InlineObjectHash, "inline Object::hashCode() native that is known to be part " "of base library DLL", "", DEFAULT },
 { "bool", "InlineNatives", &InlineNatives, "inline natives that are known to be part of base library DLL", "", DEFAULT },
 { "bool", "InlineMathNatives", &InlineMathNatives, "inline SinD, CosD, etc.", "", DEFAULT },
 { "bool", "InlineClassNatives", &InlineClassNatives, "inline Class.isInstance, etc", "", DEFAULT },
 { "bool", "InlineThreadNatives", &InlineThreadNatives, "inline Thread.currentThread, etc", "", DEFAULT },
 { "bool", "InlineUnsafeOps", &InlineUnsafeOps, "inline memory ops (native methods) from sun.misc.Unsafe", "", DEFAULT },
 { "bool", "CriticalJNINatives", &CriticalJNINatives, "check for critical JNI entry points", "{product}", DEFAULT },
 { "bool", "StressCriticalJNINatives", &StressCriticalJNINatives, "Exercise register saving code in critical natives", "{notproduct}", DEFAULT },
 { "bool", "UseSSE42Intrinsics", &UseSSE42Intrinsics, "SSE4.2 versions of intrinsics", "{product}", DEFAULT },
 { "bool", "UseAESIntrinsics", &UseAESIntrinsics, "use intrinsics for AES versions of crypto", "{product}", DEFAULT },
 { "bool", "TraceCallFixup", &TraceCallFixup, "traces all call fixups", "", DEFAULT },
 { "bool", "DeoptimizeALot", &DeoptimizeALot, "deoptimize at every exit from the runtime system", "", DEFAULT },
 { "ccstrlist", "DeoptimizeOnlyAt", &DeoptimizeOnlyAt, "a comma separated list of bcis to deoptimize at", "{notproduct}", DEFAULT },
 { "bool", "DeoptimizeRandom", &DeoptimizeRandom, "deoptimize random frames on random exit from the runtime system", "{product}", DEFAULT },
 { "bool", "ZombieALot", &ZombieALot, "creates zombies (non-entrant) at exit from the runt. system", "{notproduct}", DEFAULT },
 { "bool", "UnlinkSymbolsALot", &UnlinkSymbolsALot, "unlink unreferenced symbols from the symbol table at safepoints", "{product}", DEFAULT },
 { "bool", "WalkStackALot", &WalkStackALot, "trace stack (no print) at every exit from the runtime system", "{notproduct}", DEFAULT },
 { "bool", "Debugging", &Debugging, "set when executing debug methods in debug.ccp " "(to prevent triggering assertions)", "{product}", DEFAULT },
 { "bool", "StrictSafepointChecks", &StrictSafepointChecks, "Enable strict checks that safepoints cannot happen for threads " "that used No_Safepoint_Verifier", "{notproduct}", DEFAULT },
 { "bool", "VerifyLastFrame", &VerifyLastFrame, "Verify oops on last frame on entry to VM", "{notproduct}", DEFAULT },
 { "bool", "TraceHandleAllocation", &TraceHandleAllocation, "Prints out warnings when suspicious many handles are allocated", "", DEFAULT },
 { "bool", "UseCompilerSafepoints", &UseCompilerSafepoints, "Stop at safepoints in compiled code", "{product}", DEFAULT },
 { "bool", "UseSplitVerifier", &UseSplitVerifier, "use split verifier with StackMapTable attributes", "{product}", DEFAULT },
 { "bool", "FailOverToOldVerifier", &FailOverToOldVerifier, "fail over to old verifier when split verifier fails", "{product}", DEFAULT },
 { "bool", "ShowSafepointMsgs", &ShowSafepointMsgs, "Show msg. about safepoint synch.", "", DEFAULT },
 { "bool", "SafepointTimeout", &SafepointTimeout, "Time out and warn or fail after SafepointTimeoutDelay " "milliseconds if failed to reach safepoint", "{product}", DEFAULT },
 { "bool", "DieOnSafepointTimeout", &DieOnSafepointTimeout, "Die upon failure to reach safepoint (see SafepointTimeout)", "", DEFAULT },
 { "intx", "SuspendRetryCount", &SuspendRetryCount, "Maximum retry count for an external suspend request", "{product}", DEFAULT },
 { "intx", "SuspendRetryDelay", &SuspendRetryDelay, "Milliseconds to delay per retry (* current_retry_count)", "{product}", DEFAULT },
 { "bool", "AssertOnSuspendWaitFailure", &AssertOnSuspendWaitFailure, "Assert/Guarantee on external suspend wait failure", "{product}", DEFAULT },
 { "bool", "TraceSuspendWaitFailures", &TraceSuspendWaitFailures, "Trace external suspend wait failures", "{product}", DEFAULT },
 { "bool", "MaxFDLimit", &MaxFDLimit, "Bump the number of file descriptors to max in solaris.", "{product}", DEFAULT },
 { "bool", "LogEvents", &LogEvents, "Enable the various ring buffer event logs", "{diagnostic}", DEFAULT },
 { "intx", "LogEventsBufferEntries", &LogEventsBufferEntries, "Enable the various ring buffer event logs", "{diagnostic}", DEFAULT },
 { "bool", "BytecodeVerificationRemote", &BytecodeVerificationRemote, "Enables the Java bytecode verifier for remote classes", "{product}", DEFAULT },
 { "bool", "BytecodeVerificationLocal", &BytecodeVerificationLocal, "Enables the Java bytecode verifier for local classes", "{product}", DEFAULT },
 { "bool", "ForceFloatExceptions", &ForceFloatExceptions, "Force exceptions on FP stack under/overflow", "", DEFAULT },
 { "bool", "VerifyStackAtCalls", &VerifyStackAtCalls, "Verify that the stack pointer is unchanged after calls", "", DEFAULT },
 { "bool", "TraceJavaAssertions", &TraceJavaAssertions, "Trace java language assertions", "", DEFAULT },
 { "bool", "CheckAssertionStatusDirectives", &CheckAssertionStatusDirectives, "temporary - see javaClasses.cpp", "{notproduct}", DEFAULT },
 { "bool", "PrintMallocFree", &PrintMallocFree, "Trace calls to C heap malloc/free allocation", "{notproduct}", DEFAULT },
 { "bool", "PrintOopAddress", &PrintOopAddress, "Always print the location of the oop", "{product}", DEFAULT },
 { "bool", "VerifyCodeCacheOften", &VerifyCodeCacheOften, "Verify compiled-code cache often", "{notproduct}", DEFAULT },
 { "bool", "ZapDeadCompiledLocals", &ZapDeadCompiledLocals, "Zap dead locals in compiler frames", "", DEFAULT },
 { "bool", "ZapDeadLocalsOld", &ZapDeadLocalsOld, "Zap dead locals (old version, zaps all frames when " "entering the VM", "{notproduct}", DEFAULT },
 { "bool", "CheckOopishValues", &CheckOopishValues, "Warn if value contains oop ( requires ZapDeadLocals)", "{notproduct}", DEFAULT },
 { "bool", "UseMallocOnly", &UseMallocOnly, "use only malloc/free for allocation (no resource area/arena)", "", DEFAULT },
 { "bool", "PrintMalloc", &PrintMalloc, "print all malloc/free calls", "", DEFAULT },
 { "bool", "PrintMallocStatistics", &PrintMallocStatistics, "print malloc/free statistics", "", DEFAULT },
 { "bool", "ZapResourceArea", &ZapResourceArea, "Zap freed resource/arena space with 0xABABABAB", "", DEFAULT },
 { "bool", "ZapVMHandleArea", &ZapVMHandleArea, "Zap freed VM handle space with 0xBCBCBCBC", "{notproduct}", DEFAULT },
 { "bool", "ZapJNIHandleArea", &ZapJNIHandleArea, "Zap freed JNI handle space with 0xFEFEFEFE", "", DEFAULT },
 { "bool", "ZapStackSegments", &ZapStackSegments, "Zap allocated/freed Stack segments with 0xFADFADED", "{notproduct}", DEFAULT },
 { "bool", "ZapUnusedHeapArea", &ZapUnusedHeapArea, "Zap unused heap space with 0xBAADBABE", "", DEFAULT },
 { "bool", "TraceZapUnusedHeapArea", &TraceZapUnusedHeapArea, "Trace zapping of unused heap space", "", DEFAULT },
 { "bool", "CheckZapUnusedHeapArea", &CheckZapUnusedHeapArea, "Check zapping of unused heap space", "", DEFAULT },
 { "bool", "ZapFillerObjects", &ZapFillerObjects, "Zap filler objects with 0xDEAFBABE", "", DEFAULT },
 { "bool", "PrintVMMessages", &PrintVMMessages, "Print vm messages on console", "", DEFAULT },
 { "bool", "PrintGCApplicationConcurrentTime", &PrintGCApplicationConcurrentTime, "Print the time the application has been running", "{product}", DEFAULT },
 { "bool", "PrintGCApplicationStoppedTime", &PrintGCApplicationStoppedTime, "Print the time the application has been stopped", "{product}", DEFAULT },
 { "bool", "VerboseVerification", &VerboseVerification, "Display detailed verification details", "{diagnostic}", DEFAULT },
 { "uintx", "ErrorHandlerTest", &ErrorHandlerTest, "If > 0, provokes an error after VM initialization; the value" "determines which error to provoke.  See test_error_handler()" "in debug.cpp.", "{notproduct}", DEFAULT },
 { "bool", "Verbose", &Verbose, "Prints additional debugging information from other modes", "", DEFAULT },
 { "bool", "PrintMiscellaneous", &PrintMiscellaneous, "Prints uncategorized debugging information (requires +Verbose)", "", DEFAULT },
 { "bool", "WizardMode", &WizardMode, "Prints much more debugging information", "", DEFAULT },
 { "bool", "ShowMessageBoxOnError", &ShowMessageBoxOnError, "Keep process alive on VM fatal error", "{product}", DEFAULT },
 { "bool", "CreateMinidumpOnCrash", &CreateMinidumpOnCrash, "Create minidump on VM fatal error", "{product}", DEFAULT },
 { "bool", "UseOSErrorReporting", &UseOSErrorReporting, "Let VM fatal error propagate to the OS (ie. WER on Windows)", "{pd product}", DEFAULT },
 { "bool", "SuppressFatalErrorMessage", &SuppressFatalErrorMessage, "Do NO Fatal Error report [Avoid deadlock]", "{product}", DEFAULT },
 { "ccstrlist", "OnError", &OnError, "Run user-defined commands on fatal error; see VMError.cpp " "for examples", "{product}", DEFAULT },
 { "ccstrlist", "OnOutOfMemoryError", &OnOutOfMemoryError, "Run user-defined commands on first java.lang.OutOfMemoryError", "{product}", DEFAULT },
 { "bool", "HeapDumpBeforeFullGC", &HeapDumpBeforeFullGC, "Dump heap to file before any major stop-world GC", "{manageable}", DEFAULT },
 { "bool", "HeapDumpAfterFullGC", &HeapDumpAfterFullGC, "Dump heap to file after any major stop-world GC", "{manageable}", DEFAULT },
 { "bool", "HeapDumpOnOutOfMemoryError", &HeapDumpOnOutOfMemoryError, "Dump heap to file when java.lang.OutOfMemoryError is thrown", "{manageable}", DEFAULT },
 { "ccstr", "HeapDumpPath", &HeapDumpPath, "When HeapDumpOnOutOfMemoryError is on, the path (filename or" "directory) of the dump file (defaults to java_pid<pid>.hprof" "in the working directory)", "{manageable}", DEFAULT },
 { "uintx", "SegmentedHeapDumpThreshold", &SegmentedHeapDumpThreshold, "Generate a segmented heap dump (JAVA PROFILE 1.0.2 format) " "when the heap usage is larger than this", "", DEFAULT },
 { "uintx", "HeapDumpSegmentSize", &HeapDumpSegmentSize, "Approximate segment size when generating a segmented heap dump", "", DEFAULT },
 { "bool", "BreakAtWarning", &BreakAtWarning, "Execute breakpoint upon encountering VM warning", "", DEFAULT },
 { "bool", "UseVectoredExceptions", &UseVectoredExceptions, "Temp Flag - Use Vectored Exceptions rather than SEH (Windows Only)", "{pd product}", DEFAULT },
 { "bool", "TraceVMOperation", &TraceVMOperation, "Trace vm operations", "", DEFAULT },
 { "bool", "UseFakeTimers", &UseFakeTimers, "Tells whether the VM should use system time or a fake timer", "", DEFAULT },
 { "ccstr", "NativeMemoryTracking", &NativeMemoryTracking, "Native memory tracking options", "{product}", DEFAULT },
 { "bool", "PrintNMTStatistics", &PrintNMTStatistics, "Print native memory tracking summary data if it is on", "{diagnostic}", DEFAULT },
 { "bool", "AutoShutdownNMT", &AutoShutdownNMT, "Automatically shutdown native memory tracking under stress " "situation. When set to false, native memory tracking tries to " "stay alive at the expense of JVM performance", "{diagnostic}", DEFAULT },
 { "bool", "LogCompilation", &LogCompilation, "Log compilation activity in detail to hotspot.log or LogFile", "{diagnostic}", DEFAULT },
 { "bool", "PrintCompilation", &PrintCompilation, "Print compilations", "{product}", DEFAULT },
 { "bool", "TraceNMethodInstalls", &TraceNMethodInstalls, "Trace nmethod intallation", "{diagnostic}", DEFAULT },
 { "intx", "ScavengeRootsInCode", &ScavengeRootsInCode, "0: do not allow scavengable oops in the code cache; " "1: allow scavenging from the code cache; " "2: emit as many constants as the compiler can see", "{diagnostic}", DEFAULT },
 { "bool", "AlwaysRestoreFPU", &AlwaysRestoreFPU, "Restore the FPU control word after every JNI call (expensive)", "{product}", DEFAULT },
 { "bool", "PrintCompilation2", &PrintCompilation2, "Print additional statistics per compilation", "{diagnostic}", DEFAULT },
 { "bool", "PrintAdapterHandlers", &PrintAdapterHandlers, "Print code generated for i2c/c2i adapters", "{diagnostic}", DEFAULT },
 { "bool", "VerifyAdapterCalls", &VerifyAdapterCalls, "Verify that i2c/c2i adapters are called properly", "{diagnostic}", DEFAULT },
 { "bool", "VerifyAdapterSharing", &VerifyAdapterSharing, "Verify that the code for shared adapters is the equivalent", "", DEFAULT },
 { "bool", "PrintAssembly", &PrintAssembly, "Print assembly code (using external disassembler.so)", "{diagnostic}", DEFAULT },
 { "ccstr", "PrintAssemblyOptions", &PrintAssemblyOptions, "Options string passed to disassembler.so", "{diagnostic}", DEFAULT },
 { "bool", "PrintNMethods", &PrintNMethods, "Print assembly code for nmethods when generated", "{diagnostic}", DEFAULT },
 { "bool", "PrintNativeNMethods", &PrintNativeNMethods, "Print assembly code for native nmethods when generated", "{diagnostic}", DEFAULT },
 { "bool", "PrintDebugInfo", &PrintDebugInfo, "Print debug information for all nmethods when generated", "", DEFAULT },
 { "bool", "PrintRelocations", &PrintRelocations, "Print relocation information for all nmethods when generated", "", DEFAULT },
 { "bool", "PrintDependencies", &PrintDependencies, "Print dependency information for all nmethods when generated", "", DEFAULT },
 { "bool", "PrintExceptionHandlers", &PrintExceptionHandlers, "Print exception handler tables for all nmethods when generated", "", DEFAULT },
 { "bool", "StressCompiledExceptionHandlers", &StressCompiledExceptionHandlers, "Exercise compiled exception handlers", "", DEFAULT },
 { "bool", "InterceptOSException", &InterceptOSException, "Starts debugger when an implicit OS (e.g., NULL) " "exception happens", "", DEFAULT },
 { "bool", "PrintCodeCache", &PrintCodeCache, "Print the compiled_code cache when exiting", "{notproduct}", DEFAULT },
 { "bool", "PrintCodeCache2", &PrintCodeCache2, "Print detailed info on the compiled_code cache when exiting", "", DEFAULT },
 { "bool", "PrintStubCode", &PrintStubCode, "Print generated stub code", "{diagnostic}", DEFAULT },
 { "bool", "StackTraceInThrowable", &StackTraceInThrowable, "Collect backtrace in throwable when exception happens", "{product}", DEFAULT },
 { "bool", "OmitStackTraceInFastThrow", &OmitStackTraceInFastThrow, "Omit backtraces for some 'hot' exceptions in optimized code", "{product}", DEFAULT },
 { "bool", "ProfilerPrintByteCodeStatistics", &ProfilerPrintByteCodeStatistics, "Prints byte code statictics when dumping profiler output", "{product}", DEFAULT },
 { "bool", "ProfilerRecordPC", &ProfilerRecordPC, "Collects tick for each 16 byte interval of compiled code", "{product}", DEFAULT },
 { "bool", "ProfileVM", &ProfileVM, "Profiles ticks that fall within VM (either in the VM Thread " "or VM code called through stubs)", "{product}", DEFAULT },
 { "bool", "ProfileIntervals", &ProfileIntervals, "Prints profiles for each interval (see ProfileIntervalsTicks)", "{product}", DEFAULT },
 { "bool", "ProfilerCheckIntervals", &ProfilerCheckIntervals, "Collect and print info on spacing of profiler ticks", "{notproduct}", DEFAULT },
 { "bool", "PrintJVMWarnings", &PrintJVMWarnings, "Prints warnings for unimplemented JVM functions", "", DEFAULT },
 { "bool", "PrintWarnings", &PrintWarnings, "Prints JVM warnings to output stream", "{product}", DEFAULT },
 { "uintx", "WarnOnStalledSpinLock", &WarnOnStalledSpinLock, "Prints warnings for stalled SpinLocks", "{notproduct}", DEFAULT },
 { "bool", "InitializeJavaLangSystem", &InitializeJavaLangSystem, "Initialize java.lang.System - turn off for individual " "method debugging", "", DEFAULT },
 { "bool", "InitializeJavaLangString", &InitializeJavaLangString, "Initialize java.lang.String - turn off for individual " "method debugging", "", DEFAULT },
 { "bool", "InitializeJavaLangExceptionsErrors", &InitializeJavaLangExceptionsErrors, "Initialize various error and exception classes - turn off for " "individual method debugging", "", DEFAULT },
 { "bool", "RegisterFinalizersAtInit", &RegisterFinalizersAtInit, "Register finalizable objects at end of Object.<init> or " "after allocation", "{product}", DEFAULT },
 { "bool", "RegisterReferences", &RegisterReferences, "Tells whether the VM should register soft/weak/final/phantom " "references", "", DEFAULT },
 { "bool", "IgnoreRewrites", &IgnoreRewrites, "Supress rewrites of bytecodes in the oopmap generator. " "This is unsafe!", "", DEFAULT },
 { "bool", "PrintCodeCacheExtension", &PrintCodeCacheExtension, "Print extension of code cache", "", DEFAULT },
 { "bool", "UsePrivilegedStack", &UsePrivilegedStack, "Enable the security JVM functions", "", DEFAULT },
 { "bool", "ProtectionDomainVerification", &ProtectionDomainVerification, "Verifies protection domain before resolution in system " "dictionary", "", DEFAULT },
 { "bool", "ClassUnloading", &ClassUnloading, "Do unloading of classes", "{product}", DEFAULT },
 { "bool", "DisableStartThread", &DisableStartThread, "Disable starting of additional Java threads " "(for debugging only)", "", DEFAULT },
 { "bool", "MemProfiling", &MemProfiling, "Write memory usage profiling to log file", "", DEFAULT },
 { "bool", "PrintSystemDictionaryAtExit", &PrintSystemDictionaryAtExit, "Prints the system dictionary at exit", "{notproduct}", DEFAULT },
 { "intx", "PredictedLoadedClassCount", &PredictedLoadedClassCount, "Experimental: Tune loaded class cache starting size.", "{experimental}", DEFAULT },
 { "bool", "UnsyncloadClass", &UnsyncloadClass, "Unstable: VM calls loadClass unsynchronized. Custom " "class loader  must call VM synchronized for findClass " "and defineClass.", "{diagnostic}", DEFAULT },
 { "bool", "AlwaysLockClassLoader", &AlwaysLockClassLoader, "Require the VM to acquire the class loader lock before calling " "loadClass() even for class loaders registering " "as parallel capable", "{product}", DEFAULT },
 { "bool", "AllowParallelDefineClass", &AllowParallelDefineClass, "Allow parallel defineClass requests for class loaders " "registering as parallel capable", "{product}", DEFAULT },
 { "bool", "MustCallLoadClassInternal", &MustCallLoadClassInternal, "Call loadClassInternal() rather than loadClass()", "{product}", DEFAULT },
 { "bool", "DontYieldALot", &DontYieldALot, "Throw away obvious excess yield calls (for SOLARIS only)", "{pd product}", DEFAULT },
 { "bool", "ConvertSleepToYield", &ConvertSleepToYield, "Converts sleep(0) to thread yield " "(may be off for SOLARIS to improve GUI)", "{pd product}", DEFAULT },
 { "bool", "ConvertYieldToSleep", &ConvertYieldToSleep, "Converts yield to a sleep of MinSleepInterval to simulate Win32 " "behavior (SOLARIS only)", "{product}", DEFAULT },
 { "bool", "UseBoundThreads", &UseBoundThreads, "Bind user level threads to kernel threads (for SOLARIS only)", "{product}", DEFAULT },
 { "bool", "UseDetachedThreads", &UseDetachedThreads, "Use detached threads that are recycled upon termination " "(for SOLARIS only)", "", DEFAULT },
 { "bool", "UseLWPSynchronization", &UseLWPSynchronization, "Use LWP-based instead of libthread-based synchronization " "(SPARC only)", "{product}", DEFAULT },
 { "ccstr", "SyncKnobs", &SyncKnobs, "(Unstable) Various monitor synchronization tunables", "{product}", DEFAULT },
 { "intx", "EmitSync", &EmitSync, "(Unsafe,Unstable) " " Controls emission of inline sync fast-path code", "{product}", DEFAULT },
 { "intx", "MonitorBound", &MonitorBound, "Bound Monitor population", "{product}", DEFAULT },
 { "bool", "MonitorInUseLists", &MonitorInUseLists, "Track Monitors for Deflation", "{product}", DEFAULT },
 { "intx", "Atomics", &Atomics, "(Unsafe,Unstable) Diagnostic - Controls emission of atomics", "{product}", DEFAULT },
 { "intx", "SyncFlags", &SyncFlags, "(Unsafe,Unstable) Experimental Sync flags", "{product}", DEFAULT },
 { "intx", "SyncVerbose", &SyncVerbose, "(Unstable)", "{product}", DEFAULT },
 { "intx", "ClearFPUAtPark", &ClearFPUAtPark, "(Unsafe,Unstable)", "{product}", DEFAULT },
 { "intx", "hashCode", &hashCode, "(Unstable) select hashCode generation algorithm", "{product}", DEFAULT },
 { "intx", "WorkAroundNPTLTimedWaitHang", &WorkAroundNPTLTimedWaitHang, "(Unstable, Linux-specific)" " avoid NPTL-FUTEX hang pthread_cond_timedwait", "{product}", DEFAULT },
 { "bool", "FilterSpuriousWakeups", &FilterSpuriousWakeups, "Prevent spurious or premature wakeups from object.wait " "(Solaris only)", "{product}", DEFAULT },
 { "intx", "NativeMonitorTimeout", &NativeMonitorTimeout, "(Unstable)", "{product}", DEFAULT },
 { "intx", "NativeMonitorFlags", &NativeMonitorFlags, "(Unstable)", "{product}", DEFAULT },
 { "intx", "NativeMonitorSpinLimit", &NativeMonitorSpinLimit, "(Unstable)", "{product}", DEFAULT },
 { "bool", "UsePthreads", &UsePthreads, "Use pthread-based instead of libthread-based synchronization " "(SPARC only)", "", DEFAULT },
 { "bool", "AdjustConcurrency", &AdjustConcurrency, "call thr_setconcurrency at thread create time to avoid " "LWP starvation on MP systems (For Solaris Only)", "{product}", DEFAULT },
 { "bool", "ReduceSignalUsage", &ReduceSignalUsage, "Reduce the use of OS signals in Java and/or the VM", "{product}", DEFAULT },
 { "bool", "ValidateMarkSweep", &ValidateMarkSweep, "Do extra validation during MarkSweep collection", "{notproduct}", DEFAULT },
 { "bool", "RecordMarkSweepCompaction", &RecordMarkSweepCompaction, "Enable GC-to-GC recording and querying of compaction during " "MarkSweep", "{notproduct}", DEFAULT },
 { "bool", "ShareVtableStubs", &ShareVtableStubs, "Share vtable stubs (smaller code but worse branch prediction", "{pd}", DEFAULT },
 { "bool", "LoadLineNumberTables", &LoadLineNumberTables, "Tells whether the class file parser loads line number tables", "", DEFAULT },
 { "bool", "LoadLocalVariableTables", &LoadLocalVariableTables, "Tells whether the class file parser loads local variable tables", "", DEFAULT },
 { "bool", "LoadLocalVariableTypeTables", &LoadLocalVariableTypeTables, "Tells whether the class file parser loads local variable type tables", "", DEFAULT },
 { "bool", "AllowUserSignalHandlers", &AllowUserSignalHandlers, "Do not complain if the application installs signal handlers " "(Solaris & Linux only)", "{product}", DEFAULT },
 { "bool", "UseSignalChaining", &UseSignalChaining, "Use signal-chaining to invoke signal handlers installed " "by the application (Solaris & Linux only)", "{product}", DEFAULT },
 { "bool", "UseAltSigs", &UseAltSigs, "Use alternate signals instead of SIGUSR1 & SIGUSR2 for VM " "internal signals (Solaris only)", "{product}", DEFAULT },
 { "bool", "AllowJNIEnvProxy", &AllowJNIEnvProxy, "Allow JNIEnv proxies for jdbx", "{product}", DEFAULT },
 { "bool", "JNIDetachReleasesMonitors", &JNIDetachReleasesMonitors, "JNI DetachCurrentThread releases monitors owned by thread", "{product}", DEFAULT },
 { "bool", "RestoreMXCSROnJNICalls", &RestoreMXCSROnJNICalls, "Restore MXCSR when returning from JNI calls", "{product}", DEFAULT },
 { "bool", "CheckJNICalls", &CheckJNICalls, "Verify all arguments to JNI calls", "{product}", DEFAULT },
 { "bool", "UseFastJNIAccessors", &UseFastJNIAccessors, "Use optimized versions of Get<Primitive>Field", "{product}", DEFAULT },
 { "bool", "EagerXrunInit", &EagerXrunInit, "Eagerly initialize -Xrun libraries; allows startup profiling, " " but not all -Xrun libraries may support the state of the VM at this time", "{product}", DEFAULT },
 { "bool", "PreserveAllAnnotations", &PreserveAllAnnotations, "Preserve RuntimeInvisibleAnnotations as well as RuntimeVisibleAnnotations", "{product}", DEFAULT },
 { "uintx", "PreallocatedOutOfMemoryErrorCount", &PreallocatedOutOfMemoryErrorCount, "Number of OutOfMemoryErrors preallocated with backtrace", "", DEFAULT },
 { "bool", "LazyBootClassLoader", &LazyBootClassLoader, "Enable/disable lazy opening of boot class path entries", "{product}", DEFAULT },
 { "bool", "UseXMMForArrayCopy", &UseXMMForArrayCopy, "Use SSE2 MOVQ instruction for Arraycopy", "{product}", DEFAULT },
 { "intx", "FieldsAllocationStyle", &FieldsAllocationStyle, "0 - type based with oops first, 1 - with oops last, " "2 - oops in super and sub classes are together", "{product}", DEFAULT },
 { "bool", "CompactFields", &CompactFields, "Allocate nonstatic fields in gaps between previous fields", "{product}", DEFAULT },
 { "bool", "PrintCompactFieldsSavings", &PrintCompactFieldsSavings, "Print how many words were saved with CompactFields", "{notproduct}", DEFAULT },
 { "bool", "UseBiasedLocking", &UseBiasedLocking, "Enable biased locking in JVM", "{product}", DEFAULT },
 { "intx", "BiasedLockingStartupDelay", &BiasedLockingStartupDelay, "Number of milliseconds to wait before enabling biased locking", "{product}", DEFAULT },
 { "bool", "PrintBiasedLockingStatistics", &PrintBiasedLockingStatistics, "Print statistics of biased locking in JVM", "{diagnostic}", DEFAULT },
 { "intx", "BiasedLockingBulkRebiasThreshold", &BiasedLockingBulkRebiasThreshold, "Threshold of number of revocations per type to try to " "rebias all objects in the heap of that type", "{product}", DEFAULT },
 { "intx", "BiasedLockingBulkRevokeThreshold", &BiasedLockingBulkRevokeThreshold, "Threshold of number of revocations per type to permanently " "revoke biases of all objects in the heap of that type", "{product}", DEFAULT },
 { "intx", "BiasedLockingDecayTime", &BiasedLockingDecayTime, "Decay time (in milliseconds) to re-enable bulk rebiasing of a " "type after previous bulk rebias", "{product}", DEFAULT },
 { "bool", "JavaObjectsInPerm", &JavaObjectsInPerm, "controls whether Classes and interned Strings are allocated" "in perm.  This purely intended to allow debugging issues" "in production.", "", DEFAULT },
 { "bool", "TraceRuntimeCalls", &TraceRuntimeCalls, "Trace run-time calls", "{notproduct}", DEFAULT },
 { "bool", "TraceJNICalls", &TraceJNICalls, "Trace JNI calls", "", DEFAULT },
 { "bool", "TraceJVMCalls", &TraceJVMCalls, "Trace JVM calls", "{notproduct}", DEFAULT },
 { "ccstr", "TraceJVMTI", &TraceJVMTI, "Trace flags for JVMTI functions and events", "{product}", DEFAULT },
 { "bool", "StressLdcRewrite", &StressLdcRewrite, "Force ldc -> ldc_w rewrite during RedefineClasses", "{product}", DEFAULT },
 { "intx", "TraceRedefineClasses", &TraceRedefineClasses, "Trace level for JVMTI RedefineClasses", "{product}", DEFAULT },
 { "bool", "StressMethodComparator", &StressMethodComparator, "run the MethodComparator on all loaded methods", "", DEFAULT },
 { "bool", "VerifyMergedCPBytecodes", &VerifyMergedCPBytecodes, "Verify bytecodes after RedefineClasses constant pool merging", "{product}", DEFAULT },
 { "bool", "TraceJNIHandleAllocation", &TraceJNIHandleAllocation, "Trace allocation/deallocation of JNI handle blocks", "", DEFAULT },
 { "bool", "TraceThreadEvents", &TraceThreadEvents, "Trace all thread events", "", DEFAULT },
 { "bool", "TraceBytecodes", &TraceBytecodes, "Trace bytecode execution", "", DEFAULT },
 { "bool", "TraceClassInitialization", &TraceClassInitialization, "Trace class initialization", "", DEFAULT },
 { "bool", "TraceExceptions", &TraceExceptions, "Trace exceptions", "", DEFAULT },
 { "bool", "TraceICs", &TraceICs, "Trace inline cache changes", "", DEFAULT },
 { "bool", "TraceInvocationCounterOverflow", &TraceInvocationCounterOverflow, "Trace method invocation counter overflow", "{notproduct}", DEFAULT },
 { "bool", "TraceInlineCacheClearing", &TraceInlineCacheClearing, "Trace clearing of inline caches in nmethods", "", DEFAULT },
 { "bool", "TraceDependencies", &TraceDependencies, "Trace dependencies", "", DEFAULT },
 { "bool", "VerifyDependencies", &VerifyDependencies, "Exercise and verify the compilation dependency mechanism", "", DEFAULT },
 { "bool", "TraceNewOopMapGeneration", &TraceNewOopMapGeneration, "Trace OopMapGeneration", "", DEFAULT },
 { "bool", "TraceNewOopMapGenerationDetailed", &TraceNewOopMapGenerationDetailed, "Trace OopMapGeneration: print detailed cell states", "", DEFAULT },
 { "bool", "TimeOopMap", &TimeOopMap, "Time calls to GenerateOopMap::compute_map() in sum", "", DEFAULT },
 { "bool", "TimeOopMap2", &TimeOopMap2, "Time calls to GenerateOopMap::compute_map() individually", "", DEFAULT },
 { "bool", "TraceMonitorMismatch", &TraceMonitorMismatch, "Trace monitor matching failures during OopMapGeneration", "", DEFAULT },
 { "bool", "TraceOopMapRewrites", &TraceOopMapRewrites, "Trace rewritting of method oops during oop map generation", "", DEFAULT },
 { "bool", "TraceSafepoint", &TraceSafepoint, "Trace safepoint operations", "", DEFAULT },
 { "bool", "TraceICBuffer", &TraceICBuffer, "Trace usage of IC buffer", "", DEFAULT },
 { "bool", "TraceCompiledIC", &TraceCompiledIC, "Trace changes of compiled IC", "", DEFAULT },
 { "bool", "TraceZapDeadLocals", &TraceZapDeadLocals, "Trace zapping dead locals", "{notproduct}", DEFAULT },
 { "bool", "TraceStartupTime", &TraceStartupTime, "Trace setup time", "", DEFAULT },
 { "bool", "TraceProtectionDomainVerification", &TraceProtectionDomainVerification, "Trace protection domain verifcation", "", DEFAULT },
 { "bool", "TraceClearedExceptions", &TraceClearedExceptions, "Prints when an exception is forcibly cleared", "", DEFAULT },
 { "bool", "TraceClassResolution", &TraceClassResolution, "Trace all constant pool resolutions (for debugging)", "{product}", DEFAULT },
 { "bool", "TraceBiasedLocking", &TraceBiasedLocking, "Trace biased locking in JVM", "{product}", DEFAULT },
 { "bool", "TraceMonitorInflation", &TraceMonitorInflation, "Trace monitor inflation in JVM", "{product}", DEFAULT },
 { "bool", "UseSerialGC", &UseSerialGC, "Use the serial garbage collector", "{product}", DEFAULT },
 { "bool", "UseG1GC", &UseG1GC, "Use the Garbage-First garbage collector", "{product}", DEFAULT },
 { "bool", "UseParallelGC", &UseParallelGC, "Use the Parallel Scavenge garbage collector", "{product}", DEFAULT },
 { "bool", "UseParallelOldGC", &UseParallelOldGC, "Use the Parallel Old garbage collector", "{product}", DEFAULT },
 { "uintx", "HeapMaximumCompactionInterval", &HeapMaximumCompactionInterval, "How often should we maximally compact the heap (not allowing " "any dead space)", "{product}", DEFAULT },
 { "uintx", "HeapFirstMaximumCompactionCount", &HeapFirstMaximumCompactionCount, "The collection count for the first maximum compaction", "{product}", DEFAULT },
 { "bool", "UseMaximumCompactionOnSystemGC", &UseMaximumCompactionOnSystemGC, "In the Parallel Old garbage collector maximum compaction for " "a system GC", "{product}", DEFAULT },
 { "uintx", "ParallelOldDeadWoodLimiterMean", &ParallelOldDeadWoodLimiterMean, "The mean used by the par compact dead wood" "limiter (a number between 0-100).", "{product}", DEFAULT },
 { "uintx", "ParallelOldDeadWoodLimiterStdDev", &ParallelOldDeadWoodLimiterStdDev, "The standard deviation used by the par compact dead wood" "limiter (a number between 0-100).", "{product}", DEFAULT },
 { "uintx", "ParallelGCThreads", &ParallelGCThreads, "Number of parallel threads parallel gc will use", "{product}", DEFAULT },
 { "bool", "UseDynamicNumberOfGCThreads", &UseDynamicNumberOfGCThreads, "Dynamically choose the number of parallel threads " "parallel gc will use", "{product}", DEFAULT },
 { "bool", "ForceDynamicNumberOfGCThreads", &ForceDynamicNumberOfGCThreads, "Force dynamic selection of the number of" "parallel threads parallel gc will use to aid debugging", "{diagnostic}", DEFAULT },
 { "uintx", "HeapSizePerGCThread", &HeapSizePerGCThread, "Size of heap (bytes) per GC thread used in calculating the " "number of GC threads", "{product}", DEFAULT },
 { "bool", "TraceDynamicGCThreads", &TraceDynamicGCThreads, "Trace the dynamic GC thread usage", "{product}", DEFAULT },
 { "bool", "ParallelOldGCSplitALot", &ParallelOldGCSplitALot, "Provoke splitting (copying data from a young gen space to" "multiple destination spaces)", "", DEFAULT },
 { "uintx", "ParallelOldGCSplitInterval", &ParallelOldGCSplitInterval, "How often to provoke splitting a young gen space", "", DEFAULT },
 { "uintx", "ConcGCThreads", &ConcGCThreads, "Number of threads concurrent gc will use", "{product}", DEFAULT },
 { "uintx", "YoungPLABSize", &YoungPLABSize, "Size of young gen promotion labs (in HeapWords)", "{product}", DEFAULT },
 { "uintx", "OldPLABSize", &OldPLABSize, "Size of old gen promotion labs (in HeapWords)", "{product}", DEFAULT },
 { "uintx", "GCTaskTimeStampEntries", &GCTaskTimeStampEntries, "Number of time stamp entries per gc worker thread", "{product}", DEFAULT },
 { "bool", "AlwaysTenure", &AlwaysTenure, "Always tenure objects in eden. (ParallelGC only)", "{product}", DEFAULT },
 { "bool", "NeverTenure", &NeverTenure, "Never tenure objects in eden, May tenure on overflow " "(ParallelGC only)", "{product}", DEFAULT },
 { "bool", "ScavengeBeforeFullGC", &ScavengeBeforeFullGC, "Scavenge youngest generation before each full GC, " "used with UseParallelGC", "{product}", DEFAULT },
 { "bool", "ScavengeWithObjectsInToSpace", &ScavengeWithObjectsInToSpace, "Allow scavenges to occur when to_space contains objects.", "", DEFAULT },
 { "bool", "UseConcMarkSweepGC", &UseConcMarkSweepGC, "Use Concurrent Mark-Sweep GC in the old generation", "{product}", DEFAULT },
 { "bool", "ExplicitGCInvokesConcurrent", &ExplicitGCInvokesConcurrent, "A System.gc() request invokes a concurrent collection;" " (effective only when UseConcMarkSweepGC)", "{product}", DEFAULT },
 { "bool", "ExplicitGCInvokesConcurrentAndUnloadsClasses", &ExplicitGCInvokesConcurrentAndUnloadsClasses, "A System.gc() request invokes a concurrent collection and " "also unloads classes during such a concurrent gc cycle " "(effective only when UseConcMarkSweepGC)", "{product}", DEFAULT },
 { "bool", "GCLockerInvokesConcurrent", &GCLockerInvokesConcurrent, "The exit of a JNI CS necessitating a scavenge also" " kicks off a bkgrd concurrent collection", "{product}", DEFAULT },
 { "uintx", "GCLockerEdenExpansionPercent", &GCLockerEdenExpansionPercent, "How much the GC can expand the eden by while the GC locker  " "is active (as a percentage)", "{product}", DEFAULT },
 { "bool", "UseCMSAdaptiveFreeLists", &UseCMSAdaptiveFreeLists, "Use Adaptive Free Lists in the CMS generation", "", DEFAULT },
 { "bool", "UseAsyncConcMarkSweepGC", &UseAsyncConcMarkSweepGC, "Use Asynchronous Concurrent Mark-Sweep GC in the old generation", "", DEFAULT },
 { "bool", "RotateCMSCollectionTypes", &RotateCMSCollectionTypes, "Rotate the CMS collections among concurrent and STW", "", DEFAULT },
 { "bool", "UseCMSBestFit", &UseCMSBestFit, "Use CMS best fit allocation strategy", "{product}", DEFAULT },
 { "bool", "UseCMSCollectionPassing", &UseCMSCollectionPassing, "Use passing of collection from background to foreground", "{product}", DEFAULT },
 { "bool", "UseParNewGC", &UseParNewGC, "Use parallel threads in the new generation.", "{product}", DEFAULT },
 { "bool", "ParallelGCVerbose", &ParallelGCVerbose, "Verbose output for parallel GC.", "{product}", DEFAULT },
 { "intx", "ParallelGCBufferWastePct", &ParallelGCBufferWastePct, "wasted fraction of parallel allocation buffer.", "{product}", DEFAULT },
 { "bool", "ParallelGCRetainPLAB", &ParallelGCRetainPLAB, "Retain parallel allocation buffers across scavenges; " " -- disabled because this currently conflicts with " " parallel card scanning under certain conditions ", "{diagnostic}", DEFAULT },
 { "intx", "TargetPLABWastePct", &TargetPLABWastePct, "target wasted space in last buffer as pct of overall allocation", "{product}", DEFAULT },
 { "uintx", "PLABWeight", &PLABWeight, "Percentage (0-100) used to weight the current sample when" "computing exponentially decaying average for ResizePLAB.", "{product}", DEFAULT },
 { "bool", "ResizePLAB", &ResizePLAB, "Dynamically resize (survivor space) promotion labs", "{product}", DEFAULT },
 { "bool", "PrintPLAB", &PrintPLAB, "Print (survivor space) promotion labs sizing decisions", "{product}", DEFAULT },
 { "intx", "ParGCArrayScanChunk", &ParGCArrayScanChunk, "Scan a subset and push remainder, if array is bigger than this", "{product}", DEFAULT },
 { "bool", "ParGCUseLocalOverflow", &ParGCUseLocalOverflow, "Instead of a global overflow list, use local overflow stacks", "{product}", DEFAULT },
 { "bool", "ParGCTrimOverflow", &ParGCTrimOverflow, "Eagerly trim the local overflow lists (when ParGCUseLocalOverflow", "{product}", DEFAULT },
 { "bool", "ParGCWorkQueueOverflowALot", &ParGCWorkQueueOverflowALot, "Whether we should simulate work queue overflow in ParNew", "{notproduct}", DEFAULT },
 { "uintx", "ParGCWorkQueueOverflowInterval", &ParGCWorkQueueOverflowInterval, "An `interval' counter that determines how frequently " "we simulate overflow; a smaller number increases frequency", "{notproduct}", DEFAULT },
 { "uintx", "ParGCDesiredObjsFromOverflowList", &ParGCDesiredObjsFromOverflowList, "The desired number of objects to claim from the overflow list", "{product}", DEFAULT },
 { "uintx", "ParGCStridesPerThread", &ParGCStridesPerThread, "The number of strides per worker thread that we divide up the " "card table scanning work into", "{diagnostic}", DEFAULT },
 { "intx", "ParGCCardsPerStrideChunk", &ParGCCardsPerStrideChunk, "The number of cards in each chunk of the parallel chunks used " "during card table scanning", "{diagnostic}", DEFAULT },
 { "uintx", "CMSParPromoteBlocksToClaim", &CMSParPromoteBlocksToClaim, "Number of blocks to attempt to claim when refilling CMS LAB for " "parallel GC.", "{product}", DEFAULT },
 { "uintx", "OldPLABWeight", &OldPLABWeight, "Percentage (0-100) used to weight the current sample when" "computing exponentially decaying average for resizing CMSParPromoteBlocksToClaim.", "{product}", DEFAULT },
 { "bool", "ResizeOldPLAB", &ResizeOldPLAB, "Dynamically resize (old gen) promotion labs", "{product}", DEFAULT },
 { "bool", "PrintOldPLAB", &PrintOldPLAB, "Print (old gen) promotion labs sizing decisions", "{product}", DEFAULT },
 { "uintx", "CMSOldPLABMin", &CMSOldPLABMin, "Min size of CMS gen promotion lab caches per worker per blksize", "{product}", DEFAULT },
 { "uintx", "CMSOldPLABMax", &CMSOldPLABMax, "Max size of CMS gen promotion lab caches per worker per blksize", "{product}", DEFAULT },
 { "uintx", "CMSOldPLABNumRefills", &CMSOldPLABNumRefills, "Nominal number of refills of CMS gen promotion lab cache" " per worker per block size", "{product}", DEFAULT },
 { "bool", "CMSOldPLABResizeQuicker", &CMSOldPLABResizeQuicker, "Whether to react on-the-fly during a scavenge to a sudden" " change in block demand rate", "{product}", DEFAULT },
 { "uintx", "CMSOldPLABToleranceFactor", &CMSOldPLABToleranceFactor, "The tolerance of the phase-change detector for on-the-fly" " PLAB resizing during a scavenge", "{product}", DEFAULT },
 { "uintx", "CMSOldPLABReactivityFactor", &CMSOldPLABReactivityFactor, "The gain in the feedback loop for on-the-fly PLAB resizing" " during a scavenge", "{product}", DEFAULT },
 { "bool", "AlwaysPreTouch", &AlwaysPreTouch, "It forces all freshly committed pages to be pre-touched.", "{product}", DEFAULT },
 { "intx", "CMSYoungGenPerWorker", &CMSYoungGenPerWorker, "The maximum size of young gen chosen by default per GC worker " "thread available", "{pd product}", DEFAULT },
 { "bool", "CMSIncrementalMode", &CMSIncrementalMode, "Whether CMS GC should operate in \"incremental\" mode", "{product}", DEFAULT },
 { "uintx", "CMSIncrementalDutyCycle", &CMSIncrementalDutyCycle, "CMS incremental mode duty cycle (a percentage, 0-100).  If" "CMSIncrementalPacing is enabled, then this is just the initial" "value", "{product}", DEFAULT },
 { "bool", "CMSIncrementalPacing", &CMSIncrementalPacing, "Whether the CMS incremental mode duty cycle should be " "automatically adjusted", "{product}", DEFAULT },
 { "uintx", "CMSIncrementalDutyCycleMin", &CMSIncrementalDutyCycleMin, "Lower bound on the duty cycle when CMSIncrementalPacing is " "enabled (a percentage, 0-100)", "{product}", DEFAULT },
 { "uintx", "CMSIncrementalSafetyFactor", &CMSIncrementalSafetyFactor, "Percentage (0-100) used to add conservatism when computing the " "duty cycle", "{product}", DEFAULT },
 { "uintx", "CMSIncrementalOffset", &CMSIncrementalOffset, "Percentage (0-100) by which the CMS incremental mode duty cycle" " is shifted to the right within the period between young GCs", "{product}", DEFAULT },
 { "uintx", "CMSExpAvgFactor", &CMSExpAvgFactor, "Percentage (0-100) used to weight the current sample when" "computing exponential averages for CMS statistics.", "{product}", DEFAULT },
 { "uintx", "CMS_FLSWeight", &CMS_FLSWeight, "Percentage (0-100) used to weight the current sample when" "computing exponentially decating averages for CMS FLS statistics.", "{product}", DEFAULT },
 { "uintx", "CMS_FLSPadding", &CMS_FLSPadding, "The multiple of deviation from mean to use for buffering" "against volatility in free list demand.", "{product}", DEFAULT },
 { "uintx", "FLSCoalescePolicy", &FLSCoalescePolicy, "CMS: Aggression level for coalescing, increasing from 0 to 4", "{product}", DEFAULT },
 { "bool", "FLSAlwaysCoalesceLarge", &FLSAlwaysCoalesceLarge, "CMS: Larger free blocks are always available for coalescing", "{product}", DEFAULT },
 { "double", "FLSLargestBlockCoalesceProximity", &FLSLargestBlockCoalesceProximity, "CMS: the smaller the percentage the greater the coalition force", "{product}", DEFAULT },
 { "double", "CMSSmallCoalSurplusPercent", &CMSSmallCoalSurplusPercent, "CMS: the factor by which to inflate estimated demand of small" " block sizes to prevent coalescing with an adjoining block", "{product}", DEFAULT },
 { "double", "CMSLargeCoalSurplusPercent", &CMSLargeCoalSurplusPercent, "CMS: the factor by which to inflate estimated demand of large" " block sizes to prevent coalescing with an adjoining block", "{product}", DEFAULT },
 { "double", "CMSSmallSplitSurplusPercent", &CMSSmallSplitSurplusPercent, "CMS: the factor by which to inflate estimated demand of small" " block sizes to prevent splitting to supply demand for smaller" " blocks", "{product}", DEFAULT },
 { "double", "CMSLargeSplitSurplusPercent", &CMSLargeSplitSurplusPercent, "CMS: the factor by which to inflate estimated demand of large" " block sizes to prevent splitting to supply demand for smaller" " blocks", "{product}", DEFAULT },
 { "bool", "CMSExtrapolateSweep", &CMSExtrapolateSweep, "CMS: cushion for block demand during sweep", "{product}", DEFAULT },
 { "uintx", "CMS_SweepWeight", &CMS_SweepWeight, "Percentage (0-100) used to weight the current sample when " "computing exponentially decaying average for inter-sweep " "duration", "{product}", DEFAULT },
 { "uintx", "CMS_SweepPadding", &CMS_SweepPadding, "The multiple of deviation from mean to use for buffering " "against volatility in inter-sweep duration.", "{product}", DEFAULT },
 { "uintx", "CMS_SweepTimerThresholdMillis", &CMS_SweepTimerThresholdMillis, "Skip block flux-rate sampling for an epoch unless inter-sweep " "duration exceeds this threhold in milliseconds", "{product}", DEFAULT },
 { "bool", "CMSTraceIncrementalMode", &CMSTraceIncrementalMode, "Trace CMS incremental mode", "", DEFAULT },
 { "bool", "CMSTraceIncrementalPacing", &CMSTraceIncrementalPacing, "Trace CMS incremental mode pacing computation", "", DEFAULT },
 { "bool", "CMSTraceThreadState", &CMSTraceThreadState, "Trace the CMS thread state (enable the trace_state() method)", "", DEFAULT },
 { "bool", "CMSClassUnloadingEnabled", &CMSClassUnloadingEnabled, "Whether class unloading enabled when using CMS GC", "{product}", DEFAULT },
 { "uintx", "CMSClassUnloadingMaxInterval", &CMSClassUnloadingMaxInterval, "When CMS class unloading is enabled, the maximum CMS cycle count" " for which classes may not be unloaded", "{product}", DEFAULT },
 { "bool", "CMSCompactWhenClearAllSoftRefs", &CMSCompactWhenClearAllSoftRefs, "Compact when asked to collect CMS gen with clear_all_soft_refs", "{product}", DEFAULT },
 { "bool", "UseCMSCompactAtFullCollection", &UseCMSCompactAtFullCollection, "Use mark sweep compact at full collections", "{product}", DEFAULT },
 { "uintx", "CMSFullGCsBeforeCompaction", &CMSFullGCsBeforeCompaction, "Number of CMS full collection done before compaction if > 0", "{product}", DEFAULT },
 { "intx", "CMSDictionaryChoice", &CMSDictionaryChoice, "Use BinaryTreeDictionary as default in the CMS generation", "", DEFAULT },
 { "uintx", "CMSIndexedFreeListReplenish", &CMSIndexedFreeListReplenish, "Replenish an indexed free list with this number of chunks", "{product}", DEFAULT },
 { "bool", "CMSReplenishIntermediate", &CMSReplenishIntermediate, "Replenish all intermediate free-list caches", "{product}", DEFAULT },
 { "bool", "CMSSplitIndexedFreeListBlocks", &CMSSplitIndexedFreeListBlocks, "When satisfying batched demand, split blocks from the " "IndexedFreeList whose size is a multiple of requested size", "{product}", DEFAULT },
 { "bool", "CMSLoopWarn", &CMSLoopWarn, "Warn in case of excessive CMS looping", "{product}", DEFAULT },
 { "bool", "CMSOverflowEarlyRestoration", &CMSOverflowEarlyRestoration, "Whether preserved marks should be restored early", "", DEFAULT },
 { "uintx", "MarkStackSize", &MarkStackSize, "Size of marking stack", "{product}", DEFAULT },
 { "uintx", "MarkStackSizeMax", &MarkStackSizeMax, "Max size of marking stack", "{product}", DEFAULT },
 { "bool", "CMSMarkStackOverflowALot", &CMSMarkStackOverflowALot, "Whether we should simulate frequent marking stack / work queue" " overflow", "{notproduct}", DEFAULT },
 { "uintx", "CMSMarkStackOverflowInterval", &CMSMarkStackOverflowInterval, "An `interval' counter that determines how frequently" " we simulate overflow; a smaller number increases frequency", "{notproduct}", DEFAULT },
 { "uintx", "CMSMaxAbortablePrecleanLoops", &CMSMaxAbortablePrecleanLoops, "(Temporary, subject to experimentation)" "Maximum number of abortable preclean iterations, if > 0", "{product}", DEFAULT },
 { "intx", "CMSMaxAbortablePrecleanTime", &CMSMaxAbortablePrecleanTime, "(Temporary, subject to experimentation)" "Maximum time in abortable preclean in ms", "{product}", DEFAULT },
 { "uintx", "CMSAbortablePrecleanMinWorkPerIteration", &CMSAbortablePrecleanMinWorkPerIteration, "(Temporary, subject to experimentation)" "Nominal minimum work per abortable preclean iteration", "{product}", DEFAULT },
 { "intx", "CMSAbortablePrecleanWaitMillis", &CMSAbortablePrecleanWaitMillis, "(Temporary, subject to experimentation)" " Time that we sleep between iterations when not given" " enough work per iteration", "{manageable}", DEFAULT },
 { "uintx", "CMSRescanMultiple", &CMSRescanMultiple, "Size (in cards) of CMS parallel rescan task", "{product}", DEFAULT },
 { "uintx", "CMSConcMarkMultiple", &CMSConcMarkMultiple, "Size (in cards) of CMS concurrent MT marking task", "{product}", DEFAULT },
 { "uintx", "CMSRevisitStackSize", &CMSRevisitStackSize, "Size of CMS KlassKlass revisit stack", "{product}", DEFAULT },
 { "bool", "CMSAbortSemantics", &CMSAbortSemantics, "Whether abort-on-overflow semantics is implemented", "{product}", DEFAULT },
 { "bool", "CMSParallelRemarkEnabled", &CMSParallelRemarkEnabled, "Whether parallel remark enabled (only if ParNewGC)", "{product}", DEFAULT },
 { "bool", "CMSParallelSurvivorRemarkEnabled", &CMSParallelSurvivorRemarkEnabled, "Whether parallel remark of survivor space" " enabled (effective only if CMSParallelRemarkEnabled)", "{product}", DEFAULT },
 { "bool", "CMSPLABRecordAlways", &CMSPLABRecordAlways, "Whether to always record survivor space PLAB bdries" " (effective only if CMSParallelSurvivorRemarkEnabled)", "{product}", DEFAULT },
 { "bool", "CMSConcurrentMTEnabled", &CMSConcurrentMTEnabled, "Whether multi-threaded concurrent work enabled (if ParNewGC)", "{product}", DEFAULT },
 { "bool", "CMSPermGenPrecleaningEnabled", &CMSPermGenPrecleaningEnabled, "Whether concurrent precleaning enabled in perm gen" " (effective only when CMSPrecleaningEnabled is true)", "{product}", DEFAULT },
 { "bool", "CMSPrecleaningEnabled", &CMSPrecleaningEnabled, "Whether concurrent precleaning enabled", "{product}", DEFAULT },
 { "uintx", "CMSPrecleanIter", &CMSPrecleanIter, "Maximum number of precleaning iteration passes", "{product}", DEFAULT },
 { "uintx", "CMSPrecleanNumerator", &CMSPrecleanNumerator, "CMSPrecleanNumerator:CMSPrecleanDenominator yields convergence" " ratio", "{product}", DEFAULT },
 { "uintx", "CMSPrecleanDenominator", &CMSPrecleanDenominator, "CMSPrecleanNumerator:CMSPrecleanDenominator yields convergence" " ratio", "{product}", DEFAULT },
 { "bool", "CMSPrecleanRefLists1", &CMSPrecleanRefLists1, "Preclean ref lists during (initial) preclean phase", "{product}", DEFAULT },
 { "bool", "CMSPrecleanRefLists2", &CMSPrecleanRefLists2, "Preclean ref lists during abortable preclean phase", "{product}", DEFAULT },
 { "bool", "CMSPrecleanSurvivors1", &CMSPrecleanSurvivors1, "Preclean survivors during (initial) preclean phase", "{product}", DEFAULT },
 { "bool", "CMSPrecleanSurvivors2", &CMSPrecleanSurvivors2, "Preclean survivors during abortable preclean phase", "{product}", DEFAULT },
 { "uintx", "CMSPrecleanThreshold", &CMSPrecleanThreshold, "Don't re-iterate if #dirty cards less than this", "{product}", DEFAULT },
 { "bool", "CMSCleanOnEnter", &CMSCleanOnEnter, "Clean-on-enter optimization for reducing number of dirty cards", "{product}", DEFAULT },
 { "uintx", "CMSRemarkVerifyVariant", &CMSRemarkVerifyVariant, "Choose variant (1,2) of verification following remark", "{product}", DEFAULT },
 { "uintx", "CMSScheduleRemarkEdenSizeThreshold", &CMSScheduleRemarkEdenSizeThreshold, "If Eden used is below this value, don't try to schedule remark", "{product}", DEFAULT },
 { "uintx", "CMSScheduleRemarkEdenPenetration", &CMSScheduleRemarkEdenPenetration, "The Eden occupancy % at which to try and schedule remark pause", "{product}", DEFAULT },
 { "uintx", "CMSScheduleRemarkSamplingRatio", &CMSScheduleRemarkSamplingRatio, "Start sampling Eden top at least before yg occupancy reaches" " 1/<ratio> of the size at which we plan to schedule remark", "{product}", DEFAULT },
 { "uintx", "CMSSamplingGrain", &CMSSamplingGrain, "The minimum distance between eden samples for CMS (see above)", "{product}", DEFAULT },
 { "bool", "CMSScavengeBeforeRemark", &CMSScavengeBeforeRemark, "Attempt scavenge before the CMS remark step", "{product}", DEFAULT },
 { "bool", "CMSTraceSweeper", &CMSTraceSweeper, "Trace some actions of the CMS sweeper", "", DEFAULT },
 { "uintx", "CMSWorkQueueDrainThreshold", &CMSWorkQueueDrainThreshold, "Don't drain below this size per parallel worker/thief", "{product}", DEFAULT },
 { "intx", "CMSWaitDuration", &CMSWaitDuration, "Time in milliseconds that CMS thread waits for young GC", "{manageable}", DEFAULT },
 { "bool", "CMSYield", &CMSYield, "Yield between steps of concurrent mark & sweep", "{product}", DEFAULT },
 { "uintx", "CMSBitMapYieldQuantum", &CMSBitMapYieldQuantum, "Bitmap operations should process at most this many bits" "between yields", "{product}", DEFAULT },
 { "bool", "CMSDumpAtPromotionFailure", &CMSDumpAtPromotionFailure, "Dump useful information about the state of the CMS old " " generation upon a promotion failure.", "{product}", DEFAULT },
 { "bool", "CMSPrintChunksInDump", &CMSPrintChunksInDump, "In a dump enabled by CMSDumpAtPromotionFailure, include " " more detailed information about the free chunks.", "{product}", DEFAULT },
 { "bool", "CMSPrintObjectsInDump", &CMSPrintObjectsInDump, "In a dump enabled by CMSDumpAtPromotionFailure, include " " more detailed information about the allocated objects.", "{product}", DEFAULT },
 { "bool", "FLSVerifyAllHeapReferences", &FLSVerifyAllHeapReferences, "Verify that all refs across the FLS boundary " " are to valid objects", "{diagnostic}", DEFAULT },
 { "bool", "FLSVerifyLists", &FLSVerifyLists, "Do lots of (expensive) FreeListSpace verification", "{diagnostic}", DEFAULT },
 { "bool", "FLSVerifyIndexTable", &FLSVerifyIndexTable, "Do lots of (expensive) FLS index table verification", "{diagnostic}", DEFAULT },
 { "bool", "FLSVerifyDictionary", &FLSVerifyDictionary, "Do lots of (expensive) FLS dictionary verification", "", DEFAULT },
 { "bool", "VerifyBlockOffsetArray", &VerifyBlockOffsetArray, "Do (expensive!) block offset array verification", "", DEFAULT },
 { "bool", "BlockOffsetArrayUseUnallocatedBlock", &BlockOffsetArrayUseUnallocatedBlock, "Maintain _unallocated_block in BlockOffsetArray" " (currently applicable only to CMS collector)", "{diagnostic}", DEFAULT },
 { "bool", "TraceCMSState", &TraceCMSState, "Trace the state of the CMS collection", "", DEFAULT },
 { "intx", "RefDiscoveryPolicy", &RefDiscoveryPolicy, "Whether reference-based(0) or referent-based(1)", "{product}", DEFAULT },
 { "bool", "ParallelRefProcEnabled", &ParallelRefProcEnabled, "Enable parallel reference processing whenever possible", "{product}", DEFAULT },
 { "bool", "ParallelRefProcBalancingEnabled", &ParallelRefProcBalancingEnabled, "Enable balancing of reference processing queues", "{product}", DEFAULT },
 { "intx", "CMSTriggerRatio", &CMSTriggerRatio, "Percentage of MinHeapFreeRatio in CMS generation that is " "allocated before a CMS collection cycle commences", "{product}", DEFAULT },
 { "intx", "CMSTriggerPermRatio", &CMSTriggerPermRatio, "Percentage of MinHeapFreeRatio in the CMS perm generation that " "is allocated before a CMS collection cycle commences, that " "also collects the perm generation", "{product}", DEFAULT },
 { "uintx", "CMSBootstrapOccupancy", &CMSBootstrapOccupancy, "Percentage CMS generation occupancy at which to " "initiate CMS collection for bootstrapping collection stats", "{product}", DEFAULT },
 { "intx", "CMSInitiatingOccupancyFraction", &CMSInitiatingOccupancyFraction, "Percentage CMS generation occupancy to start a CMS collection " "cycle. A negative value means that CMSTriggerRatio is used", "{product}", DEFAULT },
 { "uintx", "InitiatingHeapOccupancyPercent", &InitiatingHeapOccupancyPercent, "Percentage of the (entire) heap occupancy to start a " "concurrent GC cycle. It us used by GCs that trigger a " "concurrent GC cycle based on the occupancy of the entire heap, " "not just one of the generations (e.g., G1). A value of 0 " "denotes 'do constant GC cycles'.", "{product}", DEFAULT },
 { "intx", "CMSInitiatingPermOccupancyFraction", &CMSInitiatingPermOccupancyFraction, "Percentage CMS perm generation occupancy to start a " "CMScollection cycle. A negative value means that " "CMSTriggerPermRatio is used", "{product}", DEFAULT },
 { "bool", "UseCMSInitiatingOccupancyOnly", &UseCMSInitiatingOccupancyOnly, "Only use occupancy as a crierion for starting a CMS collection", "{product}", DEFAULT },
 { "intx", "CMSIsTooFullPercentage", &CMSIsTooFullPercentage, "An absolute ceiling above which CMS will always consider the " "perm gen ripe for collection", "{product}", DEFAULT },
 { "bool", "CMSTestInFreeList", &CMSTestInFreeList, "Check if the coalesced range is already in the " "free lists as claimed", "", DEFAULT },
 { "bool", "CMSVerifyReturnedBytes", &CMSVerifyReturnedBytes, "Check that all the garbage collected was returned to the " "free lists.", "{notproduct}", DEFAULT },
 { "bool", "ScavengeALot", &ScavengeALot, "Force scavenge at every Nth exit from the runtime system " "(N=ScavengeALotInterval)", "{notproduct}", DEFAULT },
 { "bool", "FullGCALot", &FullGCALot, "Force full gc at every Nth exit from the runtime system " "(N=FullGCALotInterval)", "", DEFAULT },
 { "bool", "GCALotAtAllSafepoints", &GCALotAtAllSafepoints, "Enforce ScavengeALot/GCALot at all potential safepoints", "{notproduct}", DEFAULT },
 { "bool", "PrintPromotionFailure", &PrintPromotionFailure, "Print additional diagnostic information following " " promotion failure", "{product}", DEFAULT },
 { "bool", "PromotionFailureALot", &PromotionFailureALot, "Use promotion failure handling on every youngest generation " "collection", "{notproduct}", DEFAULT },
 { "uintx", "PromotionFailureALotCount", &PromotionFailureALotCount, "Number of promotion failures occurring at ParGCAllocBuffer" "refill attempts (ParNew) or promotion attempts " "(other young collectors) ", "", DEFAULT },
 { "uintx", "PromotionFailureALotInterval", &PromotionFailureALotInterval, "Total collections between promotion failures alot", "", DEFAULT },
 { "intx", "WorkStealingSleepMillis", &WorkStealingSleepMillis, "Sleep time when sleep is used for yields", "{experimental}", DEFAULT },
 { "uintx", "WorkStealingYieldsBeforeSleep", &WorkStealingYieldsBeforeSleep, "Number of yields before a sleep is done during workstealing", "{experimental}", DEFAULT },
 { "uintx", "WorkStealingHardSpins", &WorkStealingHardSpins, "Number of iterations in a spin loop between checks on " "time out of hard spin", "{experimental}", DEFAULT },
 { "uintx", "WorkStealingSpinToYieldRatio", &WorkStealingSpinToYieldRatio, "Ratio of hard spins to calls to yield", "{experimental}", DEFAULT },
 { "uintx", "ObjArrayMarkingStride", &ObjArrayMarkingStride, "Number of ObjArray elements to push onto the marking stack" "before pushing a continuation entry", "", DEFAULT },
 { "bool", "ExecuteInternalVMTests", &ExecuteInternalVMTests, "Enable execution of internal VM tests.", "{notproduct}", DEFAULT },
 { "bool", "UseTLAB", &UseTLAB, "Use thread-local object allocation", "{pd product}", DEFAULT },
 { "bool", "ResizeTLAB", &ResizeTLAB, "Dynamically resize tlab size for threads", "{pd product}", DEFAULT },
 { "bool", "ZeroTLAB", &ZeroTLAB, "Zero out the newly created TLAB", "{product}", DEFAULT },
 { "bool", "FastTLABRefill", &FastTLABRefill, "Use fast TLAB refill code", "{product}", DEFAULT },
 { "bool", "PrintTLAB", &PrintTLAB, "Print various TLAB related information", "{product}", DEFAULT },
 { "bool", "TLABStats", &TLABStats, "Print various TLAB related information", "{product}", DEFAULT },
 { "bool", "PrintRevisitStats", &PrintRevisitStats, "Print revisit (klass and MDO) stack related information", "{product}", DEFAULT },
  { "bool", "NeverActAsServerClassMachine", &NeverActAsServerClassMachine, "Never act like a server-class machine", "{pd product}", DEFAULT },
 { "bool", "AlwaysActAsServerClassMachine", &AlwaysActAsServerClassMachine, "Always act like a server-class machine", "{product}", DEFAULT },
 { "uint64_t", "MaxRAM", &MaxRAM, "Real memory size (in bytes) used to set maximum heap size", "{pd product}", DEFAULT },
 { "uintx", "ErgoHeapSizeLimit", &ErgoHeapSizeLimit, "Maximum ergonomically set heap size (in bytes); zero means use " "MaxRAM / MaxRAMFraction", "{product}", DEFAULT },
 { "uintx", "MaxRAMFraction", &MaxRAMFraction, "Maximum fraction (1/n) of real memory used for maximum heap " "size", "{product}", DEFAULT },
 { "uintx", "DefaultMaxRAMFraction", &DefaultMaxRAMFraction, "Maximum fraction (1/n) of real memory used for maximum heap " "size; deprecated: to be renamed to MaxRAMFraction", "{product}", DEFAULT },
 { "uintx", "MinRAMFraction", &MinRAMFraction, "Minimum fraction (1/n) of real memory used for maxmimum heap " "size on systems with small physical memory size", "{product}", DEFAULT },
 { "uintx", "InitialRAMFraction", &InitialRAMFraction, "Fraction (1/n) of real memory used for initial heap size", "{product}", DEFAULT },
 { "bool", "UseAutoGCSelectPolicy", &UseAutoGCSelectPolicy, "Use automatic collection selection policy", "{product}", DEFAULT },
 { "uintx", "AutoGCSelectPauseMillis", &AutoGCSelectPauseMillis, "Automatic GC selection pause threshhold in ms", "{product}", DEFAULT },
 { "bool", "UseAdaptiveSizePolicy", &UseAdaptiveSizePolicy, "Use adaptive generation sizing policies", "{product}", DEFAULT },
 { "bool", "UsePSAdaptiveSurvivorSizePolicy", &UsePSAdaptiveSurvivorSizePolicy, "Use adaptive survivor sizing policies", "{product}", DEFAULT },
 { "bool", "UseAdaptiveGenerationSizePolicyAtMinorCollection", &UseAdaptiveGenerationSizePolicyAtMinorCollection, "Use adaptive young-old sizing policies at minor collections", "{product}", DEFAULT },
 { "bool", "UseAdaptiveGenerationSizePolicyAtMajorCollection", &UseAdaptiveGenerationSizePolicyAtMajorCollection, "Use adaptive young-old sizing policies at major collections", "{product}", DEFAULT },
 { "bool", "UseAdaptiveSizePolicyWithSystemGC", &UseAdaptiveSizePolicyWithSystemGC, "Use statistics from System.GC for adaptive size policy", "{product}", DEFAULT },
 { "bool", "UseAdaptiveGCBoundary", &UseAdaptiveGCBoundary, "Allow young-old boundary to move", "{product}", DEFAULT },
 { "bool", "TraceAdaptiveGCBoundary", &TraceAdaptiveGCBoundary, "Trace young-old boundary moves", "", DEFAULT },
 { "intx", "PSAdaptiveSizePolicyResizeVirtualSpaceAlot", &PSAdaptiveSizePolicyResizeVirtualSpaceAlot, "Resize the virtual spaces of the young or old generations", "", DEFAULT },
 { "uintx", "AdaptiveSizeThroughPutPolicy", &AdaptiveSizeThroughPutPolicy, "Policy for changeing generation size for throughput goals", "{product}", DEFAULT },
 { "uintx", "AdaptiveSizePausePolicy", &AdaptiveSizePausePolicy, "Policy for changing generation size for pause goals", "{product}", DEFAULT },
 { "bool", "PSAdjustTenuredGenForMinorPause", &PSAdjustTenuredGenForMinorPause, "Adjust tenured generation to achive a minor pause goal", "", DEFAULT },
 { "bool", "PSAdjustYoungGenForMajorPause", &PSAdjustYoungGenForMajorPause, "Adjust young generation to achive a major pause goal", "", DEFAULT },
 { "uintx", "AdaptiveSizePolicyInitializingSteps", &AdaptiveSizePolicyInitializingSteps, "Number of steps where heuristics is used before data is used", "{product}", DEFAULT },
 { "uintx", "AdaptiveSizePolicyReadyThreshold", &AdaptiveSizePolicyReadyThreshold, "Number of collections before the adaptive sizing is started", "", DEFAULT },
 { "uintx", "AdaptiveSizePolicyOutputInterval", &AdaptiveSizePolicyOutputInterval, "Collecton interval for printing information; zero => never", "{product}", DEFAULT },
 { "bool", "UseAdaptiveSizePolicyFootprintGoal", &UseAdaptiveSizePolicyFootprintGoal, "Use adaptive minimum footprint as a goal", "{product}", DEFAULT },
 { "uintx", "AdaptiveSizePolicyWeight", &AdaptiveSizePolicyWeight, "Weight given to exponential resizing, between 0 and 100", "{product}", DEFAULT },
 { "uintx", "AdaptiveTimeWeight", &AdaptiveTimeWeight, "Weight given to time in adaptive policy, between 0 and 100", "{product}", DEFAULT },
 { "uintx", "PausePadding", &PausePadding, "How much buffer to keep for pause time", "{product}", DEFAULT },
 { "uintx", "PromotedPadding", &PromotedPadding, "How much buffer to keep for promotion failure", "{product}", DEFAULT },
 { "uintx", "SurvivorPadding", &SurvivorPadding, "How much buffer to keep for survivor overflow", "{product}", DEFAULT },
 { "uintx", "AdaptivePermSizeWeight", &AdaptivePermSizeWeight, "Weight for perm gen exponential resizing, between 0 and 100", "{product}", DEFAULT },
 { "uintx", "PermGenPadding", &PermGenPadding, "How much buffer to keep for perm gen sizing", "{product}", DEFAULT },
 { "uintx", "ThresholdTolerance", &ThresholdTolerance, "Allowed collection cost difference between generations", "{product}", DEFAULT },
 { "uintx", "AdaptiveSizePolicyCollectionCostMargin", &AdaptiveSizePolicyCollectionCostMargin, "If collection costs are within margin, reduce both by full " "delta", "{product}", DEFAULT },
 { "uintx", "YoungGenerationSizeIncrement", &YoungGenerationSizeIncrement, "Adaptive size percentage change in young generation", "{product}", DEFAULT },
 { "uintx", "YoungGenerationSizeSupplement", &YoungGenerationSizeSupplement, "Supplement to YoungedGenerationSizeIncrement used at startup", "{product}", DEFAULT },
 { "uintx", "YoungGenerationSizeSupplementDecay", &YoungGenerationSizeSupplementDecay, "Decay factor to YoungedGenerationSizeSupplement", "{product}", DEFAULT },
 { "uintx", "TenuredGenerationSizeIncrement", &TenuredGenerationSizeIncrement, "Adaptive size percentage change in tenured generation", "{product}", DEFAULT },
 { "uintx", "TenuredGenerationSizeSupplement", &TenuredGenerationSizeSupplement, "Supplement to TenuredGenerationSizeIncrement used at startup", "{product}", DEFAULT },
 { "uintx", "TenuredGenerationSizeSupplementDecay", &TenuredGenerationSizeSupplementDecay, "Decay factor to TenuredGenerationSizeIncrement", "{product}", DEFAULT },
 { "uintx", "MaxGCPauseMillis", &MaxGCPauseMillis, "Adaptive size policy maximum GC pause time goal in msec, " "or (G1 Only) the max. GC time per MMU time slice", "{product}", DEFAULT },
 { "uintx", "GCPauseIntervalMillis", &GCPauseIntervalMillis, "Time slice for MMU specification", "{product}", DEFAULT },
 { "uintx", "MaxGCMinorPauseMillis", &MaxGCMinorPauseMillis, "Adaptive size policy maximum GC minor pause time goal in msec", "{product}", DEFAULT },
 { "uintx", "GCTimeRatio", &GCTimeRatio, "Adaptive size policy application time to GC time ratio", "{product}", DEFAULT },
 { "uintx", "AdaptiveSizeDecrementScaleFactor", &AdaptiveSizeDecrementScaleFactor, "Adaptive size scale down factor for shrinking", "{product}", DEFAULT },
 { "bool", "UseAdaptiveSizeDecayMajorGCCost", &UseAdaptiveSizeDecayMajorGCCost, "Adaptive size decays the major cost for long major intervals", "{product}", DEFAULT },
 { "uintx", "AdaptiveSizeMajorGCDecayTimeScale", &AdaptiveSizeMajorGCDecayTimeScale, "Time scale over which major costs decay", "{product}", DEFAULT },
 { "uintx", "MinSurvivorRatio", &MinSurvivorRatio, "Minimum ratio of young generation/survivor space size", "{product}", DEFAULT },
 { "uintx", "InitialSurvivorRatio", &InitialSurvivorRatio, "Initial ratio of eden/survivor space size", "{product}", DEFAULT },
 { "uintx", "BaseFootPrintEstimate", &BaseFootPrintEstimate, "Estimate of footprint other than Java Heap", "{product}", DEFAULT },
 { "bool", "UseGCOverheadLimit", &UseGCOverheadLimit, "Use policy to limit of proportion of time spent in GC " "before an OutOfMemory error is thrown", "{product}", DEFAULT },
 { "uintx", "GCTimeLimit", &GCTimeLimit, "Limit of proportion of time spent in GC before an OutOfMemory" "error is thrown (used with GCHeapFreeLimit)", "{product}", DEFAULT },
 { "uintx", "GCHeapFreeLimit", &GCHeapFreeLimit, "Minimum percentage of free space after a full GC before an " "OutOfMemoryError is thrown (used with GCTimeLimit)", "{product}", DEFAULT },
 { "uintx", "AdaptiveSizePolicyGCTimeLimitThreshold", &AdaptiveSizePolicyGCTimeLimitThreshold, "Number of consecutive collections before gc time limit fires", "", DEFAULT },
 { "bool", "PrintAdaptiveSizePolicy", &PrintAdaptiveSizePolicy, "Print information about AdaptiveSizePolicy", "{product}", DEFAULT },
 { "intx", "PrefetchCopyIntervalInBytes", &PrefetchCopyIntervalInBytes, "How far ahead to prefetch destination area (<= 0 means off)", "{product}", DEFAULT },
 { "intx", "PrefetchScanIntervalInBytes", &PrefetchScanIntervalInBytes, "How far ahead to prefetch scan area (<= 0 means off)", "{product}", DEFAULT },
 { "intx", "PrefetchFieldsAhead", &PrefetchFieldsAhead, "How many fields ahead to prefetch in oop scan (<= 0 means off)", "{product}", DEFAULT },
 { "bool", "VerifyBeforeExit", &VerifyBeforeExit, "Verify system before exiting", "{diagnostic}", DEFAULT },
 { "bool", "VerifyBeforeGC", &VerifyBeforeGC, "Verify memory system before GC", "{diagnostic}", DEFAULT },
 { "bool", "VerifyAfterGC", &VerifyAfterGC, "Verify memory system after GC", "{diagnostic}", DEFAULT },
 { "bool", "VerifyDuringGC", &VerifyDuringGC, "Verify memory system during GC (between phases)", "{diagnostic}", DEFAULT },
 { "bool", "GCParallelVerificationEnabled", &GCParallelVerificationEnabled, "Enable parallel memory system verification", "{diagnostic}", DEFAULT },
 { "bool", "DeferInitialCardMark", &DeferInitialCardMark, "When +ReduceInitialCardMarks, explicitly defer any that " "may arise from new_pre_store_barrier", "{diagnostic}", DEFAULT },
 { "bool", "VerifyRememberedSets", &VerifyRememberedSets, "Verify GC remembered sets", "{diagnostic}", DEFAULT },
 { "bool", "VerifyObjectStartArray", &VerifyObjectStartArray, "Verify GC object start array if verify before/after", "{diagnostic}", DEFAULT },
 { "bool", "DisableExplicitGC", &DisableExplicitGC, "Tells whether calling System.gc() does a full GC", "{product}", DEFAULT },
 { "bool", "CheckMemoryInitialization", &CheckMemoryInitialization, "Checks memory initialization", "{notproduct}", DEFAULT },
 { "bool", "CollectGen0First", &CollectGen0First, "Collect youngest generation before each full GC", "{product}", DEFAULT },
 { "bool", "BindCMSThreadToCPU", &BindCMSThreadToCPU, "Bind CMS Thread to CPU if possible", "{diagnostic}", DEFAULT },
 { "uintx", "CPUForCMSThread", &CPUForCMSThread, "When BindCMSThreadToCPU is true, the CPU to bind CMS thread to", "{diagnostic}", DEFAULT },
 { "bool", "BindGCTaskThreadsToCPUs", &BindGCTaskThreadsToCPUs, "Bind GCTaskThreads to CPUs if possible", "{product}", DEFAULT },
 { "bool", "UseGCTaskAffinity", &UseGCTaskAffinity, "Use worker affinity when asking for GCTasks", "{product}", DEFAULT },
 { "uintx", "ProcessDistributionStride", &ProcessDistributionStride, "Stride through processors when distributing processes", "{product}", DEFAULT },
 { "uintx", "CMSCoordinatorYieldSleepCount", &CMSCoordinatorYieldSleepCount, "number of times the coordinator GC thread will sleep while " "yielding before giving up and resuming GC", "{product}", DEFAULT },
 { "uintx", "CMSYieldSleepCount", &CMSYieldSleepCount, "number of times a GC thread (minus the coordinator) " "will sleep while yielding before giving up and resuming GC", "{product}", DEFAULT },
 { "bool", "PrintGC", &PrintGC, "Print message at garbage collect", "{manageable}", DEFAULT },
 { "bool", "PrintGCDetails", &PrintGCDetails, "Print more details at garbage collect", "{manageable}", DEFAULT },
 { "bool", "PrintGCDateStamps", &PrintGCDateStamps, "Print date stamps at garbage collect", "{manageable}", DEFAULT },
 { "bool", "PrintGCTimeStamps", &PrintGCTimeStamps, "Print timestamps at garbage collect", "{manageable}", DEFAULT },
 { "bool", "PrintGCTaskTimeStamps", &PrintGCTaskTimeStamps, "Print timestamps for individual gc worker thread tasks", "{product}", DEFAULT },
 { "intx", "ConcGCYieldTimeout", &ConcGCYieldTimeout, "If non-zero, assert that GC threads yield within this # of ms.", "", DEFAULT },
 { "bool", "TraceMarkSweep", &TraceMarkSweep, "Trace mark sweep", "{notproduct}", DEFAULT },
 { "bool", "PrintReferenceGC", &PrintReferenceGC, "Print times spent handling reference objects during GC " " (enabled only when PrintGCDetails)", "{product}", DEFAULT },
 { "bool", "TraceReferenceGC", &TraceReferenceGC, "Trace handling of soft/weak/final/phantom references", "", DEFAULT },
 { "bool", "TraceFinalizerRegistration", &TraceFinalizerRegistration, "Trace registration of final references", "", DEFAULT },
 { "bool", "TraceScavenge", &TraceScavenge, "Trace scavenge", "{notproduct}", DEFAULT },
 { "bool", "TraceClassLoading", &TraceClassLoading, "Trace all classes loaded", "{product rw}", DEFAULT },
 { "bool", "TraceClassLoadingPreorder", &TraceClassLoadingPreorder, "Trace all classes loaded in order referenced (not loaded)", "{product}", DEFAULT },
 { "bool", "TraceClassUnloading", &TraceClassUnloading, "Trace unloading of classes", "{product rw}", DEFAULT },
 { "bool", "TraceLoaderConstraints", &TraceLoaderConstraints, "Trace loader constraints", "{product rw}", DEFAULT },
 { "bool", "TraceGen0Time", &TraceGen0Time, "Trace accumulated time for Gen 0 collection", "{product}", DEFAULT },
 { "bool", "TraceGen1Time", &TraceGen1Time, "Trace accumulated time for Gen 1 collection", "{product}", DEFAULT },
 { "bool", "PrintTenuringDistribution", &PrintTenuringDistribution, "Print tenuring age information", "{product}", DEFAULT },
 { "bool", "PrintHeapAtGC", &PrintHeapAtGC, "Print heap layout before and after each GC", "{product rw}", DEFAULT },
 { "bool", "PrintHeapAtGCExtended", &PrintHeapAtGCExtended, "Prints extended information about the layout of the heap " "when -XX:+PrintHeapAtGC is set", "{product rw}", DEFAULT },
 { "bool", "PrintHeapAtSIGBREAK", &PrintHeapAtSIGBREAK, "Print heap layout in response to SIGBREAK", "{product}", DEFAULT },
 { "bool", "PrintClassHistogramBeforeFullGC", &PrintClassHistogramBeforeFullGC, "Print a class histogram before any major stop-world GC", "{manageable}", DEFAULT },
 { "bool", "PrintClassHistogramAfterFullGC", &PrintClassHistogramAfterFullGC, "Print a class histogram after any major stop-world GC", "{manageable}", DEFAULT },
 { "bool", "PrintClassHistogram", &PrintClassHistogram, "Print a histogram of class instances", "{manageable}", DEFAULT },
 { "bool", "TraceWorkGang", &TraceWorkGang, "Trace activities of work gangs", "", DEFAULT },
 { "bool", "TraceParallelOldGCTasks", &TraceParallelOldGCTasks, "Trace multithreaded GC activity", "{product}", DEFAULT },
 { "bool", "TraceBlockOffsetTable", &TraceBlockOffsetTable, "Print BlockOffsetTable maps", "", DEFAULT },
 { "bool", "TraceCardTableModRefBS", &TraceCardTableModRefBS, "Print CardTableModRefBS maps", "", DEFAULT },
 { "bool", "TraceGCTaskManager", &TraceGCTaskManager, "Trace actions of the GC task manager", "", DEFAULT },
 { "bool", "TraceGCTaskQueue", &TraceGCTaskQueue, "Trace actions of the GC task queues", "", DEFAULT },
 { "bool", "TraceGCTaskThread", &TraceGCTaskThread, "Trace actions of the GC task threads", "{diagnostic}", DEFAULT },
 { "bool", "PrintParallelOldGCPhaseTimes", &PrintParallelOldGCPhaseTimes, "Print the time taken by each parallel old gc phase." "PrintGCDetails must also be enabled.", "{product}", DEFAULT },
 { "bool", "TraceParallelOldGCMarkingPhase", &TraceParallelOldGCMarkingPhase, "Trace parallel old gc marking phase", "", DEFAULT },
 { "bool", "TraceParallelOldGCSummaryPhase", &TraceParallelOldGCSummaryPhase, "Trace parallel old gc summary phase", "", DEFAULT },
 { "bool", "TraceParallelOldGCCompactionPhase", &TraceParallelOldGCCompactionPhase, "Trace parallel old gc compaction phase", "", DEFAULT },
 { "bool", "TraceParallelOldGCDensePrefix", &TraceParallelOldGCDensePrefix, "Trace parallel old gc dense prefix computation", "", DEFAULT },
 { "bool", "IgnoreLibthreadGPFault", &IgnoreLibthreadGPFault, "Suppress workaround for libthread GP fault", "", DEFAULT },
 { "bool", "PrintJNIGCStalls", &PrintJNIGCStalls, "Print diagnostic message when GC is stalled" "by JNI critical section", "{product}", DEFAULT },
 { "double", "ObjectCountCutOffPercent", &ObjectCountCutOffPercent, "The percentage of the used heap that the instances of a class " "must occupy for the class to generate a trace event.", "{experimental}", DEFAULT },
 { "bool", "UseGCLogFileRotation", &UseGCLogFileRotation, "Prevent large gclog file for long running app. " "Requires -Xloggc:<filename>", "{product}", DEFAULT },
 { "uintx", "NumberOfGCLogFiles", &NumberOfGCLogFiles, "Number of gclog files in rotation, " "Default: 0, no rotation", "{product}", DEFAULT },
 { "uintx", "GCLogFileSize", &GCLogFileSize, "GC log file size, Default: 0 bytes, no rotation " "Only valid with UseGCLogFileRotation", "{product}", DEFAULT },
 { "bool", "TraceJVMTIObjectTagging", &TraceJVMTIObjectTagging, "Trace JVMTI object tagging calls", "{diagnostic}", DEFAULT },
 { "bool", "VerifyBeforeIteration", &VerifyBeforeIteration, "Verify memory system before JVMTI iteration", "{diagnostic}", DEFAULT },
 { "bool", "CIPrintCompilerName", &CIPrintCompilerName, "when CIPrint is active, print the name of the active compiler", "", DEFAULT },
 { "bool", "CIPrintCompileQueue", &CIPrintCompileQueue, "display the contents of the compile queue whenever a " "compilation is enqueued", "", DEFAULT },
 { "bool", "CIPrintRequests", &CIPrintRequests, "display every request for compilation", "", DEFAULT },
 { "bool", "CITime", &CITime, "collect timing information for compilation", "{product}", DEFAULT },
 { "bool", "CITimeEach", &CITimeEach, "display timing information after each successful compilation", "", DEFAULT },
 { "bool", "CICountOSR", &CICountOSR, "use a separate counter when assigning ids to osr compilations", "", DEFAULT },
 { "bool", "CICompileNatives", &CICompileNatives, "compile native methods if supported by the compiler", "", DEFAULT },
 { "bool", "CICompileOSR", &CICompileOSR, "compile on stack replacement methods if supported by the " "compiler", "{pd}", DEFAULT },
 { "bool", "CIPrintMethodCodes", &CIPrintMethodCodes, "print method bytecodes of the compiled code", "", DEFAULT },
 { "bool", "CIPrintTypeFlow", &CIPrintTypeFlow, "print the results of ciTypeFlow analysis", "", DEFAULT },
 { "bool", "CITraceTypeFlow", &CITraceTypeFlow, "detailed per-bytecode tracing of ciTypeFlow analysis", "", DEFAULT },
 { "intx", "OSROnlyBCI", &OSROnlyBCI, "OSR only at this bci.  Negative values mean exclude that bci", "", DEFAULT },
 { "intx", "CICompilerCount", &CICompilerCount, "Number of compiler threads to run", "{product}", DEFAULT },
 { "intx", "CompilationPolicyChoice", &CompilationPolicyChoice, "which compilation policy (0/1)", "{product}", DEFAULT },
 { "bool", "UseStackBanging", &UseStackBanging, "use stack banging for stack overflow checks (required for " "proper StackOverflow handling; disable only to measure cost " "of stackbanging)", "", DEFAULT },
 { "bool", "UseStrictFP", &UseStrictFP, "use strict fp if modifier strictfp is set", "", DEFAULT },
 { "bool", "GenerateSynchronizationCode", &GenerateSynchronizationCode, "generate locking/unlocking code for synchronized methods and " "monitors", "", DEFAULT },
 { "bool", "GenerateCompilerNullChecks", &GenerateCompilerNullChecks, "Generate explicit null checks for loads/stores/calls", "", DEFAULT },
 { "bool", "GenerateRangeChecks", &GenerateRangeChecks, "Generate range checks for array accesses", "", DEFAULT },
 { "bool", "ImplicitNullChecks", &ImplicitNullChecks, "generate code for implicit null checks", "{pd}", DEFAULT },
 { "bool", "PrintSafepointStatistics", &PrintSafepointStatistics, "print statistics about safepoint synchronization", "{product}", DEFAULT },
 { "intx", "PrintSafepointStatisticsCount", &PrintSafepointStatisticsCount, "total number of safepoint statistics collected " "before printing them out", "{product}", DEFAULT },
 { "intx", "PrintSafepointStatisticsTimeout", &PrintSafepointStatisticsTimeout, "print safepoint statistics only when safepoint takes" " more than PrintSafepointSatisticsTimeout in millis", "{product}", DEFAULT },
 { "bool", "TraceSafepointCleanupTime", &TraceSafepointCleanupTime, "print the break down of clean up tasks performed during" " safepoint", "{product}", DEFAULT },
 { "bool", "Inline", &Inline, "enable inlining", "{product}", DEFAULT },
 { "bool", "ClipInlining", &ClipInlining, "clip inlining if aggregate method exceeds DesiredMethodLimit", "{product}", DEFAULT },
 { "bool", "UseCHA", &UseCHA, "enable CHA", "", DEFAULT },
 { "bool", "UseTypeProfile", &UseTypeProfile, "Check interpreter profile for historically monomorphic calls", "{product}", DEFAULT },
 { "bool", "TimeCompiler", &TimeCompiler, "time the compiler", "{notproduct}", DEFAULT },
 { "bool", "PrintInlining", &PrintInlining, "prints inlining optimizations", "{diagnostic}", DEFAULT },
 { "bool", "UsePopCountInstruction", &UsePopCountInstruction, "Use population count instruction", "{product}", DEFAULT },
 { "bool", "EagerInitialization", &EagerInitialization, "Eagerly initialize classes if possible", "", DEFAULT },
 { "bool", "TraceMethodReplacement", &TraceMethodReplacement, "Print when methods are replaced do to recompilation", "", DEFAULT },
 { "bool", "PrintMethodFlushing", &PrintMethodFlushing, "print the nmethods being flushed", "", DEFAULT },
 { "bool", "UseRelocIndex", &UseRelocIndex, "use an index to speed random access to relocations", "", DEFAULT },
 { "bool", "StressCodeBuffers", &StressCodeBuffers, "Exercise code buffer expansion and other rare state changes", "", DEFAULT },
 { "bool", "DebugNonSafepoints", &DebugNonSafepoints, "Generate extra debugging info for non-safepoints in nmethods", "{diagnostic}", DEFAULT },
 { "bool", "PrintVMOptions", &PrintVMOptions, "Print flags that appeared on the command line", "{product}", DEFAULT },
 { "bool", "IgnoreUnrecognizedVMOptions", &IgnoreUnrecognizedVMOptions, "Ignore unrecognized VM options", "{product}", DEFAULT },
 { "bool", "PrintCommandLineFlags", &PrintCommandLineFlags, "Print flags specified on command line or set by ergonomics", "{product}", DEFAULT },
 { "bool", "PrintFlagsInitial", &PrintFlagsInitial, "Print all VM flags before argument processing and exit VM", "{product}", DEFAULT },
 { "bool", "PrintFlagsFinal", &PrintFlagsFinal, "Print all VM flags after argument and ergonomic processing", "{product}", DEFAULT },
 { "bool", "PrintFlagsWithComments", &PrintFlagsWithComments, "Print all VM flags with default values and descriptions and exit", "{notproduct}", DEFAULT },
 { "bool", "SerializeVMOutput", &SerializeVMOutput, "Use a mutex to serialize output to tty and hotspot.log", "{diagnostic}", DEFAULT },
 { "bool", "DisplayVMOutput", &DisplayVMOutput, "Display all VM output on the tty, independently of LogVMOutput", "{diagnostic}", DEFAULT },
 { "bool", "LogVMOutput", &LogVMOutput, "Save VM output to hotspot.log, or to LogFile", "{diagnostic}", DEFAULT },
 { "ccstr", "LogFile", &LogFile, "If LogVMOutput is on, save VM output to this file [hotspot.log]", "{diagnostic}", DEFAULT },
 { "ccstr", "ErrorFile", &ErrorFile, "If an error occurs, save the error data to this file " "[default: ./hs_err_pid%p.log] (%p replaced with pid)", "{product}", DEFAULT },
 { "bool", "DisplayVMOutputToStderr", &DisplayVMOutputToStderr, "If DisplayVMOutput is true, display all VM output to stderr", "{product}", DEFAULT },
 { "bool", "DisplayVMOutputToStdout", &DisplayVMOutputToStdout, "If DisplayVMOutput is true, display all VM output to stdout", "{product}", DEFAULT },
 { "bool", "UseHeavyMonitors", &UseHeavyMonitors, "use heavyweight instead of lightweight Java monitors", "{product}", DEFAULT },
 { "bool", "PrintStringTableStatistics", &PrintStringTableStatistics, "print statistics about the StringTable and SymbolTable", "{product}", DEFAULT },
 { "bool", "PrintSymbolTableSizeHistogram", &PrintSymbolTableSizeHistogram, "print histogram of the symbol table", "{notproduct}", DEFAULT },
 { "bool", "ExitVMOnVerifyError", &ExitVMOnVerifyError, "standard exit from VM if bytecode verify error " "(only in debug mode)", "{notproduct}", DEFAULT },
 { "ccstr", "AbortVMOnException", &AbortVMOnException, "Call fatal if this exception is thrown.  Example: " "java -XX:AbortVMOnException=java.lang.NullPointerException Foo", "{notproduct}", DEFAULT },
 { "ccstr", "AbortVMOnExceptionMessage", &AbortVMOnExceptionMessage, "Call fatal if the exception pointed by AbortVMOnException " "has this message.", "{notproduct}", DEFAULT },
 { "bool", "DebugVtables", &DebugVtables, "add debugging code to vtable dispatch", "", DEFAULT },
 { "bool", "PrintVtables", &PrintVtables, "print vtables when printing klass", "", DEFAULT },
 { "bool", "PrintVtableStats", &PrintVtableStats, "print vtables stats at end of run", "{notproduct}", DEFAULT },
 { "bool", "TraceCreateZombies", &TraceCreateZombies, "trace creation of zombie nmethods", "", DEFAULT },
 { "bool", "IgnoreLockingAssertions", &IgnoreLockingAssertions, "disable locking assertions (for speed)", "{notproduct}", DEFAULT },
 { "bool", "RangeCheckElimination", &RangeCheckElimination, "Split loop iterations to eliminate range checks", "{product}", DEFAULT },
 { "bool", "UncommonNullCast", &UncommonNullCast, "track occurrences of null in casts; adjust compiler tactics", "{pd}", DEFAULT },
 { "bool", "TypeProfileCasts", &TypeProfileCasts, "treat casts like calls for purposes of type profiling", "", DEFAULT },
 { "bool", "DelayCompilationDuringStartup", &DelayCompilationDuringStartup, "Delay invoking the compiler until main application class is " "loaded", "", DEFAULT },
 { "bool", "CompileTheWorld", &CompileTheWorld, "Compile all methods in all classes in bootstrap class path " "(stress test)", "", DEFAULT },
 { "bool", "CompileTheWorldPreloadClasses", &CompileTheWorldPreloadClasses, "Preload all classes used by a class before start loading", "", DEFAULT },
 { "intx", "CompileTheWorldSafepointInterval", &CompileTheWorldSafepointInterval, "Force a safepoint every n compiles so sweeper can keep up", "{notproduct}", DEFAULT },
 { "bool", "FillDelaySlots", &FillDelaySlots, "Fill delay slots (on SPARC only)", "", DEFAULT },
 { "bool", "TimeLivenessAnalysis", &TimeLivenessAnalysis, "Time computation of bytecode liveness analysis", "", DEFAULT },
 { "bool", "TraceLivenessGen", &TraceLivenessGen, "Trace the generation of liveness analysis information", "", DEFAULT },
 { "bool", "TraceLivenessQuery", &TraceLivenessQuery, "Trace queries of liveness analysis information", "{notproduct}", DEFAULT },
 { "bool", "CollectIndexSetStatistics", &CollectIndexSetStatistics, "Collect information about IndexSets", "{notproduct}", DEFAULT },
 { "bool", "UseLoopSafepoints", &UseLoopSafepoints, "Generate Safepoint nodes in every loop", "", DEFAULT },
 { "intx", "FastAllocateSizeLimit", &FastAllocateSizeLimit, "Inline allocations larger than this in doublewords must go slow", "", DEFAULT },
 { "bool", "AggressiveOpts", &AggressiveOpts, "Enable aggressive optimizations - see arguments.cpp", "{product}", DEFAULT },
 { "bool", "UseStringCache", &UseStringCache, "Enable String cache capabilities on String.java", "{product}", DEFAULT },
 { "bool", "CountCompiledCalls", &CountCompiledCalls, "counts method invocations", "", DEFAULT },
 { "bool", "CountRuntimeCalls", &CountRuntimeCalls, "counts VM runtime calls", "{notproduct}", DEFAULT },
 { "bool", "CountJNICalls", &CountJNICalls, "counts jni method invocations", "", DEFAULT },
 { "bool", "CountJVMCalls", &CountJVMCalls, "counts jvm method invocations", "{notproduct}", DEFAULT },
 { "bool", "CountRemovableExceptions", &CountRemovableExceptions, "count exceptions that could be replaced by branches due to " "inlining", "{notproduct}", DEFAULT },
 { "bool", "ICMissHistogram", &ICMissHistogram, "produce histogram of IC misses", "{notproduct}", DEFAULT },
 { "bool", "PrintClassStatistics", &PrintClassStatistics, "prints class statistics at end of run", "{notproduct}", DEFAULT },
 { "bool", "PrintMethodStatistics", &PrintMethodStatistics, "prints method statistics at end of run", "{notproduct}", DEFAULT },
 { "bool", "ClearInterpreterLocals", &ClearInterpreterLocals, "Always clear local variables of interpreter activations upon " "entry", "", DEFAULT },
 { "bool", "RewriteBytecodes", &RewriteBytecodes, "Allow rewriting of bytecodes (bytecodes are not immutable)", "{pd product}", DEFAULT },
 { "bool", "RewriteFrequentPairs", &RewriteFrequentPairs, "Rewrite frequently used bytecode pairs into a single bytecode", "{pd product}", DEFAULT },
 { "bool", "PrintInterpreter", &PrintInterpreter, "Prints the generated interpreter code", "{diagnostic}", DEFAULT },
 { "bool", "UseInterpreter", &UseInterpreter, "Use interpreter for non-compiled methods", "{product}", DEFAULT },
 { "bool", "UseFastSignatureHandlers", &UseFastSignatureHandlers, "Use fast signature handlers for native calls", "", DEFAULT },
 { "bool", "UseLoopCounter", &UseLoopCounter, "Increment invocation counter on backward branch", "{product}", DEFAULT },
 { "bool", "UseFastEmptyMethods", &UseFastEmptyMethods, "Use fast method entry code for empty methods", "{product}", DEFAULT },
 { "bool", "UseFastAccessorMethods", &UseFastAccessorMethods, "Use fast method entry code for accessor methods", "{product}", DEFAULT },
 { "bool", "UseOnStackReplacement", &UseOnStackReplacement, "Use on stack replacement, calls runtime if invoc. counter " "overflows in loop", "{pd product}", DEFAULT },
 { "bool", "TraceOnStackReplacement", &TraceOnStackReplacement, "Trace on stack replacement", "{notproduct}", DEFAULT },
 { "bool", "PreferInterpreterNativeStubs", &PreferInterpreterNativeStubs, "Use always interpreter stubs for native methods invoked via " "interpreter", "{pd product}", DEFAULT },
 { "bool", "CountBytecodes", &CountBytecodes, "Count number of bytecodes executed", "", DEFAULT },
 { "bool", "PrintBytecodeHistogram", &PrintBytecodeHistogram, "Print histogram of the executed bytecodes", "", DEFAULT },
 { "bool", "PrintBytecodePairHistogram", &PrintBytecodePairHistogram, "Print histogram of the executed bytecode pairs", "", DEFAULT },
 { "bool", "PrintSignatureHandlers", &PrintSignatureHandlers, "Print code generated for native method signature handlers", "{diagnostic}", DEFAULT },
 { "bool", "VerifyOops", &VerifyOops, "Do plausibility checks for oops", "", DEFAULT },
 { "bool", "CheckUnhandledOops", &CheckUnhandledOops, "Check for unhandled oops in VM code", "", DEFAULT },
 { "bool", "VerifyJNIFields", &VerifyJNIFields, "Verify jfieldIDs for instance fields", "", DEFAULT },
 { "bool", "VerifyJNIEnvThread", &VerifyJNIEnvThread, "Verify JNIEnv.thread == Thread::current() when entering VM " "from JNI", "{notproduct}", DEFAULT },
 { "bool", "VerifyFPU", &VerifyFPU, "Verify FPU state (check for NaN's, etc.)", "", DEFAULT },
 { "bool", "VerifyThread", &VerifyThread, "Watch the thread register for corruption (SPARC only)", "", DEFAULT },
 { "bool", "VerifyActivationFrameSize", &VerifyActivationFrameSize, "Verify that activation frame didn't become smaller than its " "minimal size", "", DEFAULT },
 { "bool", "TraceFrequencyInlining", &TraceFrequencyInlining, "Trace frequency based inlining", "", DEFAULT },
 { "bool", "InlineIntrinsics", &InlineIntrinsics, "Inline intrinsics that can be statically resolved", "{pd}", DEFAULT },
 { "bool", "ProfileInterpreter", &ProfileInterpreter, "Profile at the bytecode level during interpretation", "{pd product}", DEFAULT },
 { "bool", "ProfileTraps", &ProfileTraps, "Profile deoptimization traps at the bytecode level", "{pd}", DEFAULT },
 { "intx", "ProfileMaturityPercentage", &ProfileMaturityPercentage, "number of method invocations/branches (expressed as % of " "CompileThreshold) before using the method's profile", "{product}", DEFAULT },
 { "bool", "PrintMethodData", &PrintMethodData, "Print the results of +ProfileInterpreter at end of run", "", DEFAULT },
 { "bool", "VerifyDataPointer", &VerifyDataPointer, "Verify the method data pointer during interpreter profiling", "", DEFAULT },
 { "bool", "VerifyCompiledCode", &VerifyCompiledCode, "Include miscellaneous runtime verifications in nmethod code; " "default off because it disturbs nmethod size heuristics", "", DEFAULT },
 { "bool", "CrashGCForDumpingJavaThread", &CrashGCForDumpingJavaThread, "Manually make GC thread crash then dump java stack trace;  " "Test only", "{notproduct}", DEFAULT },
 { "bool", "UseCompiler", &UseCompiler, "use compilation", "{product}", DEFAULT },
 { "bool", "TraceCompilationPolicy", &TraceCompilationPolicy, "Trace compilation policy", "", DEFAULT },
 { "bool", "TimeCompilationPolicy", &TimeCompilationPolicy, "Time the compilation policy", "", DEFAULT },
 { "bool", "UseCounterDecay", &UseCounterDecay, "adjust recompilation counters", "{product}", DEFAULT },
 { "intx", "CounterHalfLifeTime", &CounterHalfLifeTime, "half-life time of invocation counters (in secs)", "", DEFAULT },
 { "intx", "CounterDecayMinIntervalLength", &CounterDecayMinIntervalLength, "Min. ms. between invocation of CounterDecay", "", DEFAULT },
 { "bool", "AlwaysCompileLoopMethods", &AlwaysCompileLoopMethods, "when using recompilation, never interpret methods " "containing loops", "{product}", DEFAULT },
 { "bool", "DontCompileHugeMethods", &DontCompileHugeMethods, "don't compile methods > HugeMethodLimit", "{product}", DEFAULT },
 { "bool", "EstimateArgEscape", &EstimateArgEscape, "Analyze bytecodes to estimate escape state of arguments", "{product}", DEFAULT },
 { "intx", "BCEATraceLevel", &BCEATraceLevel, "How much tracing to do of bytecode escape analysis estimates", "{product}", DEFAULT },
 { "intx", "MaxBCEAEstimateLevel", &MaxBCEAEstimateLevel, "Maximum number of nested calls that are analyzed by BC EA.", "{product}", DEFAULT },
 { "intx", "MaxBCEAEstimateSize", &MaxBCEAEstimateSize, "Maximum bytecode size of a method to be analyzed by BC EA.", "{product}", DEFAULT },
 { "intx", "AllocatePrefetchStyle", &AllocatePrefetchStyle, "0 = no prefetch, " "1 = prefetch instructions for each allocation, " "2 = use TLAB watermark to gate allocation prefetch, " "3 = use BIS instruction on Sparc for allocation prefetch", "{product}", DEFAULT },
 { "intx", "AllocatePrefetchDistance", &AllocatePrefetchDistance, "Distance to prefetch ahead of allocation pointer", "{product}", DEFAULT },
 { "intx", "AllocatePrefetchLines", &AllocatePrefetchLines, "Number of lines to prefetch ahead of array allocation pointer", "{product}", DEFAULT },
 { "intx", "AllocateInstancePrefetchLines", &AllocateInstancePrefetchLines, "Number of lines to prefetch ahead of instance allocation pointer", "{product}", DEFAULT },
 { "intx", "AllocatePrefetchStepSize", &AllocatePrefetchStepSize, "Step size in bytes of sequential prefetch instructions", "{product}", DEFAULT },
 { "intx", "AllocatePrefetchInstr", &AllocatePrefetchInstr, "Prefetch instruction to prefetch ahead of allocation pointer", "{product}", DEFAULT },
 { "bool", "TraceDeoptimization", &TraceDeoptimization, "Trace deoptimization", "", DEFAULT },
 { "bool", "DebugDeoptimization", &DebugDeoptimization, "Tracing various information while debugging deoptimization", "", DEFAULT },
 { "intx", "SelfDestructTimer", &SelfDestructTimer, "Will cause VM to terminate after a given time (in minutes) " "(0 means off)", "{product}", DEFAULT },
 { "intx", "MaxJavaStackTraceDepth", &MaxJavaStackTraceDepth, "Max. no. of lines in the stack trace for Java exceptions " "(0 means all)", "{product}", DEFAULT },
 { "intx", "GuaranteedSafepointInterval", &GuaranteedSafepointInterval, "Guarantee a safepoint (at least) every so many milliseconds " "(0 means none)", "{diagnostic}", DEFAULT },
  { "intx", "SafepointTimeoutDelay", &SafepointTimeoutDelay, "Delay in milliseconds for option SafepointTimeout", "{product}", DEFAULT },
 { "intx", "NmethodSweepFraction", &NmethodSweepFraction, "Number of invocations of sweeper to cover all nmethods", "{product}", DEFAULT },
 { "intx", "NmethodSweepCheckInterval", &NmethodSweepCheckInterval, "Compilers wake up every n seconds to possibly sweep nmethods", "{product}", DEFAULT },
 { "bool", "LogSweeper", &LogSweeper, "Keep a ring buffer of sweeper activity", "{notproduct}", DEFAULT },
 { "intx", "SweeperLogEntries", &SweeperLogEntries, "Number of records in the ring buffer of sweeper activity", "{notproduct}", DEFAULT },
 { "intx", "MemProfilingInterval", &MemProfilingInterval, "Time between each invocation of the MemProfiler", "{notproduct}", DEFAULT },
 { "intx", "MallocCatchPtr", &MallocCatchPtr, "Hit breakpoint when mallocing/freeing this pointer", "", DEFAULT },
 { "intx", "AssertRepeat", &AssertRepeat, "number of times to evaluate expression in assert " "(to estimate overhead); only works with -DUSE_REPEATED_ASSERTS", "{notproduct}", DEFAULT },
 { "ccstrlist", "SuppressErrorAt", &SuppressErrorAt, "List of assertions (file:line) to muzzle", "{notproduct}", DEFAULT },
 { "uintx", "HandleAllocationLimit", &HandleAllocationLimit, "Threshold for HandleMark allocation when +TraceHandleAllocation " "is used", "{notproduct}", DEFAULT },
 { "uintx", "TotalHandleAllocationLimit", &TotalHandleAllocationLimit, "Threshold for total handle allocation when " "+TraceHandleAllocation is used", "", DEFAULT },
 { "intx", "StackPrintLimit", &StackPrintLimit, "number of stack frames to print in VM-level stack dump", "", DEFAULT },
 { "intx", "MaxElementPrintSize", &MaxElementPrintSize, "maximum number of elements to print", "{notproduct}", DEFAULT },
 { "intx", "MaxSubklassPrintSize", &MaxSubklassPrintSize, "maximum number of subklasses to print when printing klass", "{notproduct}", DEFAULT },
 { "intx", "MaxInlineLevel", &MaxInlineLevel, "maximum number of nested calls that are inlined", "{product}", DEFAULT },
 { "intx", "MaxRecursiveInlineLevel", &MaxRecursiveInlineLevel, "maximum number of nested recursive calls that are inlined", "{product}", DEFAULT },
 { "intx", "InlineSmallCode", &InlineSmallCode, "Only inline already compiled methods if their code size is " "less than this", "{pd product}", DEFAULT },
 { "intx", "MaxInlineSize", &MaxInlineSize, "maximum bytecode size of a method to be inlined", "{product}", DEFAULT },
 { "intx", "FreqInlineSize", &FreqInlineSize, "maximum bytecode size of a frequent method to be inlined", "{pd product}", DEFAULT },
 { "intx", "MaxTrivialSize", &MaxTrivialSize, "maximum bytecode size of a trivial method to be inlined", "{product}", DEFAULT },
 { "intx", "MinInliningThreshold", &MinInliningThreshold, "min. invocation count a method needs to have to be inlined", "{product}", DEFAULT },
 { "intx", "MethodHistogramCutoff", &MethodHistogramCutoff, "cutoff value for method invoc. histogram (+CountCalls)", "", DEFAULT },
 { "intx", "ProfilerNumberOfInterpretedMethods", &ProfilerNumberOfInterpretedMethods, "# of interpreted methods to show in profile", "", DEFAULT },
 { "intx", "ProfilerNumberOfCompiledMethods", &ProfilerNumberOfCompiledMethods, "# of compiled methods to show in profile", "", DEFAULT },
 { "intx", "ProfilerNumberOfStubMethods", &ProfilerNumberOfStubMethods, "# of stub methods to show in profile", "", DEFAULT },
 { "intx", "ProfilerNumberOfRuntimeStubNodes", &ProfilerNumberOfRuntimeStubNodes, "# of runtime stub nodes to show in profile", "", DEFAULT },
 { "intx", "ProfileIntervalsTicks", &ProfileIntervalsTicks, "# of ticks between printing of interval profile " "(+ProfileIntervals)", "{product}", DEFAULT },
 { "intx", "ScavengeALotInterval", &ScavengeALotInterval, "Interval between which scavenge will occur with +ScavengeALot", "{notproduct}", DEFAULT },
 { "intx", "FullGCALotInterval", &FullGCALotInterval, "Interval between which full gc will occur with +FullGCALot", "{notproduct}", DEFAULT },
 { "intx", "FullGCALotStart", &FullGCALotStart, "For which invocation to start FullGCAlot", "{notproduct}", DEFAULT },
 { "intx", "FullGCALotDummies", &FullGCALotDummies, "Dummy object allocated with +FullGCALot, forcing all objects " "to move", "{notproduct}", DEFAULT },
 { "intx", "DontYieldALotInterval", &DontYieldALotInterval, "Interval between which yields will be dropped (milliseconds)", "", DEFAULT },
 { "intx", "MinSleepInterval", &MinSleepInterval, "Minimum sleep() interval (milliseconds) when " "ConvertSleepToYield is off (used for SOLARIS)", "", DEFAULT },
 { "intx", "ProfilerPCTickThreshold", &ProfilerPCTickThreshold, "Number of ticks in a PC buckets to be a hotspot", "", DEFAULT },
 { "intx", "DeoptimizeALotInterval", &DeoptimizeALotInterval, "Number of exits until DeoptimizeALot kicks in", "{notproduct}", DEFAULT },
 { "intx", "ZombieALotInterval", &ZombieALotInterval, "Number of exits until ZombieALot kicks in", "{notproduct}", DEFAULT },
 { "bool", "StressNonEntrant", &StressNonEntrant, "Mark nmethods non-entrant at registration", "", DEFAULT },
 { "intx", "MallocVerifyInterval", &MallocVerifyInterval, "if non-zero, verify C heap after every N calls to " "malloc/realloc/free", "{diagnostic}", DEFAULT },
 { "intx", "MallocVerifyStart", &MallocVerifyStart, "if non-zero, start verifying C heap after Nth call to " "malloc/realloc/free", "{diagnostic}", DEFAULT },
 { "intx", "TypeProfileWidth", &TypeProfileWidth, "number of receiver types to record in call/cast profile", "{product}", DEFAULT },
 { "intx", "BciProfileWidth", &BciProfileWidth, "number of return bci's to record in ret profile", "", DEFAULT },
 { "intx", "PerMethodRecompilationCutoff", &PerMethodRecompilationCutoff, "After recompiling N times, stay in the interpreter (-1=>'Inf')", "{product}", DEFAULT },
 { "intx", "PerBytecodeRecompilationCutoff", &PerBytecodeRecompilationCutoff, "Per-BCI limit on repeated recompilation (-1=>'Inf')", "{product}", DEFAULT },
 { "intx", "PerMethodTrapLimit", &PerMethodTrapLimit, "Limit on traps (of one kind) in a method (includes inlines)", "{product}", DEFAULT },
 { "intx", "PerBytecodeTrapLimit", &PerBytecodeTrapLimit, "Limit on traps (of one kind) at a particular BCI", "{product}", DEFAULT },
 { "intx", "InlineFrequencyRatio", &InlineFrequencyRatio, "Ratio of call site execution to caller method invocation", "", DEFAULT },
 { "intx", "InlineFrequencyCount", &InlineFrequencyCount, "Count of call site execution necessary to trigger frequent " "inlining", "{pd}", DEFAULT },
 { "intx", "InlineThrowCount", &InlineThrowCount, "Force inlining of interpreted methods that throw this often", "", DEFAULT },
 { "intx", "InlineThrowMaxSize", &InlineThrowMaxSize, "Force inlining of throwing methods smaller than this", "", DEFAULT },
 { "intx", "ProfilerNodeSize", &ProfilerNodeSize, "Size in K to allocate for the Profile Nodes of each thread", "", DEFAULT },
 { "intx", "PreInflateSpin", &PreInflateSpin, "Number of times to spin wait before inflation", "{pd product}", DEFAULT },
 { "uintx", "InitialHeapSize", &InitialHeapSize, "Initial heap size (in bytes); zero means OldSize + NewSize", "{product}", DEFAULT },
 { "uintx", "MaxHeapSize", &MaxHeapSize, "Maximum heap size (in bytes)", "{product}", DEFAULT },
 { "uintx", "OldSize", &OldSize, "Initial tenured generation size (in bytes)", "{product}", DEFAULT },
 { "uintx", "NewSize", &NewSize, "Initial new generation size (in bytes)", "{product}", DEFAULT },
 { "uintx", "MaxNewSize", &MaxNewSize, "Maximum new generation size (in bytes), max_uintx means set " "ergonomically", "{product}", DEFAULT },
 { "uintx", "PretenureSizeThreshold", &PretenureSizeThreshold, "Maximum size in bytes of objects allocated in DefNew " "generation; zero means no maximum", "{product}", DEFAULT },
 { "uintx", "TLABSize", &TLABSize, "Starting TLAB size (in bytes); zero means set ergonomically", "{product}", DEFAULT },
 { "uintx", "MinTLABSize", &MinTLABSize, "Minimum allowed TLAB size (in bytes)", "{product}", DEFAULT },
 { "uintx", "TLABAllocationWeight", &TLABAllocationWeight, "Allocation averaging weight", "{product}", DEFAULT },
 { "uintx", "TLABWasteTargetPercent", &TLABWasteTargetPercent, "Percentage of Eden that can be wasted", "{product}", DEFAULT },
 { "uintx", "TLABRefillWasteFraction", &TLABRefillWasteFraction, "Max TLAB waste at a refill (internal fragmentation)", "{product}", DEFAULT },
 { "uintx", "TLABWasteIncrement", &TLABWasteIncrement, "Increment allowed waste at slow allocation", "{product}", DEFAULT },
 { "intx", "SurvivorRatio", &SurvivorRatio, "Ratio of eden/survivor space size", "{product}", DEFAULT },
 { "intx", "NewRatio", &NewRatio, "Ratio of new/old generation sizes", "{product}", DEFAULT },
 { "uintx", "NewSizeThreadIncrease", &NewSizeThreadIncrease, "Additional size added to desired new generation size per " "non-daemon thread (in bytes)", "{pd product}", DEFAULT },
 { "uintx", "PermSize", &PermSize, "Initial size of permanent generation (in bytes)", "{pd product}", DEFAULT },
 { "uintx", "MaxPermSize", &MaxPermSize, "Maximum size of permanent generation (in bytes)", "{pd product}", DEFAULT },
 { "uintx", "MinHeapFreeRatio", &MinHeapFreeRatio, "Min percentage of heap free after GC to avoid expansion", "{product}", DEFAULT },
 { "uintx", "MaxHeapFreeRatio", &MaxHeapFreeRatio, "Max percentage of heap free after GC to avoid shrinking", "{product}", DEFAULT },
 { "intx", "SoftRefLRUPolicyMSPerMB", &SoftRefLRUPolicyMSPerMB, "Number of milliseconds per MB of free space in the heap", "{product}", DEFAULT },
 { "uintx", "MinHeapDeltaBytes", &MinHeapDeltaBytes, "Min change in heap space due to GC (in bytes)", "{product}", DEFAULT },
 { "uintx", "MinPermHeapExpansion", &MinPermHeapExpansion, "Min expansion of permanent heap (in bytes)", "{product}", DEFAULT },
 { "uintx", "MaxPermHeapExpansion", &MaxPermHeapExpansion, "Max expansion of permanent heap without full GC (in bytes)", "{product}", DEFAULT },
 { "intx", "QueuedAllocationWarningCount", &QueuedAllocationWarningCount, "Number of times an allocation that queues behind a GC " "will retry before printing a warning", "{product}", DEFAULT },
 { "uintx", "VerifyGCStartAt", &VerifyGCStartAt, "GC invoke count where +VerifyBefore/AfterGC kicks in", "{diagnostic}", DEFAULT },
 { "intx", "VerifyGCLevel", &VerifyGCLevel, "Generation level at which to start +VerifyBefore/AfterGC", "{diagnostic}", DEFAULT },
 { "intx", "MaxTenuringThreshold", &MaxTenuringThreshold, "Maximum value for tenuring threshold", "{product}", DEFAULT },
 { "intx", "InitialTenuringThreshold", &InitialTenuringThreshold, "Initial value for tenuring threshold", "{product}", DEFAULT },
 { "intx", "TargetSurvivorRatio", &TargetSurvivorRatio, "Desired percentage of survivor space used after scavenge", "{product}", DEFAULT },
 { "uintx", "MarkSweepDeadRatio", &MarkSweepDeadRatio, "Percentage (0-100) of the old gen allowed as dead wood." "Serial mark sweep treats this as both the min and max value." "CMS uses this value only if it falls back to mark sweep." "Par compact uses a variable scale based on the density of the" "generation and treats this as the max value when the heap is" "either completely full or completely empty.  Par compact also" "has a smaller default value; see arguments.cpp.", "{product}", DEFAULT },
 { "uintx", "PermMarkSweepDeadRatio", &PermMarkSweepDeadRatio, "Percentage (0-100) of the perm gen allowed as dead wood." "See MarkSweepDeadRatio for collector-specific comments.", "{product}", DEFAULT },
 { "intx", "MarkSweepAlwaysCompactCount", &MarkSweepAlwaysCompactCount, "How often should we fully compact the heap (ignoring the dead " "space parameters)", "{product}", DEFAULT },
 { "intx", "PrintCMSStatistics", &PrintCMSStatistics, "Statistics for CMS", "{product}", DEFAULT },
 { "bool", "PrintCMSInitiationStatistics", &PrintCMSInitiationStatistics, "Statistics for initiating a CMS collection", "{product}", DEFAULT },
 { "intx", "PrintFLSStatistics", &PrintFLSStatistics, "Statistics for CMS' FreeListSpace", "{product}", DEFAULT },
 { "intx", "PrintFLSCensus", &PrintFLSCensus, "Census for CMS' FreeListSpace", "{product}", DEFAULT },
 { "uintx", "GCExpandToAllocateDelayMillis", &GCExpandToAllocateDelayMillis, "Delay in ms between expansion and allocation", "", DEFAULT },
 { "intx", "DeferThrSuspendLoopCount", &DeferThrSuspendLoopCount, "(Unstable) Number of times to iterate in safepoint loop " " before blocking VM threads ", "{product}", DEFAULT },
 { "intx", "DeferPollingPageLoopCount", &DeferPollingPageLoopCount, "(Unsafe,Unstable) Number of iterations in safepoint loop " "before changing safepoint polling page to RO ", "{product}", DEFAULT },
 { "intx", "SafepointSpinBeforeYield", &SafepointSpinBeforeYield, "(Unstable)", "{product}", DEFAULT },
 { "bool", "PSChunkLargeArrays", &PSChunkLargeArrays, "true: process large arrays in chunks", "{product}", DEFAULT },
 { "uintx", "GCDrainStackTargetSize", &GCDrainStackTargetSize, "how many entries we'll try to leave on the stack during " "parallel GC", "{product}", DEFAULT },
 { "intx", "StackYellowPages", &StackYellowPages, "Number of yellow zone (recoverable overflows) pages", "{pd product}", DEFAULT },
 { "intx", "StackRedPages", &StackRedPages, "Number of red zone (unrecoverable overflows) pages", "{pd product}", DEFAULT },
 { "intx", "StackShadowPages", &StackShadowPages, "Number of shadow zone (for overflow checking) pages" " this should exceed the depth of the VM and native call stack", "{pd product}", DEFAULT },
 { "intx", "ThreadStackSize", &ThreadStackSize, "Thread Stack Size (in Kbytes)", "{pd product}", DEFAULT },
 { "intx", "VMThreadStackSize", &VMThreadStackSize, "Non-Java Thread Stack Size (in Kbytes)", "{pd product}", DEFAULT },
 { "intx", "CompilerThreadStackSize", &CompilerThreadStackSize, "Compiler Thread Stack Size (in Kbytes)", "{pd product}", DEFAULT },
 { "uintx", "JVMInvokeMethodSlack", &JVMInvokeMethodSlack, "Stack space (bytes) required for JVM_InvokeMethod to complete", "{pd}", DEFAULT },
 { "uintx", "ThreadSafetyMargin", &ThreadSafetyMargin, "Thread safety margin is used on fixed-stack LinuxThreads (on " "Linux/x86 only) to prevent heap-stack collision. Set to 0 to " "disable this feature", "{product}", DEFAULT },
 { "uintx", "CodeCacheSegmentSize", &CodeCacheSegmentSize, "Code cache segment size (in bytes) - smallest unit of " "allocation", "", DEFAULT },
 { "intx", "CodeEntryAlignment", &CodeEntryAlignment, "Code entry alignment for generated code (in bytes)", "{pd}", DEFAULT },
 { "intx", "OptoLoopAlignment", &OptoLoopAlignment, "Align inner loops to zero relative to this modulus", "{pd product}", DEFAULT },
 { "uintx", "InitialCodeCacheSize", &InitialCodeCacheSize, "Initial code cache size (in bytes)", "{pd product}", DEFAULT },
 { "uintx", "ReservedCodeCacheSize", &ReservedCodeCacheSize, "Reserved code cache size (in bytes) - maximum code cache size", "{pd product}", DEFAULT },
 { "uintx", "CodeCacheMinimumFreeSpace", &CodeCacheMinimumFreeSpace, "When less than X space left, we stop compiling.", "{product}", DEFAULT },
 { "uintx", "CodeCacheExpansionSize", &CodeCacheExpansionSize, "Code cache expansion size (in bytes)", "{pd product}", DEFAULT },
 { "uintx", "CodeCacheMinBlockLength", &CodeCacheMinBlockLength, "Minimum number of segments in a code cache block.", "{pd}", DEFAULT },
 { "bool", "ExitOnFullCodeCache", &ExitOnFullCodeCache, "Exit the VM if we fill the code cache.", "{notproduct}", DEFAULT },
 { "bool", "UseCodeCacheFlushing", &UseCodeCacheFlushing, "Attempt to clean the code cache before shutting off compiler", "{product}", DEFAULT },
 { "intx", "MinCodeCacheFlushingInterval", &MinCodeCacheFlushingInterval, "Min number of seconds between code cache cleaning sessions", "{product}", DEFAULT },
 { "uintx", "CodeCacheFlushingMinimumFreeSpace", &CodeCacheFlushingMinimumFreeSpace, "When less than X space left, start code cache cleaning", "{product}", DEFAULT },
 { "intx", "BinarySwitchThreshold", &BinarySwitchThreshold, "Minimal number of lookupswitch entries for rewriting to binary " "switch", "", DEFAULT },
 { "intx", "StopInterpreterAt", &StopInterpreterAt, "Stops interpreter execution at specified bytecode number", "", DEFAULT },
 { "intx", "TraceBytecodesAt", &TraceBytecodesAt, "Traces bytecodes starting with specified bytecode number", "", DEFAULT },
 { "intx", "CIStart", &CIStart, "the id of the first compilation to permit", "", DEFAULT },
 { "intx", "CIStop", &CIStop, "the id of the last compilation to permit", "", DEFAULT },
 { "intx", "CIStartOSR", &CIStartOSR, "the id of the first osr compilation to permit " "(CICountOSR must be on)", "", DEFAULT },
 { "intx", "CIStopOSR", &CIStopOSR, "the id of the last osr compilation to permit " "(CICountOSR must be on)", "", DEFAULT },
 { "intx", "CIBreakAtOSR", &CIBreakAtOSR, "id of osr compilation to break at", "", DEFAULT },
 { "intx", "CIBreakAt", &CIBreakAt, "id of compilation to break at", "", DEFAULT },
 { "ccstrlist", "CompileOnly", &CompileOnly, "List of methods (pkg/class.name) to restrict compilation to", "{product}", DEFAULT },
 { "ccstr", "CompileCommandFile", &CompileCommandFile, "Read compiler commands from this file [.hotspot_compiler]", "{product}", DEFAULT },
 { "ccstrlist", "CompileCommand", &CompileCommand, "Prepend to .hotspot_compiler; e.g. log,java/lang/String.<init>", "{product}", DEFAULT },
 { "bool", "CICompilerCountPerCPU", &CICompilerCountPerCPU, "1 compiler thread for log(N CPUs)", "{product}", DEFAULT },
 { "intx", "CIFireOOMAt", &CIFireOOMAt, "Fire OutOfMemoryErrors throughout CI for testing the compiler " "(non-negative value throws OOM after this many CI accesses " "in each compile)", "", DEFAULT },
 { "bool", "CIObjectFactoryVerify", &CIObjectFactoryVerify, "enable potentially expensive verification in ciObjectFactory", "{notproduct}", DEFAULT },
 { "bool", "UseThreadPriorities", &UseThreadPriorities, "Use native thread priorities", "{pd product}", DEFAULT },
 { "intx", "ThreadPriorityPolicy", &ThreadPriorityPolicy, "0 : Normal.                                                     " "    VM chooses priorities that are appropriate for normal       " "    applications. On Solaris NORM_PRIORITY and above are mapped " "    to normal native priority. Java priorities below NORM_PRIORITY" "    map to lower native priority values. On Windows applications" "    are allowed to use higher native priorities. However, with  " "    ThreadPriorityPolicy=0, VM will not use the highest possible" "    native priority, THREAD_PRIORITY_TIME_CRITICAL, as it may   " "    interfere with system threads. On Linux thread priorities   " "    are ignored because the OS does not support static priority " "    in SCHED_OTHER scheduling class which is the only choice for" "    non-root, non-realtime applications.                        " "1 : Aggressive.                                                 " "    Java thread priorities map over to the entire range of      " "    native thread priorities. Higher Java thread priorities map " "    to higher native thread priorities. This policy should be   " "    used with care, as sometimes it can cause performance       " "    degradation in the application and/or the entire system. On " "    Linux this policy requires root privilege.", "{product}", DEFAULT },
 { "bool", "ThreadPriorityVerbose", &ThreadPriorityVerbose, "Print priority changes", "{product}", DEFAULT },
 { "intx", "DefaultThreadPriority", &DefaultThreadPriority, "The native priority at which threads run if not elsewhere " "specified (-1 means no change)", "{product}", DEFAULT },
 { "intx", "CompilerThreadPriority", &CompilerThreadPriority, "The native priority at which compiler threads should run " "(-1 means no change)", "{product}", DEFAULT },
 { "intx", "VMThreadPriority", &VMThreadPriority, "The native priority at which the VM thread should run " "(-1 means no change)", "{product}", DEFAULT },
 { "bool", "CompilerThreadHintNoPreempt", &CompilerThreadHintNoPreempt, "(Solaris only) Give compiler threads an extra quanta", "{product}", DEFAULT },
 { "bool", "VMThreadHintNoPreempt", &VMThreadHintNoPreempt, "(Solaris only) Give VM thread an extra quanta", "{product}", DEFAULT },
 { "intx", "JavaPriority1_To_OSPriority", &JavaPriority1_To_OSPriority, "Map Java priorities to OS priorities", "{product}", DEFAULT },
 { "intx", "JavaPriority2_To_OSPriority", &JavaPriority2_To_OSPriority, "Map Java priorities to OS priorities", "{product}", DEFAULT },
 { "intx", "JavaPriority3_To_OSPriority", &JavaPriority3_To_OSPriority, "Map Java priorities to OS priorities", "{product}", DEFAULT },
 { "intx", "JavaPriority4_To_OSPriority", &JavaPriority4_To_OSPriority, "Map Java priorities to OS priorities", "{product}", DEFAULT },
 { "intx", "JavaPriority5_To_OSPriority", &JavaPriority5_To_OSPriority, "Map Java priorities to OS priorities", "{product}", DEFAULT },
 { "intx", "JavaPriority6_To_OSPriority", &JavaPriority6_To_OSPriority, "Map Java priorities to OS priorities", "{product}", DEFAULT },
 { "intx", "JavaPriority7_To_OSPriority", &JavaPriority7_To_OSPriority, "Map Java priorities to OS priorities", "{product}", DEFAULT },
 { "intx", "JavaPriority8_To_OSPriority", &JavaPriority8_To_OSPriority, "Map Java priorities to OS priorities", "{product}", DEFAULT },
 { "intx", "JavaPriority9_To_OSPriority", &JavaPriority9_To_OSPriority, "Map Java priorities to OS priorities", "{product}", DEFAULT },
 { "intx", "JavaPriority10_To_OSPriority", &JavaPriority10_To_OSPriority, "Map Java priorities to OS priorities", "{product}", DEFAULT },
 { "bool", "UseCriticalJavaThreadPriority", &UseCriticalJavaThreadPriority, "Java thread priority 10 maps to critical scheduling priority", "{experimental}", DEFAULT },
 { "bool", "UseCriticalCompilerThreadPriority", &UseCriticalCompilerThreadPriority, "Compiler thread(s) run at critical scheduling priority", "{experimental}", DEFAULT },
 { "bool", "UseCriticalCMSThreadPriority", &UseCriticalCMSThreadPriority, "ConcurrentMarkSweep thread runs at critical scheduling priority", "{experimental}", DEFAULT },
 { "intx", "CompileTheWorldStartAt", &CompileTheWorldStartAt, "First class to consider when using +CompileTheWorld", "{notproduct}", DEFAULT },
 { "intx", "CompileTheWorldStopAt", &CompileTheWorldStopAt, "Last class to consider when using +CompileTheWorld", "{notproduct}", DEFAULT },
 { "intx", "NewCodeParameter", &NewCodeParameter, "Testing Only: Create a dedicated integer parameter before " "putback", "", DEFAULT },
 { "intx", "MinOopMapAllocation", &MinOopMapAllocation, "Minimum number of OopMap entries in an OopMapSet", "", DEFAULT },
 { "intx", "LongCompileThreshold", &LongCompileThreshold, "Used with +TraceLongCompiles", "", DEFAULT },
 { "intx", "StarvationMonitorInterval", &StarvationMonitorInterval, "Pause between each check in ms", "{product}", DEFAULT },
 { "intx", "CompileThreshold", &CompileThreshold, "number of interpreted method invocations before (re-)compiling", "{pd product}", DEFAULT },
 { "intx", "BackEdgeThreshold", &BackEdgeThreshold, "Interpreter Back edge threshold at which an OSR compilation is invoked", "{pd product}", DEFAULT },
 { "intx", "Tier0InvokeNotifyFreqLog", &Tier0InvokeNotifyFreqLog, "Interpreter (tier 0) invocation notification frequency.", "{product}", DEFAULT },
 { "intx", "Tier2InvokeNotifyFreqLog", &Tier2InvokeNotifyFreqLog, "C1 without MDO (tier 2) invocation notification frequency.", "{product}", DEFAULT },
 { "intx", "Tier3InvokeNotifyFreqLog", &Tier3InvokeNotifyFreqLog, "C1 with MDO profiling (tier 3) invocation notification " "frequency.", "{product}", DEFAULT },
 { "intx", "Tier23InlineeNotifyFreqLog", &Tier23InlineeNotifyFreqLog, "Inlinee invocation (tiers 2 and 3) notification frequency", "{product}", DEFAULT },
 { "intx", "Tier0BackedgeNotifyFreqLog", &Tier0BackedgeNotifyFreqLog, "Interpreter (tier 0) invocation notification frequency.", "{product}", DEFAULT },
 { "intx", "Tier2BackedgeNotifyFreqLog", &Tier2BackedgeNotifyFreqLog, "C1 without MDO (tier 2) invocation notification frequency.", "{product}", DEFAULT },
 { "intx", "Tier3BackedgeNotifyFreqLog", &Tier3BackedgeNotifyFreqLog, "C1 with MDO profiling (tier 3) invocation notification " "frequency.", "{product}", DEFAULT },
 { "intx", "Tier2CompileThreshold", &Tier2CompileThreshold, "threshold at which tier 2 compilation is invoked", "{product}", DEFAULT },
 { "intx", "Tier2BackEdgeThreshold", &Tier2BackEdgeThreshold, "Back edge threshold at which tier 2 compilation is invoked", "{product}", DEFAULT },
 { "intx", "Tier3InvocationThreshold", &Tier3InvocationThreshold, "Compile if number of method invocations crosses this " "threshold", "{product}", DEFAULT },
 { "intx", "Tier3MinInvocationThreshold", &Tier3MinInvocationThreshold, "Minimum invocation to compile at tier 3", "{product}", DEFAULT },
 { "intx", "Tier3CompileThreshold", &Tier3CompileThreshold, "Threshold at which tier 3 compilation is invoked (invocation " "minimum must be satisfied.", "{product}", DEFAULT },
 { "intx", "Tier3BackEdgeThreshold", &Tier3BackEdgeThreshold, "Back edge threshold at which tier 3 OSR compilation is invoked", "{product}", DEFAULT },
 { "intx", "Tier4InvocationThreshold", &Tier4InvocationThreshold, "Compile if number of method invocations crosses this " "threshold", "{product}", DEFAULT },
 { "intx", "Tier4MinInvocationThreshold", &Tier4MinInvocationThreshold, "Minimum invocation to compile at tier 4", "{product}", DEFAULT },
 { "intx", "Tier4CompileThreshold", &Tier4CompileThreshold, "Threshold at which tier 4 compilation is invoked (invocation " "minimum must be satisfied.", "{product}", DEFAULT },
 { "intx", "Tier4BackEdgeThreshold", &Tier4BackEdgeThreshold, "Back edge threshold at which tier 4 OSR compilation is invoked", "{product}", DEFAULT },
 { "intx", "Tier3DelayOn", &Tier3DelayOn, "If C2 queue size grows over this amount per compiler thread " "stop compiling at tier 3 and start compiling at tier 2", "{product}", DEFAULT },
 { "intx", "Tier3DelayOff", &Tier3DelayOff, "If C2 queue size is less than this amount per compiler thread " "allow methods compiled at tier 2 transition to tier 3", "{product}", DEFAULT },
 { "intx", "Tier3LoadFeedback", &Tier3LoadFeedback, "Tier 3 thresholds will increase twofold when C1 queue size " "reaches this amount per compiler thread", "{product}", DEFAULT },
 { "intx", "Tier4LoadFeedback", &Tier4LoadFeedback, "Tier 4 thresholds will increase twofold when C2 queue size " "reaches this amount per compiler thread", "{product}", DEFAULT },
 { "intx", "TieredCompileTaskTimeout", &TieredCompileTaskTimeout, "Kill compile task if method was not used within " "given timeout in milliseconds", "{product}", DEFAULT },
 { "intx", "TieredStopAtLevel", &TieredStopAtLevel, "Stop at given compilation level", "{product}", DEFAULT },
 { "intx", "Tier0ProfilingStartPercentage", &Tier0ProfilingStartPercentage, "Start profiling in interpreter if the counters exceed tier 3" "thresholds by the specified percentage", "{product}", DEFAULT },
 { "intx", "TieredRateUpdateMinTime", &TieredRateUpdateMinTime, "Minimum rate sampling interval (in milliseconds)", "{product}", DEFAULT },
 { "intx", "TieredRateUpdateMaxTime", &TieredRateUpdateMaxTime, "Maximum rate sampling interval (in milliseconds)", "{product}", DEFAULT },
 { "bool", "TieredCompilation", &TieredCompilation, "Enable tiered compilation", "{pd product}", DEFAULT },
 { "bool", "PrintTieredEvents", &PrintTieredEvents, "Print tiered events notifications", "{product}", DEFAULT },
 { "intx", "OnStackReplacePercentage", &OnStackReplacePercentage, "NON_TIERED number of method invocations/branches (expressed as %" "of CompileThreshold) before (re-)compiling OSR code", "{pd product}", DEFAULT },
 { "intx", "InterpreterProfilePercentage", &InterpreterProfilePercentage, "NON_TIERED number of method invocations/branches (expressed as %" "of CompileThreshold) before profiling in the interpreter", "{product}", DEFAULT },
 { "intx", "MaxRecompilationSearchLength", &MaxRecompilationSearchLength, "max. # frames to inspect searching for recompilee", "", DEFAULT },
 { "intx", "MaxInterpretedSearchLength", &MaxInterpretedSearchLength, "max. # interp. frames to skip when searching for recompilee", "", DEFAULT },
 { "intx", "DesiredMethodLimit", &DesiredMethodLimit, "desired max. method size (in bytecodes) after inlining", "", DEFAULT },
 { "intx", "HugeMethodLimit", &HugeMethodLimit, "don't compile methods larger than this if " "+DontCompileHugeMethods", "", DEFAULT },
 { "bool", "UseNewReflection", &UseNewReflection, "Temporary flag for transition to reflection based on dynamic " "bytecode generation in 1.4; can no longer be turned off in 1.4 " "JDK, and is unneeded in 1.3 JDK, but marks most places VM " "changes were needed", "", DEFAULT },
 { "bool", "VerifyReflectionBytecodes", &VerifyReflectionBytecodes, "Force verification of 1.4 reflection bytecodes. Does not work " "in situations like that described in 4486457 or for " "constructors generated for serialization, so can not be enabled " "in product.", "", DEFAULT },
 { "bool", "ReflectionWrapResolutionErrors", &ReflectionWrapResolutionErrors, "Temporary flag for transition to AbstractMethodError wrapped " "in InvocationTargetException. See 6531596", "{product}", DEFAULT },
 { "intx", "FastSuperclassLimit", &FastSuperclassLimit, "Depth of hardwired instanceof accelerator array", "", DEFAULT },
 { "uintx", "MaxDirectMemorySize", &MaxDirectMemorySize, "Maximum total size of NIO direct-buffer allocations", "{product}", DEFAULT },
 { "bool", "UseNewCode", &UseNewCode, "Testing Only: Use the new version while testing", "{diagnostic}", DEFAULT },
 { "bool", "UseNewCode2", &UseNewCode2, "Testing Only: Use the new version while testing", "{diagnostic}", DEFAULT },
 { "bool", "UseNewCode3", &UseNewCode3, "Testing Only: Use the new version while testing", "{diagnostic}", DEFAULT },
 { "bool", "UsePerfData", &UsePerfData, "Flag to disable jvmstat instrumentation for performance testing" "and problem isolation purposes.", "{product}", DEFAULT },
 { "bool", "PerfDataSaveToFile", &PerfDataSaveToFile, "Save PerfData memory to hsperfdata_<pid> file on exit", "{product}", DEFAULT },
 { "ccstr", "PerfDataSaveFile", &PerfDataSaveFile, "Save PerfData memory to the specified absolute pathname," "%p in the file name if present will be replaced by pid", "{product}", DEFAULT },
 { "intx", "PerfDataSamplingInterval", &PerfDataSamplingInterval, "Data sampling interval in milliseconds", "{product}", DEFAULT },
 { "bool", "PerfTraceDataCreation", &PerfTraceDataCreation, "Trace creation of Performance Data Entries", "", DEFAULT },
 { "bool", "PerfTraceMemOps", &PerfTraceMemOps, "Trace PerfMemory create/attach/detach calls", "", DEFAULT },
 { "bool", "PerfDisableSharedMem", &PerfDisableSharedMem, "Store performance data in standard memory", "{product}", DEFAULT },
 { "intx", "PerfDataMemorySize", &PerfDataMemorySize, "Size of performance data memory region. Will be rounded " "up to a multiple of the native os page size.", "{product}", DEFAULT },
 { "intx", "PerfMaxStringConstLength", &PerfMaxStringConstLength, "Maximum PerfStringConstant string length before truncation", "{product}", DEFAULT },
 { "bool", "PerfAllowAtExitRegistration", &PerfAllowAtExitRegistration, "Allow registration of atexit() methods", "{product}", DEFAULT },
 { "bool", "PerfBypassFileSystemCheck", &PerfBypassFileSystemCheck, "Bypass Win32 file system criteria checks (Windows Only)", "{product}", DEFAULT },
 { "intx", "UnguardOnExecutionViolation", &UnguardOnExecutionViolation, "Unguard page and retry on no-execute fault (Win32 only)" "0=off, 1=conservative, 2=aggressive", "{product}", DEFAULT },
 { "bool", "ManagementServer", &ManagementServer, "Create JMX Management Server", "{product}", DEFAULT },
 { "bool", "DisableAttachMechanism", &DisableAttachMechanism, "Disable mechanism that allows tools to attach to this VM", "{product}", DEFAULT },
 { "bool", "StartAttachListener", &StartAttachListener, "Always start Attach Listener at VM startup", "{product}", DEFAULT },
 { "bool", "PrintConcurrentLocks", &PrintConcurrentLocks, "Print java.util.concurrent locks in thread dump", "{manageable}", DEFAULT },
 { "bool", "TransmitErrorReport", &TransmitErrorReport, "Enable error report transmission on erroneous termination", "{product}", DEFAULT },
 { "ccstr", "ErrorReportServer", &ErrorReportServer, "Override built-in error report server address", "{product}", DEFAULT },
 { "bool", "UseSharedSpaces", &UseSharedSpaces, "Use shared spaces in the permanent generation", "{product}", DEFAULT },
 { "bool", "RequireSharedSpaces", &RequireSharedSpaces, "Require shared spaces in the permanent generation", "{product}", DEFAULT },
 { "bool", "DumpSharedSpaces", &DumpSharedSpaces, "Special mode: JVM reads a class list, loads classes, builds " "shared spaces, and dumps the shared spaces to a file to be " "used in future JVM runs.", "{product}", DEFAULT },
 { "bool", "PrintSharedSpaces", &PrintSharedSpaces, "Print usage of shared spaces", "{product}", DEFAULT },
 { "uintx", "SharedDummyBlockSize", &SharedDummyBlockSize, "Size of dummy block used to shift heap addresses (in bytes)", "{product}", DEFAULT },
 { "uintx", "SharedReadWriteSize", &SharedReadWriteSize, "Size of read-write space in permanent generation (in bytes)", "{product}", DEFAULT },
 { "uintx", "SharedReadOnlySize", &SharedReadOnlySize, "Size of read-only space in permanent generation (in bytes)", "{product}", DEFAULT },
 { "uintx", "SharedMiscDataSize", &SharedMiscDataSize, "Size of the shared data area adjacent to the heap (in bytes)", "{product}", DEFAULT },
 { "uintx", "SharedMiscCodeSize", &SharedMiscCodeSize, "Size of the shared code area adjacent to the heap (in bytes)", "{product}", DEFAULT },
 { "bool", "SharedOptimizeColdStart", &SharedOptimizeColdStart, "At dump time, order shared objects to achieve better " "cold startup time.", "{diagnostic}", DEFAULT },
 { "intx", "SharedOptimizeColdStartPolicy", &SharedOptimizeColdStartPolicy, "Reordering policy for SharedOptimizeColdStart " "0=favor classload-time locality, 1=balanced, " "2=favor runtime locality", "", DEFAULT },
 { "bool", "SharedSkipVerify", &SharedSkipVerify, "Skip assert() and verify() which page-in unwanted shared " "objects. ", "{diagnostic}", DEFAULT },
 { "bool", "EnableInvokeDynamic", &EnableInvokeDynamic, "support JSR 292 (method handles, invokedynamic, " "anonymous classes", "{diagnostic}", DEFAULT },
 { "bool", "PrintMethodHandleStubs", &PrintMethodHandleStubs, "Print generated stub code for method handles", "{diagnostic}", DEFAULT },
 { "bool", "TraceMethodHandles", &TraceMethodHandles, "trace internal method handle operations", "", DEFAULT },
 { "bool", "VerifyMethodHandles", &VerifyMethodHandles, "perform extra checks when constructing method handles", "{diagnostic}", DEFAULT },
 { "bool", "ShowHiddenFrames", &ShowHiddenFrames, "show method handle implementation frames (usually hidden)", "{diagnostic}", DEFAULT },
 { "bool", "TrustFinalNonStaticFields", &TrustFinalNonStaticFields, "trust final non-static declarations for constant folding", "{experimental}", DEFAULT },
 { "bool", "TraceInvokeDynamic", &TraceInvokeDynamic, "trace internal invoke dynamic operations", "", DEFAULT },
 { "bool", "PauseAtStartup", &PauseAtStartup, "Causes the VM to pause at startup time and wait for the pause " "file to be removed (default: ./vm.paused.<pid>)", "{diagnostic}", DEFAULT },
 { "ccstr", "PauseAtStartupFile", &PauseAtStartupFile, "The file to create and for whose removal to await when pausing " "at startup. (default: ./vm.paused.<pid>)", "{diagnostic}", DEFAULT },
 { "bool", "PauseAtExit", &PauseAtExit, "Pause and wait for keypress on exit if a debugger is attached", "{diagnostic}", DEFAULT },
 { "bool", "ExtendedDTraceProbes", &ExtendedDTraceProbes, "Enable performance-impacting dtrace probes", "{product}", DEFAULT },
 { "bool", "DTraceMethodProbes", &DTraceMethodProbes, "Enable dtrace probes for method-entry and method-exit", "{product}", DEFAULT },
 { "bool", "DTraceAllocProbes", &DTraceAllocProbes, "Enable dtrace probes for object allocation", "{product}", DEFAULT },
 { "bool", "DTraceMonitorProbes", &DTraceMonitorProbes, "Enable dtrace probes for monitor events", "{product}", DEFAULT },
 { "bool", "RelaxAccessControlCheck", &RelaxAccessControlCheck, "Relax the access control checks in the verifier", "{product}", DEFAULT },
 { "bool", "PrintDTraceDOF", &PrintDTraceDOF, "Print the DTrace DOF passed to the system for JSDT probes", "{diagnostic}", DEFAULT },
 { "uintx", "StringTableSize", &StringTableSize, "Number of buckets in the interned String table", "{product}", DEFAULT },
 { "bool", "UseVMInterruptibleIO", &UseVMInterruptibleIO, "(Unstable, Solaris-specific) Thread interrupt before or with " "EINTR for I/O operations results in OS_INTRPT. The default value" " of this flag is true for JDK 6 and earlier", "{product}", DEFAULT },
 { "bool", "AllowNonVirtualCalls", &AllowNonVirtualCalls, "Obey the ACC_SUPER flag and allow invokenonvirtual calls", "{product}", DEFAULT },
 { "bool", "WhiteBoxAPI", &WhiteBoxAPI, "Enable internal testing APIs", "{diagnostic}", DEFAULT },
 { "bool", "PrintGCCause", &PrintGCCause, "Include GC cause in GC logging", "{product}", DEFAULT },
 { "uintx", "ArrayAllocatorMallocLimit", &ArrayAllocatorMallocLimit, "Allocation less than this value will be allocated " "using malloc. Larger allocations will use mmap.", "{experimental}", DEFAULT },
 { "bool", "EnableTracing", &EnableTracing, "Enable event-based tracing", "{product}", DEFAULT },
 { "bool", "UseLockedTracing", &UseLockedTracing, "Use locked-tracing when doing event-based tracing", "{product}", DEFAULT },
 { "bool", "UseUTCFileTimestamp", &UseUTCFileTimestamp, "Adjust the timestamp returned from stat() to be UTC", "{product}", DEFAULT },
 { "uintx", "G1ConfidencePercent", &G1ConfidencePercent, "Confidence level for MMU/pause predictions", "{product}", DEFAULT },
 { "intx", "G1MarkingOverheadPercent", &G1MarkingOverheadPercent, "Overhead of concurrent marking", "", DEFAULT },
 { "intx", "G1MarkingVerboseLevel", &G1MarkingVerboseLevel, "Level (0-4) of verboseness of the marking code", "", DEFAULT },
 { "bool", "G1PrintReachableAtInitialMark", &G1PrintReachableAtInitialMark, "Reachable object dump at the initial mark pause", "", DEFAULT },
 { "bool", "G1VerifyDuringGCPrintReachable", &G1VerifyDuringGCPrintReachable, "If conc mark verification fails, dump reachable objects", "", DEFAULT },
 { "ccstr", "G1PrintReachableBaseFile", &G1PrintReachableBaseFile, "The base file name for the reachable object dumps", "", DEFAULT },
 { "bool", "G1TraceMarkStackOverflow", &G1TraceMarkStackOverflow, "If true, extra debugging code for CM restart for ovflw.", "", DEFAULT },
 { "bool", "G1TraceHeapRegionRememberedSet", &G1TraceHeapRegionRememberedSet, "Enables heap region remembered set debug logs", "", DEFAULT },
 { "bool", "G1SummarizeConcMark", &G1SummarizeConcMark, "Summarize concurrent mark info", "{diagnostic}", DEFAULT },
 { "bool", "G1SummarizeRSetStats", &G1SummarizeRSetStats, "Summarize remembered set processing info", "{diagnostic}", DEFAULT },
 { "intx", "G1SummarizeRSetStatsPeriod", &G1SummarizeRSetStatsPeriod, "The period (in number of GCs) at which we will generate " "update buffer processing info " "(0 means do not periodically generate this info); " "it also requires -XX:+G1SummarizeRSetStats", "{diagnostic}", DEFAULT },
 { "bool", "G1TraceConcRefinement", &G1TraceConcRefinement, "Trace G1 concurrent refinement", "{diagnostic}", DEFAULT },
 { "double", "G1ConcMarkStepDurationMillis", &G1ConcMarkStepDurationMillis, "Target duration of individual concurrent marking steps " "in milliseconds.", "{product}", DEFAULT },
 { "intx", "G1RefProcDrainInterval", &G1RefProcDrainInterval, "The number of discovered reference objects to process before " "draining concurrent marking work queues.", "{product}", DEFAULT },
 { "bool", "G1UseConcMarkReferenceProcessing", &G1UseConcMarkReferenceProcessing, "If true, enable reference discovery during concurrent " "marking and reference processing at the end of remark.", "{experimental}", DEFAULT },
 { "intx", "G1SATBBufferSize", &G1SATBBufferSize, "Number of entries in an SATB log buffer.", "{product}", DEFAULT },
 { "intx", "G1SATBProcessCompletedThreshold", &G1SATBProcessCompletedThreshold, "Number of completed buffers that triggers log processing.", "", DEFAULT },
 { "uintx", "G1SATBBufferEnqueueingThresholdPercent", &G1SATBBufferEnqueueingThresholdPercent, "Before enqueueing them, each mutator thread tries to do some " "filtering on the SATB buffers it generates. If post-filtering " "the percentage of retained entries is over this threshold " "the buffer will be enqueued for processing. A value of 0 " "specifies that mutator threads should not do such filtering.", "{product}", DEFAULT },
 { "intx", "G1ExtraRegionSurvRate", &G1ExtraRegionSurvRate, "If the young survival rate is S, and there's room left in " "to-space, we will allow regions whose survival rate is up to " "S + (1 - S)*X, where X is this parameter (as a fraction.)", "", DEFAULT },
 { "intx", "G1InitYoungSurvRatio", &G1InitYoungSurvRatio, "Expected Survival Rate for newly allocated bytes", "", DEFAULT },
 { "bool", "G1SATBPrintStubs", &G1SATBPrintStubs, "If true, print generated stubs for the SATB barrier", "", DEFAULT },
 { "intx", "G1ExpandByPercentOfAvailable", &G1ExpandByPercentOfAvailable, "When expanding, % of uncommitted space to claim.", "{experimental}", DEFAULT },
 { "bool", "G1RSBarrierRegionFilter", &G1RSBarrierRegionFilter, "If true, generate region filtering code in RS barrier", "", DEFAULT },
 { "bool", "G1RSBarrierNullFilter", &G1RSBarrierNullFilter, "If true, generate null-pointer filtering code in RS barrier", "", DEFAULT },
 { "bool", "G1DeferredRSUpdate", &G1DeferredRSUpdate, "If true, use deferred RS updates", "", DEFAULT },
 { "bool", "G1RSLogCheckCardTable", &G1RSLogCheckCardTable, "If true, verify that no dirty cards remain after RS log " "processing.", "", DEFAULT },
 { "bool", "G1RSCountHisto", &G1RSCountHisto, "If true, print a histogram of RS occupancies after each pause", "", DEFAULT },
 { "bool", "G1PrintRegionLivenessInfo", &G1PrintRegionLivenessInfo, "Prints the liveness information for all regions in the heap " "at the end of a marking cycle.", "{diagnostic}", DEFAULT },
 { "intx", "G1UpdateBufferSize", &G1UpdateBufferSize, "Size of an update buffer", "{product}", DEFAULT },
 { "intx", "G1ConcRefinementYellowZone", &G1ConcRefinementYellowZone, "Number of enqueued update buffers that will " "trigger concurrent processing. Will be selected ergonomically " "by default.", "{product}", DEFAULT },
 { "intx", "G1ConcRefinementRedZone", &G1ConcRefinementRedZone, "Maximum number of enqueued update buffers before mutator " "threads start processing new ones instead of enqueueing them. " "Will be selected ergonomically by default. Zero will disable " "concurrent processing.", "{product}", DEFAULT },
 { "intx", "G1ConcRefinementGreenZone", &G1ConcRefinementGreenZone, "The number of update buffers that are left in the queue by the " "concurrent processing threads. Will be selected ergonomically " "by default.", "{product}", DEFAULT },
 { "intx", "G1ConcRefinementServiceIntervalMillis", &G1ConcRefinementServiceIntervalMillis, "The last concurrent refinement thread wakes up every " "specified number of milliseconds to do miscellaneous work.", "{product}", DEFAULT },
 { "intx", "G1ConcRefinementThresholdStep", &G1ConcRefinementThresholdStep, "Each time the rset update queue increases by this amount " "activate the next refinement thread if available. " "Will be selected ergonomically by default.", "{product}", DEFAULT },
 { "intx", "G1RSetUpdatingPauseTimePercent", &G1RSetUpdatingPauseTimePercent, "A target percentage of time that is allowed to be spend on " "process RS update buffers during the collection pause.", "{product}", DEFAULT },
 { "bool", "G1UseAdaptiveConcRefinement", &G1UseAdaptiveConcRefinement, "Select green, yellow and red zones adaptively to meet the " "the pause requirements.", "{product}", DEFAULT },
 { "uintx", "G1ConcRSLogCacheSize", &G1ConcRSLogCacheSize, "Log base 2 of the length of conc RS hot-card cache.", "{product}", DEFAULT },
 { "uintx", "G1ConcRSHotCardLimit", &G1ConcRSHotCardLimit, "The threshold that defines (>=) a hot card.", "{product}", DEFAULT },
 { "bool", "G1PrintOopAppls", &G1PrintOopAppls, "When true, print applications of closures to external locs.", "", DEFAULT },
 { "intx", "G1RSetRegionEntriesBase", &G1RSetRegionEntriesBase, "Max number of regions in a fine-grain table per MB.", "", DEFAULT },
 { "intx", "G1RSetRegionEntries", &G1RSetRegionEntries, "Max number of regions for which we keep bitmaps." "Will be set ergonomically by default", "{product}", DEFAULT },
 { "intx", "G1RSetSparseRegionEntriesBase", &G1RSetSparseRegionEntriesBase, "Max number of entries per region in a sparse table " "per MB.", "", DEFAULT },
 { "intx", "G1RSetSparseRegionEntries", &G1RSetSparseRegionEntries, "Max number of entries per region in a sparse table." "Will be set ergonomically by default.", "{product}", DEFAULT },
 { "bool", "G1RecordHRRSOops", &G1RecordHRRSOops, "When true, record recent calls to rem set operations.", "", DEFAULT },
 { "bool", "G1RecordHRRSEvents", &G1RecordHRRSEvents, "When true, record recent calls to rem set operations.", "", DEFAULT },
 { "intx", "G1MaxVerifyFailures", &G1MaxVerifyFailures, "The maximum number of verification failrues to print.  " "-1 means print all.", "", DEFAULT },
 { "bool", "G1ScrubRemSets", &G1ScrubRemSets, "When true, do RS scrubbing after cleanup.", "", DEFAULT },
 { "bool", "G1RSScrubVerbose", &G1RSScrubVerbose, "When true, do RS scrubbing with verbose output.", "", DEFAULT },
 { "bool", "G1YoungSurvRateVerbose", &G1YoungSurvRateVerbose, "print out the survival rate of young regions according to age.", "", DEFAULT },
 { "intx", "G1YoungSurvRateNumRegionsSummary", &G1YoungSurvRateNumRegionsSummary, "the number of regions for which we'll print a surv rate " "summary.", "", DEFAULT },
 { "uintx", "G1ReservePercent", &G1ReservePercent, "It determines the minimum reserve we should have in the heap " "to minimize the probability of promotion failure.", "{product}", DEFAULT },
 { "bool", "G1PrintHeapRegions", &G1PrintHeapRegions, "If set G1 will print information on which regions are being " "allocated and which are reclaimed.", "{diagnostic}", DEFAULT },
 { "bool", "G1HRRSUseSparseTable", &G1HRRSUseSparseTable, "When true, use sparse table to save space.", "", DEFAULT },
 { "bool", "G1HRRSFlushLogBuffersOnVerify", &G1HRRSFlushLogBuffersOnVerify, "Forces flushing of log buffers before verification.", "", DEFAULT },
 { "bool", "G1FailOnFPError", &G1FailOnFPError, "When set, G1 will fail when it encounters an FP 'error', " "so as to allow debugging", "", DEFAULT },
 { "uintx", "G1HeapRegionSize", &G1HeapRegionSize, "Size of the G1 regions.", "{product}", DEFAULT },
 { "bool", "G1UseParallelRSetUpdating", &G1UseParallelRSetUpdating, "Enables the parallelization of remembered set updating " "during evacuation pauses", "{experimental}", DEFAULT },
 { "bool", "G1UseParallelRSetScanning", &G1UseParallelRSetScanning, "Enables the parallelization of remembered set scanning " "during evacuation pauses", "{experimental}", DEFAULT },
 { "uintx", "G1ConcRefinementThreads", &G1ConcRefinementThreads, "If non-0 is the number of parallel rem set update threads, " "otherwise the value is determined ergonomically.", "{product}", DEFAULT },
 { "bool", "G1VerifyCTCleanup", &G1VerifyCTCleanup, "Verify card table cleanup.", "", DEFAULT },
 { "uintx", "G1RSetScanBlockSize", &G1RSetScanBlockSize, "Size of a work unit of cards claimed by a worker thread" "during RSet scanning.", "{product}", DEFAULT },
 { "uintx", "G1SecondaryFreeListAppendLength", &G1SecondaryFreeListAppendLength, "The number of regions we will add to the secondary free list " "at every append operation", "", DEFAULT },
 { "bool", "G1ConcRegionFreeingVerbose", &G1ConcRegionFreeingVerbose, "Enables verboseness during concurrent region freeing", "", DEFAULT },
 { "bool", "G1StressConcRegionFreeing", &G1StressConcRegionFreeing, "It stresses the concurrent region freeing operation", "", DEFAULT },
 { "uintx", "G1StressConcRegionFreeingDelayMillis", &G1StressConcRegionFreeingDelayMillis, "Artificial delay during concurrent region freeing", "", DEFAULT },
 { "uintx", "G1DummyRegionsPerGC", &G1DummyRegionsPerGC, "The number of dummy regions G1 will allocate at the end of " "each evacuation pause in order to artificially fill up the " "heap and stress the marking implementation.", "", DEFAULT },
 { "bool", "G1ExitOnExpansionFailure", &G1ExitOnExpansionFailure, "Raise a fatal VM exit out of memory failure in the event " " that heap expansion fails due to running out of swap.", "", DEFAULT },
 { "uintx", "G1ConcMarkForceOverflow", &G1ConcMarkForceOverflow, "The number of times we'll force an overflow during " "concurrent marking", "", DEFAULT },
 { "uintx", "G1NewSizePercent", &G1NewSizePercent, "Percentage (0-100) of the heap size to use as default " "minimum young gen size.", "{experimental}", DEFAULT },
 { "uintx", "G1MaxNewSizePercent", &G1MaxNewSizePercent, "Percentage (0-100) of the heap size to use as default " " maximum young gen size.", "{experimental}", DEFAULT },
 { "uintx", "G1MixedGCLiveThresholdPercent", &G1MixedGCLiveThresholdPercent, "Threshold for regions to be considered for inclusion in the " "collection set of mixed GCs. " "Regions with live bytes exceeding this will not be collected.", "{experimental}", DEFAULT },
 { "uintx", "G1HeapWastePercent", &G1HeapWastePercent, "Amount of space, expressed as a percentage of the heap size, " "that G1 is willing not to collect to avoid expensive GCs.", "{product}", DEFAULT },
 { "uintx", "G1MixedGCCountTarget", &G1MixedGCCountTarget, "The target number of mixed GCs after a marking cycle.", "{product}", DEFAULT },
 { "uintx", "G1OldCSetRegionThresholdPercent", &G1OldCSetRegionThresholdPercent, "An upper bound for the number of old CSet regions expressed " "as a percentage of the heap size.", "{experimental}", DEFAULT },
 { "ccstr", "G1LogLevel", &G1LogLevel, "Log level for G1 logging: fine, finer, finest", "{experimental}", DEFAULT },
 { "bool", "G1EvacuationFailureALot", &G1EvacuationFailureALot, "Force use of evacuation failure handling during certain " "evacuation pauses", "{notproduct}", DEFAULT },
 { "uintx", "G1EvacuationFailureALotCount", &G1EvacuationFailureALotCount, "Number of successful evacuations between evacuation failures " "occurring at object copying", "", DEFAULT },
 { "uintx", "G1EvacuationFailureALotInterval", &G1EvacuationFailureALotInterval, "Total collections between forced triggering of evacuation " "failures", "", DEFAULT },
 { "bool", "G1EvacuationFailureALotDuringConcMark", &G1EvacuationFailureALotDuringConcMark, "Force use of evacuation failure handling during evacuation " "pauses when marking is in progress", "", DEFAULT },
 { "bool", "G1EvacuationFailureALotDuringInitialMark", &G1EvacuationFailureALotDuringInitialMark, "Force use of evacuation failure handling during initial mark " "evacuation pauses", "", DEFAULT },
 { "bool", "G1EvacuationFailureALotDuringYoungGC", &G1EvacuationFailureALotDuringYoungGC, "Force use of evacuation failure handling during young " "evacuation pauses", "", DEFAULT },
 { "bool", "G1EvacuationFailureALotDuringMixedGC", &G1EvacuationFailureALotDuringMixedGC, "Force use of evacuation failure handling during mixed " "evacuation pauses", "", DEFAULT },
 { "bool", "PrintC1Statistics", &PrintC1Statistics, "Print Compiler1 statistics", "{C1 notproduct}", DEFAULT },
 { "bool", "PrintInitialBlockList", &PrintInitialBlockList, "Print block list of BlockListBuilder", "{C1 notproduct}", DEFAULT },
 { "bool", "PrintCFG", &PrintCFG, "Print control flow graph after each change", "{C1 notproduct}", DEFAULT },
 { "bool", "PrintCFG0", &PrintCFG0, "Print control flow graph after construction", "{C1 notproduct}", DEFAULT },
 { "bool", "PrintCFG1", &PrintCFG1, "Print control flow graph after optimizations", "{C1 notproduct}", DEFAULT },
 { "bool", "PrintCFG2", &PrintCFG2, "Print control flow graph before code generation", "{C1 notproduct}", DEFAULT },
 { "bool", "PrintIRDuringConstruction", &PrintIRDuringConstruction, "Print IR as it's being constructed (helpful for debugging frontend)", "{C1 notproduct}", DEFAULT },
 { "bool", "PrintPhiFunctions", &PrintPhiFunctions, "Print phi functions when they are created and simplified", "{C1 notproduct}", DEFAULT },
 { "bool", "PrintIR", &PrintIR, "Print full intermediate representation after each change", "{C1 notproduct}", DEFAULT },
 { "bool", "PrintIR0", &PrintIR0, "Print full intermediate representation after construction", "{C1 notproduct}", DEFAULT },
 { "bool", "PrintIR1", &PrintIR1, "Print full intermediate representation after optimizations", "{C1 notproduct}", DEFAULT },
 { "bool", "PrintIR2", &PrintIR2, "Print full intermediate representation before code generation", "{C1 notproduct}", DEFAULT },
 { "bool", "PrintSimpleStubs", &PrintSimpleStubs, "Print SimpleStubs", "{C1 notproduct}", DEFAULT },
 { "bool", "UseC1Optimizations", &UseC1Optimizations, "Turn on C1 optimizations", "{C1}", DEFAULT },
 { "bool", "SelectivePhiFunctions", &SelectivePhiFunctions, "create phi functions at loop headers only when necessary", "{C1}", DEFAULT },
 { "bool", "OptimizeIfOps", &OptimizeIfOps, "Optimize multiple IfOps", "{C1}", DEFAULT },
 { "bool", "DoCEE", &DoCEE, "Do Conditional Expression Elimination to simplify CFG", "{C1}", DEFAULT },
 { "bool", "PrintCEE", &PrintCEE, "Print Conditional Expression Elimination", "{C1}", DEFAULT },
 { "bool", "UseLocalValueNumbering", &UseLocalValueNumbering, "Use Local Value Numbering (embedded in GraphBuilder)", "{C1}", DEFAULT },
 { "bool", "UseGlobalValueNumbering", &UseGlobalValueNumbering, "Use Global Value Numbering (separate phase)", "{C1}", DEFAULT },
 { "bool", "PrintValueNumbering", &PrintValueNumbering, "Print Value Numbering", "{C1}", DEFAULT },
 { "intx", "ValueMapInitialSize", &ValueMapInitialSize, "Initial size of a value map", "{C1 product}", DEFAULT },
 { "intx", "ValueMapMaxLoopSize", &ValueMapMaxLoopSize, "maximum size of a loop optimized by global value numbering", "{C1 product}", DEFAULT },
 { "bool", "EliminateBlocks", &EliminateBlocks, "Eliminate unneccessary basic blocks", "{C1}", DEFAULT },
 { "bool", "PrintBlockElimination", &PrintBlockElimination, "Print basic block elimination", "{C1}", DEFAULT },
 { "bool", "EliminateNullChecks", &EliminateNullChecks, "Eliminate unneccessary null checks", "{C1}", DEFAULT },
 { "bool", "PrintNullCheckElimination", &PrintNullCheckElimination, "Print null check elimination", "{C1}", DEFAULT },
 { "bool", "EliminateFieldAccess", &EliminateFieldAccess, "Optimize field loads and stores", "{C1}", DEFAULT },
 { "bool", "InlineMethodsWithExceptionHandlers", &InlineMethodsWithExceptionHandlers, "Inline methods containing exception handlers " "(NOTE: does not work with current backend)", "{C1}", DEFAULT },
 { "bool", "InlineSynchronizedMethods", &InlineSynchronizedMethods, "Inline synchronized methods", "{C1}", DEFAULT },
 { "bool", "InlineNIOCheckIndex", &InlineNIOCheckIndex, "Intrinsify java.nio.Buffer.checkIndex", "{C1}", DEFAULT },
 { "bool", "CanonicalizeNodes", &CanonicalizeNodes, "Canonicalize graph nodes", "{C1}", DEFAULT },
 { "bool", "PrintCanonicalization", &PrintCanonicalization, "Print graph node canonicalization", "{C1}", DEFAULT },
 { "bool", "UseTableRanges", &UseTableRanges, "Faster versions of lookup table using ranges", "{C1}", DEFAULT },
 { "bool", "RoundFPResults", &RoundFPResults, "Indicates whether rounding is needed for floating point results", "{C1 pd}", DEFAULT },
 { "intx", "NestedInliningSizeRatio", &NestedInliningSizeRatio, "Percentage of prev. allowed inline size in recursive inlining", "{C1}", DEFAULT },
 { "bool", "PrintIRWithLIR", &PrintIRWithLIR, "Print IR instructions with generated LIR", "{C1 notproduct}", DEFAULT },
 { "bool", "PrintLIRWithAssembly", &PrintLIRWithAssembly, "Show LIR instruction with generated assembly", "{C1 notproduct}", DEFAULT },
 { "bool", "CommentedAssembly", &CommentedAssembly, "Show extra info in PrintNMethods output", "{C1}", DEFAULT },
 { "bool", "LIRTracePeephole", &LIRTracePeephole, "Trace peephole optimizer", "{C1}", DEFAULT },
 { "bool", "LIRTraceExecution", &LIRTraceExecution, "add LIR code which logs the execution of blocks", "{C1}", DEFAULT },
 { "bool", "LIRFillDelaySlots", &LIRFillDelaySlots, "fill delays on on SPARC with LIR", "{C1 pd product}", DEFAULT },
 { "bool", "CSEArrayLength", &CSEArrayLength, "Create separate nodes for length in array accesses", "{C1 pd}", DEFAULT },
 { "bool", "TwoOperandLIRForm", &TwoOperandLIRForm, "true if LIR requires src1 and dst to match in binary LIR ops", "{C1 pd}", DEFAULT },
 { "intx", "TraceLinearScanLevel", &TraceLinearScanLevel, "Debug levels for the linear scan allocator", "{C1}", DEFAULT },
 { "bool", "StressLinearScan", &StressLinearScan, "scramble block order used by LinearScan (stress test)", "{C1}", DEFAULT },
 { "bool", "TimeLinearScan", &TimeLinearScan, "detailed timing of LinearScan phases", "{C1 product}", DEFAULT },
 { "bool", "TimeEachLinearScan", &TimeEachLinearScan, "print detailed timing of each LinearScan run", "{C1}", DEFAULT },
 { "bool", "CountLinearScan", &CountLinearScan, "collect statistic counters during LinearScan", "{C1}", DEFAULT },
 { "bool", "C1Breakpoint", &C1Breakpoint, "Sets a breakpoint at entry of each compiled method", "{C1}", DEFAULT },
 { "bool", "ImplicitDiv0Checks", &ImplicitDiv0Checks, "Use implicit division by zero checks", "{C1}", DEFAULT },
 { "bool", "PinAllInstructions", &PinAllInstructions, "All instructions are pinned", "{C1}", DEFAULT },
 { "bool", "UseFastNewInstance", &UseFastNewInstance, "Use fast inlined instance allocation", "{C1}", DEFAULT },
 { "bool", "UseFastNewTypeArray", &UseFastNewTypeArray, "Use fast inlined type array allocation", "{C1}", DEFAULT },
 { "bool", "UseFastNewObjectArray", &UseFastNewObjectArray, "Use fast inlined object array allocation", "{C1}", DEFAULT },
 { "bool", "UseFastLocking", &UseFastLocking, "Use fast inlined locking code", "{C1}", DEFAULT },
 { "bool", "UseSlowPath", &UseSlowPath, "For debugging: test slow cases by always using them", "{C1}", DEFAULT },
 { "bool", "GenerateArrayStoreCheck", &GenerateArrayStoreCheck, "Generates code for array store checks", "{C1}", DEFAULT },
 { "bool", "DeoptC1", &DeoptC1, "Use deoptimization in C1", "{C1}", DEFAULT },
 { "bool", "PrintBailouts", &PrintBailouts, "Print bailout and its reason", "{C1}", DEFAULT },
 { "bool", "TracePatching", &TracePatching, "Trace patching of field access on uninitialized classes", "{C1}", DEFAULT },
 { "bool", "PatchALot", &PatchALot, "Marks all fields as having unloaded classes", "{C1}", DEFAULT },
 { "bool", "PrintNotLoaded", &PrintNotLoaded, "Prints where classes are not loaded during code generation", "{C1}", DEFAULT },
 { "bool", "VerifyOopMaps", &VerifyOopMaps, "Adds oopmap verification code to the generated code", "{C1 notproduct}", DEFAULT },
 { "bool", "PrintLIR", &PrintLIR, "print low-level IR", "{C1}", DEFAULT },
 { "bool", "BailoutAfterHIR", &BailoutAfterHIR, "bailout of compilation after building of HIR", "{C1}", DEFAULT },
 { "bool", "BailoutAfterLIR", &BailoutAfterLIR, "bailout of compilation after building of LIR", "{C1}", DEFAULT },
 { "bool", "BailoutOnExceptionHandlers", &BailoutOnExceptionHandlers, "bailout of compilation for methods with exception handlers", "{C1}", DEFAULT },
 { "bool", "InstallMethods", &InstallMethods, "Install methods at the end of successful compilations", "{C1}", DEFAULT },
 { "intx", "CompilationRepeat", &CompilationRepeat, "Number of times to recompile method before returning result", "{C1 product}", DEFAULT },
 { "intx", "NMethodSizeLimit", &NMethodSizeLimit, "Maximum size of a compiled method.", "{C1}", DEFAULT },
 { "bool", "TraceFPUStack", &TraceFPUStack, "Trace emulation of the FPU stack (intel only)", "{C1}", DEFAULT },
 { "bool", "TraceFPURegisterUsage", &TraceFPURegisterUsage, "Trace usage of FPU registers at start of blocks (intel only)", "{C1}", DEFAULT },
 { "bool", "OptimizeUnsafes", &OptimizeUnsafes, "Optimize raw unsafe ops", "{C1}", DEFAULT },
 { "bool", "PrintUnsafeOptimization", &PrintUnsafeOptimization, "Print optimization of raw unsafe ops", "{C1}", DEFAULT },
 { "intx", "InstructionCountCutoff", &InstructionCountCutoff, "If GraphBuilder adds this many instructions, bails out", "{C1}", DEFAULT },
 { "intx", "SafepointPollOffset", &SafepointPollOffset, "Offset added to polling address (Intel only)", "{C1 pd product}", DEFAULT },
 { "bool", "ComputeExactFPURegisterUsage", &ComputeExactFPURegisterUsage, "Compute additional live set for fpu registers to simplify fpu stack merge (Intel only)", "{C1}", DEFAULT },
 { "bool", "C1ProfileCalls", &C1ProfileCalls, "Profile calls when generating code for updating MDOs", "{C1 product}", DEFAULT },
 { "bool", "C1ProfileVirtualCalls", &C1ProfileVirtualCalls, "Profile virtual calls when generating code for updating MDOs", "{C1 product}", DEFAULT },
 { "bool", "C1ProfileInlinedCalls", &C1ProfileInlinedCalls, "Profile inlined calls when generating code for updating MDOs", "{C1 product}", DEFAULT },
 { "bool", "C1ProfileBranches", &C1ProfileBranches, "Profile branches when generating code for updating MDOs", "{C1 product}", DEFAULT },
 { "bool", "C1ProfileCheckcasts", &C1ProfileCheckcasts, "Profile checkcasts when generating code for updating MDOs", "{C1 product}", DEFAULT },
 { "bool", "C1OptimizeVirtualCallProfiling", &C1OptimizeVirtualCallProfiling, "Use CHA and exact type results at call sites when updating MDOs", "{C1 product}", DEFAULT },
 { "bool", "C1UpdateMethodData", &C1UpdateMethodData, "Update methodDataOops in Tier1-generated code", "{C1 product}", DEFAULT },
 { "bool", "PrintCFGToFile", &PrintCFGToFile, "print control flow graph to a separate file during compilation", "{C1}", DEFAULT },
 { "intx", "CompileZapFirst", &CompileZapFirst, "If +ZapDeadCompiledLocals, " "skip this many before compiling in zap calls", "{C2 notproduct}", DEFAULT },
 { "intx", "CompileZapLast", &CompileZapLast, "If +ZapDeadCompiledLocals, " "compile this many after skipping (incl. skip count, -1 = all)", "{C2 notproduct}", DEFAULT },
 { "intx", "ZapDeadCompiledLocalsFirst", &ZapDeadCompiledLocalsFirst, "If +ZapDeadCompiledLocals, " "skip this many before really doing it", "{C2 notproduct}", DEFAULT },
 { "intx", "ZapDeadCompiledLocalsLast", &ZapDeadCompiledLocalsLast, "If +ZapDeadCompiledLocals, " "do this many after skipping (incl. skip count, -1 = all)", "{C2 notproduct}", DEFAULT },
 { "intx", "OptoPrologueNops", &OptoPrologueNops, "Insert this many extra nop instructions " "in the prologue of every nmethod", "{C2}", DEFAULT },
 { "intx", "InteriorEntryAlignment", &InteriorEntryAlignment, "Code alignment for interior entry points " "in generated code (in bytes)", "{C2 pd product}", DEFAULT },
 { "intx", "MaxLoopPad", &MaxLoopPad, "Align a loop if padding size in bytes is less or equal to this value", "{C2 product}", DEFAULT },
 { "intx", "MaxVectorSize", &MaxVectorSize, "Max vector size in bytes, " "actual size could be less depending on elements type", "{C2 product}", DEFAULT },
 { "bool", "AlignVector", &AlignVector, "Perform vector store/load alignment in loop", "{C2 product}", DEFAULT },
 { "intx", "NumberOfLoopInstrToAlign", &NumberOfLoopInstrToAlign, "Number of first instructions in a loop to align", "{C2 product}", DEFAULT },
 { "intx", "IndexSetWatch", &IndexSetWatch, "Trace all operations on this IndexSet (-1 means all, 0 none)", "{C2 notproduct}", DEFAULT },
 { "intx", "OptoNodeListSize", &OptoNodeListSize, "Starting allocation size of Node_List data structures", "{C2}", DEFAULT },
 { "intx", "OptoBlockListSize", &OptoBlockListSize, "Starting allocation size of Block_List data structures", "{C2}", DEFAULT },
 { "intx", "OptoPeepholeAt", &OptoPeepholeAt, "Apply peephole optimizations to this peephole rule", "{C2}", DEFAULT },
 { "bool", "PrintIdeal", &PrintIdeal, "Print ideal graph before code generation", "{C2 notproduct}", DEFAULT },
 { "bool", "PrintOpto", &PrintOpto, "Print compiler2 attempts", "{C2 notproduct}", DEFAULT },
 { "bool", "PrintOptoInlining", &PrintOptoInlining, "Print compiler2 inlining decisions", "{C2 notproduct}", DEFAULT },
 { "bool", "VerifyOpto", &VerifyOpto, "Apply more time consuming verification during compilation", "{C2 notproduct}", DEFAULT },
 { "bool", "VerifyIdealNodeCount", &VerifyIdealNodeCount, "Verify that tracked dead ideal node count is accurate", "{C2 notproduct}", DEFAULT },
 { "bool", "PrintIdealNodeCount", &PrintIdealNodeCount, "Print liveness counts of ideal nodes", "{C2 notproduct}", DEFAULT },
 { "bool", "VerifyOptoOopOffsets", &VerifyOptoOopOffsets, "Check types of base addresses in field references", "{C2 notproduct}", DEFAULT },
 { "bool", "IdealizedNumerics", &IdealizedNumerics, "Check performance difference allowing FP " "associativity and commutativity...", "{C2}", DEFAULT },
 { "bool", "OptoBreakpoint", &OptoBreakpoint, "insert breakpoint at method entry", "{C2}", DEFAULT },
 { "bool", "OptoBreakpointOSR", &OptoBreakpointOSR, "insert breakpoint at osr method entry", "{C2 notproduct}", DEFAULT },
 { "intx", "BreakAtNode", &BreakAtNode, "Break at construction of this Node (either _idx or _debug_idx)", "{C2 notproduct}", DEFAULT },
 { "bool", "OptoBreakpointC2R", &OptoBreakpointC2R, "insert breakpoint at runtime stub entry", "{C2 notproduct}", DEFAULT },
 { "bool", "OptoNoExecute", &OptoNoExecute, "Attempt to parse and compile but do not execute generated code", "{C2 notproduct}", DEFAULT },
 { "bool", "PrintOptoStatistics", &PrintOptoStatistics, "Print New compiler statistics", "{C2 notproduct}", DEFAULT },
 { "bool", "PrintOptoAssembly", &PrintOptoAssembly, "Print New compiler assembly output", "{C2 notproduct}", DEFAULT },
 { "bool", "OptoPeephole", &OptoPeephole, "Apply peephole optimizations after register allocation", "{C2 pd}", DEFAULT },
 { "bool", "OptoRemoveUseless", &OptoRemoveUseless, "Remove useless nodes after parsing", "{C2}", DEFAULT },
 { "bool", "PrintFrameConverterAssembly", &PrintFrameConverterAssembly, "Print New compiler assembly output for frame converters", "{C2 notproduct}", DEFAULT },
 { "bool", "PrintParseStatistics", &PrintParseStatistics, "Print nodes, transforms and new values made per bytecode parsed", "{C2 notproduct}", DEFAULT },
 { "bool", "PrintOptoPeephole", &PrintOptoPeephole, "Print New compiler peephole replacements", "{C2 notproduct}", DEFAULT },
 { "bool", "PrintCFGBlockFreq", &PrintCFGBlockFreq, "Print CFG block freqencies", "{C2}", DEFAULT },
 { "bool", "TraceOptoParse", &TraceOptoParse, "Trace bytecode parse and control-flow merge", "{C2}", DEFAULT },
 { "intx", "LoopUnrollLimit", &LoopUnrollLimit, "Unroll loop bodies with node count less than this", "{C2 pd product}", DEFAULT },
 { "intx", "LoopUnrollMin", &LoopUnrollMin, "Minimum number of unroll loop bodies before checking progress" "of rounds of unroll,optimize,..", "{C2 product}", DEFAULT },
 { "intx", "UnrollLimitForProfileCheck", &UnrollLimitForProfileCheck, "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.", "{C2}", DEFAULT },
 { "intx", "MultiArrayExpandLimit", &MultiArrayExpandLimit, "Maximum number of individual allocations in an inline-expanded " "multianewarray instruction", "{C2 product}", DEFAULT },
 { "bool", "TraceProfileTripCount", &TraceProfileTripCount, "Trace profile loop trip count information", "{C2 notproduct}", DEFAULT },
 { "bool", "UseLoopPredicate", &UseLoopPredicate, "Generate a predicate to select fast/slow loop versions", "{C2 product}", DEFAULT },
 { "bool", "TraceLoopPredicate", &TraceLoopPredicate, "Trace generation of loop predicates", "{C2}", DEFAULT },
 { "bool", "TraceLoopOpts", &TraceLoopOpts, "Trace executed loop optimizations", "{C2}", DEFAULT },
 { "bool", "LoopLimitCheck", &LoopLimitCheck, "Generate a loop limits check for overflow", "{C2 diagnostic}", DEFAULT },
 { "bool", "TraceLoopLimitCheck", &TraceLoopLimitCheck, "Trace generation of loop limits checks", "{C2}", DEFAULT },
 { "bool", "RangeLimitCheck", &RangeLimitCheck, "Additional overflow checks during range check elimination", "{C2 diagnostic}", DEFAULT },
 { "bool", "TraceRangeLimitCheck", &TraceRangeLimitCheck, "Trace additional overflow checks in RCE", "{C2}", DEFAULT },
 { "bool", "UnrollLimitCheck", &UnrollLimitCheck, "Additional overflow checks during loop unroll", "{C2 diagnostic}", DEFAULT },
 { "bool", "OptimizeFill", &OptimizeFill, "convert fill/copy loops into intrinsic", "{C2 product}", DEFAULT },
 { "bool", "TraceOptimizeFill", &TraceOptimizeFill, "print detailed information about fill conversion", "{C2}", DEFAULT },
 { "bool", "OptoCoalesce", &OptoCoalesce, "Use Conservative Copy Coalescing in the Register Allocator", "{C2}", DEFAULT },
 { "bool", "UseUniqueSubclasses", &UseUniqueSubclasses, "Narrow an abstract reference to the unique concrete subclass", "{C2}", DEFAULT },
 { "bool", "UseExactTypes", &UseExactTypes, "Use exact types to eliminate array store checks and v-calls", "{C2}", DEFAULT },
 { "intx", "TrackedInitializationLimit", &TrackedInitializationLimit, "When initializing fields, track up to this many words", "{C2 product}", DEFAULT },
 { "bool", "ReduceFieldZeroing", &ReduceFieldZeroing, "When initializing fields, try to avoid needless zeroing", "{C2 product}", DEFAULT },
 { "bool", "ReduceInitialCardMarks", &ReduceInitialCardMarks, "When initializing fields, try to avoid needless card marks", "{C2 product}", DEFAULT },
 { "bool", "ReduceBulkZeroing", &ReduceBulkZeroing, "When bulk-initializing, try to avoid needless zeroing", "{C2 product}", DEFAULT },
 { "bool", "UseFPUForSpilling", &UseFPUForSpilling, "Spill integer registers to FPU instead of stack when possible", "{C2 product}", DEFAULT },
 { "intx", "RegisterCostAreaRatio", &RegisterCostAreaRatio, "Spill selection in reg allocator: scale area by (X/64K) before " "adding cost", "{C2 pd}", DEFAULT },
 { "bool", "UseCISCSpill", &UseCISCSpill, "Use ADLC supplied cisc instructions during allocation", "{C2 pd}", DEFAULT },
 { "bool", "VerifyGraphEdges", &VerifyGraphEdges, "Verify Bi-directional Edges", "{C2 notproduct}", DEFAULT },
 { "bool", "VerifyDUIterators", &VerifyDUIterators, "Verify the safety of all iterations of Bi-directional Edges", "{C2 notproduct}", DEFAULT },
 { "bool", "VerifyHashTableKeys", &VerifyHashTableKeys, "Verify the immutability of keys in the VN hash tables", "{C2 notproduct}", DEFAULT },
 { "bool", "VerifyRegisterAllocator", &VerifyRegisterAllocator, "Verify Register Allocator", "{C2 notproduct}", DEFAULT },
 { "intx", "FLOATPRESSURE", &FLOATPRESSURE, "Number of float LRG's that constitute high register pressure", "{C2 pd}", DEFAULT },
 { "intx", "INTPRESSURE", &INTPRESSURE, "Number of integer LRG's that constitute high register pressure", "{C2 pd}", DEFAULT },
 { "bool", "TraceOptoPipelining", &TraceOptoPipelining, "Trace pipelining information", "{C2 notproduct}", DEFAULT },
 { "bool", "TraceOptoOutput", &TraceOptoOutput, "Trace pipelining information", "{C2 notproduct}", DEFAULT },
 { "bool", "OptoScheduling", &OptoScheduling, "Instruction Scheduling after register allocation", "{C2 pd product}", DEFAULT },
 { "bool", "PartialPeelLoop", &PartialPeelLoop, "Partial peel (rotate) loops", "{C2 product}", DEFAULT },
 { "intx", "PartialPeelNewPhiDelta", &PartialPeelNewPhiDelta, "Additional phis that can be created by partial peeling", "{C2 product}", DEFAULT },
 { "bool", "TracePartialPeeling", &TracePartialPeeling, "Trace partial peeling (loop rotation) information", "{C2 notproduct}", DEFAULT },
 { "bool", "PartialPeelAtUnsignedTests", &PartialPeelAtUnsignedTests, "Partial peel at unsigned tests if no signed test exists", "{C2 product}", DEFAULT },
 { "bool", "ReassociateInvariants", &ReassociateInvariants, "Enable reassociation of expressions with loop invariants.", "{C2 product}", DEFAULT },
 { "bool", "LoopUnswitching", &LoopUnswitching, "Enable loop unswitching (a form of invariant test hoisting)", "{C2 product}", DEFAULT },
 { "bool", "TraceLoopUnswitching", &TraceLoopUnswitching, "Trace loop unswitching", "{C2 notproduct}", DEFAULT },
 { "bool", "UseSuperWord", &UseSuperWord, "Transform scalar operations into superword operations", "{C2 product}", DEFAULT },
 { "bool", "SuperWordRTDepCheck", &SuperWordRTDepCheck, "Enable runtime dependency checks.", "{C2}", DEFAULT },
 { "bool", "TraceSuperWord", &TraceSuperWord, "Trace superword transforms", "{C2 notproduct}", DEFAULT },
 { "bool", "TraceNewVectors", &TraceNewVectors, "Trace creation of Vector nodes", "{C2 notproduct}", DEFAULT },
 { "bool", "OptoBundling", &OptoBundling, "Generate nops to fill i-cache lines", "{C2 pd product}", DEFAULT },
 { "intx", "ConditionalMoveLimit", &ConditionalMoveLimit, "Limit of ops to make speculative when using CMOVE", "{C2 pd product}", DEFAULT },
 { "bool", "BranchOnRegister", &BranchOnRegister, "Use Sparc V9 branch-on-register opcodes", "{C2 product}", DEFAULT },
 { "bool", "SparcV9RegsHiBitsZero", &SparcV9RegsHiBitsZero, "Assume Sparc V9 I&L registers on V8+ systems are zero-extended", "{C2}", DEFAULT },
 { "bool", "UseRDPCForConstantTableBase", &UseRDPCForConstantTableBase, "Use Sparc RDPC instruction for the constant table base.", "{C2 product}", DEFAULT },
 { "intx", "PrintIdealGraphLevel", &PrintIdealGraphLevel, "Print ideal graph to XML file / network interface. " "By default attempts to connect to the visualizer on a socket.", "{C2}", DEFAULT },
 { "intx", "PrintIdealGraphPort", &PrintIdealGraphPort, "Ideal graph printer to network port", "{C2}", DEFAULT },
 { "ccstr", "PrintIdealGraphAddress", &PrintIdealGraphAddress, "IP address to connect to visualizer", "{C2 notproduct}", DEFAULT },
 { "ccstr", "PrintIdealGraphFile", &PrintIdealGraphFile, "File to dump ideal graph to.  If set overrides the " "use of the network", "{C2 notproduct}", DEFAULT },
 { "bool", "UseOldInlining", &UseOldInlining, "Enable the 1.3 inlining strategy", "{C2 product}", DEFAULT },
 { "bool", "UseBimorphicInlining", &UseBimorphicInlining, "Profiling based inlining for two receivers", "{C2 product}", DEFAULT },
 { "bool", "UseOnlyInlinedBimorphic", &UseOnlyInlinedBimorphic, "Don't use BimorphicInlining if can't inline a second method", "{C2 product}", DEFAULT },
 { "bool", "InsertMemBarAfterArraycopy", &InsertMemBarAfterArraycopy, "Insert memory barrier after arraycopy call", "{C2 product}", DEFAULT },
 { "bool", "SubsumeLoads", &SubsumeLoads, "Attempt to compile while subsuming loads into machine instructions.", "{C2}", DEFAULT },
 { "bool", "StressRecompilation", &StressRecompilation, "Recompile each compiled method without subsuming loads or escape analysis.", "{C2}", DEFAULT },
 { "intx", "ImplicitNullCheckThreshold", &ImplicitNullCheckThreshold, "Don't do implicit null checks if NPE's in a method exceeds limit", "{C2}", DEFAULT },
 { "intx", "LoopOptsCount", &LoopOptsCount, "Set level of loop optimization for tier 1 compiles", "{C2 product}", DEFAULT },
 { "intx", "NodeCountInliningCutoff", &NodeCountInliningCutoff, "If parser node generation exceeds limit stop inlining", "{C2}", DEFAULT },
 { "intx", "NodeCountInliningStep", &NodeCountInliningStep, "Target size of warm calls inlined between optimization passes", "{C2}", DEFAULT },
 { "bool", "InlineWarmCalls", &InlineWarmCalls, "Use a heat-based priority queue to govern inlining", "{C2}", DEFAULT },
 { "intx", "HotCallCountThreshold", &HotCallCountThreshold, "large numbers of calls (per method invocation) force hotness", "{C2}", DEFAULT },
 { "intx", "HotCallProfitThreshold", &HotCallProfitThreshold, "highly profitable inlining opportunities force hotness", "{C2}", DEFAULT },
 { "intx", "HotCallTrivialWork", &HotCallTrivialWork, "trivial execution time (no larger than this) forces hotness", "{C2}", DEFAULT },
 { "intx", "HotCallTrivialSize", &HotCallTrivialSize, "trivial methods (no larger than this) force calls to be hot", "{C2}", DEFAULT },
 { "intx", "WarmCallMinCount", &WarmCallMinCount, "number of calls (per method invocation) to enable inlining", "{C2}", DEFAULT },
 { "intx", "WarmCallMinProfit", &WarmCallMinProfit, "number of calls (per method invocation) to enable inlining", "{C2}", DEFAULT },
 { "intx", "WarmCallMaxWork", &WarmCallMaxWork, "execution time of the largest inlinable method", "{C2}", DEFAULT },
 { "intx", "WarmCallMaxSize", &WarmCallMaxSize, "size of the largest inlinable method", "{C2}", DEFAULT },
 { "intx", "MaxNodeLimit", &MaxNodeLimit, "Maximum number of nodes", "{C2 product}", DEFAULT },
 { "intx", "NodeLimitFudgeFactor", &NodeLimitFudgeFactor, "Fudge Factor for certain optimizations", "{C2 product}", DEFAULT },
 { "bool", "UseJumpTables", &UseJumpTables, "Use JumpTables instead of a binary search tree for switches", "{C2 product}", DEFAULT },
 { "bool", "UseDivMod", &UseDivMod, "Use combined DivMod instruction if available", "{C2 product}", DEFAULT },
 { "intx", "MinJumpTableSize", &MinJumpTableSize, "Minimum number of targets in a generated jump table", "{C2 product}", DEFAULT },
 { "intx", "MaxJumpTableSize", &MaxJumpTableSize, "Maximum number of targets in a generated jump table", "{C2 product}", DEFAULT },
 { "intx", "MaxJumpTableSparseness", &MaxJumpTableSparseness, "Maximum sparseness for jumptables", "{C2 product}", DEFAULT },
 { "bool", "EliminateLocks", &EliminateLocks, "Coarsen locks when possible", "{C2 product}", DEFAULT },
 { "bool", "EliminateNestedLocks", &EliminateNestedLocks, "Eliminate nested locks of the same object when possible", "{C2 product}", DEFAULT },
 { "bool", "PrintLockStatistics", &PrintLockStatistics, "Print precise statistics on the dynamic lock usage", "{C2 notproduct}", DEFAULT },
 { "bool", "PrintPreciseBiasedLockingStatistics", &PrintPreciseBiasedLockingStatistics, "Print per-lock-site statistics of biased locking in JVM", "{C2 diagnostic}", DEFAULT },
 { "bool", "PrintEliminateLocks", &PrintEliminateLocks, "Print out when locks are eliminated", "{C2 notproduct}", DEFAULT },
 { "bool", "EliminateAutoBox", &EliminateAutoBox, "Private flag to control optimizations for autobox elimination", "{C2 diagnostic}", DEFAULT },
 { "intx", "AutoBoxCacheMax", &AutoBoxCacheMax, "Sets max value cached by the java.lang.Integer autobox cache", "{C2 product}", DEFAULT },
 { "bool", "DoEscapeAnalysis", &DoEscapeAnalysis, "Perform escape analysis", "{C2 product}", DEFAULT },
 { "bool", "ExitEscapeAnalysisOnTimeout", &ExitEscapeAnalysisOnTimeout, "Exit or throw assert in EA when it reaches time limit", "{C2}", DEFAULT },
 { "bool", "PrintEscapeAnalysis", &PrintEscapeAnalysis, "Print the results of escape analysis", "{C2 notproduct}", DEFAULT },
 { "bool", "EliminateAllocations", &EliminateAllocations, "Use escape analysis to eliminate allocations", "{C2 product}", DEFAULT },
 { "bool", "PrintEliminateAllocations", &PrintEliminateAllocations, "Print out when allocations are eliminated", "{C2 notproduct}", DEFAULT },
 { "intx", "EliminateAllocationArraySizeLimit", &EliminateAllocationArraySizeLimit, "Array size (number of elements) limit for scalar replacement", "{C2 product}", DEFAULT },
 { "bool", "OptimizePtrCompare", &OptimizePtrCompare, "Use escape analysis to optimize pointers compare", "{C2 product}", DEFAULT },
 { "bool", "PrintOptimizePtrCompare", &PrintOptimizePtrCompare, "Print information about optimized pointers compare", "{C2 notproduct}", DEFAULT },
 { "bool", "VerifyConnectionGraph", &VerifyConnectionGraph, "Verify Connection Graph construction in Escape Analysis", "{C2 notproduct}", DEFAULT },
 { "bool", "UseOptoBiasInlining", &UseOptoBiasInlining, "Generate biased locking code in C2 ideal graph", "{C2 product}", DEFAULT },
 { "bool", "OptimizeStringConcat", &OptimizeStringConcat, "Optimize the construction of Strings by StringBuilder", "{C2 product}", DEFAULT },
 { "bool", "PrintOptimizeStringConcat", &PrintOptimizeStringConcat, "Print information about transformations performed on Strings", "{C2 notproduct}", DEFAULT },
 { "intx", "ValueSearchLimit", &ValueSearchLimit, "Recursion limit in PhaseMacroExpand::value_from_mem_phi", "{C2 product}", DEFAULT },
 { "intx", "MaxLabelRootDepth", &MaxLabelRootDepth, "Maximum times call Label_Root to prevent stack overflow", "{C2 product}", DEFAULT },
 { "intx", "DominatorSearchLimit", &DominatorSearchLimit, "Iterations limit in Node::dominates", "{C2 diagnostic}", DEFAULT },
 { "bool", "BlockLayoutByFrequency", &BlockLayoutByFrequency, "Use edge frequencies to drive block ordering", "{C2 product}", DEFAULT },
 { "intx", "BlockLayoutMinDiamondPercentage", &BlockLayoutMinDiamondPercentage, "Miniumum %% of a successor (predecessor) for which block layout " "a will allow a fork (join) in a single chain", "{C2 product}", DEFAULT },
 { "bool", "BlockLayoutRotateLoops", &BlockLayoutRotateLoops, "Allow back branches to be fall throughs in the block layour", "{C2 product}", DEFAULT },
 { "bool", "InlineReflectionGetCallerClass", &InlineReflectionGetCallerClass, "inline sun.reflect.Reflection.getCallerClass(), known to be part " "of base library DLL", "{C2}", DEFAULT },
 { "bool", "InlineObjectCopy", &InlineObjectCopy, "inline Object.clone and Arrays.copyOf[Range] intrinsics", "{C2}", DEFAULT },
 { "bool", "SpecialStringCompareTo", &SpecialStringCompareTo, "special version of string compareTo", "{C2}", DEFAULT },
 { "bool", "SpecialStringIndexOf", &SpecialStringIndexOf, "special version of string indexOf", "{C2}", DEFAULT },
 { "bool", "SpecialStringEquals", &SpecialStringEquals, "special version of string equals", "{C2}", DEFAULT },
 { "bool", "SpecialArraysEquals", &SpecialArraysEquals, "special version of Arrays.equals(char[],char[])", "{C2}", DEFAULT },
 { "bool", "BailoutToInterpreterForThrows", &BailoutToInterpreterForThrows, "Compiled methods which throws/catches exceptions will be " "deopt and intp.", "{C2}", DEFAULT },
 { "bool", "ConvertCmpD2CmpF", &ConvertCmpD2CmpF, "Convert cmpD to cmpF when one input is constant in float range", "{C2}", DEFAULT },
 { "bool", "ConvertFloat2IntClipping", &ConvertFloat2IntClipping, "Convert float2int clipping idiom to integer clipping", "{C2}", DEFAULT },
 { "bool", "Use24BitFPMode", &Use24BitFPMode, "Set 24-bit FPU mode on a per-compile basis ", "{C2}", DEFAULT },
 { "bool", "Use24BitFP", &Use24BitFP, "use FP instructions that produce 24-bit precise results", "{C2}", DEFAULT },
 { "bool", "MonomorphicArrayCheck", &MonomorphicArrayCheck, "Uncommon-trap array store checks that require full type check", "{C2}", DEFAULT },
 { "bool", "TracePhaseCCP", &TracePhaseCCP, "Print progress during Conditional Constant Propagation", "{C2 notproduct}", DEFAULT },
 { "bool", "PrintDominators", &PrintDominators, "Print out dominator trees for GVN", "{C2}", DEFAULT },
 { "bool", "TraceSpilling", &TraceSpilling, "Trace spilling", "{C2 notproduct}", DEFAULT },
 { "bool", "TraceTypeProfile", &TraceTypeProfile, "Trace type profile", "{C2 diagnostic}", DEFAULT },
 { "bool", "PoisonOSREntry", &PoisonOSREntry, "Detect abnormal calls to OSR code", "{C2}", DEFAULT },
 { "bool", "UseCondCardMark", &UseCondCardMark, "Check for already marked card before updating card table", "{C2 product}", DEFAULT },
 { "bool", "SoftMatchFailure", &SoftMatchFailure, "If the DFA fails to match a node, print a message and bail out", "{C2}", DEFAULT },
 { "bool", "InlineAccessors", &InlineAccessors, "inline accessor methods (get/set)", "{C2}", DEFAULT },
 { "intx", "TypeProfileMajorReceiverPercent", &TypeProfileMajorReceiverPercent, "% of major receiver type to all profiled receivers", "{C2 product}", DEFAULT },
 { "bool", "TimeCompiler2", &TimeCompiler2, "detailed time the compiler (requires +TimeCompiler)", "{C2 notproduct}", DEFAULT },
 { "bool", "PrintIntrinsics", &PrintIntrinsics, "prints attempted and successful inlining of intrinsics", "{C2 diagnostic}", DEFAULT },
 { "ccstrlist", "DisableIntrinsic", &DisableIntrinsic, "do not expand intrinsics whose (internal) names appear here", "{C2 diagnostic}", DEFAULT },
 { "bool", "StressReflectiveCode", &StressReflectiveCode, "Use inexact types at allocations, etc., to test reflection", "{C2}", DEFAULT },
 { "bool", "DebugInlinedCalls", &DebugInlinedCalls, "If false, restricts profiled locations to the root method only", "{C2 diagnostic}", DEFAULT },
 { "bool", "VerifyLoopOptimizations", &VerifyLoopOptimizations, "verify major loop optimizations", "{C2 notproduct}", DEFAULT },
 { "bool", "ProfileDynamicTypes", &ProfileDynamicTypes, "do extra type profiling and use it more aggressively", "{C2 diagnostic}", DEFAULT },
 { "bool", "TraceIterativeGVN", &TraceIterativeGVN, "Print progress during Iterative Global Value Numbering", "{C2}", DEFAULT },
 { "bool", "VerifyIterativeGVN", &VerifyIterativeGVN, "Verify Def-Use modifications during sparse Iterative Global " "Value Numbering", "{C2}", DEFAULT },
 { "bool", "TraceCISCSpill", &TraceCISCSpill, "Trace allocators use of cisc spillable instructions", "{C2 notproduct}", DEFAULT },
 { "bool", "SplitIfBlocks", &SplitIfBlocks, "Clone compares and control flow through merge points to fold " "some branches", "{C2 product}", DEFAULT },
 { "intx", "FreqCountInvocations", &FreqCountInvocations, "Scaling factor for branch frequencies (deprecated)", "{C2}", DEFAULT },
 { "intx", "AliasLevel", &AliasLevel, "0 for no aliasing, 1 for oop/field/static/array split, " "2 for class split, 3 for unique instances", "{C2 product}", DEFAULT },
 { "bool", "VerifyAliases", &VerifyAliases, "perform extra checks on the results of alias analysis", "{C2}", DEFAULT },
 { "bool", "IncrementalInline", &IncrementalInline, "do post parse inlining", "{C2 product}", DEFAULT },
 { "bool", "AlwaysIncrementalInline", &AlwaysIncrementalInline, "do all inlining incrementally", "{C2}", DEFAULT },
 { "intx", "LiveNodeCountInliningCutoff", &LiveNodeCountInliningCutoff, "max number of live nodes in a method", "{C2 product}", DEFAULT },
 { "bool", "OptimizeExpensiveOps", &OptimizeExpensiveOps, "Find best control for expensive operations", "{C2 diagnostic}", DEFAULT },
 { "bool", "IEEEPrecision", &IEEEPrecision, "Enables IEEE precision (for INTEL only)", "{ARCH}", DEFAULT },
 { "intx", "FenceInstruction", &FenceInstruction, "(Unsafe,Unstable) Experimental", "{ARCH product}", DEFAULT },
 { "intx", "ReadPrefetchInstr", &ReadPrefetchInstr, "Prefetch instruction to prefetch ahead", "{ARCH product}", DEFAULT },
 { "bool", "UseStoreImmI16", &UseStoreImmI16, "Use store immediate 16-bits value instruction on x86", "{ARCH product}", DEFAULT },
 { "intx", "UseAVX", &UseAVX, "Highest supported AVX instructions set on x86/x64", "{ARCH product}", DEFAULT },
 { "bool", "UseIncDec", &UseIncDec, "Use INC, DEC instructions on x86", "{ARCH diagnostic}", DEFAULT },
 { "bool", "UseNewLongLShift", &UseNewLongLShift, "Use optimized bitwise shift left", "{ARCH product}", DEFAULT },
 { "bool", "UseAddressNop", &UseAddressNop, "Use '0F 1F [addr]' NOP instructions on x86 cpus", "{ARCH product}", DEFAULT },
 { "bool", "UseXmmLoadAndClearUpper", &UseXmmLoadAndClearUpper, "Load low part of XMM register and clear upper part", "{ARCH product}", DEFAULT },
 { "bool", "UseXmmRegToRegMoveAll", &UseXmmRegToRegMoveAll, "Copy all XMM register bits when moving value between registers", "{ARCH product}", DEFAULT },
 { "bool", "UseXmmI2D", &UseXmmI2D, "Use SSE2 CVTDQ2PD instruction to convert Integer to Double", "{ARCH product}", DEFAULT },
 { "bool", "UseXmmI2F", &UseXmmI2F, "Use SSE2 CVTDQ2PS instruction to convert Integer to Float", "{ARCH product}", DEFAULT },
 { "bool", "UseUnalignedLoadStores", &UseUnalignedLoadStores, "Use SSE2 MOVDQU instruction for Arraycopy", "{ARCH product}", DEFAULT },
 { "bool", "UseFastStosb", &UseFastStosb, "Use fast-string operation for zeroing: rep stosb", "{ARCH product}", DEFAULT },
 { "bool", "Use486InstrsOnly", &Use486InstrsOnly, "Use 80486 Compliant instruction subset", "{ARCH product}", DEFAULT },
 { "bool", "UseCountLeadingZerosInstruction", &UseCountLeadingZerosInstruction, "Use count leading zeros instruction", "{ARCH product}", DEFAULT },

 {0, 0i64, 0i64}
};