/* * Copyright (c) 1997, 2020, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 only, as * published by the Free Software Foundation. * * This code is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License * version 2 for more details (a copy is included in the LICENSE file that * accompanied this code). * * You should have received a copy of the GNU General Public License version * 2 along with this work; if not, write to the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.com if you need additional information or have any * questions. * */ #ifndef SHARE_RUNTIME_GLOBALS_HPP #define SHARE_RUNTIME_GLOBALS_HPP #include "compiler/compiler_globals.hpp" #include "gc/shared/gc_globals.hpp" #include "runtime/flags/jvmFlagConstraintsCompiler.hpp" #include "runtime/flags/jvmFlagConstraintsRuntime.hpp" #include "runtime/globals_shared.hpp" #include "utilities/align.hpp" #include "utilities/globalDefinitions.hpp" #include "utilities/macros.hpp" #include CPU_HEADER(globals) #include OS_HEADER(globals) #include OS_CPU_HEADER(globals) // Command-line flag specification in HotSpot is divided into individual modules. // Each module should have 2 files in the module's directory. For example, C2 has the // following 2 files: // // c2_globals.hpp - specification of all flags for C2, including meta-information // such as docs, range and constraints. // c2_globals.cpp - definitions of the C++ variables that implements these flags. // // // In the xxx_globals.hpp file, each flag must be specified with one of the // following 5 macros. // // Platform-Independent Flags -- each flag has 5 arguments: (type, name, default_value, attr, docs) // // PRODUCT_FLAG -- always settable // DEVELOP_FLAG -- settable only during development and are constant in the PRODUCT version // NOTPROD_FLAG -- settable only during development and are *not* declared in the PRODUCT version // // Platform-Dependent Flags -- each flag has 4 arguments: (type, name, attr, docs) // // PRODUCT_FLAG_PD // DEVELOP_FLAG_PD // // type: A flag must be declared with one of the following types: // bool, int, uint, intx, uintx, size_t, ccstr, ccstr, double, or uint64_t. // // The type "ccstr" is an alias for "const char*" because the macrology // requires single-token type names. For this type, you can optionally // set the JVMFlag::STRINGLIST bit in the argument. This allows you // to specify the flag multiple times on the command-line to build // a string list. These flags are printed as "ccstrlist" by -XX:PrintFlagsFinal. // // name: The name of the flag. // // default_value: The default value of the flag. // Note that the default values for the _PD flags are declared in // platform-dependent header files such as cpu/x86/c2_globals_x86.hpp // // attr: See discussion below on flag attributes // // docs: Description of the flag. This is mostly for the benefits of HotSpot // developers, and is excluded from PRODUCT builds. // // // Optionally, a flag can be given a range and/or constraint by using the following // macros: // // FLAG_RANGE(name, min, max) // FLAG_CONSTRAINT(name, func, phase) // // When a range is specified, the flag's attr must include JVMFlag::RANGE. // When a constraint is specified, the flag's attr must include JVMFlag::CONSTRAINT. // // For example: // // PRODUCT_FLAG(size_t, LargePageSizeInBytes, 0, JVMFlag::RANGE, // "Large page size (0 to let VM choose the page size)"); // FLAG_RANGE( LargePageSizeInBytes, 0, max_uintx); // // PRODUCT_FLAG_PD(size_t,MetaspaceSize, JVMFlag::CONSTRAINT, // "Initial threshold (in bytes) at which a garbage collection " // "is done to reduce Metaspace usage"); // FLAG_CONSTRAINT( MetaspaceSize, (void*)MetaspaceSizeConstraintFunc, JVMFlag::AfterErgo); // // // Command-line Flag Attributes // // The argument for each flag may be any combination of the following // bits. // // JVMFlag::MANAGEABLE // JVMFlag::DIAGNOSTIC // JVMFlag::EXPERIMENTAL // // DIAGNOSTIC options are not meant for VM tuning or for product modes. // They are to be used for VM quality assurance or field diagnosis // of VM bugs. They are hidden so that users will not be encouraged to // try them as if they were VM ordinary execution options. However, they // are available in the product version of the VM. Under instruction // from support engineers, VM customers can turn them on to collect // diagnostic information about VM problems. To use a VM diagnostic // option, you must first specify +UnlockDiagnosticVMOptions. // (This master switch also affects the behavior of -Xprintflags.) // // EXPERIMENTAL flags are in support of features that are not // part of the officially supported product, but are available // for experimenting with. They could, for example, be performance // features that may not have undergone full or rigorous QA, but which may // help performance in some cases and released for experimentation // by the community of users and developers. This flag also allows one to // be able to build a fully supported product that nonetheless also // ships with some unsupported, lightly tested, experimental features. // Like the UnlockDiagnosticVMOptions flag above, there is a corresponding // UnlockExperimentalVMOptions flag, which allows the control and // modification of the experimental flags. // // Nota bene: neither diagnostic nor experimental options should be used casually, // and they are not supported on production loads, except under explicit // direction from support engineers. // // MANAGEABLE flags are writeable external product flags. // They are dynamically writeable through the JDK management interface // (com.sun.management.HotSpotDiagnosticMXBean API) and also through JConsole. // These flags are external exported interface (see CCC). The list of // manageable flags can be queried programmatically through the management // interface. // // A flag can be made as "manageable" only if // - the flag is defined in a CCC as an external exported interface. // - the VM implementation supports dynamic setting of the flag. // This implies that the VM must *always* query the flag variable // and not reuse state related to the flag state at any given time. // - you want the flag to be queried programmatically by the customers. // Additional flag attributes // // In addition to the 3 bits described above, more can be specified. These // usually only affects the printing of the flag (see java -XX:PrintFlagsFinal). // However, you can also write code to process a certain group of // flags. See JVMCIGlobals::check_jvmci_flags_are_consistent() for an example. // // JVMFlag::PLATFORM_DEPENDENT // JVMFlag::C1 // JVMFlag::C2 // JVMFlag::ARCH // JVMFlag::JVMCI // // To add these extra bits to a group of flags, you can use the FLAG_COMMON_ATTRS // macro. See c2_globals.cpp for an example. // Default and minimum StringTable and SymbolTable size values // Must be powers of 2 const size_t defaultStringTableSize = NOT_LP64(1024) LP64_ONLY(65536); const size_t minimumStringTableSize = 128; const size_t defaultSymbolTableSize = 32768; // 2^15 const size_t minimumSymbolTableSize = 1024; #include "runtime/flags/jvmFlag.hpp" NOTPROD_FLAG(bool, CheckCompressedOops, true, JVMFlag::DEFAULT, "Generate checks in encoding/decoding code in debug VM"); PRODUCT_FLAG(uintx, HeapSearchSteps, 3 PPC64_ONLY(+17), JVMFlag::RANGE, "Heap allocation steps through preferred address regions to find" " where it can allocate the heap. Number of steps to take per " "region."); FLAG_RANGE( HeapSearchSteps, 1, max_uintx); DEVELOP_FLAG(bool, CleanChunkPoolAsync, true, JVMFlag::DEFAULT, "Clean the chunk pool asynchronously"); PRODUCT_FLAG(uint, HandshakeTimeout, 0, JVMFlag::DIAGNOSTIC, "If nonzero set a timeout in milliseconds for handshakes"); PRODUCT_FLAG(bool, AlwaysSafeConstructors, false, JVMFlag::EXPERIMENTAL, "Force safe construction, as if all fields are final."); PRODUCT_FLAG(bool, UnlockDiagnosticVMOptions, trueInDebug, JVMFlag::DIAGNOSTIC, "Enable normal processing of flags relating to field diagnostics"); PRODUCT_FLAG(bool, UnlockExperimentalVMOptions, false, JVMFlag::EXPERIMENTAL, "Enable normal processing of flags relating to experimental " "features"); PRODUCT_FLAG(bool, JavaMonitorsInStackTrace, true, JVMFlag::DEFAULT, "Print information about Java monitor locks when the stacks are" "dumped"); PRODUCT_FLAG_PD(bool, UseLargePages, JVMFlag::DEFAULT, "Use large page memory"); PRODUCT_FLAG_PD(bool, UseLargePagesIndividualAllocation, JVMFlag::DEFAULT, "Allocate large pages individually for better affinity"); DEVELOP_FLAG(bool, LargePagesIndividualAllocationInjectError, false, JVMFlag::DEFAULT, "Fail large pages individual allocation"); PRODUCT_FLAG(bool, UseLargePagesInMetaspace, false, JVMFlag::DEFAULT, "Use large page memory in metaspace. " "Only used if UseLargePages is enabled."); PRODUCT_FLAG(bool, UseNUMA, false, JVMFlag::DEFAULT, "Use NUMA if available"); PRODUCT_FLAG(bool, UseNUMAInterleaving, false, JVMFlag::DEFAULT, "Interleave memory across NUMA nodes if available"); PRODUCT_FLAG(size_t, NUMAInterleaveGranularity, 2*M, JVMFlag::RANGE, "Granularity to use for NUMA interleaving on Windows OS"); FLAG_CUSTOM_RANGE( NUMAInterleaveGranularity, VMAllocationGranularity); PRODUCT_FLAG(bool, ForceNUMA, false, JVMFlag::DEFAULT, "Force NUMA optimizations on single-node/UMA systems"); PRODUCT_FLAG(uintx, NUMAChunkResizeWeight, 20, JVMFlag::RANGE, "Percentage (0-100) used to weight the current sample when " "computing exponentially decaying average for " "AdaptiveNUMAChunkSizing"); FLAG_RANGE( NUMAChunkResizeWeight, 0, 100); PRODUCT_FLAG(size_t, NUMASpaceResizeRate, 1*G, JVMFlag::RANGE, "Do not reallocate more than this amount per collection"); FLAG_RANGE( NUMASpaceResizeRate, 0, max_uintx); PRODUCT_FLAG(bool, UseAdaptiveNUMAChunkSizing, true, JVMFlag::DEFAULT, "Enable adaptive chunk sizing for NUMA"); PRODUCT_FLAG(bool, NUMAStats, false, JVMFlag::DEFAULT, "Print NUMA stats in detailed heap information"); PRODUCT_FLAG(uintx, NUMAPageScanRate, 256, JVMFlag::RANGE, "Maximum number of pages to include in the page scan procedure"); FLAG_RANGE( NUMAPageScanRate, 0, max_uintx); PRODUCT_FLAG(bool, UseAES, false, JVMFlag::DEFAULT, "Control whether AES instructions are used when available"); PRODUCT_FLAG(bool, UseFMA, false, JVMFlag::DEFAULT, "Control whether FMA instructions are used when available"); PRODUCT_FLAG(bool, UseSHA, false, JVMFlag::DEFAULT, "Control whether SHA instructions are used when available"); PRODUCT_FLAG(bool, UseGHASHIntrinsics, false, JVMFlag::DIAGNOSTIC, "Use intrinsics for GHASH versions of crypto"); PRODUCT_FLAG(bool, UseBASE64Intrinsics, false, JVMFlag::DEFAULT, "Use intrinsics for java.util.Base64"); PRODUCT_FLAG(size_t, LargePageSizeInBytes, 0, JVMFlag::RANGE, "Large page size (0 to let VM choose the page size)"); FLAG_RANGE( LargePageSizeInBytes, 0, max_uintx); PRODUCT_FLAG(size_t, LargePageHeapSizeThreshold, 128*M, JVMFlag::RANGE, "Use large pages if maximum heap is at least this big"); FLAG_RANGE( LargePageHeapSizeThreshold, 0, max_uintx); PRODUCT_FLAG(bool, ForceTimeHighResolution, false, JVMFlag::DEFAULT, "Using high time resolution (for Win32 only)"); DEVELOP_FLAG(bool, TracePcPatching, false, JVMFlag::DEFAULT, "Trace usage of frame::patch_pc"); DEVELOP_FLAG(bool, TraceRelocator, false, JVMFlag::DEFAULT, "Trace the bytecode relocator"); DEVELOP_FLAG(bool, TraceLongCompiles, false, JVMFlag::DEFAULT, "Print out every time compilation is longer than " "a given threshold"); PRODUCT_FLAG(bool, SafepointALot, false, JVMFlag::DIAGNOSTIC, "Generate a lot of safepoints. This works with " "GuaranteedSafepointInterval"); PRODUCT_FLAG(bool, HandshakeALot, false, JVMFlag::DIAGNOSTIC, "Generate a lot of handshakes. This works with " "GuaranteedSafepointInterval"); PRODUCT_FLAG_PD(bool, BackgroundCompilation, JVMFlag::DEFAULT, "A thread requesting compilation is not blocked during " "compilation"); PRODUCT_FLAG(bool, PrintVMQWaitTime, false, JVMFlag::DEFAULT, "(Deprecated) Print out the waiting time in VM operation queue"); PRODUCT_FLAG(bool, MethodFlushing, true, JVMFlag::DEFAULT, "Reclamation of zombie and not-entrant methods"); DEVELOP_FLAG(bool, VerifyStack, false, JVMFlag::DEFAULT, "Verify stack of each thread when it is entering a runtime call"); PRODUCT_FLAG(bool, ForceUnreachable, false, JVMFlag::DIAGNOSTIC, "Make all non code cache addresses to be unreachable by " "forcing use of 64bit literal fixups"); NOTPROD_FLAG(bool, StressDerivedPointers, false, JVMFlag::DEFAULT, "Force scavenge when a derived pointer is detected on stack " "after rtm call"); DEVELOP_FLAG(bool, TraceDerivedPointers, false, JVMFlag::DEFAULT, "Trace traversal of derived pointers on stack"); NOTPROD_FLAG(bool, TraceCodeBlobStacks, false, JVMFlag::DEFAULT, "Trace stack-walk of codeblobs"); NOTPROD_FLAG(bool, PrintRewrites, false, JVMFlag::DEFAULT, "Print methods that are being rewritten"); PRODUCT_FLAG(bool, UseInlineCaches, true, JVMFlag::DEFAULT, "Use Inline Caches for virtual calls "); PRODUCT_FLAG(bool, InlineArrayCopy, true, JVMFlag::DIAGNOSTIC, "Inline arraycopy native that is known to be part of " "base library DLL"); PRODUCT_FLAG(bool, InlineObjectHash, true, JVMFlag::DIAGNOSTIC, "Inline Object::hashCode() native that is known to be part " "of base library DLL"); PRODUCT_FLAG(bool, InlineNatives, true, JVMFlag::DIAGNOSTIC, "Inline natives that are known to be part of base library DLL"); PRODUCT_FLAG(bool, InlineMathNatives, true, JVMFlag::DIAGNOSTIC, "Inline SinD, CosD, etc."); PRODUCT_FLAG(bool, InlineClassNatives, true, JVMFlag::DIAGNOSTIC, "Inline Class.isInstance, etc"); PRODUCT_FLAG(bool, InlineThreadNatives, true, JVMFlag::DIAGNOSTIC, "Inline Thread.currentThread, etc"); PRODUCT_FLAG(bool, InlineUnsafeOps, true, JVMFlag::DIAGNOSTIC, "Inline memory ops (native methods) from Unsafe"); PRODUCT_FLAG(bool, CriticalJNINatives, true, JVMFlag::DEFAULT, "Check for critical JNI entry points"); NOTPROD_FLAG(bool, StressCriticalJNINatives, false, JVMFlag::DEFAULT, "Exercise register saving code in critical natives"); PRODUCT_FLAG(bool, UseAESIntrinsics, false, JVMFlag::DIAGNOSTIC, "Use intrinsics for AES versions of crypto"); PRODUCT_FLAG(bool, UseAESCTRIntrinsics, false, JVMFlag::DIAGNOSTIC, "Use intrinsics for the paralleled version of AES/CTR crypto"); PRODUCT_FLAG(bool, UseSHA1Intrinsics, false, JVMFlag::DIAGNOSTIC, "Use intrinsics for SHA-1 crypto hash function. " "Requires that UseSHA is enabled."); PRODUCT_FLAG(bool, UseSHA256Intrinsics, false, JVMFlag::DIAGNOSTIC, "Use intrinsics for SHA-224 and SHA-256 crypto hash functions. " "Requires that UseSHA is enabled."); PRODUCT_FLAG(bool, UseSHA512Intrinsics, false, JVMFlag::DIAGNOSTIC, "Use intrinsics for SHA-384 and SHA-512 crypto hash functions. " "Requires that UseSHA is enabled."); PRODUCT_FLAG(bool, UseCRC32Intrinsics, false, JVMFlag::DIAGNOSTIC, "use intrinsics for java.util.zip.CRC32"); PRODUCT_FLAG(bool, UseCRC32CIntrinsics, false, JVMFlag::DIAGNOSTIC, "use intrinsics for java.util.zip.CRC32C"); PRODUCT_FLAG(bool, UseAdler32Intrinsics, false, JVMFlag::DIAGNOSTIC, "use intrinsics for java.util.zip.Adler32"); PRODUCT_FLAG(bool, UseVectorizedMismatchIntrinsic, false, JVMFlag::DIAGNOSTIC, "Enables intrinsification of ArraysSupport.vectorizedMismatch()"); PRODUCT_FLAG(ccstr, DisableIntrinsic, "", JVMFlag::DIAGNOSTIC | JVMFlag::STRINGLIST, "do not expand intrinsics whose (internal) names appear here"); DEVELOP_FLAG(bool, TraceCallFixup, false, JVMFlag::DEFAULT, "Trace all call fixups"); DEVELOP_FLAG(bool, DeoptimizeALot, false, JVMFlag::DEFAULT, "Deoptimize at every exit from the runtime system"); NOTPROD_FLAG(ccstr, DeoptimizeOnlyAt, "", JVMFlag::STRINGLIST, "A comma separated list of bcis to deoptimize at"); DEVELOP_FLAG(bool, DeoptimizeRandom, false, JVMFlag::DEFAULT, "Deoptimize random frames on random exit from the runtime system"); NOTPROD_FLAG(bool, ZombieALot, false, JVMFlag::DEFAULT, "Create zombies (non-entrant) at exit from the runtime system"); NOTPROD_FLAG(bool, WalkStackALot, false, JVMFlag::DEFAULT, "Trace stack (no print) at every exit from the runtime system"); PRODUCT_FLAG(bool, Debugging, false, JVMFlag::DEFAULT, "Set when executing debug methods in debug.cpp " "(to prevent triggering assertions)"); NOTPROD_FLAG(bool, VerifyLastFrame, false, JVMFlag::DEFAULT, "Verify oops on last frame on entry to VM"); PRODUCT_FLAG(bool, SafepointTimeout, false, JVMFlag::DEFAULT, "Time out and warn or fail after SafepointTimeoutDelay " "milliseconds if failed to reach safepoint"); PRODUCT_FLAG(bool, AbortVMOnSafepointTimeout, false, JVMFlag::DIAGNOSTIC, "Abort upon failure to reach safepoint (see SafepointTimeout)"); PRODUCT_FLAG(bool, AbortVMOnVMOperationTimeout, false, JVMFlag::DIAGNOSTIC, "Abort upon failure to complete VM operation promptly"); PRODUCT_FLAG(intx, AbortVMOnVMOperationTimeoutDelay, 1000, JVMFlag::DIAGNOSTIC | JVMFlag::RANGE, "Delay in milliseconds for option AbortVMOnVMOperationTimeout"); FLAG_RANGE( AbortVMOnVMOperationTimeoutDelay, 0, max_intx); // 50 retries * (5 * current_retry_count) millis = ~6.375 seconds // typically, at most a few retries are needed PRODUCT_FLAG(intx, SuspendRetryCount, 50, JVMFlag::RANGE, "Maximum retry count for an external suspend request"); FLAG_RANGE( SuspendRetryCount, 0, max_intx); PRODUCT_FLAG(intx, SuspendRetryDelay, 5, JVMFlag::RANGE, "Milliseconds to delay per retry (* current_retry_count)"); FLAG_RANGE( SuspendRetryDelay, 0, max_intx); PRODUCT_FLAG(bool, AssertOnSuspendWaitFailure, false, JVMFlag::DEFAULT, "Assert/Guarantee on external suspend wait failure"); PRODUCT_FLAG(bool, TraceSuspendWaitFailures, false, JVMFlag::DEFAULT, "Trace external suspend wait failures"); PRODUCT_FLAG(bool, MaxFDLimit, true, JVMFlag::DEFAULT, "Bump the number of file descriptors to maximum in Solaris"); PRODUCT_FLAG(bool, LogEvents, true, JVMFlag::DIAGNOSTIC, "Enable the various ring buffer event logs"); PRODUCT_FLAG(uintx, LogEventsBufferEntries, 20, JVMFlag::DIAGNOSTIC | JVMFlag::RANGE, "Number of ring buffer event logs"); FLAG_RANGE( LogEventsBufferEntries, 1, NOT_LP64(1*K) LP64_ONLY(1*M)); PRODUCT_FLAG(bool, BytecodeVerificationRemote, true, JVMFlag::DIAGNOSTIC, "Enable the Java bytecode verifier for remote classes"); PRODUCT_FLAG(bool, BytecodeVerificationLocal, false, JVMFlag::DIAGNOSTIC, "Enable the Java bytecode verifier for local classes"); DEVELOP_FLAG(bool, ForceFloatExceptions, trueInDebug, JVMFlag::DEFAULT, "Force exceptions on FP stack under/overflow"); DEVELOP_FLAG(bool, VerifyStackAtCalls, false, JVMFlag::DEFAULT, "Verify that the stack pointer is unchanged after calls"); DEVELOP_FLAG(bool, TraceJavaAssertions, false, JVMFlag::DEFAULT, "Trace java language assertions"); NOTPROD_FLAG(bool, VerifyCodeCache, false, JVMFlag::DEFAULT, "Verify code cache on memory allocation/deallocation"); DEVELOP_FLAG(bool, UseMallocOnly, false, JVMFlag::DEFAULT, "Use only malloc/free for allocation (no resource area/arena)"); DEVELOP_FLAG(bool, ZapResourceArea, trueInDebug, JVMFlag::DEFAULT, "Zap freed resource/arena space with 0xABABABAB"); NOTPROD_FLAG(bool, ZapVMHandleArea, trueInDebug, JVMFlag::DEFAULT, "Zap freed VM handle space with 0xBCBCBCBC"); NOTPROD_FLAG(bool, ZapStackSegments, trueInDebug, JVMFlag::DEFAULT, "Zap allocated/freed stack segments with 0xFADFADED"); DEVELOP_FLAG(bool, ZapUnusedHeapArea, trueInDebug, JVMFlag::DEFAULT, "Zap unused heap space with 0xBAADBABE"); DEVELOP_FLAG(bool, CheckZapUnusedHeapArea, false, JVMFlag::DEFAULT, "Check zapping of unused heap space"); DEVELOP_FLAG(bool, ZapFillerObjects, trueInDebug, JVMFlag::DEFAULT, "Zap filler objects with 0xDEAFBABE"); DEVELOP_FLAG(bool, PrintVMMessages, true, JVMFlag::DEFAULT, "Print VM messages on console"); NOTPROD_FLAG(uintx, ErrorHandlerTest, 0, JVMFlag::DEFAULT, "If > 0, provokes an error after VM initialization; the value " "determines which error to provoke. See test_error_handler() " "in vmError.cpp."); NOTPROD_FLAG(uintx, TestCrashInErrorHandler, 0, JVMFlag::DEFAULT, "If > 0, provokes an error inside VM error handler (a secondary " "crash). see test_error_handler() in vmError.cpp"); NOTPROD_FLAG(bool, TestSafeFetchInErrorHandler, false, JVMFlag::DEFAULT, "If true, tests SafeFetch inside error handler."); DEVELOP_FLAG(bool, TestUnresponsiveErrorHandler, false, JVMFlag::DEFAULT, "If true, simulates an unresponsive error handler."); DEVELOP_FLAG(bool, Verbose, false, JVMFlag::DEFAULT, "Print additional debugging information from other modes"); DEVELOP_FLAG(bool, PrintMiscellaneous, false, JVMFlag::DEFAULT, "Print uncategorized debugging information (requires +Verbose)"); DEVELOP_FLAG(bool, WizardMode, false, JVMFlag::DEFAULT, "Print much more debugging information"); PRODUCT_FLAG(bool, ShowMessageBoxOnError, false, JVMFlag::DEFAULT, "Keep process alive on VM fatal error"); PRODUCT_FLAG(bool, CreateCoredumpOnCrash, true, JVMFlag::DEFAULT, "Create core/mini dump on VM fatal error"); PRODUCT_FLAG(uint64_t, ErrorLogTimeout, 2 * 60, JVMFlag::RANGE, "Timeout, in seconds, to limit the time spent on writing an " "error log in case of a crash."); FLAG_RANGE( ErrorLogTimeout, 0, (uint64_t)max_jlong/1000); PRODUCT_FLAG_PD(bool, UseOSErrorReporting, JVMFlag::DEFAULT, "Let VM fatal error propagate to the OS (ie. WER on Windows)"); PRODUCT_FLAG(bool, SuppressFatalErrorMessage, false, JVMFlag::DEFAULT, "Report NO fatal error message (avoid deadlock)"); PRODUCT_FLAG(ccstr, OnError, "", JVMFlag::STRINGLIST, "Run user-defined commands on fatal error; see VMError.cpp " "for examples"); PRODUCT_FLAG(ccstr, OnOutOfMemoryError, "", JVMFlag::STRINGLIST, "Run user-defined commands on first java.lang.OutOfMemoryError"); PRODUCT_FLAG(bool, HeapDumpBeforeFullGC, false, JVMFlag::MANAGEABLE, "Dump heap to file before any major stop-the-world GC"); PRODUCT_FLAG(bool, HeapDumpAfterFullGC, false, JVMFlag::MANAGEABLE, "Dump heap to file after any major stop-the-world GC"); PRODUCT_FLAG(bool, HeapDumpOnOutOfMemoryError, false, JVMFlag::MANAGEABLE, "Dump heap to file when java.lang.OutOfMemoryError is thrown"); PRODUCT_FLAG(ccstr, HeapDumpPath, NULL, JVMFlag::MANAGEABLE, "When HeapDumpOnOutOfMemoryError is on, the path (filename or " "directory) of the dump file (defaults to java_pid.hprof " "in the working directory)"); DEVELOP_FLAG(bool, BreakAtWarning, false, JVMFlag::DEFAULT, "Execute breakpoint upon encountering VM warning"); PRODUCT_FLAG(ccstr, NativeMemoryTracking, "off", JVMFlag::DEFAULT, "Native memory tracking options"); PRODUCT_FLAG(bool, PrintNMTStatistics, false, JVMFlag::DIAGNOSTIC, "Print native memory tracking summary data if it is on"); PRODUCT_FLAG(bool, LogCompilation, false, JVMFlag::DIAGNOSTIC, "Log compilation activity in detail to LogFile"); PRODUCT_FLAG(bool, PrintCompilation, false, JVMFlag::DEFAULT, "Print compilations"); PRODUCT_FLAG(bool, PrintExtendedThreadInfo, false, JVMFlag::DEFAULT, "Print more information in thread dump"); PRODUCT_FLAG(intx, ScavengeRootsInCode, 2, JVMFlag::DIAGNOSTIC | JVMFlag::RANGE, "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"); FLAG_RANGE( ScavengeRootsInCode, 0, 2); PRODUCT_FLAG(bool, AlwaysRestoreFPU, false, JVMFlag::DEFAULT, "Restore the FPU control word after every JNI call (expensive)"); PRODUCT_FLAG(bool, PrintCompilation2, false, JVMFlag::DIAGNOSTIC, "Print additional statistics per compilation"); PRODUCT_FLAG(bool, PrintAdapterHandlers, false, JVMFlag::DIAGNOSTIC, "Print code generated for i2c/c2i adapters"); PRODUCT_FLAG(bool, VerifyAdapterCalls, trueInDebug, JVMFlag::DIAGNOSTIC, "Verify that i2c/c2i adapters are called properly"); DEVELOP_FLAG(bool, VerifyAdapterSharing, false, JVMFlag::DEFAULT, "Verify that the code for shared adapters is the equivalent"); PRODUCT_FLAG(bool, PrintAssembly, false, JVMFlag::DIAGNOSTIC, "Print assembly code (using external disassembler.so)"); PRODUCT_FLAG(ccstr, PrintAssemblyOptions, NULL, JVMFlag::DIAGNOSTIC, "Print options string passed to disassembler.so"); NOTPROD_FLAG(bool, PrintNMethodStatistics, false, JVMFlag::DEFAULT, "Print a summary statistic for the generated nmethods"); PRODUCT_FLAG(bool, PrintNMethods, false, JVMFlag::DIAGNOSTIC, "Print assembly code for nmethods when generated"); PRODUCT_FLAG(bool, PrintNativeNMethods, false, JVMFlag::DIAGNOSTIC, "Print assembly code for native nmethods when generated"); DEVELOP_FLAG(bool, PrintDebugInfo, false, JVMFlag::DEFAULT, "Print debug information for all nmethods when generated"); DEVELOP_FLAG(bool, PrintRelocations, false, JVMFlag::DEFAULT, "Print relocation information for all nmethods when generated"); DEVELOP_FLAG(bool, PrintDependencies, false, JVMFlag::DEFAULT, "Print dependency information for all nmethods when generated"); DEVELOP_FLAG(bool, PrintExceptionHandlers, false, JVMFlag::DEFAULT, "Print exception handler tables for all nmethods when generated"); DEVELOP_FLAG(bool, StressCompiledExceptionHandlers, false, JVMFlag::DEFAULT, "Exercise compiled exception handlers"); DEVELOP_FLAG(bool, InterceptOSException, false, JVMFlag::DEFAULT, "Start debugger when an implicit OS (e.g. NULL) " "exception happens"); PRODUCT_FLAG(bool, PrintCodeCache, false, JVMFlag::DEFAULT, "Print the code cache memory usage when exiting"); DEVELOP_FLAG(bool, PrintCodeCache2, false, JVMFlag::DEFAULT, "Print detailed usage information on the code cache when exiting"); PRODUCT_FLAG(bool, PrintCodeCacheOnCompilation, false, JVMFlag::DEFAULT, "Print the code cache memory usage each time a method is " "compiled"); PRODUCT_FLAG(bool, PrintCodeHeapAnalytics, false, JVMFlag::DIAGNOSTIC, "Print code heap usage statistics on exit and on full condition"); PRODUCT_FLAG(bool, PrintStubCode, false, JVMFlag::DIAGNOSTIC, "Print generated stub code"); PRODUCT_FLAG(bool, StackTraceInThrowable, true, JVMFlag::DEFAULT, "Collect backtrace in throwable when exception happens"); PRODUCT_FLAG(bool, OmitStackTraceInFastThrow, true, JVMFlag::DEFAULT, "Omit backtraces for some 'hot' exceptions in optimized code"); PRODUCT_FLAG(bool, ShowCodeDetailsInExceptionMessages, false, JVMFlag::MANAGEABLE, "Show exception messages from RuntimeExceptions that contain " "snippets of the failing code. Disable this to improve privacy."); PRODUCT_FLAG(bool, PrintWarnings, true, JVMFlag::DEFAULT, "Print JVM warnings to output stream"); NOTPROD_FLAG(uintx, WarnOnStalledSpinLock, 0, JVMFlag::DEFAULT, "Print warnings for stalled SpinLocks"); PRODUCT_FLAG(bool, RegisterFinalizersAtInit, true, JVMFlag::DEFAULT, "Register finalizable objects at end of Object. or " "after allocation"); DEVELOP_FLAG(bool, RegisterReferences, true, JVMFlag::DEFAULT, "Tell whether the VM should register soft/weak/final/phantom " "references"); DEVELOP_FLAG(bool, IgnoreRewrites, false, JVMFlag::DEFAULT, "Suppress rewrites of bytecodes in the oopmap generator. " "This is unsafe!"); DEVELOP_FLAG(bool, PrintCodeCacheExtension, false, JVMFlag::DEFAULT, "Print extension of code cache"); DEVELOP_FLAG(bool, UsePrivilegedStack, true, JVMFlag::DEFAULT, "Enable the security JVM functions"); DEVELOP_FLAG(bool, ProtectionDomainVerification, true, JVMFlag::DEFAULT, "Verify protection domain before resolution in system dictionary"); PRODUCT_FLAG(bool, ClassUnloading, true, JVMFlag::DEFAULT, "Do unloading of classes"); PRODUCT_FLAG(bool, ClassUnloadingWithConcurrentMark, true, JVMFlag::DEFAULT, "Do unloading of classes with a concurrent marking cycle"); DEVELOP_FLAG(bool, DisableStartThread, false, JVMFlag::DEFAULT, "Disable starting of additional Java threads " "(for debugging only)"); DEVELOP_FLAG(bool, MemProfiling, false, JVMFlag::DEFAULT, "Write memory usage profiling to log file"); DEVELOP_FLAG(bool, PrintSystemDictionaryAtExit, false, JVMFlag::DEFAULT, "Print the system dictionary at exit"); PRODUCT_FLAG(bool, DynamicallyResizeSystemDictionaries, true, JVMFlag::DIAGNOSTIC, "Dynamically resize system dictionaries as needed"); PRODUCT_FLAG(bool, AlwaysLockClassLoader, false, JVMFlag::DEFAULT, "Require the VM to acquire the class loader lock before calling " "loadClass() even for class loaders registering " "as parallel capable"); PRODUCT_FLAG(bool, AllowParallelDefineClass, false, JVMFlag::DEFAULT, "Allow parallel defineClass requests for class loaders " "registering as parallel capable"); PRODUCT_FLAG_PD(bool, DontYieldALot, JVMFlag::DEFAULT, "Throw away obvious excess yield calls"); DEVELOP_FLAG(bool, UseDetachedThreads, true, JVMFlag::DEFAULT, "Use detached threads that are recycled upon termination " "(for Solaris only)"); PRODUCT_FLAG(bool, DisablePrimordialThreadGuardPages, false, JVMFlag::EXPERIMENTAL, "Disable the use of stack guard pages if the JVM is loaded " "on the primordial process thread"); PRODUCT_FLAG(bool, UseLWPSynchronization, true, JVMFlag::DEFAULT, "Use LWP-based instead of libthread-based synchronization " "(SPARC only)"); PRODUCT_FLAG(intx, MonitorBound, 0, JVMFlag::RANGE, "(Deprecated) Bound Monitor population"); FLAG_RANGE( MonitorBound, 0, max_jint); PRODUCT_FLAG(intx, MonitorUsedDeflationThreshold, 90, JVMFlag::EXPERIMENTAL | JVMFlag::RANGE, "Percentage of used monitors before triggering cleanup " "safepoint which deflates monitors (0 is off). " "The check is performed on GuaranteedSafepointInterval."); FLAG_RANGE( MonitorUsedDeflationThreshold, 0, 100); PRODUCT_FLAG(intx, hashCode, 5, JVMFlag::EXPERIMENTAL, "(Unstable) select hashCode generation algorithm"); PRODUCT_FLAG(bool, FilterSpuriousWakeups, true, JVMFlag::DEFAULT, "When true prevents OS-level spurious, or premature, wakeups " "from Object.wait (Ignored for Windows)"); DEVELOP_FLAG(bool, UsePthreads, false, JVMFlag::DEFAULT, "Use pthread-based instead of libthread-based synchronization " "(SPARC only)"); PRODUCT_FLAG(bool, ReduceSignalUsage, false, JVMFlag::DEFAULT, "Reduce the use of OS signals in Java and/or the VM"); DEVELOP_FLAG(bool, LoadLineNumberTables, true, JVMFlag::DEFAULT, "Tell whether the class file parser loads line number tables"); DEVELOP_FLAG(bool, LoadLocalVariableTables, true, JVMFlag::DEFAULT, "Tell whether the class file parser loads local variable tables"); DEVELOP_FLAG(bool, LoadLocalVariableTypeTables, true, JVMFlag::DEFAULT, "Tell whether the class file parser loads local variable type" "tables"); PRODUCT_FLAG(bool, AllowUserSignalHandlers, false, JVMFlag::DEFAULT, "Do not complain if the application installs signal handlers " "(Solaris & Linux only)"); PRODUCT_FLAG(bool, UseSignalChaining, true, JVMFlag::DEFAULT, "Use signal-chaining to invoke signal handlers installed " "by the application (Solaris & Linux only)"); PRODUCT_FLAG(bool, RestoreMXCSROnJNICalls, false, JVMFlag::DEFAULT, "Restore MXCSR when returning from JNI calls"); PRODUCT_FLAG(bool, CheckJNICalls, false, JVMFlag::DEFAULT, "Verify all arguments to JNI calls"); PRODUCT_FLAG(bool, UseFastJNIAccessors, true, JVMFlag::DEFAULT, "Use optimized versions of GetField"); PRODUCT_FLAG(intx, MaxJNILocalCapacity, 65536, JVMFlag::RANGE, "Maximum allowable local JNI handle capacity to " "EnsureLocalCapacity() and PushLocalFrame(), " "where <= 0 is unlimited, default: 65536"); FLAG_RANGE( MaxJNILocalCapacity, min_intx, max_intx); PRODUCT_FLAG(bool, EagerXrunInit, false, JVMFlag::DEFAULT, "Eagerly initialize -Xrun libraries; allows startup profiling, " "but not all -Xrun libraries may support the state of the VM " "at this time"); PRODUCT_FLAG(bool, PreserveAllAnnotations, false, JVMFlag::DEFAULT, "Preserve RuntimeInvisibleAnnotations as well " "as RuntimeVisibleAnnotations"); DEVELOP_FLAG(uintx, PreallocatedOutOfMemoryErrorCount, 4, JVMFlag::DEFAULT, "Number of OutOfMemoryErrors preallocated with backtrace"); PRODUCT_FLAG(bool, UseXMMForArrayCopy, false, JVMFlag::DEFAULT, "Use SSE2 MOVQ instruction for Arraycopy"); NOTPROD_FLAG(bool, PrintFieldLayout, false, JVMFlag::DEFAULT, "Print field layout for each class"); // Need to limit the extent of the padding to reasonable size. // 8K is well beyond the reasonable HW cache line size, even with // aggressive prefetching, while still leaving the room for segregating // among the distinct pages. PRODUCT_FLAG(intx, ContendedPaddingWidth, 128, JVMFlag::RANGE | JVMFlag::CONSTRAINT, "How many bytes to pad the fields/classes marked @Contended with"); FLAG_RANGE( ContendedPaddingWidth, 0, 8192); FLAG_CONSTRAINT( ContendedPaddingWidth, (void*)ContendedPaddingWidthConstraintFunc, JVMFlag::AfterErgo); PRODUCT_FLAG(bool, EnableContended, true, JVMFlag::DEFAULT, "Enable @Contended annotation support"); PRODUCT_FLAG(bool, RestrictContended, true, JVMFlag::DEFAULT, "Restrict @Contended to trusted classes"); PRODUCT_FLAG(bool, UseBiasedLocking, true, JVMFlag::DEFAULT, "Enable biased locking in JVM"); PRODUCT_FLAG(intx, BiasedLockingStartupDelay, 0, JVMFlag::RANGE | JVMFlag::CONSTRAINT, "Number of milliseconds to wait before enabling biased locking"); //TODO: to avoid circular dependency, the min/max cannot be declared in header file //FLAG_RANGE( BiasedLockingStartupDelay, 0, (intx)(max_jint-(max_jint%PeriodicTask::interval_gran))); FLAG_CONSTRAINT( BiasedLockingStartupDelay, (void*)BiasedLockingStartupDelayFunc, JVMFlag::AfterErgo); PRODUCT_FLAG(bool, PrintBiasedLockingStatistics, false, JVMFlag::DIAGNOSTIC, "Print statistics of biased locking in JVM"); PRODUCT_FLAG(intx, BiasedLockingBulkRebiasThreshold, 20, JVMFlag::RANGE | JVMFlag::CONSTRAINT, "Threshold of number of revocations per type to try to " "rebias all objects in the heap of that type"); FLAG_RANGE( BiasedLockingBulkRebiasThreshold, 0, max_intx); FLAG_CONSTRAINT( BiasedLockingBulkRebiasThreshold, (void*)BiasedLockingBulkRebiasThresholdFunc, JVMFlag::AfterErgo); PRODUCT_FLAG(intx, BiasedLockingBulkRevokeThreshold, 40, JVMFlag::RANGE | JVMFlag::CONSTRAINT, "Threshold of number of revocations per type to permanently " "revoke biases of all objects in the heap of that type"); FLAG_RANGE( BiasedLockingBulkRevokeThreshold, 0, max_intx); FLAG_CONSTRAINT( BiasedLockingBulkRevokeThreshold, (void*)BiasedLockingBulkRevokeThresholdFunc, JVMFlag::AfterErgo); PRODUCT_FLAG(intx, BiasedLockingDecayTime, 25000, JVMFlag::RANGE | JVMFlag::CONSTRAINT, "Decay time (in milliseconds) to re-enable bulk rebiasing of a " "type after previous bulk rebias"); FLAG_RANGE( BiasedLockingDecayTime, 500, max_intx); FLAG_CONSTRAINT( BiasedLockingDecayTime, (void*)BiasedLockingDecayTimeFunc, JVMFlag::AfterErgo); PRODUCT_FLAG(bool, ExitOnOutOfMemoryError, false, JVMFlag::DEFAULT, "JVM exits on the first occurrence of an out-of-memory error"); PRODUCT_FLAG(bool, CrashOnOutOfMemoryError, false, JVMFlag::DEFAULT, "JVM aborts, producing an error log and core/mini dump, on the " "first occurrence of an out-of-memory error"); // tracing DEVELOP_FLAG(bool, StressRewriter, false, JVMFlag::DEFAULT, "Stress linktime bytecode rewriting"); PRODUCT_FLAG(ccstr, TraceJVMTI, NULL, JVMFlag::DEFAULT, "Trace flags for JVMTI functions and events"); // This option can change an EMCP method into an obsolete method. // This can affect tests that except specific methods to be EMCP. // This option should be used with caution. PRODUCT_FLAG(bool, StressLdcRewrite, false, JVMFlag::DEFAULT, "Force ldc -> ldc_w rewrite during RedefineClasses"); // change to false by default sometime after Mustang PRODUCT_FLAG(bool, VerifyMergedCPBytecodes, true, JVMFlag::DEFAULT, "Verify bytecodes after RedefineClasses constant pool merging"); PRODUCT_FLAG(bool, AllowRedefinitionToAddDeleteMethods, false, JVMFlag::DEFAULT, "(Deprecated) Allow redefinition to add and delete private " "static or final methods for compatibility with old releases"); DEVELOP_FLAG(bool, TraceBytecodes, false, JVMFlag::DEFAULT, "Trace bytecode execution"); DEVELOP_FLAG(bool, TraceICs, false, JVMFlag::DEFAULT, "Trace inline cache changes"); NOTPROD_FLAG(bool, TraceInvocationCounterOverflow, false, JVMFlag::DEFAULT, "Trace method invocation counter overflow"); DEVELOP_FLAG(bool, TraceInlineCacheClearing, false, JVMFlag::DEFAULT, "Trace clearing of inline caches in nmethods"); DEVELOP_FLAG(bool, TraceDependencies, false, JVMFlag::DEFAULT, "Trace dependencies"); DEVELOP_FLAG(bool, VerifyDependencies, trueInDebug, JVMFlag::DEFAULT, "Exercise and verify the compilation dependency mechanism"); DEVELOP_FLAG(bool, TraceNewOopMapGeneration, false, JVMFlag::DEFAULT, "Trace OopMapGeneration"); DEVELOP_FLAG(bool, TraceNewOopMapGenerationDetailed, false, JVMFlag::DEFAULT, "Trace OopMapGeneration: print detailed cell states"); DEVELOP_FLAG(bool, TimeOopMap, false, JVMFlag::DEFAULT, "Time calls to GenerateOopMap::compute_map() in sum"); DEVELOP_FLAG(bool, TimeOopMap2, false, JVMFlag::DEFAULT, "Time calls to GenerateOopMap::compute_map() individually"); DEVELOP_FLAG(bool, TraceOopMapRewrites, false, JVMFlag::DEFAULT, "Trace rewriting of method oops during oop map generation"); DEVELOP_FLAG(bool, TraceICBuffer, false, JVMFlag::DEFAULT, "Trace usage of IC buffer"); DEVELOP_FLAG(bool, TraceCompiledIC, false, JVMFlag::DEFAULT, "Trace changes of compiled IC"); DEVELOP_FLAG(bool, FLSVerifyDictionary, false, JVMFlag::DEFAULT, "Do lots of (expensive) FLS dictionary verification"); DEVELOP_FLAG(bool, CheckMemoryInitialization, false, JVMFlag::DEFAULT, "Check memory initialization"); PRODUCT_FLAG(uintx, ProcessDistributionStride, 4, JVMFlag::RANGE, "Stride through processors when distributing processes"); FLAG_RANGE( ProcessDistributionStride, 0, max_juint); DEVELOP_FLAG(bool, TraceFinalizerRegistration, false, JVMFlag::DEFAULT, "Trace registration of final references"); PRODUCT_FLAG(bool, IgnoreEmptyClassPaths, false, JVMFlag::DEFAULT, "Ignore empty path elements in -classpath"); PRODUCT_FLAG(size_t, InitialBootClassLoaderMetaspaceSize, NOT_LP64(2200*K) LP64_ONLY(4*M), JVMFlag::RANGE | JVMFlag::CONSTRAINT, "Initial size of the boot class loader data metaspace"); FLAG_RANGE( InitialBootClassLoaderMetaspaceSize, 30*K, max_uintx/BytesPerWord); FLAG_CONSTRAINT( InitialBootClassLoaderMetaspaceSize, (void*)InitialBootClassLoaderMetaspaceSizeConstraintFunc, JVMFlag::AfterErgo); PRODUCT_FLAG(bool, PrintHeapAtSIGBREAK, true, JVMFlag::DEFAULT, "Print heap layout in response to SIGBREAK"); PRODUCT_FLAG(bool, PrintClassHistogram, false, JVMFlag::MANAGEABLE, "Print a histogram of class instances"); PRODUCT_FLAG(double, ObjectCountCutOffPercent, 0.5, JVMFlag::EXPERIMENTAL | JVMFlag::RANGE, "The percentage of the used heap that the instances of a class " "must occupy for the class to generate a trace event"); FLAG_RANGE( ObjectCountCutOffPercent, 0.0, 100.0); // JVMTI heap profiling PRODUCT_FLAG(bool, TraceJVMTIObjectTagging, false, JVMFlag::DIAGNOSTIC, "Trace JVMTI object tagging calls"); PRODUCT_FLAG(bool, VerifyBeforeIteration, false, JVMFlag::DIAGNOSTIC, "Verify memory system before JVMTI iteration"); // compiler interface DEVELOP_FLAG(bool, CIPrintCompilerName, false, JVMFlag::DEFAULT, "when CIPrint is active, print the name of the active compiler"); PRODUCT_FLAG(bool, CIPrintCompileQueue, false, JVMFlag::DIAGNOSTIC, "display the contents of the compile queue whenever a " "compilation is enqueued"); DEVELOP_FLAG(bool, CIPrintRequests, false, JVMFlag::DEFAULT, "display every request for compilation"); PRODUCT_FLAG(bool, CITime, false, JVMFlag::DEFAULT, "collect timing information for compilation"); DEVELOP_FLAG(bool, CITimeVerbose, false, JVMFlag::DEFAULT, "be more verbose in compilation timings"); DEVELOP_FLAG(bool, CITimeEach, false, JVMFlag::DEFAULT, "display timing information after each successful compilation"); DEVELOP_FLAG(bool, CICountOSR, false, JVMFlag::DEFAULT, "use a separate counter when assigning ids to osr compilations"); DEVELOP_FLAG(bool, CICompileNatives, true, JVMFlag::DEFAULT, "compile native methods if supported by the compiler"); DEVELOP_FLAG_PD(bool, CICompileOSR, JVMFlag::DEFAULT, "compile on stack replacement methods if supported by the " "compiler"); DEVELOP_FLAG(bool, CIPrintMethodCodes, false, JVMFlag::DEFAULT, "print method bytecodes of the compiled code"); DEVELOP_FLAG(bool, CIPrintTypeFlow, false, JVMFlag::DEFAULT, "print the results of ciTypeFlow analysis"); DEVELOP_FLAG(bool, CITraceTypeFlow, false, JVMFlag::DEFAULT, "detailed per-bytecode tracing of ciTypeFlow analysis"); DEVELOP_FLAG(intx, OSROnlyBCI, -1, JVMFlag::DEFAULT, "OSR only at this bci. Negative values mean exclude that bci"); // compiler // notice: the max range value here is max_jint, not max_intx // because of overflow issue PRODUCT_FLAG(intx, CICompilerCount, CI_COMPILER_COUNT, JVMFlag::RANGE | JVMFlag::CONSTRAINT, "Number of compiler threads to run"); FLAG_RANGE( CICompilerCount, 0, max_jint); FLAG_CONSTRAINT( CICompilerCount, (void*)CICompilerCountConstraintFunc, JVMFlag::AfterErgo); PRODUCT_FLAG(bool, UseDynamicNumberOfCompilerThreads, true, JVMFlag::DEFAULT, "Dynamically choose the number of parallel compiler threads"); PRODUCT_FLAG(bool, ReduceNumberOfCompilerThreads, true, JVMFlag::DIAGNOSTIC, "Reduce the number of parallel compiler threads when they " "are not used"); PRODUCT_FLAG(bool, TraceCompilerThreads, false, JVMFlag::DIAGNOSTIC, "Trace creation and removal of compiler threads"); DEVELOP_FLAG(bool, InjectCompilerCreationFailure, false, JVMFlag::DEFAULT, "Inject thread creation failures for " "UseDynamicNumberOfCompilerThreads"); DEVELOP_FLAG(bool, UseStackBanging, true, JVMFlag::DEFAULT, "use stack banging for stack overflow checks (required for " "proper StackOverflow handling; disable only to measure cost " "of stackbanging)"); DEVELOP_FLAG(bool, GenerateSynchronizationCode, true, JVMFlag::DEFAULT, "generate locking/unlocking code for synchronized methods and " "monitors"); DEVELOP_FLAG(bool, GenerateRangeChecks, true, JVMFlag::DEFAULT, "Generate range checks for array accesses"); PRODUCT_FLAG_PD(bool, ImplicitNullChecks, JVMFlag::DIAGNOSTIC, "Generate code for implicit null checks"); PRODUCT_FLAG_PD(bool, TrapBasedNullChecks, JVMFlag::DEFAULT, "Generate code for null checks that uses a cmp and trap " "instruction raising SIGTRAP. This is only used if an access to" "null (+offset) will not raise a SIGSEGV, i.e.," "ImplicitNullChecks don't work (PPC64)."); PRODUCT_FLAG(bool, EnableThreadSMRExtraValidityChecks, true, JVMFlag::DIAGNOSTIC, "Enable Thread SMR extra validity checks"); PRODUCT_FLAG(bool, EnableThreadSMRStatistics, trueInDebug, JVMFlag::DIAGNOSTIC, "Enable Thread SMR Statistics"); PRODUCT_FLAG(bool, UseNotificationThread, true, JVMFlag::DEFAULT, "Use Notification Thread"); PRODUCT_FLAG(bool, Inline, true, JVMFlag::DEFAULT, "Enable inlining"); PRODUCT_FLAG(bool, ClipInlining, true, JVMFlag::DEFAULT, "Clip inlining if aggregate method exceeds DesiredMethodLimit"); DEVELOP_FLAG(bool, UseCHA, true, JVMFlag::DEFAULT, "Enable CHA"); PRODUCT_FLAG(bool, UseTypeProfile, true, JVMFlag::DEFAULT, "Check interpreter profile for historically monomorphic calls"); PRODUCT_FLAG(bool, PrintInlining, false, JVMFlag::DIAGNOSTIC, "Print inlining optimizations"); PRODUCT_FLAG(bool, UsePopCountInstruction, false, JVMFlag::DEFAULT, "Use population count instruction"); DEVELOP_FLAG(bool, EagerInitialization, false, JVMFlag::DEFAULT, "Eagerly initialize classes if possible"); PRODUCT_FLAG(bool, LogTouchedMethods, false, JVMFlag::DIAGNOSTIC, "Log methods which have been ever touched in runtime"); PRODUCT_FLAG(bool, PrintTouchedMethodsAtExit, false, JVMFlag::DIAGNOSTIC, "Print all methods that have been ever touched in runtime"); DEVELOP_FLAG(bool, TraceMethodReplacement, false, JVMFlag::DEFAULT, "Print when methods are replaced do to recompilation"); DEVELOP_FLAG(bool, PrintMethodFlushing, false, JVMFlag::DEFAULT, "Print the nmethods being flushed"); PRODUCT_FLAG(bool, PrintMethodFlushingStatistics, false, JVMFlag::DIAGNOSTIC, "print statistics about method flushing"); PRODUCT_FLAG(intx, HotMethodDetectionLimit, 100000, JVMFlag::DIAGNOSTIC | JVMFlag::RANGE, "Number of compiled code invocations after which " "the method is considered as hot by the flusher"); FLAG_RANGE( HotMethodDetectionLimit, 1, max_jint); PRODUCT_FLAG(intx, MinPassesBeforeFlush, 10, JVMFlag::DIAGNOSTIC | JVMFlag::RANGE, "Minimum number of sweeper passes before an nmethod " "can be flushed"); FLAG_RANGE( MinPassesBeforeFlush, 0, max_intx); PRODUCT_FLAG(bool, UseCodeAging, true, JVMFlag::DEFAULT, "Insert counter to detect warm methods"); PRODUCT_FLAG(bool, StressCodeAging, false, JVMFlag::DIAGNOSTIC, "Start with counters compiled in"); DEVELOP_FLAG(bool, StressCodeBuffers, false, JVMFlag::DEFAULT, "Exercise code buffer expansion and other rare state changes"); PRODUCT_FLAG(bool, DebugNonSafepoints, trueInDebug, JVMFlag::DIAGNOSTIC, "Generate extra debugging information for non-safepoints in " "nmethods"); PRODUCT_FLAG(bool, PrintVMOptions, false, JVMFlag::DEFAULT, "Print flags that appeared on the command line"); PRODUCT_FLAG(bool, IgnoreUnrecognizedVMOptions, false, JVMFlag::DEFAULT, "Ignore unrecognized VM options"); PRODUCT_FLAG(bool, PrintCommandLineFlags, false, JVMFlag::DEFAULT, "Print flags specified on command line or set by ergonomics"); PRODUCT_FLAG(bool, PrintFlagsInitial, false, JVMFlag::DEFAULT, "Print all VM flags before argument processing and exit VM"); PRODUCT_FLAG(bool, PrintFlagsFinal, false, JVMFlag::DEFAULT, "Print all VM flags after argument and ergonomic processing"); NOTPROD_FLAG(bool, PrintFlagsWithComments, false, JVMFlag::DEFAULT, "Print all VM flags with default values and descriptions and " "exit"); PRODUCT_FLAG(bool, PrintFlagsRanges, false, JVMFlag::DEFAULT, "Print VM flags and their ranges"); PRODUCT_FLAG(bool, SerializeVMOutput, true, JVMFlag::DIAGNOSTIC, "Use a mutex to serialize output to tty and LogFile"); PRODUCT_FLAG(bool, DisplayVMOutput, true, JVMFlag::DIAGNOSTIC, "Display all VM output on the tty, independently of LogVMOutput"); PRODUCT_FLAG(bool, LogVMOutput, false, JVMFlag::DIAGNOSTIC, "Save VM output to LogFile"); PRODUCT_FLAG(ccstr, LogFile, NULL, JVMFlag::DIAGNOSTIC, "If LogVMOutput or LogCompilation is on, save VM output to " "this file [default: ./hotspot_pid%p.log] (%p replaced with pid)"); PRODUCT_FLAG(ccstr, ErrorFile, NULL, JVMFlag::DEFAULT, "If an error occurs, save the error data to this file " "[default: ./hs_err_pid%p.log] (%p replaced with pid)"); PRODUCT_FLAG(bool, ExtensiveErrorReports, PRODUCT_ONLY(false) NOT_PRODUCT(true), JVMFlag::DEFAULT, "Error reports are more extensive."); PRODUCT_FLAG(bool, DisplayVMOutputToStderr, false, JVMFlag::DEFAULT, "If DisplayVMOutput is true, display all VM output to stderr"); PRODUCT_FLAG(bool, DisplayVMOutputToStdout, false, JVMFlag::DEFAULT, "If DisplayVMOutput is true, display all VM output to stdout"); PRODUCT_FLAG(bool, ErrorFileToStderr, false, JVMFlag::DEFAULT, "If true, error data is printed to stderr instead of a file"); PRODUCT_FLAG(bool, ErrorFileToStdout, false, JVMFlag::DEFAULT, "If true, error data is printed to stdout instead of a file"); PRODUCT_FLAG(bool, UseHeavyMonitors, false, JVMFlag::DEFAULT, "use heavyweight instead of lightweight Java monitors"); PRODUCT_FLAG(bool, PrintStringTableStatistics, false, JVMFlag::DEFAULT, "print statistics about the StringTable and SymbolTable"); PRODUCT_FLAG(bool, VerifyStringTableAtExit, false, JVMFlag::DIAGNOSTIC, "verify StringTable contents at exit"); NOTPROD_FLAG(bool, PrintSymbolTableSizeHistogram, false, JVMFlag::DEFAULT, "print histogram of the symbol table"); NOTPROD_FLAG(bool, ExitVMOnVerifyError, false, JVMFlag::DEFAULT, "standard exit from VM if bytecode verify error " "(only in debug mode)"); PRODUCT_FLAG(ccstr, AbortVMOnException, NULL, JVMFlag::DIAGNOSTIC, "Call fatal if this exception is thrown. Example: " "java -XX:AbortVMOnException=java.lang.NullPointerException Foo"); PRODUCT_FLAG(ccstr, AbortVMOnExceptionMessage, NULL, JVMFlag::DIAGNOSTIC, "Call fatal if the exception pointed by AbortVMOnException " "has this message"); DEVELOP_FLAG(bool, DebugVtables, false, JVMFlag::DEFAULT, "add debugging code to vtable dispatch"); NOTPROD_FLAG(bool, PrintVtableStats, false, JVMFlag::DEFAULT, "print vtables stats at end of run"); DEVELOP_FLAG(bool, TraceCreateZombies, false, JVMFlag::DEFAULT, "trace creation of zombie nmethods"); PRODUCT_FLAG(bool, RangeCheckElimination, true, JVMFlag::DEFAULT, "Eliminate range checks"); DEVELOP_FLAG_PD(bool, UncommonNullCast, JVMFlag::DEFAULT, "track occurrences of null in casts; adjust compiler tactics"); DEVELOP_FLAG(bool, TypeProfileCasts, true, JVMFlag::DEFAULT, "treat casts like calls for purposes of type profiling"); DEVELOP_FLAG(bool, TraceLivenessGen, false, JVMFlag::DEFAULT, "Trace the generation of liveness analysis information"); NOTPROD_FLAG(bool, TraceLivenessQuery, false, JVMFlag::DEFAULT, "Trace queries of liveness analysis information"); NOTPROD_FLAG(bool, CollectIndexSetStatistics, false, JVMFlag::DEFAULT, "Collect information about IndexSets"); DEVELOP_FLAG(bool, UseLoopSafepoints, true, JVMFlag::DEFAULT, "Generate Safepoint nodes in every loop"); DEVELOP_FLAG(intx, FastAllocateSizeLimit, 128*K, JVMFlag::DEFAULT, /* Note: This value is zero mod 1<<13 for a cheap sparc set. */ "Inline allocations larger than this in doublewords must go slow"); // Note: This value is zero mod 1<<13 for a cheap sparc set. PRODUCT_FLAG_PD(bool, CompactStrings, JVMFlag::DEFAULT, "Enable Strings to use single byte chars in backing store"); PRODUCT_FLAG_PD(uintx, TypeProfileLevel, JVMFlag::CONSTRAINT, "=XYZ, with Z: Type profiling of arguments at call; " "Y: Type profiling of return value at call; " "X: Type profiling of parameters to methods; " "X, Y and Z in 0=off ; 1=jsr292 only; 2=all methods"); FLAG_CONSTRAINT( TypeProfileLevel, (void*)TypeProfileLevelConstraintFunc, JVMFlag::AfterErgo); PRODUCT_FLAG(intx, TypeProfileArgsLimit, 2, JVMFlag::RANGE, "max number of call arguments to consider for type profiling"); FLAG_RANGE( TypeProfileArgsLimit, 0, 16); PRODUCT_FLAG(intx, TypeProfileParmsLimit, 2, JVMFlag::RANGE, "max number of incoming parameters to consider for type profiling" ", -1 for all"); FLAG_RANGE( TypeProfileParmsLimit, -1, 64); // statistics DEVELOP_FLAG(bool, CountCompiledCalls, false, JVMFlag::DEFAULT, "Count method invocations"); NOTPROD_FLAG(bool, CountRuntimeCalls, false, JVMFlag::DEFAULT, "Count VM runtime calls"); DEVELOP_FLAG(bool, CountJNICalls, false, JVMFlag::DEFAULT, "Count jni method invocations"); NOTPROD_FLAG(bool, CountJVMCalls, false, JVMFlag::DEFAULT, "Count jvm method invocations"); NOTPROD_FLAG(bool, CountRemovableExceptions, false, JVMFlag::DEFAULT, "Count exceptions that could be replaced by branches due to " "inlining"); NOTPROD_FLAG(bool, ICMissHistogram, false, JVMFlag::DEFAULT, "Produce histogram of IC misses"); // interpreter PRODUCT_FLAG_PD(bool, RewriteBytecodes, JVMFlag::DEFAULT, "Allow rewriting of bytecodes (bytecodes are not immutable)"); PRODUCT_FLAG_PD(bool, RewriteFrequentPairs, JVMFlag::DEFAULT, "Rewrite frequently used bytecode pairs into a single bytecode"); PRODUCT_FLAG(bool, PrintInterpreter, false, JVMFlag::DIAGNOSTIC, "Print the generated interpreter code"); PRODUCT_FLAG(bool, UseInterpreter, true, JVMFlag::DEFAULT, "Use interpreter for non-compiled methods"); DEVELOP_FLAG(bool, UseFastSignatureHandlers, true, JVMFlag::DEFAULT, "Use fast signature handlers for native calls"); PRODUCT_FLAG(bool, UseLoopCounter, true, JVMFlag::DEFAULT, "Increment invocation counter on backward branch"); PRODUCT_FLAG_PD(bool, UseOnStackReplacement, JVMFlag::DEFAULT, "Use on stack replacement, calls runtime if invoc. counter " "overflows in loop"); NOTPROD_FLAG(bool, TraceOnStackReplacement, false, JVMFlag::DEFAULT, "Trace on stack replacement"); PRODUCT_FLAG_PD(bool, PreferInterpreterNativeStubs, JVMFlag::DEFAULT, "Use always interpreter stubs for native methods invoked via " "interpreter"); DEVELOP_FLAG(bool, CountBytecodes, false, JVMFlag::DEFAULT, "Count number of bytecodes executed"); DEVELOP_FLAG(bool, PrintBytecodeHistogram, false, JVMFlag::DEFAULT, "Print histogram of the executed bytecodes"); DEVELOP_FLAG(bool, PrintBytecodePairHistogram, false, JVMFlag::DEFAULT, "Print histogram of the executed bytecode pairs"); PRODUCT_FLAG(bool, PrintSignatureHandlers, false, JVMFlag::DIAGNOSTIC, "Print code generated for native method signature handlers"); DEVELOP_FLAG(bool, VerifyOops, false, JVMFlag::DEFAULT, "Do plausibility checks for oops"); DEVELOP_FLAG(bool, CheckUnhandledOops, false, JVMFlag::DEFAULT, "Check for unhandled oops in VM code"); DEVELOP_FLAG(bool, VerifyJNIFields, trueInDebug, JVMFlag::DEFAULT, "Verify jfieldIDs for instance fields"); NOTPROD_FLAG(bool, VerifyJNIEnvThread, false, JVMFlag::DEFAULT, "Verify JNIEnv.thread == Thread::current() when entering VM " "from JNI"); DEVELOP_FLAG(bool, VerifyFPU, false, JVMFlag::DEFAULT, "Verify FPU state (check for NaN's, etc.)"); DEVELOP_FLAG(bool, VerifyThread, false, JVMFlag::DEFAULT, "Watch the thread register for corruption (SPARC only)"); DEVELOP_FLAG(bool, VerifyActivationFrameSize, false, JVMFlag::DEFAULT, "Verify that activation frame didn't become smaller than its " "minimal size"); DEVELOP_FLAG(bool, TraceFrequencyInlining, false, JVMFlag::DEFAULT, "Trace frequency based inlining"); DEVELOP_FLAG_PD(bool, InlineIntrinsics, JVMFlag::DEFAULT, "Inline intrinsics that can be statically resolved"); PRODUCT_FLAG_PD(bool, ProfileInterpreter, JVMFlag::DEFAULT, "Profile at the bytecode level during interpretation"); DEVELOP_FLAG(bool, TraceProfileInterpreter, false, JVMFlag::DEFAULT, "Trace profiling at the bytecode level during interpretation. " "This outputs the profiling information collected to improve " "jit compilation."); DEVELOP_FLAG_PD(bool, ProfileTraps, JVMFlag::DEFAULT, "Profile deoptimization traps at the bytecode level"); PRODUCT_FLAG(intx, ProfileMaturityPercentage, 20, JVMFlag::RANGE, "number of method invocations/branches (expressed as % of " "CompileThreshold) before using the method's profile"); FLAG_RANGE( ProfileMaturityPercentage, 0, 100); PRODUCT_FLAG(bool, PrintMethodData, false, JVMFlag::DIAGNOSTIC, "Print the results of +ProfileInterpreter at end of run"); DEVELOP_FLAG(bool, VerifyDataPointer, trueInDebug, JVMFlag::DEFAULT, "Verify the method data pointer during interpreter profiling"); DEVELOP_FLAG(bool, VerifyCompiledCode, false, JVMFlag::DEFAULT, "Include miscellaneous runtime verifications in nmethod code; " "default off because it disturbs nmethod size heuristics"); NOTPROD_FLAG(bool, CrashGCForDumpingJavaThread, false, JVMFlag::DEFAULT, "Manually make GC thread crash then dump java stack trace; " "Test only"); // compilation PRODUCT_FLAG(bool, UseCompiler, true, JVMFlag::DEFAULT, "Use Just-In-Time compilation"); PRODUCT_FLAG(bool, UseCounterDecay, true, JVMFlag::DEFAULT, "Adjust recompilation counters"); DEVELOP_FLAG(intx, CounterHalfLifeTime, 30, JVMFlag::DEFAULT, "Half-life time of invocation counters (in seconds)"); DEVELOP_FLAG(intx, CounterDecayMinIntervalLength, 500, JVMFlag::DEFAULT, "The minimum interval (in milliseconds) between invocation of " "CounterDecay"); PRODUCT_FLAG(bool, AlwaysCompileLoopMethods, false, JVMFlag::DEFAULT, "When using recompilation, never interpret methods " "containing loops"); PRODUCT_FLAG(bool, DontCompileHugeMethods, true, JVMFlag::DEFAULT, "Do not compile methods > HugeMethodLimit"); // Bytecode escape analysis estimation. PRODUCT_FLAG(bool, EstimateArgEscape, true, JVMFlag::DEFAULT, "Analyze bytecodes to estimate escape state of arguments"); PRODUCT_FLAG(intx, BCEATraceLevel, 0, JVMFlag::RANGE, "How much tracing to do of bytecode escape analysis estimates " "(0-3)"); FLAG_RANGE( BCEATraceLevel, 0, 3); PRODUCT_FLAG(intx, MaxBCEAEstimateLevel, 5, JVMFlag::RANGE, "Maximum number of nested calls that are analyzed by BC EA"); FLAG_RANGE( MaxBCEAEstimateLevel, 0, max_jint); PRODUCT_FLAG(intx, MaxBCEAEstimateSize, 150, JVMFlag::RANGE, "Maximum bytecode size of a method to be analyzed by BC EA"); FLAG_RANGE( MaxBCEAEstimateSize, 0, max_jint); PRODUCT_FLAG(intx, AllocatePrefetchStyle, 1, JVMFlag::RANGE, "0 = no prefetch, " "1 = generate prefetch instructions for each allocation, " "2 = use TLAB watermark to gate allocation prefetch, " "3 = generate one prefetch instruction per cache line"); FLAG_RANGE( AllocatePrefetchStyle, 0, 3); PRODUCT_FLAG(intx, AllocatePrefetchDistance, -1, JVMFlag::CONSTRAINT, "Distance to prefetch ahead of allocation pointer. " "-1: use system-specific value (automatically determined"); FLAG_CONSTRAINT( AllocatePrefetchDistance, (void*)AllocatePrefetchDistanceConstraintFunc, JVMFlag::AfterMemoryInit); PRODUCT_FLAG(intx, AllocatePrefetchLines, 3, JVMFlag::RANGE, "Number of lines to prefetch ahead of array allocation pointer"); FLAG_RANGE( AllocatePrefetchLines, 1, 64); PRODUCT_FLAG(intx, AllocateInstancePrefetchLines, 1, JVMFlag::RANGE, "Number of lines to prefetch ahead of instance allocation " "pointer"); FLAG_RANGE( AllocateInstancePrefetchLines, 1, 64); PRODUCT_FLAG(intx, AllocatePrefetchStepSize, 16, JVMFlag::RANGE | JVMFlag::CONSTRAINT, "Step size in bytes of sequential prefetch instructions"); FLAG_RANGE( AllocatePrefetchStepSize, 1, 512); FLAG_CONSTRAINT( AllocatePrefetchStepSize, (void*)AllocatePrefetchStepSizeConstraintFunc, JVMFlag::AfterMemoryInit); PRODUCT_FLAG(intx, AllocatePrefetchInstr, 0, JVMFlag::CONSTRAINT, "Select instruction to prefetch ahead of allocation pointer"); FLAG_CONSTRAINT( AllocatePrefetchInstr, (void*)AllocatePrefetchInstrConstraintFunc, JVMFlag::AfterMemoryInit); // deoptimization DEVELOP_FLAG(bool, TraceDeoptimization, false, JVMFlag::DEFAULT, "Trace deoptimization"); DEVELOP_FLAG(bool, PrintDeoptimizationDetails, false, JVMFlag::DEFAULT, "Print more information about deoptimization"); DEVELOP_FLAG(bool, DebugDeoptimization, false, JVMFlag::DEFAULT, "Tracing various information while debugging deoptimization"); PRODUCT_FLAG(intx, SelfDestructTimer, 0, JVMFlag::RANGE, "Will cause VM to terminate after a given time (in minutes) " "(0 means off)"); FLAG_RANGE( SelfDestructTimer, 0, max_intx); PRODUCT_FLAG(intx, MaxJavaStackTraceDepth, 1024, JVMFlag::RANGE, "The maximum number of lines in the stack trace for Java " "exceptions (0 means all)"); FLAG_RANGE( MaxJavaStackTraceDepth, 0, max_jint/2); // notice: the max range value here is max_jint, not max_intx // because of overflow issue PRODUCT_FLAG(intx, GuaranteedSafepointInterval, 1000, JVMFlag::DIAGNOSTIC | JVMFlag::RANGE, "Guarantee a safepoint (at least) every so many milliseconds " "(0 means none)"); FLAG_RANGE( GuaranteedSafepointInterval, 0, max_jint); PRODUCT_FLAG(intx, SafepointTimeoutDelay, 10000, JVMFlag::RANGE, "Delay in milliseconds for option SafepointTimeout"); FLAG_RANGE( SafepointTimeoutDelay, 0, max_intx LP64_ONLY(/MICROUNITS)); PRODUCT_FLAG(intx, NmethodSweepActivity, 10, JVMFlag::RANGE, "Removes cold nmethods from code cache if > 0. Higher values " "result in more aggressive sweeping"); FLAG_RANGE( NmethodSweepActivity, 0, 2000); NOTPROD_FLAG(bool, LogSweeper, false, JVMFlag::DEFAULT, "Keep a ring buffer of sweeper activity"); NOTPROD_FLAG(intx, SweeperLogEntries, 1024, JVMFlag::DEFAULT, "Number of records in the ring buffer of sweeper activity"); NOTPROD_FLAG(intx, MemProfilingInterval, 500, JVMFlag::DEFAULT, "Time between each invocation of the MemProfiler"); DEVELOP_FLAG(intx, MallocCatchPtr, -1, JVMFlag::DEFAULT, "Hit breakpoint when mallocing/freeing this pointer"); NOTPROD_FLAG(ccstr, SuppressErrorAt, "", JVMFlag::STRINGLIST, "List of assertions (file:line) to muzzle"); DEVELOP_FLAG(intx, StackPrintLimit, 100, JVMFlag::DEFAULT, "number of stack frames to print in VM-level stack dump"); NOTPROD_FLAG(intx, MaxElementPrintSize, 256, JVMFlag::DEFAULT, "maximum number of elements to print"); NOTPROD_FLAG(intx, MaxSubklassPrintSize, 4, JVMFlag::DEFAULT, "maximum number of subklasses to print when printing klass"); PRODUCT_FLAG(intx, MaxInlineLevel, 15, JVMFlag::RANGE, "maximum number of nested calls that are inlined"); FLAG_RANGE( MaxInlineLevel, 0, max_jint); PRODUCT_FLAG(intx, MaxRecursiveInlineLevel, 1, JVMFlag::RANGE, "maximum number of nested recursive calls that are inlined"); FLAG_RANGE( MaxRecursiveInlineLevel, 0, max_jint); DEVELOP_FLAG(intx, MaxForceInlineLevel, 100, JVMFlag::RANGE, "maximum number of nested calls that are forced for inlining " "(using CompileCommand or marked w/ @ForceInline)"); FLAG_RANGE( MaxForceInlineLevel, 0, max_jint); PRODUCT_FLAG_PD(intx, InlineSmallCode, JVMFlag::RANGE, "Only inline already compiled methods if their code size is " "less than this"); FLAG_RANGE( InlineSmallCode, 0, max_jint); PRODUCT_FLAG(intx, MaxInlineSize, 35, JVMFlag::RANGE, "The maximum bytecode size of a method to be inlined"); FLAG_RANGE( MaxInlineSize, 0, max_jint); PRODUCT_FLAG_PD(intx, FreqInlineSize, JVMFlag::RANGE, "The maximum bytecode size of a frequent method to be inlined"); FLAG_RANGE( FreqInlineSize, 0, max_jint); PRODUCT_FLAG(intx, MaxTrivialSize, 6, JVMFlag::RANGE, "The maximum bytecode size of a trivial method to be inlined"); FLAG_RANGE( MaxTrivialSize, 0, max_jint); PRODUCT_FLAG(intx, MinInliningThreshold, 250, JVMFlag::RANGE, "The minimum invocation count a method needs to have to be " "inlined"); FLAG_RANGE( MinInliningThreshold, 0, max_jint); DEVELOP_FLAG(intx, MethodHistogramCutoff, 100, JVMFlag::DEFAULT, "The cutoff value for method invocation histogram (+CountCalls)"); DEVELOP_FLAG(intx, DontYieldALotInterval, 10, JVMFlag::DEFAULT, "Interval between which yields will be dropped (milliseconds)"); NOTPROD_FLAG(intx, DeoptimizeALotInterval, 5, JVMFlag::DEFAULT, "Number of exits until DeoptimizeALot kicks in"); NOTPROD_FLAG(intx, ZombieALotInterval, 5, JVMFlag::DEFAULT, "Number of exits until ZombieALot kicks in"); PRODUCT_FLAG(uintx, MallocMaxTestWords, 0, JVMFlag::DIAGNOSTIC | JVMFlag::RANGE, "If non-zero, maximum number of words that malloc/realloc can " "allocate (for testing only)"); FLAG_RANGE( MallocMaxTestWords, 0, max_uintx); PRODUCT_FLAG(intx, TypeProfileWidth, 2, JVMFlag::RANGE, "Number of receiver types to record in call/cast profile"); FLAG_RANGE( TypeProfileWidth, 0, 8); DEVELOP_FLAG(intx, BciProfileWidth, 2, JVMFlag::DEFAULT, "Number of return bci's to record in ret profile"); PRODUCT_FLAG(intx, PerMethodRecompilationCutoff, 400, JVMFlag::RANGE, "After recompiling N times, stay in the interpreter (-1=>'Inf')"); FLAG_RANGE( PerMethodRecompilationCutoff, -1, max_intx); PRODUCT_FLAG(intx, PerBytecodeRecompilationCutoff, 200, JVMFlag::RANGE, "Per-BCI limit on repeated recompilation (-1=>'Inf')"); FLAG_RANGE( PerBytecodeRecompilationCutoff, -1, max_intx); PRODUCT_FLAG(intx, PerMethodTrapLimit, 100, JVMFlag::RANGE, "Limit on traps (of one kind) in a method (includes inlines)"); FLAG_RANGE( PerMethodTrapLimit, 0, max_jint); PRODUCT_FLAG(intx, PerMethodSpecTrapLimit, 5000, JVMFlag::EXPERIMENTAL | JVMFlag::RANGE, "Limit on speculative traps (of one kind) in a method " "(includes inlines)"); FLAG_RANGE( PerMethodSpecTrapLimit, 0, max_jint); PRODUCT_FLAG(intx, PerBytecodeTrapLimit, 4, JVMFlag::RANGE, "Limit on traps (of one kind) at a particular BCI"); FLAG_RANGE( PerBytecodeTrapLimit, 0, max_jint); PRODUCT_FLAG(intx, SpecTrapLimitExtraEntries, 3, JVMFlag::EXPERIMENTAL, "Extra method data trap entries for speculation"); DEVELOP_FLAG(intx, InlineFrequencyRatio, 20, JVMFlag::RANGE, "Ratio of call site execution to caller method invocation"); FLAG_RANGE( InlineFrequencyRatio, 0, max_jint); PRODUCT_FLAG_PD(intx, InlineFrequencyCount, JVMFlag::DIAGNOSTIC | JVMFlag::RANGE, "Count of call site execution necessary to trigger frequent " "inlining"); FLAG_RANGE( InlineFrequencyCount, 0, max_jint); DEVELOP_FLAG(intx, InlineThrowCount, 50, JVMFlag::RANGE, "Force inlining of interpreted methods that throw this often"); FLAG_RANGE( InlineThrowCount, 0, max_jint); DEVELOP_FLAG(intx, InlineThrowMaxSize, 200, JVMFlag::RANGE, "Force inlining of throwing methods smaller than this"); FLAG_RANGE( InlineThrowMaxSize, 0, max_jint); DEVELOP_FLAG(intx, ProfilerNodeSize, 1024, JVMFlag::RANGE, "Size in K to allocate for the Profile Nodes of each thread"); FLAG_RANGE( ProfilerNodeSize, 0, 1024); PRODUCT_FLAG_PD(size_t, MetaspaceSize, JVMFlag::CONSTRAINT, "Initial threshold (in bytes) at which a garbage collection " "is done to reduce Metaspace usage"); FLAG_CONSTRAINT( MetaspaceSize, (void*)MetaspaceSizeConstraintFunc, JVMFlag::AfterErgo); PRODUCT_FLAG(size_t, MaxMetaspaceSize, max_uintx, JVMFlag::CONSTRAINT, "Maximum size of Metaspaces (in bytes)"); FLAG_CONSTRAINT( MaxMetaspaceSize, (void*)MaxMetaspaceSizeConstraintFunc, JVMFlag::AfterErgo); PRODUCT_FLAG(size_t, CompressedClassSpaceSize, 1*G, JVMFlag::RANGE, "Maximum size of class area in Metaspace when compressed " "class pointers are used"); FLAG_RANGE( CompressedClassSpaceSize, 1*M, 3*G); PRODUCT_FLAG(uintx, MinHeapFreeRatio, 40, JVMFlag::MANAGEABLE | JVMFlag::RANGE | JVMFlag::CONSTRAINT, "The minimum percentage of heap free after GC to avoid expansion." " For most GCs this applies to the old generation. In G1 and" " ParallelGC it applies to the whole heap."); FLAG_RANGE( MinHeapFreeRatio, 0, 100); FLAG_CONSTRAINT( MinHeapFreeRatio, (void*)MinHeapFreeRatioConstraintFunc, JVMFlag::AfterErgo); PRODUCT_FLAG(uintx, MaxHeapFreeRatio, 70, JVMFlag::MANAGEABLE | JVMFlag::RANGE | JVMFlag::CONSTRAINT, "The maximum percentage of heap free after GC to avoid shrinking." " For most GCs this applies to the old generation. In G1 and" " ParallelGC it applies to the whole heap."); FLAG_RANGE( MaxHeapFreeRatio, 0, 100); FLAG_CONSTRAINT( MaxHeapFreeRatio, (void*)MaxHeapFreeRatioConstraintFunc, JVMFlag::AfterErgo); PRODUCT_FLAG(bool, ShrinkHeapInSteps, true, JVMFlag::DEFAULT, "When disabled, informs the GC to shrink the java heap directly" " to the target size at the next full GC rather than requiring" " smaller steps during multiple full GCs."); PRODUCT_FLAG(intx, SoftRefLRUPolicyMSPerMB, 1000, JVMFlag::RANGE | JVMFlag::CONSTRAINT, "Number of milliseconds per MB of free space in the heap"); FLAG_RANGE( SoftRefLRUPolicyMSPerMB, 0, max_intx); FLAG_CONSTRAINT( SoftRefLRUPolicyMSPerMB, (void*)SoftRefLRUPolicyMSPerMBConstraintFunc, JVMFlag::AfterMemoryInit); PRODUCT_FLAG(size_t, MinHeapDeltaBytes, ScaleForWordSize(128*K), JVMFlag::RANGE, "The minimum change in heap space due to GC (in bytes)"); FLAG_RANGE( MinHeapDeltaBytes, 0, max_uintx); PRODUCT_FLAG(size_t, MinMetaspaceExpansion, ScaleForWordSize(256*K), JVMFlag::RANGE, "The minimum expansion of Metaspace (in bytes)"); FLAG_RANGE( MinMetaspaceExpansion, 0, max_uintx); PRODUCT_FLAG(uintx, MaxMetaspaceFreeRatio, 70, JVMFlag::RANGE | JVMFlag::CONSTRAINT, "The maximum percentage of Metaspace free after GC to avoid " "shrinking"); FLAG_RANGE( MaxMetaspaceFreeRatio, 0, 100); FLAG_CONSTRAINT( MaxMetaspaceFreeRatio, (void*)MaxMetaspaceFreeRatioConstraintFunc, JVMFlag::AfterErgo); PRODUCT_FLAG(uintx, MinMetaspaceFreeRatio, 40, JVMFlag::RANGE | JVMFlag::CONSTRAINT, "The minimum percentage of Metaspace free after GC to avoid " "expansion"); FLAG_RANGE( MinMetaspaceFreeRatio, 0, 99); FLAG_CONSTRAINT( MinMetaspaceFreeRatio, (void*)MinMetaspaceFreeRatioConstraintFunc, JVMFlag::AfterErgo); PRODUCT_FLAG(size_t, MaxMetaspaceExpansion, ScaleForWordSize(4*M), JVMFlag::RANGE, "The maximum expansion of Metaspace without full GC (in bytes)"); FLAG_RANGE( MaxMetaspaceExpansion, 0, max_uintx); // stack parameters PRODUCT_FLAG_PD(intx, StackYellowPages, JVMFlag::RANGE, "Number of yellow zone (recoverable overflows) pages of size " "4KB. If pages are bigger yellow zone is aligned up."); FLAG_RANGE( StackYellowPages, MIN_STACK_YELLOW_PAGES, (DEFAULT_STACK_YELLOW_PAGES+5)); PRODUCT_FLAG_PD(intx, StackRedPages, JVMFlag::RANGE, "Number of red zone (unrecoverable overflows) pages of size " "4KB. If pages are bigger red zone is aligned up."); FLAG_RANGE( StackRedPages, MIN_STACK_RED_PAGES, (DEFAULT_STACK_RED_PAGES+2)); PRODUCT_FLAG_PD(intx, StackReservedPages, JVMFlag::RANGE, "Number of reserved zone (reserved to annotated methods) pages" " of size 4KB. If pages are bigger reserved zone is aligned up."); FLAG_RANGE( StackReservedPages, MIN_STACK_RESERVED_PAGES, (DEFAULT_STACK_RESERVED_PAGES+10)); PRODUCT_FLAG(bool, RestrictReservedStack, true, JVMFlag::DEFAULT, "Restrict @ReservedStackAccess to trusted classes"); // greater stack shadow pages can't generate instruction to bang stack PRODUCT_FLAG_PD(intx, StackShadowPages, JVMFlag::RANGE, "Number of shadow zone (for overflow checking) pages of size " "4KB. If pages are bigger shadow zone is aligned up. " "This should exceed the depth of the VM and native call stack."); FLAG_RANGE( StackShadowPages, MIN_STACK_SHADOW_PAGES, (DEFAULT_STACK_SHADOW_PAGES+30)); PRODUCT_FLAG_PD(intx, ThreadStackSize, JVMFlag::RANGE, "Thread Stack Size (in Kbytes)"); FLAG_RANGE( ThreadStackSize, 0, 1 * M); PRODUCT_FLAG_PD(intx, VMThreadStackSize, JVMFlag::RANGE, "Non-Java Thread Stack Size (in Kbytes)"); FLAG_RANGE( VMThreadStackSize, 0, max_intx/(1 * K)); PRODUCT_FLAG_PD(intx, CompilerThreadStackSize, JVMFlag::RANGE, "Compiler Thread Stack Size (in Kbytes)"); FLAG_RANGE( CompilerThreadStackSize, 0, max_intx/(1 * K)); DEVELOP_FLAG_PD(size_t, JVMInvokeMethodSlack, JVMFlag::DEFAULT, "Stack space (bytes) required for JVM_InvokeMethod to complete"); // code cache parameters DEVELOP_FLAG_PD(uintx, CodeCacheSegmentSize, JVMFlag::RANGE | JVMFlag::CONSTRAINT, "Code cache segment size (in bytes) - smallest unit of " "allocation"); FLAG_RANGE( CodeCacheSegmentSize, 1, 1024); FLAG_CONSTRAINT( CodeCacheSegmentSize, (void*)CodeCacheSegmentSizeConstraintFunc, JVMFlag::AfterErgo); DEVELOP_FLAG_PD(intx, CodeEntryAlignment, JVMFlag::CONSTRAINT, "Code entry alignment for generated code (in bytes)"); FLAG_CONSTRAINT( CodeEntryAlignment, (void*)CodeEntryAlignmentConstraintFunc, JVMFlag::AfterErgo); PRODUCT_FLAG_PD(intx, OptoLoopAlignment, JVMFlag::RANGE | JVMFlag::CONSTRAINT, "Align inner loops to zero relative to this modulus"); FLAG_RANGE( OptoLoopAlignment, 1, 16); FLAG_CONSTRAINT( OptoLoopAlignment, (void*)OptoLoopAlignmentConstraintFunc, JVMFlag::AfterErgo); PRODUCT_FLAG_PD(uintx, InitialCodeCacheSize, JVMFlag::RANGE, "Initial code cache size (in bytes)"); FLAG_CUSTOM_RANGE( InitialCodeCacheSize, VMPageSize); DEVELOP_FLAG_PD(uintx, CodeCacheMinimumUseSpace, JVMFlag::RANGE, "Minimum code cache size (in bytes) required to start VM."); FLAG_RANGE( CodeCacheMinimumUseSpace, 0, max_uintx); PRODUCT_FLAG(bool, SegmentedCodeCache, false, JVMFlag::DEFAULT, "Use a segmented code cache"); PRODUCT_FLAG_PD(uintx, ReservedCodeCacheSize, JVMFlag::RANGE, "Reserved code cache size (in bytes) - maximum code cache size"); FLAG_CUSTOM_RANGE( ReservedCodeCacheSize, VMPageSize); PRODUCT_FLAG_PD(uintx, NonProfiledCodeHeapSize, JVMFlag::RANGE, "Size of code heap with non-profiled methods (in bytes)"); FLAG_RANGE( NonProfiledCodeHeapSize, 0, max_uintx); PRODUCT_FLAG_PD(uintx, ProfiledCodeHeapSize, JVMFlag::RANGE, "Size of code heap with profiled methods (in bytes)"); FLAG_RANGE( ProfiledCodeHeapSize, 0, max_uintx); PRODUCT_FLAG_PD(uintx, NonNMethodCodeHeapSize, JVMFlag::RANGE, "Size of code heap with non-nmethods (in bytes)"); FLAG_CUSTOM_RANGE( NonNMethodCodeHeapSize, VMPageSize); PRODUCT_FLAG_PD(uintx, CodeCacheExpansionSize, JVMFlag::RANGE, "Code cache expansion size (in bytes)"); FLAG_RANGE( CodeCacheExpansionSize, 32*K, max_uintx); PRODUCT_FLAG_PD(uintx, CodeCacheMinBlockLength, JVMFlag::DIAGNOSTIC | JVMFlag::RANGE, "Minimum number of segments in a code cache block"); FLAG_RANGE( CodeCacheMinBlockLength, 1, 100); NOTPROD_FLAG(bool, ExitOnFullCodeCache, false, JVMFlag::DEFAULT, "Exit the VM if we fill the code cache"); PRODUCT_FLAG(bool, UseCodeCacheFlushing, true, JVMFlag::DEFAULT, "Remove cold/old nmethods from the code cache"); PRODUCT_FLAG(uintx, StartAggressiveSweepingAt, 10, JVMFlag::RANGE, "Start aggressive sweeping if X[%] of the code cache is free." "Segmented code cache: X[%] of the non-profiled heap." "Non-segmented code cache: X[%] of the total code cache"); FLAG_RANGE( StartAggressiveSweepingAt, 0, 100); // AOT parameters PRODUCT_FLAG(bool, UseAOT, false, JVMFlag::EXPERIMENTAL, "Use AOT compiled files"); PRODUCT_FLAG(ccstr, AOTLibrary, NULL, JVMFlag::EXPERIMENTAL | JVMFlag::STRINGLIST, "AOT library"); PRODUCT_FLAG(bool, PrintAOT, false, JVMFlag::EXPERIMENTAL, "Print used AOT klasses and methods"); NOTPROD_FLAG(bool, PrintAOTStatistics, false, JVMFlag::DEFAULT, "Print AOT statistics"); PRODUCT_FLAG(bool, UseAOTStrictLoading, false, JVMFlag::DIAGNOSTIC, "Exit the VM if any of the AOT libraries has invalid config"); PRODUCT_FLAG(bool, CalculateClassFingerprint, false, JVMFlag::DEFAULT, "Calculate class fingerprint"); // interpreter debugging DEVELOP_FLAG(intx, BinarySwitchThreshold, 5, JVMFlag::DEFAULT, "Minimal number of lookupswitch entries for rewriting to binary " "switch"); DEVELOP_FLAG(intx, StopInterpreterAt, 0, JVMFlag::DEFAULT, "Stop interpreter execution at specified bytecode number"); DEVELOP_FLAG(intx, TraceBytecodesAt, 0, JVMFlag::DEFAULT, "Trace bytecodes starting with specified bytecode number"); // compiler interface DEVELOP_FLAG(intx, CIStart, 0, JVMFlag::DEFAULT, "The id of the first compilation to permit"); DEVELOP_FLAG(intx, CIStop, max_jint, JVMFlag::DEFAULT, "The id of the last compilation to permit"); DEVELOP_FLAG(intx, CIStartOSR, 0, JVMFlag::DEFAULT, "The id of the first osr compilation to permit " "(CICountOSR must be on)"); DEVELOP_FLAG(intx, CIStopOSR, max_jint, JVMFlag::DEFAULT, "The id of the last osr compilation to permit " "(CICountOSR must be on)"); DEVELOP_FLAG(intx, CIBreakAtOSR, -1, JVMFlag::DEFAULT, "The id of osr compilation to break at"); DEVELOP_FLAG(intx, CIBreakAt, -1, JVMFlag::DEFAULT, "The id of compilation to break at"); PRODUCT_FLAG(ccstr, CompileOnly, "", JVMFlag::STRINGLIST, "List of methods (pkg/class.name) to restrict compilation to"); PRODUCT_FLAG(ccstr, CompileCommandFile, NULL, JVMFlag::DEFAULT, "Read compiler commands from this file [.hotspot_compiler]"); PRODUCT_FLAG(ccstr, CompilerDirectivesFile, NULL, JVMFlag::DIAGNOSTIC, "Read compiler directives from this file"); PRODUCT_FLAG(ccstr, CompileCommand, "", JVMFlag::STRINGLIST, "Prepend to .hotspot_compiler; e.g. log,java/lang/String."); DEVELOP_FLAG(bool, ReplayCompiles, false, JVMFlag::DEFAULT, "Enable replay of compilations from ReplayDataFile"); PRODUCT_FLAG(ccstr, ReplayDataFile, NULL, JVMFlag::DEFAULT, "File containing compilation replay information" "[default: ./replay_pid%p.log] (%p replaced with pid)"); PRODUCT_FLAG(ccstr, InlineDataFile, NULL, JVMFlag::DEFAULT, "File containing inlining replay information" "[default: ./inline_pid%p.log] (%p replaced with pid)"); DEVELOP_FLAG(intx, ReplaySuppressInitializers, 2, JVMFlag::RANGE, "Control handling of class initialization during replay: " "0 - don't do anything special; " "1 - treat all class initializers as empty; " "2 - treat class initializers for application classes as empty; " "3 - allow all class initializers to run during bootstrap but " " pretend they are empty after starting replay"); FLAG_RANGE( ReplaySuppressInitializers, 0, 3); DEVELOP_FLAG(bool, ReplayIgnoreInitErrors, false, JVMFlag::DEFAULT, "Ignore exceptions thrown during initialization for replay"); PRODUCT_FLAG(bool, DumpReplayDataOnError, true, JVMFlag::DEFAULT, "Record replay data for crashing compiler threads"); PRODUCT_FLAG(bool, CICompilerCountPerCPU, false, JVMFlag::DEFAULT, "1 compiler thread for log(N CPUs)"); NOTPROD_FLAG(intx, CICrashAt, -1, JVMFlag::DEFAULT, "id of compilation to trigger assert in compiler thread for " "the purpose of testing, e.g. generation of replay data"); NOTPROD_FLAG(bool, CIObjectFactoryVerify, false, JVMFlag::DEFAULT, "enable potentially expensive verification in ciObjectFactory"); PRODUCT_FLAG(bool, AbortVMOnCompilationFailure, false, JVMFlag::DIAGNOSTIC, "Abort VM when method had failed to compile."); // Priorities PRODUCT_FLAG_PD(bool, UseThreadPriorities, JVMFlag::DEFAULT, "Use native thread priorities"); PRODUCT_FLAG(intx, ThreadPriorityPolicy, 0, JVMFlag::RANGE, "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/BSD/macOS this policy requires root privilege or an " " extended capability."); FLAG_RANGE( ThreadPriorityPolicy, 0, 1); PRODUCT_FLAG(bool, ThreadPriorityVerbose, false, JVMFlag::DEFAULT, "Print priority changes"); PRODUCT_FLAG(intx, CompilerThreadPriority, -1, JVMFlag::RANGE | JVMFlag::CONSTRAINT, "The native priority at which compiler threads should run " "(-1 means no change)"); FLAG_RANGE( CompilerThreadPriority, min_jint, max_jint); FLAG_CONSTRAINT( CompilerThreadPriority, (void*)CompilerThreadPriorityConstraintFunc, JVMFlag::AfterErgo); PRODUCT_FLAG(intx, VMThreadPriority, -1, JVMFlag::RANGE, "The native priority at which the VM thread should run " "(-1 means no change)"); FLAG_RANGE( VMThreadPriority, -1, 127); PRODUCT_FLAG(intx, JavaPriority1_To_OSPriority, -1, JVMFlag::RANGE, "Map Java priorities to OS priorities"); FLAG_RANGE( JavaPriority1_To_OSPriority, -1, 127); PRODUCT_FLAG(intx, JavaPriority2_To_OSPriority, -1, JVMFlag::RANGE, "Map Java priorities to OS priorities"); FLAG_RANGE( JavaPriority2_To_OSPriority, -1, 127); PRODUCT_FLAG(intx, JavaPriority3_To_OSPriority, -1, JVMFlag::RANGE, "Map Java priorities to OS priorities"); FLAG_RANGE( JavaPriority3_To_OSPriority, -1, 127); PRODUCT_FLAG(intx, JavaPriority4_To_OSPriority, -1, JVMFlag::RANGE, "Map Java priorities to OS priorities"); FLAG_RANGE( JavaPriority4_To_OSPriority, -1, 127); PRODUCT_FLAG(intx, JavaPriority5_To_OSPriority, -1, JVMFlag::RANGE, "Map Java priorities to OS priorities"); FLAG_RANGE( JavaPriority5_To_OSPriority, -1, 127); PRODUCT_FLAG(intx, JavaPriority6_To_OSPriority, -1, JVMFlag::RANGE, "Map Java priorities to OS priorities"); FLAG_RANGE( JavaPriority6_To_OSPriority, -1, 127); PRODUCT_FLAG(intx, JavaPriority7_To_OSPriority, -1, JVMFlag::RANGE, "Map Java priorities to OS priorities"); FLAG_RANGE( JavaPriority7_To_OSPriority, -1, 127); PRODUCT_FLAG(intx, JavaPriority8_To_OSPriority, -1, JVMFlag::RANGE, "Map Java priorities to OS priorities"); FLAG_RANGE( JavaPriority8_To_OSPriority, -1, 127); PRODUCT_FLAG(intx, JavaPriority9_To_OSPriority, -1, JVMFlag::RANGE, "Map Java priorities to OS priorities"); FLAG_RANGE( JavaPriority9_To_OSPriority, -1, 127); PRODUCT_FLAG(intx, JavaPriority10_To_OSPriority, -1, JVMFlag::RANGE, "Map Java priorities to OS priorities"); FLAG_RANGE( JavaPriority10_To_OSPriority, -1, 127); PRODUCT_FLAG(bool, UseCriticalJavaThreadPriority, false, JVMFlag::EXPERIMENTAL, "Java thread priority 10 maps to critical scheduling priority"); PRODUCT_FLAG(bool, UseCriticalCompilerThreadPriority, false, JVMFlag::EXPERIMENTAL, "Compiler thread(s) run at critical scheduling priority"); DEVELOP_FLAG(intx, NewCodeParameter, 0, JVMFlag::DEFAULT, "Testing Only: Create a dedicated integer parameter before " "putback"); // new oopmap storage allocation DEVELOP_FLAG(intx, MinOopMapAllocation, 8, JVMFlag::DEFAULT, "Minimum number of OopMap entries in an OopMapSet"); // Background Compilation DEVELOP_FLAG(intx, LongCompileThreshold, 50, JVMFlag::DEFAULT, "Used with +TraceLongCompiles"); // recompilation PRODUCT_FLAG_PD(intx, CompileThreshold, JVMFlag::CONSTRAINT, "number of interpreted method invocations before (re-)compiling"); FLAG_CONSTRAINT( CompileThreshold, (void*)CompileThresholdConstraintFunc, JVMFlag::AfterErgo); PRODUCT_FLAG(double, CompileThresholdScaling, 1.0, JVMFlag::RANGE, "Factor to control when first compilation happens " "(both with and without tiered compilation): " "values greater than 1.0 delay counter overflow, " "values between 0 and 1.0 rush counter overflow, " "value of 1.0 leaves compilation thresholds unchanged " "value of 0.0 is equivalent to -Xint. " "" "Flag can be set as per-method option. " "If a value is specified for a method, compilation thresholds " "for that method are scaled by both the value of the global flag " "and the value of the per-method flag."); FLAG_RANGE( CompileThresholdScaling, 0.0, DBL_MAX); PRODUCT_FLAG(intx, Tier0InvokeNotifyFreqLog, 7, JVMFlag::RANGE, "Interpreter (tier 0) invocation notification frequency"); FLAG_RANGE( Tier0InvokeNotifyFreqLog, 0, 30); PRODUCT_FLAG(intx, Tier2InvokeNotifyFreqLog, 11, JVMFlag::RANGE, "C1 without MDO (tier 2) invocation notification frequency"); FLAG_RANGE( Tier2InvokeNotifyFreqLog, 0, 30); PRODUCT_FLAG(intx, Tier3InvokeNotifyFreqLog, 10, JVMFlag::RANGE, "C1 with MDO profiling (tier 3) invocation notification " "frequency"); FLAG_RANGE( Tier3InvokeNotifyFreqLog, 0, 30); PRODUCT_FLAG(intx, Tier23InlineeNotifyFreqLog, 20, JVMFlag::RANGE, "Inlinee invocation (tiers 2 and 3) notification frequency"); FLAG_RANGE( Tier23InlineeNotifyFreqLog, 0, 30); PRODUCT_FLAG(intx, Tier0BackedgeNotifyFreqLog, 10, JVMFlag::RANGE, "Interpreter (tier 0) invocation notification frequency"); FLAG_RANGE( Tier0BackedgeNotifyFreqLog, 0, 30); PRODUCT_FLAG(intx, Tier2BackedgeNotifyFreqLog, 14, JVMFlag::RANGE, "C1 without MDO (tier 2) invocation notification frequency"); FLAG_RANGE( Tier2BackedgeNotifyFreqLog, 0, 30); PRODUCT_FLAG(intx, Tier3BackedgeNotifyFreqLog, 13, JVMFlag::RANGE, "C1 with MDO profiling (tier 3) invocation notification " "frequency"); FLAG_RANGE( Tier3BackedgeNotifyFreqLog, 0, 30); PRODUCT_FLAG(intx, Tier2CompileThreshold, 0, JVMFlag::RANGE, "threshold at which tier 2 compilation is invoked"); FLAG_RANGE( Tier2CompileThreshold, 0, max_jint); PRODUCT_FLAG(intx, Tier2BackEdgeThreshold, 0, JVMFlag::RANGE, "Back edge threshold at which tier 2 compilation is invoked"); FLAG_RANGE( Tier2BackEdgeThreshold, 0, max_jint); PRODUCT_FLAG(intx, Tier3InvocationThreshold, 200, JVMFlag::RANGE, "Compile if number of method invocations crosses this " "threshold"); FLAG_RANGE( Tier3InvocationThreshold, 0, max_jint); PRODUCT_FLAG(intx, Tier3MinInvocationThreshold, 100, JVMFlag::RANGE, "Minimum invocation to compile at tier 3"); FLAG_RANGE( Tier3MinInvocationThreshold, 0, max_jint); PRODUCT_FLAG(intx, Tier3CompileThreshold, 2000, JVMFlag::RANGE, "Threshold at which tier 3 compilation is invoked (invocation " "minimum must be satisfied)"); FLAG_RANGE( Tier3CompileThreshold, 0, max_jint); PRODUCT_FLAG(intx, Tier3BackEdgeThreshold, 60000, JVMFlag::RANGE, "Back edge threshold at which tier 3 OSR compilation is invoked"); FLAG_RANGE( Tier3BackEdgeThreshold, 0, max_jint); PRODUCT_FLAG(intx, Tier3AOTInvocationThreshold, 10000, JVMFlag::RANGE, "Compile if number of method invocations crosses this " "threshold if coming from AOT"); FLAG_RANGE( Tier3AOTInvocationThreshold, 0, max_jint); PRODUCT_FLAG(intx, Tier3AOTMinInvocationThreshold, 1000, JVMFlag::RANGE, "Minimum invocation to compile at tier 3 if coming from AOT"); FLAG_RANGE( Tier3AOTMinInvocationThreshold, 0, max_jint); PRODUCT_FLAG(intx, Tier3AOTCompileThreshold, 15000, JVMFlag::RANGE, "Threshold at which tier 3 compilation is invoked (invocation " "minimum must be satisfied) if coming from AOT"); FLAG_RANGE( Tier3AOTCompileThreshold, 0, max_jint); PRODUCT_FLAG(intx, Tier3AOTBackEdgeThreshold, 120000, JVMFlag::RANGE, "Back edge threshold at which tier 3 OSR compilation is invoked " "if coming from AOT"); FLAG_RANGE( Tier3AOTBackEdgeThreshold, 0, max_jint); PRODUCT_FLAG(intx, Tier0AOTInvocationThreshold, 200, JVMFlag::DIAGNOSTIC | JVMFlag::RANGE, "Switch to interpreter to profile if the number of method " "invocations crosses this threshold if coming from AOT " "(applicable only with " "CompilationMode=high-only|high-only-quick-internal)"); FLAG_RANGE( Tier0AOTInvocationThreshold, 0, max_jint); PRODUCT_FLAG(intx, Tier0AOTMinInvocationThreshold, 100, JVMFlag::DIAGNOSTIC | JVMFlag::RANGE, "Minimum number of invocations to switch to interpreter " "to profile if coming from AOT " "(applicable only with " "CompilationMode=high-only|high-only-quick-internal)"); FLAG_RANGE( Tier0AOTMinInvocationThreshold, 0, max_jint); PRODUCT_FLAG(intx, Tier0AOTCompileThreshold, 2000, JVMFlag::DIAGNOSTIC | JVMFlag::RANGE, "Threshold at which to switch to interpreter to profile " "if coming from AOT " "(invocation minimum must be satisfied, " "applicable only with " "CompilationMode=high-only|high-only-quick-internal)"); FLAG_RANGE( Tier0AOTCompileThreshold, 0, max_jint); PRODUCT_FLAG(intx, Tier0AOTBackEdgeThreshold, 60000, JVMFlag::DIAGNOSTIC | JVMFlag::RANGE, "Back edge threshold at which to switch to interpreter " "to profile if coming from AOT " "(applicable only with " "CompilationMode=high-only|high-only-quick-internal)"); FLAG_RANGE( Tier0AOTBackEdgeThreshold, 0, max_jint); PRODUCT_FLAG(intx, Tier4InvocationThreshold, 5000, JVMFlag::RANGE, "Compile if number of method invocations crosses this " "threshold"); FLAG_RANGE( Tier4InvocationThreshold, 0, max_jint); PRODUCT_FLAG(intx, Tier4MinInvocationThreshold, 600, JVMFlag::RANGE, "Minimum invocation to compile at tier 4"); FLAG_RANGE( Tier4MinInvocationThreshold, 0, max_jint); PRODUCT_FLAG(intx, Tier4CompileThreshold, 15000, JVMFlag::RANGE, "Threshold at which tier 4 compilation is invoked (invocation " "minimum must be satisfied)"); FLAG_RANGE( Tier4CompileThreshold, 0, max_jint); PRODUCT_FLAG(intx, Tier4BackEdgeThreshold, 40000, JVMFlag::RANGE, "Back edge threshold at which tier 4 OSR compilation is invoked"); FLAG_RANGE( Tier4BackEdgeThreshold, 0, max_jint); PRODUCT_FLAG(intx, Tier40InvocationThreshold, 5000, JVMFlag::DIAGNOSTIC | JVMFlag::RANGE, "Compile if number of method invocations crosses this " "threshold (applicable only with " "CompilationMode=high-only|high-only-quick-internal)"); FLAG_RANGE( Tier40InvocationThreshold, 0, max_jint); PRODUCT_FLAG(intx, Tier40MinInvocationThreshold, 600, JVMFlag::DIAGNOSTIC | JVMFlag::RANGE, "Minimum number of invocations to compile at tier 4 " "(applicable only with " "CompilationMode=high-only|high-only-quick-internal)"); FLAG_RANGE( Tier40MinInvocationThreshold, 0, max_jint); PRODUCT_FLAG(intx, Tier40CompileThreshold, 10000, JVMFlag::DIAGNOSTIC | JVMFlag::RANGE, "Threshold at which tier 4 compilation is invoked (invocation " "minimum must be satisfied, applicable only with " "CompilationMode=high-only|high-only-quick-internal)"); FLAG_RANGE( Tier40CompileThreshold, 0, max_jint); PRODUCT_FLAG(intx, Tier40BackEdgeThreshold, 15000, JVMFlag::DIAGNOSTIC | JVMFlag::RANGE, "Back edge threshold at which tier 4 OSR compilation is invoked " "(applicable only with " "CompilationMode=high-only|high-only-quick-internal)"); FLAG_RANGE( Tier40BackEdgeThreshold, 0, max_jint); PRODUCT_FLAG(intx, Tier0Delay, 5, JVMFlag::DIAGNOSTIC | JVMFlag::RANGE, "If C2 queue size grows over this amount per compiler thread " "do not start profiling in the interpreter " "(applicable only with " "CompilationMode=high-only|high-only-quick-internal)"); FLAG_RANGE( Tier0Delay, 0, max_jint); PRODUCT_FLAG(intx, Tier3DelayOn, 5, JVMFlag::RANGE, "If C2 queue size grows over this amount per compiler thread " "stop compiling at tier 3 and start compiling at tier 2"); FLAG_RANGE( Tier3DelayOn, 0, max_jint); PRODUCT_FLAG(intx, Tier3DelayOff, 2, JVMFlag::RANGE, "If C2 queue size is less than this amount per compiler thread " "allow methods compiled at tier 2 transition to tier 3"); FLAG_RANGE( Tier3DelayOff, 0, max_jint); PRODUCT_FLAG(intx, Tier3LoadFeedback, 5, JVMFlag::RANGE, "Tier 3 thresholds will increase twofold when C1 queue size " "reaches this amount per compiler thread"); FLAG_RANGE( Tier3LoadFeedback, 0, max_jint); PRODUCT_FLAG(intx, Tier4LoadFeedback, 3, JVMFlag::RANGE, "Tier 4 thresholds will increase twofold when C2 queue size " "reaches this amount per compiler thread"); FLAG_RANGE( Tier4LoadFeedback, 0, max_jint); PRODUCT_FLAG(intx, TieredCompileTaskTimeout, 50, JVMFlag::RANGE, "Kill compile task if method was not used within " "given timeout in milliseconds"); FLAG_RANGE( TieredCompileTaskTimeout, 0, max_intx); PRODUCT_FLAG(intx, TieredStopAtLevel, 4, JVMFlag::RANGE, "Stop at given compilation level"); FLAG_RANGE( TieredStopAtLevel, 0, 4); PRODUCT_FLAG(intx, Tier0ProfilingStartPercentage, 200, JVMFlag::RANGE, "Start profiling in interpreter if the counters exceed tier 3 " "thresholds (tier 4 thresholds with " "CompilationMode=high-only|high-only-quick-internal)" "by the specified percentage"); FLAG_RANGE( Tier0ProfilingStartPercentage, 0, max_jint); PRODUCT_FLAG(uintx, IncreaseFirstTierCompileThresholdAt, 50, JVMFlag::RANGE, "Increase the compile threshold for C1 compilation if the code " "cache is filled by the specified percentage"); FLAG_RANGE( IncreaseFirstTierCompileThresholdAt, 0, 99); PRODUCT_FLAG(intx, TieredRateUpdateMinTime, 1, JVMFlag::RANGE, "Minimum rate sampling interval (in milliseconds)"); FLAG_RANGE( TieredRateUpdateMinTime, 0, max_intx); PRODUCT_FLAG(intx, TieredRateUpdateMaxTime, 25, JVMFlag::RANGE, "Maximum rate sampling interval (in milliseconds)"); FLAG_RANGE( TieredRateUpdateMaxTime, 0, max_intx); PRODUCT_FLAG(ccstr, CompilationMode, "default", JVMFlag::DEFAULT, "Compilation modes: " "default: normal tiered compilation; " "quick-only: C1-only mode; " "high-only: C2/JVMCI-only mode; " "high-only-quick-internal: C2/JVMCI-only mode, " "with JVMCI compiler compiled with C1."); PRODUCT_FLAG_PD(bool, TieredCompilation, JVMFlag::DEFAULT, "Enable tiered compilation"); PRODUCT_FLAG(bool, PrintTieredEvents, false, JVMFlag::DEFAULT, "Print tiered events notifications"); PRODUCT_FLAG_PD(intx, OnStackReplacePercentage, JVMFlag::CONSTRAINT, "NON_TIERED number of method invocations/branches (expressed as " "% of CompileThreshold) before (re-)compiling OSR code"); FLAG_CONSTRAINT( OnStackReplacePercentage, (void*)OnStackReplacePercentageConstraintFunc, JVMFlag::AfterErgo); PRODUCT_FLAG(intx, InterpreterProfilePercentage, 33, JVMFlag::RANGE, "NON_TIERED number of method invocations/branches (expressed as " "% of CompileThreshold) before profiling in the interpreter"); FLAG_RANGE( InterpreterProfilePercentage, 0, 100); DEVELOP_FLAG(intx, DesiredMethodLimit, 8000, JVMFlag::DEFAULT, "The desired maximum method size (in bytecodes) after inlining"); DEVELOP_FLAG(intx, HugeMethodLimit, 8000, JVMFlag::DEFAULT, "Don't compile methods larger than this if " "+DontCompileHugeMethods"); // Properties for Java libraries PRODUCT_FLAG(uint64_t, MaxDirectMemorySize, 0, JVMFlag::RANGE, "Maximum total size of NIO direct-buffer allocations"); FLAG_RANGE( MaxDirectMemorySize, 0, max_jlong); // Flags used for temporary code during development PRODUCT_FLAG(bool, UseNewCode, false, JVMFlag::DIAGNOSTIC, "Testing Only: Use the new version while testing"); PRODUCT_FLAG(bool, UseNewCode2, false, JVMFlag::DIAGNOSTIC, "Testing Only: Use the new version while testing"); PRODUCT_FLAG(bool, UseNewCode3, false, JVMFlag::DIAGNOSTIC, "Testing Only: Use the new version while testing"); // flags for performance data collection PRODUCT_FLAG(bool, UsePerfData, true, JVMFlag::DEFAULT, "Flag to disable jvmstat instrumentation for performance testing " "and problem isolation purposes"); PRODUCT_FLAG(bool, PerfDataSaveToFile, false, JVMFlag::DEFAULT, "Save PerfData memory to hsperfdata_ file on exit"); PRODUCT_FLAG(ccstr, PerfDataSaveFile, NULL, JVMFlag::DEFAULT, "Save PerfData memory to the specified absolute pathname. " "The string %p in the file name (if present) " "will be replaced by pid"); PRODUCT_FLAG(intx, PerfDataSamplingInterval, 50, JVMFlag::RANGE | JVMFlag::CONSTRAINT, "Data sampling interval (in milliseconds)"); //TODO: to avoid circular dependency, the min/max cannot be declared in header file //FLAG_RANGE( PerfDataSamplingInterval, PeriodicTask::min_interval, max_jint); FLAG_CONSTRAINT( PerfDataSamplingInterval, (void*)PerfDataSamplingIntervalFunc, JVMFlag::AfterErgo); PRODUCT_FLAG(bool, PerfDisableSharedMem, false, JVMFlag::DEFAULT, "Store performance data in standard memory"); PRODUCT_FLAG(intx, PerfDataMemorySize, 32*K, JVMFlag::RANGE, "Size of performance data memory region. Will be rounded " "up to a multiple of the native os page size."); FLAG_RANGE( PerfDataMemorySize, 128, 32*64*K); PRODUCT_FLAG(intx, PerfMaxStringConstLength, 1024, JVMFlag::RANGE, "Maximum PerfStringConstant string length before truncation"); FLAG_RANGE( PerfMaxStringConstLength, 32, 32*K); PRODUCT_FLAG(bool, PerfAllowAtExitRegistration, false, JVMFlag::DEFAULT, "Allow registration of atexit() methods"); PRODUCT_FLAG(bool, PerfBypassFileSystemCheck, false, JVMFlag::DEFAULT, "Bypass Win32 file system criteria checks (Windows Only)"); PRODUCT_FLAG(intx, UnguardOnExecutionViolation, 0, JVMFlag::RANGE, "Unguard page and retry on no-execute fault (Win32 only) " "0=off, 1=conservative, 2=aggressive"); FLAG_RANGE( UnguardOnExecutionViolation, 0, 2); // Serviceability Support PRODUCT_FLAG(bool, ManagementServer, false, JVMFlag::DEFAULT, "Create JMX Management Server"); PRODUCT_FLAG(bool, DisableAttachMechanism, false, JVMFlag::DEFAULT, "Disable mechanism that allows tools to attach to this VM"); PRODUCT_FLAG(bool, StartAttachListener, false, JVMFlag::DEFAULT, "Always start Attach Listener at VM startup"); PRODUCT_FLAG(bool, EnableDynamicAgentLoading, true, JVMFlag::DEFAULT, "Allow tools to load agents with the attach mechanism"); PRODUCT_FLAG(bool, PrintConcurrentLocks, false, JVMFlag::MANAGEABLE, "Print java.util.concurrent locks in thread dump"); // Shared spaces PRODUCT_FLAG(bool, UseSharedSpaces, true, JVMFlag::DEFAULT, "Use shared spaces for metadata"); PRODUCT_FLAG(bool, VerifySharedSpaces, false, JVMFlag::DEFAULT, "Verify integrity of shared spaces"); PRODUCT_FLAG(bool, RequireSharedSpaces, false, JVMFlag::DEFAULT, "Require shared spaces for metadata"); PRODUCT_FLAG(bool, DumpSharedSpaces, false, JVMFlag::DEFAULT, "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_FLAG(bool, DynamicDumpSharedSpaces, false, JVMFlag::DEFAULT, "Dynamic archive"); PRODUCT_FLAG(bool, PrintSharedArchiveAndExit, false, JVMFlag::DEFAULT, "Print shared archive file contents"); PRODUCT_FLAG(bool, PrintSharedDictionary, false, JVMFlag::DEFAULT, "If PrintSharedArchiveAndExit is true, also print the shared " "dictionary"); PRODUCT_FLAG(size_t, SharedBaseAddress, LP64_ONLY(32*G)NOT_LP64(LINUX_ONLY(2*G) NOT_LINUX(0)), JVMFlag::RANGE, "Address to allocate shared memory region for class data"); FLAG_RANGE( SharedBaseAddress, 0, SIZE_MAX); PRODUCT_FLAG(ccstr, SharedArchiveConfigFile, NULL, JVMFlag::DEFAULT, "Data to add to the CDS archive file"); PRODUCT_FLAG(uintx, SharedSymbolTableBucketSize, 4, JVMFlag::RANGE, "Average number of symbols per bucket in shared table"); FLAG_RANGE( SharedSymbolTableBucketSize, 2, 246); PRODUCT_FLAG(bool, AllowArchivingWithJavaAgent, false, JVMFlag::DIAGNOSTIC, "Allow Java agent to be run with CDS dumping"); PRODUCT_FLAG(bool, PrintMethodHandleStubs, false, JVMFlag::DIAGNOSTIC, "Print generated stub code for method handles"); DEVELOP_FLAG(bool, TraceMethodHandles, false, JVMFlag::DEFAULT, "trace internal method handle operations"); PRODUCT_FLAG(bool, VerifyMethodHandles, trueInDebug, JVMFlag::DIAGNOSTIC, "perform extra checks when constructing method handles"); PRODUCT_FLAG(bool, ShowHiddenFrames, false, JVMFlag::DIAGNOSTIC, "show method handle implementation frames (usually hidden)"); PRODUCT_FLAG(bool, TrustFinalNonStaticFields, false, JVMFlag::EXPERIMENTAL, "trust final non-static declarations for constant folding"); PRODUCT_FLAG(bool, FoldStableValues, true, JVMFlag::DIAGNOSTIC, "Optimize loads from stable fields (marked w/ @Stable)"); DEVELOP_FLAG(bool, TraceInvokeDynamic, false, JVMFlag::DEFAULT, "trace internal invoke dynamic operations"); PRODUCT_FLAG(int, UseBootstrapCallInfo, 1, JVMFlag::DIAGNOSTIC, "0: when resolving InDy or ConDy, force all BSM arguments to be " "resolved before the bootstrap method is called; 1: when a BSM " "that may accept a BootstrapCallInfo is detected, use that API " "to pass BSM arguments, which allows the BSM to delay their " "resolution; 2+: stress test the BCI API by calling more BSMs " "via that API, instead of with the eagerly-resolved array."); PRODUCT_FLAG(bool, PauseAtStartup, false, JVMFlag::DIAGNOSTIC, "Causes the VM to pause at startup time and wait for the pause " "file to be removed (default: ./vm.paused.)"); PRODUCT_FLAG(ccstr, PauseAtStartupFile, NULL, JVMFlag::DIAGNOSTIC, "The file to create and for whose removal to await when pausing " "at startup. (default: ./vm.paused.)"); PRODUCT_FLAG(bool, PauseAtExit, false, JVMFlag::DIAGNOSTIC, "Pause and wait for keypress on exit if a debugger is attached"); PRODUCT_FLAG(bool, ExtendedDTraceProbes, false, JVMFlag::DEFAULT, "Enable performance-impacting dtrace probes"); PRODUCT_FLAG(bool, DTraceMethodProbes, false, JVMFlag::DEFAULT, "Enable dtrace probes for method-entry and method-exit"); PRODUCT_FLAG(bool, DTraceAllocProbes, false, JVMFlag::DEFAULT, "Enable dtrace probes for object allocation"); PRODUCT_FLAG(bool, DTraceMonitorProbes, false, JVMFlag::DEFAULT, "Enable dtrace probes for monitor events"); PRODUCT_FLAG(bool, RelaxAccessControlCheck, false, JVMFlag::DEFAULT, "Relax the access control checks in the verifier"); PRODUCT_FLAG(uintx, StringTableSize, defaultStringTableSize, JVMFlag::RANGE, "Number of buckets in the interned String table " "(will be rounded to nearest higher power of 2)"); FLAG_RANGE( StringTableSize, minimumStringTableSize, 16777216ul); PRODUCT_FLAG(uintx, SymbolTableSize, defaultSymbolTableSize, JVMFlag::EXPERIMENTAL | JVMFlag::RANGE, "Number of buckets in the JVM internal Symbol table"); FLAG_RANGE( SymbolTableSize, minimumSymbolTableSize, 16777216ul); PRODUCT_FLAG(bool, UseStringDeduplication, false, JVMFlag::DEFAULT, "Use string deduplication"); PRODUCT_FLAG(uintx, StringDeduplicationAgeThreshold, 3, JVMFlag::RANGE, "A string must reach this age (or be promoted to an old region) " "to be considered for deduplication"); //TODO: to avoid circular dependency, the min/max cannot be declared in header file //FLAG_RANGE( StringDeduplicationAgeThreshold, 1, markWord::max_age); PRODUCT_FLAG(bool, StringDeduplicationResizeALot, false, JVMFlag::DIAGNOSTIC, "Force table resize every time the table is scanned"); PRODUCT_FLAG(bool, StringDeduplicationRehashALot, false, JVMFlag::DIAGNOSTIC, "Force table rehash every time the table is scanned"); PRODUCT_FLAG(bool, WhiteBoxAPI, false, JVMFlag::DIAGNOSTIC, "Enable internal testing APIs"); PRODUCT_FLAG(intx, SurvivorAlignmentInBytes, 0, JVMFlag::EXPERIMENTAL | JVMFlag::RANGE | JVMFlag::CONSTRAINT, "Default survivor space alignment in bytes"); FLAG_RANGE( SurvivorAlignmentInBytes, 8, 256); FLAG_CONSTRAINT( SurvivorAlignmentInBytes, (void*)SurvivorAlignmentInBytesConstraintFunc, JVMFlag::AfterErgo); PRODUCT_FLAG(ccstr, DumpLoadedClassList, NULL, JVMFlag::DEFAULT, "Dump the names all loaded classes, that could be stored into " "the CDS archive, in the specified file"); PRODUCT_FLAG(ccstr, SharedClassListFile, NULL, JVMFlag::DEFAULT, "Override the default CDS class list"); PRODUCT_FLAG(ccstr, SharedArchiveFile, NULL, JVMFlag::DEFAULT, "Override the default location of the CDS archive file"); PRODUCT_FLAG(ccstr, ArchiveClassesAtExit, NULL, JVMFlag::DEFAULT, "The path and name of the dynamic archive file"); PRODUCT_FLAG(ccstr, ExtraSharedClassListFile, NULL, JVMFlag::DEFAULT, "Extra classlist for building the CDS archive file"); PRODUCT_FLAG(intx, ArchiveRelocationMode, 0, JVMFlag::DIAGNOSTIC | JVMFlag::RANGE, "(0) first map at preferred address, and if " "unsuccessful, map at alternative address (default); " "(1) always map at alternative address; " "(2) always map at preferred address, and if unsuccessful, " "do not map the archive"); FLAG_RANGE( ArchiveRelocationMode, 0, 2); PRODUCT_FLAG(size_t, ArrayAllocatorMallocLimit, SOLARIS_ONLY(64*K) NOT_SOLARIS((size_t)-1), JVMFlag::EXPERIMENTAL, "Allocation less than this value will be allocated " "using malloc. Larger allocations will use mmap."); PRODUCT_FLAG(bool, AlwaysAtomicAccesses, false, JVMFlag::EXPERIMENTAL, "Accesses to all variables should always be atomic"); PRODUCT_FLAG(bool, UseUnalignedAccesses, false, JVMFlag::DIAGNOSTIC, "Use unaligned memory accesses in Unsafe"); PRODUCT_FLAG_PD(bool, PreserveFramePointer, JVMFlag::DEFAULT, "Use the FP register for holding the frame pointer " "and not as a general purpose register."); PRODUCT_FLAG(bool, CheckIntrinsics, true, JVMFlag::DIAGNOSTIC, "When a class C is loaded, check that " "(1) all intrinsics defined by the VM for class C are present " "in the loaded class file and are marked with the " "@HotSpotIntrinsicCandidate annotation, that " "(2) there is an intrinsic registered for all loaded methods " "that are annotated with the @HotSpotIntrinsicCandidate " "annotation, and that " "(3) no orphan methods exist for class C (i.e., methods for " "which the VM declares an intrinsic but that are not declared " "in the loaded class C. " "Check (3) is available only in debug builds."); PRODUCT_FLAG_PD(intx, InitArrayShortSize, JVMFlag::DIAGNOSTIC | JVMFlag::RANGE | JVMFlag::CONSTRAINT, "Threshold small size (in bytes) for clearing arrays. " "Anything this size or smaller may get converted to discrete " "scalar stores."); FLAG_RANGE( InitArrayShortSize, 0, max_intx); FLAG_CONSTRAINT( InitArrayShortSize, (void*)InitArrayShortSizeConstraintFunc, JVMFlag::AfterErgo); PRODUCT_FLAG(bool, CompilerDirectivesIgnoreCompileCommands, false, JVMFlag::DIAGNOSTIC, "Disable backwards compatibility for compile commands."); PRODUCT_FLAG(bool, CompilerDirectivesPrint, false, JVMFlag::DIAGNOSTIC, "Print compiler directives on installation."); PRODUCT_FLAG(int, CompilerDirectivesLimit, 50, JVMFlag::DIAGNOSTIC, "Limit on number of compiler directives."); PRODUCT_FLAG(ccstr, AllocateHeapAt, NULL, JVMFlag::DEFAULT, "Path to the directoy where a temporary file will be created " "to use as the backing store for Java Heap."); PRODUCT_FLAG(ccstr, AllocateOldGenAt, NULL, JVMFlag::EXPERIMENTAL, "Path to the directoy where a temporary file will be " "created to use as the backing store for old generation." "File of size Xmx is pre-allocated for performance reason, so" "we need that much space available"); DEVELOP_FLAG(int, VerifyMetaspaceInterval, DEBUG_ONLY(500) NOT_DEBUG(0), JVMFlag::DEFAULT, "Run periodic metaspace verifications (0 - none, " "1 - always, >1 every nth interval)"); PRODUCT_FLAG(bool, ShowRegistersOnAssert, true, JVMFlag::DIAGNOSTIC, "On internal errors, include registers in error report."); PRODUCT_FLAG(bool, UseSwitchProfiling, true, JVMFlag::DIAGNOSTIC, "leverage profiling for table/lookup switch"); DEVELOP_FLAG(bool, TraceMemoryWriteback, false, JVMFlag::DEFAULT, "Trace memory writeback operations"); JFR_ONLY(PRODUCT_FLAG(bool, FlightRecorder, false, JVMFlag::DEFAULT, "(Deprecated) Enable Flight Recorder");) JFR_ONLY(PRODUCT_FLAG(ccstr, FlightRecorderOptions, NULL, JVMFlag::DEFAULT, "Flight Recorder options");) JFR_ONLY(PRODUCT_FLAG(ccstr, StartFlightRecording, NULL, JVMFlag::DEFAULT, "Start flight recording with options");) PRODUCT_FLAG(bool, UseFastUnorderedTimeStamps, false, JVMFlag::EXPERIMENTAL, "Use platform unstable time where supported for timestamps only"); PRODUCT_FLAG(bool, UseNewFieldLayout, true, JVMFlag::DEFAULT, "(Deprecated) Use new algorithm to compute field layouts"); PRODUCT_FLAG(bool, UseEmptySlotsInSupers, true, JVMFlag::DEFAULT, "Allow allocating fields in empty slots of super-classes"); #ifdef _LP64 PRODUCT_FLAG(bool, UseCompressedOops, false, JVMFlag::LP64, "Use 32-bit object references in 64-bit VM. " "lp64_product means flag is always constant in 32 bit VM"); PRODUCT_FLAG(bool, UseCompressedClassPointers, false, JVMFlag::LP64, "Use 32-bit class pointers in 64-bit VM. " "lp64_product means flag is always constant in 32 bit VM"); PRODUCT_FLAG(intx, ObjectAlignmentInBytes, 8, JVMFlag::LP64 | JVMFlag::RANGE | JVMFlag::CONSTRAINT, "Default object alignment in bytes, 8 is minimum"); FLAG_RANGE( ObjectAlignmentInBytes, 8, 256); FLAG_CONSTRAINT( ObjectAlignmentInBytes, (void*)ObjectAlignmentInBytesConstraintFunc, JVMFlag::AtParse); #elif defined(IS_DECLARING_FLAG) const bool UseCompressedOops = false; // !JVMFlag::LP64 const bool UseCompressedClassPointers = false; // !JVMFlag::LP64 const intx ObjectAlignmentInBytes = 8; // !JVMFlag::LP64 #endif // _LP64 #endif // SHARE_RUNTIME_GLOBALS_HPP