1 /*
   2  * Copyright (c) 1997, 2020, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #ifndef SHARE_RUNTIME_GLOBALS_HPP
  26 #define SHARE_RUNTIME_GLOBALS_HPP
  27 
  28 #include "compiler/compiler_globals.hpp"
  29 #include "gc/shared/gc_globals.hpp"
  30 #include "runtime/flags/jvmFlagConstraintsCompiler.hpp"
  31 #include "runtime/flags/jvmFlagConstraintsRuntime.hpp"
  32 #include "runtime/globals_shared.hpp"
  33 #include "utilities/align.hpp"
  34 #include "utilities/globalDefinitions.hpp"
  35 #include "utilities/macros.hpp"
  36 #include CPU_HEADER(globals)
  37 #include OS_HEADER(globals)
  38 #include OS_CPU_HEADER(globals)
  39 
  40 // Command-line flag specification in HotSpot is divided into individual modules.
  41 // Each module should have 2 files in the module's directory. For example, C2 has the
  42 // following 2 files:
  43 //
  44 // c2_globals.hpp - specification of all flags for C2, including meta-information
  45 //                  such as docs, range and constraints.
  46 // c2_globals.cpp - definitions of the C++ variables that implements these flags.
  47 //
  48 //
  49 // In the xxx_globals.hpp file, each flag must be specified with one of the
  50 // following 5 macros.
  51 //
  52 // Platform-Independent Flags -- each flag has 5 arguments: (type, name, default_value, attr, docs)
  53 //
  54 // PRODUCT_FLAG -- always settable
  55 // DEVELOP_FLAG -- settable only during development and are constant in the PRODUCT version
  56 // NOTPROD_FLAG -- settable only during development and are *not* declared in the PRODUCT version
  57 //
  58 // Platform-Dependent Flags -- each flag has 4 arguments: (type, name, attr, docs)
  59 //
  60 // PRODUCT_FLAG_PD
  61 // DEVELOP_FLAG_PD
  62 //
  63 // type: A flag must be declared with one of the following types:
  64 //       bool, int, uint, intx, uintx, size_t, ccstr, ccstr, double, or uint64_t.
  65 //
  66 //       The type "ccstr" is an alias for "const char*" because the macrology
  67 //       requires single-token type names. For this type, you can optionally
  68 //       set the JVMFlag::STRINGLIST bit in the <attr> argument. This allows you
  69 //       to specify the flag multiple times on the command-line to build
  70 //       a string list. These flags are printed as "ccstrlist" by -XX:PrintFlagsFinal.
  71 //
  72 // name: The name of the flag.
  73 //
  74 // default_value: The default value of the flag.
  75 //       Note that the default values for the _PD flags are declared in
  76 //       platform-dependent header files such as cpu/x86/c2_globals_x86.hpp
  77 //
  78 // attr: See discussion below on flag attributes
  79 //
  80 // docs: Description of the flag. This is mostly for the benefits of HotSpot
  81 //       developers, and is excluded from PRODUCT builds.
  82 //
  83 //
  84 // Optionally, a flag can be given a range and/or constraint by using the following
  85 // macros:
  86 //
  87 // FLAG_RANGE(name, min, max)
  88 // FLAG_CONSTRAINT(name, func, phase)
  89 //
  90 // When a range is specified, the flag's attr must include JVMFlag::RANGE.
  91 // When a constraint is specified, the flag's attr must include JVMFlag::CONSTRAINT.
  92 //
  93 // For example:
  94 //
  95 // PRODUCT_FLAG(size_t,   LargePageSizeInBytes, 0, JVMFlag::RANGE,
  96 //                       "Large page size (0 to let VM choose the page size)");
  97 //    FLAG_RANGE(         LargePageSizeInBytes, 0, max_uintx);
  98 //
  99 // PRODUCT_FLAG_PD(size_t,MetaspaceSize, JVMFlag::CONSTRAINT,
 100 //                        "Initial threshold (in bytes) at which a garbage collection "
 101 //                        "is done to reduce Metaspace usage");
 102 //    FLAG_CONSTRAINT(    MetaspaceSize, (void*)MetaspaceSizeConstraintFunc, JVMFlag::AfterErgo);
 103 //
 104 //
 105 // Command-line Flag Attributes
 106 //
 107 // The <attr> argument for each flag may be any combination of the following
 108 // bits.
 109 //
 110 //    JVMFlag::MANAGEABLE
 111 //    JVMFlag::DIAGNOSTIC
 112 //    JVMFlag::EXPERIMENTAL
 113 //
 114 // DIAGNOSTIC options are not meant for VM tuning or for product modes.
 115 // They are to be used for VM quality assurance or field diagnosis
 116 // of VM bugs.  They are hidden so that users will not be encouraged to
 117 // try them as if they were VM ordinary execution options.  However, they
 118 // are available in the product version of the VM.  Under instruction
 119 // from support engineers, VM customers can turn them on to collect
 120 // diagnostic information about VM problems.  To use a VM diagnostic
 121 // option, you must first specify +UnlockDiagnosticVMOptions.
 122 // (This master switch also affects the behavior of -Xprintflags.)
 123 //
 124 // EXPERIMENTAL flags are in support of features that are not
 125 //    part of the officially supported product, but are available
 126 //    for experimenting with. They could, for example, be performance
 127 //    features that may not have undergone full or rigorous QA, but which may
 128 //    help performance in some cases and released for experimentation
 129 //    by the community of users and developers. This flag also allows one to
 130 //    be able to build a fully supported product that nonetheless also
 131 //    ships with some unsupported, lightly tested, experimental features.
 132 //    Like the UnlockDiagnosticVMOptions flag above, there is a corresponding
 133 //    UnlockExperimentalVMOptions flag, which allows the control and
 134 //    modification of the experimental flags.
 135 //
 136 // Nota bene: neither diagnostic nor experimental options should be used casually,
 137 //    and they are not supported on production loads, except under explicit
 138 //    direction from support engineers.
 139 //
 140 // MANAGEABLE flags are writeable external product flags.
 141 //    They are dynamically writeable through the JDK management interface
 142 //    (com.sun.management.HotSpotDiagnosticMXBean API) and also through JConsole.
 143 //    These flags are external exported interface (see CCC).  The list of
 144 //    manageable flags can be queried programmatically through the management
 145 //    interface.
 146 //
 147 //    A flag can be made as "manageable" only if
 148 //    - the flag is defined in a CCC as an external exported interface.
 149 //    - the VM implementation supports dynamic setting of the flag.
 150 //      This implies that the VM must *always* query the flag variable
 151 //      and not reuse state related to the flag state at any given time.
 152 //    - you want the flag to be queried programmatically by the customers.
 153 
 154 
 155 // Additional flag attributes
 156 //
 157 // In addition to the 3 bits described above, more can be specified. These
 158 // usually only affects the printing of the flag (see java -XX:PrintFlagsFinal).
 159 // However, you can also write code to process a certain group of
 160 // flags. See JVMCIGlobals::check_jvmci_flags_are_consistent() for an example.
 161 //
 162 //     JVMFlag::PLATFORM_DEPENDENT
 163 //     JVMFlag::C1
 164 //     JVMFlag::C2
 165 //     JVMFlag::ARCH
 166 //     JVMFlag::JVMCI
 167 //
 168 // To add these extra bits to a group of flags, you can use the FLAG_COMMON_ATTRS
 169 // macro. See c2_globals.cpp for an example.
 170 
 171 
 172 // Default and minimum StringTable and SymbolTable size values
 173 // Must be powers of 2
 174 const size_t defaultStringTableSize = NOT_LP64(1024) LP64_ONLY(65536);
 175 const size_t minimumStringTableSize = 128;
 176 const size_t defaultSymbolTableSize = 32768; // 2^15
 177 const size_t minimumSymbolTableSize = 1024;
 178 
 179 #include "runtime/flags/jvmFlag.hpp"
 180 NOTPROD_FLAG(bool,     CheckCompressedOops, true, JVMFlag::DEFAULT,
 181                        "Generate checks in encoding/decoding code in debug VM");
 182 
 183 PRODUCT_FLAG(uintx,    HeapSearchSteps, 3 PPC64_ONLY(+17), JVMFlag::RANGE,
 184                        "Heap allocation steps through preferred address regions to find"
 185                        " where it can allocate the heap. Number of steps to take per "
 186                        "region.");
 187    FLAG_RANGE(         HeapSearchSteps, 1, max_uintx);
 188 
 189 DEVELOP_FLAG(bool,     CleanChunkPoolAsync, true, JVMFlag::DEFAULT,
 190                        "Clean the chunk pool asynchronously");
 191 
 192 PRODUCT_FLAG(uint,     HandshakeTimeout, 0, JVMFlag::DIAGNOSTIC,
 193                        "If nonzero set a timeout in milliseconds for handshakes");
 194 
 195 PRODUCT_FLAG(bool,     AlwaysSafeConstructors, false, JVMFlag::EXPERIMENTAL,
 196                        "Force safe construction, as if all fields are final.");
 197 
 198 PRODUCT_FLAG(bool,     UnlockDiagnosticVMOptions, trueInDebug, JVMFlag::DIAGNOSTIC,
 199                        "Enable normal processing of flags relating to field diagnostics");
 200 
 201 PRODUCT_FLAG(bool,     UnlockExperimentalVMOptions, false, JVMFlag::EXPERIMENTAL,
 202                        "Enable normal processing of flags relating to experimental "
 203                        "features");
 204 
 205 PRODUCT_FLAG(bool,     JavaMonitorsInStackTrace, true, JVMFlag::DEFAULT,
 206                        "Print information about Java monitor locks when the stacks are"
 207                        "dumped");
 208 
 209 PRODUCT_FLAG_PD(bool,  UseLargePages, JVMFlag::DEFAULT,
 210                        "Use large page memory");
 211 
 212 PRODUCT_FLAG_PD(bool,  UseLargePagesIndividualAllocation, JVMFlag::DEFAULT,
 213                        "Allocate large pages individually for better affinity");
 214 
 215 DEVELOP_FLAG(bool,     LargePagesIndividualAllocationInjectError, false, JVMFlag::DEFAULT,
 216                        "Fail large pages individual allocation");
 217 
 218 PRODUCT_FLAG(bool,     UseLargePagesInMetaspace, false, JVMFlag::DEFAULT,
 219                        "Use large page memory in metaspace. "
 220                        "Only used if UseLargePages is enabled.");
 221 
 222 PRODUCT_FLAG(bool,     UseNUMA, false, JVMFlag::DEFAULT,
 223                        "Use NUMA if available");
 224 
 225 PRODUCT_FLAG(bool,     UseNUMAInterleaving, false, JVMFlag::DEFAULT,
 226                        "Interleave memory across NUMA nodes if available");
 227 
 228 PRODUCT_FLAG(size_t,   NUMAInterleaveGranularity, 2*M, JVMFlag::RANGE,
 229                        "Granularity to use for NUMA interleaving on Windows OS");
 230    FLAG_CUSTOM_RANGE(  NUMAInterleaveGranularity, VMAllocationGranularity);
 231 
 232 PRODUCT_FLAG(bool,     ForceNUMA, false, JVMFlag::DEFAULT,
 233                        "Force NUMA optimizations on single-node/UMA systems");
 234 
 235 PRODUCT_FLAG(uintx,    NUMAChunkResizeWeight, 20, JVMFlag::RANGE,
 236                        "Percentage (0-100) used to weight the current sample when "
 237                        "computing exponentially decaying average for "
 238                        "AdaptiveNUMAChunkSizing");
 239    FLAG_RANGE(         NUMAChunkResizeWeight, 0, 100);
 240 
 241 PRODUCT_FLAG(size_t,   NUMASpaceResizeRate, 1*G, JVMFlag::RANGE,
 242                        "Do not reallocate more than this amount per collection");
 243    FLAG_RANGE(         NUMASpaceResizeRate, 0, max_uintx);
 244 
 245 PRODUCT_FLAG(bool,     UseAdaptiveNUMAChunkSizing, true, JVMFlag::DEFAULT,
 246                        "Enable adaptive chunk sizing for NUMA");
 247 
 248 PRODUCT_FLAG(bool,     NUMAStats, false, JVMFlag::DEFAULT,
 249                        "Print NUMA stats in detailed heap information");
 250 
 251 PRODUCT_FLAG(uintx,    NUMAPageScanRate, 256, JVMFlag::RANGE,
 252                        "Maximum number of pages to include in the page scan procedure");
 253    FLAG_RANGE(         NUMAPageScanRate, 0, max_uintx);
 254 
 255 PRODUCT_FLAG(bool,     UseAES, false, JVMFlag::DEFAULT,
 256                        "Control whether AES instructions are used when available");
 257 
 258 PRODUCT_FLAG(bool,     UseFMA, false, JVMFlag::DEFAULT,
 259                        "Control whether FMA instructions are used when available");
 260 
 261 PRODUCT_FLAG(bool,     UseSHA, false, JVMFlag::DEFAULT,
 262                        "Control whether SHA instructions are used when available");
 263 
 264 PRODUCT_FLAG(bool,     UseGHASHIntrinsics, false, JVMFlag::DIAGNOSTIC,
 265                        "Use intrinsics for GHASH versions of crypto");
 266 
 267 PRODUCT_FLAG(bool,     UseBASE64Intrinsics, false, JVMFlag::DEFAULT,
 268                        "Use intrinsics for java.util.Base64");
 269 
 270 PRODUCT_FLAG(size_t,   LargePageSizeInBytes, 0, JVMFlag::RANGE,
 271                        "Large page size (0 to let VM choose the page size)");
 272    FLAG_RANGE(         LargePageSizeInBytes, 0, max_uintx);
 273 
 274 PRODUCT_FLAG(size_t,   LargePageHeapSizeThreshold, 128*M, JVMFlag::RANGE,
 275                        "Use large pages if maximum heap is at least this big");
 276    FLAG_RANGE(         LargePageHeapSizeThreshold, 0, max_uintx);
 277 
 278 PRODUCT_FLAG(bool,     ForceTimeHighResolution, false, JVMFlag::DEFAULT,
 279                        "Using high time resolution (for Win32 only)");
 280 
 281 DEVELOP_FLAG(bool,     TracePcPatching, false, JVMFlag::DEFAULT,
 282                        "Trace usage of frame::patch_pc");
 283 
 284 DEVELOP_FLAG(bool,     TraceRelocator, false, JVMFlag::DEFAULT,
 285                        "Trace the bytecode relocator");
 286 
 287 DEVELOP_FLAG(bool,     TraceLongCompiles, false, JVMFlag::DEFAULT,
 288                        "Print out every time compilation is longer than "
 289                        "a given threshold");
 290 
 291 PRODUCT_FLAG(bool,     SafepointALot, false, JVMFlag::DIAGNOSTIC,
 292                        "Generate a lot of safepoints. This works with "
 293                        "GuaranteedSafepointInterval");
 294 
 295 PRODUCT_FLAG(bool,     HandshakeALot, false, JVMFlag::DIAGNOSTIC,
 296                        "Generate a lot of handshakes. This works with "
 297                        "GuaranteedSafepointInterval");
 298 
 299 PRODUCT_FLAG_PD(bool,  BackgroundCompilation, JVMFlag::DEFAULT,
 300                        "A thread requesting compilation is not blocked during "
 301                        "compilation");
 302 
 303 PRODUCT_FLAG(bool,     PrintVMQWaitTime, false, JVMFlag::DEFAULT,
 304                        "(Deprecated) Print out the waiting time in VM operation queue");
 305 
 306 PRODUCT_FLAG(bool,     MethodFlushing, true, JVMFlag::DEFAULT,
 307                        "Reclamation of zombie and not-entrant methods");
 308 
 309 DEVELOP_FLAG(bool,     VerifyStack, false, JVMFlag::DEFAULT,
 310                        "Verify stack of each thread when it is entering a runtime call");
 311 
 312 PRODUCT_FLAG(bool,     ForceUnreachable, false, JVMFlag::DIAGNOSTIC,
 313                        "Make all non code cache addresses to be unreachable by "
 314                        "forcing use of 64bit literal fixups");
 315 
 316 NOTPROD_FLAG(bool,     StressDerivedPointers, false, JVMFlag::DEFAULT,
 317                        "Force scavenge when a derived pointer is detected on stack "
 318                        "after rtm call");
 319 
 320 DEVELOP_FLAG(bool,     TraceDerivedPointers, false, JVMFlag::DEFAULT,
 321                        "Trace traversal of derived pointers on stack");
 322 
 323 NOTPROD_FLAG(bool,     TraceCodeBlobStacks, false, JVMFlag::DEFAULT,
 324                        "Trace stack-walk of codeblobs");
 325 
 326 NOTPROD_FLAG(bool,     PrintRewrites, false, JVMFlag::DEFAULT,
 327                        "Print methods that are being rewritten");
 328 
 329 PRODUCT_FLAG(bool,     UseInlineCaches, true, JVMFlag::DEFAULT,
 330                        "Use Inline Caches for virtual calls ");
 331 
 332 PRODUCT_FLAG(bool,     InlineArrayCopy, true, JVMFlag::DIAGNOSTIC,
 333                        "Inline arraycopy native that is known to be part of "
 334                        "base library DLL");
 335 
 336 PRODUCT_FLAG(bool,     InlineObjectHash, true, JVMFlag::DIAGNOSTIC,
 337                        "Inline Object::hashCode() native that is known to be part "
 338                        "of base library DLL");
 339 
 340 PRODUCT_FLAG(bool,     InlineNatives, true, JVMFlag::DIAGNOSTIC,
 341                        "Inline natives that are known to be part of base library DLL");
 342 
 343 PRODUCT_FLAG(bool,     InlineMathNatives, true, JVMFlag::DIAGNOSTIC,
 344                        "Inline SinD, CosD, etc.");
 345 
 346 PRODUCT_FLAG(bool,     InlineClassNatives, true, JVMFlag::DIAGNOSTIC,
 347                        "Inline Class.isInstance, etc");
 348 
 349 PRODUCT_FLAG(bool,     InlineThreadNatives, true, JVMFlag::DIAGNOSTIC,
 350                        "Inline Thread.currentThread, etc");
 351 
 352 PRODUCT_FLAG(bool,     InlineUnsafeOps, true, JVMFlag::DIAGNOSTIC,
 353                        "Inline memory ops (native methods) from Unsafe");
 354 
 355 PRODUCT_FLAG(bool,     CriticalJNINatives, true, JVMFlag::DEFAULT,
 356                        "Check for critical JNI entry points");
 357 
 358 NOTPROD_FLAG(bool,     StressCriticalJNINatives, false, JVMFlag::DEFAULT,
 359                        "Exercise register saving code in critical natives");
 360 
 361 PRODUCT_FLAG(bool,     UseAESIntrinsics, false, JVMFlag::DIAGNOSTIC,
 362                        "Use intrinsics for AES versions of crypto");
 363 
 364 PRODUCT_FLAG(bool,     UseAESCTRIntrinsics, false, JVMFlag::DIAGNOSTIC,
 365                        "Use intrinsics for the paralleled version of AES/CTR crypto");
 366 
 367 PRODUCT_FLAG(bool,     UseSHA1Intrinsics, false, JVMFlag::DIAGNOSTIC,
 368                        "Use intrinsics for SHA-1 crypto hash function. "
 369                        "Requires that UseSHA is enabled.");
 370 
 371 PRODUCT_FLAG(bool,     UseSHA256Intrinsics, false, JVMFlag::DIAGNOSTIC,
 372                        "Use intrinsics for SHA-224 and SHA-256 crypto hash functions. "
 373                        "Requires that UseSHA is enabled.");
 374 
 375 PRODUCT_FLAG(bool,     UseSHA512Intrinsics, false, JVMFlag::DIAGNOSTIC,
 376                        "Use intrinsics for SHA-384 and SHA-512 crypto hash functions. "
 377                        "Requires that UseSHA is enabled.");
 378 
 379 PRODUCT_FLAG(bool,     UseCRC32Intrinsics, false, JVMFlag::DIAGNOSTIC,
 380                        "use intrinsics for java.util.zip.CRC32");
 381 
 382 PRODUCT_FLAG(bool,     UseCRC32CIntrinsics, false, JVMFlag::DIAGNOSTIC,
 383                        "use intrinsics for java.util.zip.CRC32C");
 384 
 385 PRODUCT_FLAG(bool,     UseAdler32Intrinsics, false, JVMFlag::DIAGNOSTIC,
 386                        "use intrinsics for java.util.zip.Adler32");
 387 
 388 PRODUCT_FLAG(bool,     UseVectorizedMismatchIntrinsic, false, JVMFlag::DIAGNOSTIC,
 389                        "Enables intrinsification of ArraysSupport.vectorizedMismatch()");
 390 
 391 PRODUCT_FLAG(ccstr,    DisableIntrinsic, "", JVMFlag::DIAGNOSTIC | JVMFlag::STRINGLIST,
 392                        "do not expand intrinsics whose (internal) names appear here");
 393 
 394 DEVELOP_FLAG(bool,     TraceCallFixup, false, JVMFlag::DEFAULT,
 395                        "Trace all call fixups");
 396 
 397 DEVELOP_FLAG(bool,     DeoptimizeALot, false, JVMFlag::DEFAULT,
 398                        "Deoptimize at every exit from the runtime system");
 399 
 400 NOTPROD_FLAG(ccstr,    DeoptimizeOnlyAt, "", JVMFlag::STRINGLIST,
 401                        "A comma separated list of bcis to deoptimize at");
 402 
 403 DEVELOP_FLAG(bool,     DeoptimizeRandom, false, JVMFlag::DEFAULT,
 404                        "Deoptimize random frames on random exit from the runtime system");
 405 
 406 NOTPROD_FLAG(bool,     ZombieALot, false, JVMFlag::DEFAULT,
 407                        "Create zombies (non-entrant) at exit from the runtime system");
 408 
 409 NOTPROD_FLAG(bool,     WalkStackALot, false, JVMFlag::DEFAULT,
 410                        "Trace stack (no print) at every exit from the runtime system");
 411 
 412 PRODUCT_FLAG(bool,     Debugging, false, JVMFlag::DEFAULT,
 413                        "Set when executing debug methods in debug.cpp "
 414                        "(to prevent triggering assertions)");
 415 
 416 NOTPROD_FLAG(bool,     VerifyLastFrame, false, JVMFlag::DEFAULT,
 417                        "Verify oops on last frame on entry to VM");
 418 
 419 PRODUCT_FLAG(bool,     SafepointTimeout, false, JVMFlag::DEFAULT,
 420                        "Time out and warn or fail after SafepointTimeoutDelay "
 421                        "milliseconds if failed to reach safepoint");
 422 
 423 PRODUCT_FLAG(bool,     AbortVMOnSafepointTimeout, false, JVMFlag::DIAGNOSTIC,
 424                        "Abort upon failure to reach safepoint (see SafepointTimeout)");
 425 
 426 PRODUCT_FLAG(bool,     AbortVMOnVMOperationTimeout, false, JVMFlag::DIAGNOSTIC,
 427                        "Abort upon failure to complete VM operation promptly");
 428 
 429 PRODUCT_FLAG(intx,     AbortVMOnVMOperationTimeoutDelay, 1000, JVMFlag::DIAGNOSTIC | JVMFlag::RANGE,
 430                        "Delay in milliseconds for option AbortVMOnVMOperationTimeout");
 431    FLAG_RANGE(         AbortVMOnVMOperationTimeoutDelay, 0, max_intx);
 432 
 433 
 434     //  50 retries * (5 * current_retry_count) millis = ~6.375 seconds 
 435     //  typically, at most a few retries are needed                    
 436 PRODUCT_FLAG(intx,     SuspendRetryCount, 50, JVMFlag::RANGE,
 437                        "Maximum retry count for an external suspend request");
 438    FLAG_RANGE(         SuspendRetryCount, 0, max_intx);
 439 
 440 PRODUCT_FLAG(intx,     SuspendRetryDelay, 5, JVMFlag::RANGE,
 441                        "Milliseconds to delay per retry (* current_retry_count)");
 442    FLAG_RANGE(         SuspendRetryDelay, 0, max_intx);
 443 
 444 PRODUCT_FLAG(bool,     AssertOnSuspendWaitFailure, false, JVMFlag::DEFAULT,
 445                        "Assert/Guarantee on external suspend wait failure");
 446 
 447 PRODUCT_FLAG(bool,     TraceSuspendWaitFailures, false, JVMFlag::DEFAULT,
 448                        "Trace external suspend wait failures");
 449 
 450 PRODUCT_FLAG(bool,     MaxFDLimit, true, JVMFlag::DEFAULT,
 451                        "Bump the number of file descriptors to maximum in Solaris");
 452 
 453 PRODUCT_FLAG(bool,     LogEvents, true, JVMFlag::DIAGNOSTIC,
 454                        "Enable the various ring buffer event logs");
 455 
 456 PRODUCT_FLAG(uintx,    LogEventsBufferEntries, 20, JVMFlag::DIAGNOSTIC | JVMFlag::RANGE,
 457                        "Number of ring buffer event logs");
 458    FLAG_RANGE(         LogEventsBufferEntries, 1, NOT_LP64(1*K) LP64_ONLY(1*M));
 459 
 460 PRODUCT_FLAG(bool,     BytecodeVerificationRemote, true, JVMFlag::DIAGNOSTIC,
 461                        "Enable the Java bytecode verifier for remote classes");
 462 
 463 PRODUCT_FLAG(bool,     BytecodeVerificationLocal, false, JVMFlag::DIAGNOSTIC,
 464                        "Enable the Java bytecode verifier for local classes");
 465 
 466 DEVELOP_FLAG(bool,     ForceFloatExceptions, trueInDebug, JVMFlag::DEFAULT,
 467                        "Force exceptions on FP stack under/overflow");
 468 
 469 DEVELOP_FLAG(bool,     VerifyStackAtCalls, false, JVMFlag::DEFAULT,
 470                        "Verify that the stack pointer is unchanged after calls");
 471 
 472 DEVELOP_FLAG(bool,     TraceJavaAssertions, false, JVMFlag::DEFAULT,
 473                        "Trace java language assertions");
 474 
 475 NOTPROD_FLAG(bool,     VerifyCodeCache, false, JVMFlag::DEFAULT,
 476                        "Verify code cache on memory allocation/deallocation");
 477 
 478 DEVELOP_FLAG(bool,     UseMallocOnly, false, JVMFlag::DEFAULT,
 479                        "Use only malloc/free for allocation (no resource area/arena)");
 480 
 481 DEVELOP_FLAG(bool,     ZapResourceArea, trueInDebug, JVMFlag::DEFAULT,
 482                        "Zap freed resource/arena space with 0xABABABAB");
 483 
 484 NOTPROD_FLAG(bool,     ZapVMHandleArea, trueInDebug, JVMFlag::DEFAULT,
 485                        "Zap freed VM handle space with 0xBCBCBCBC");
 486 
 487 NOTPROD_FLAG(bool,     ZapStackSegments, trueInDebug, JVMFlag::DEFAULT,
 488                        "Zap allocated/freed stack segments with 0xFADFADED");
 489 
 490 DEVELOP_FLAG(bool,     ZapUnusedHeapArea, trueInDebug, JVMFlag::DEFAULT,
 491                        "Zap unused heap space with 0xBAADBABE");
 492 
 493 DEVELOP_FLAG(bool,     CheckZapUnusedHeapArea, false, JVMFlag::DEFAULT,
 494                        "Check zapping of unused heap space");
 495 
 496 DEVELOP_FLAG(bool,     ZapFillerObjects, trueInDebug, JVMFlag::DEFAULT,
 497                        "Zap filler objects with 0xDEAFBABE");
 498 
 499 DEVELOP_FLAG(bool,     PrintVMMessages, true, JVMFlag::DEFAULT,
 500                        "Print VM messages on console");
 501 
 502 NOTPROD_FLAG(uintx,    ErrorHandlerTest, 0, JVMFlag::DEFAULT,
 503                        "If > 0, provokes an error after VM initialization; the value "
 504                        "determines which error to provoke. See test_error_handler() "
 505                        "in vmError.cpp.");
 506 
 507 NOTPROD_FLAG(uintx,    TestCrashInErrorHandler, 0, JVMFlag::DEFAULT,
 508                        "If > 0, provokes an error inside VM error handler (a secondary "
 509                        "crash). see test_error_handler() in vmError.cpp");
 510 
 511 NOTPROD_FLAG(bool,     TestSafeFetchInErrorHandler, false, JVMFlag::DEFAULT,
 512                        "If true, tests SafeFetch inside error handler.");
 513 
 514 DEVELOP_FLAG(bool,     TestUnresponsiveErrorHandler, false, JVMFlag::DEFAULT,
 515                        "If true, simulates an unresponsive error handler.");
 516 
 517 DEVELOP_FLAG(bool,     Verbose, false, JVMFlag::DEFAULT,
 518                        "Print additional debugging information from other modes");
 519 
 520 DEVELOP_FLAG(bool,     PrintMiscellaneous, false, JVMFlag::DEFAULT,
 521                        "Print uncategorized debugging information (requires +Verbose)");
 522 
 523 DEVELOP_FLAG(bool,     WizardMode, false, JVMFlag::DEFAULT,
 524                        "Print much more debugging information");
 525 
 526 PRODUCT_FLAG(bool,     ShowMessageBoxOnError, false, JVMFlag::DEFAULT,
 527                        "Keep process alive on VM fatal error");
 528 
 529 PRODUCT_FLAG(bool,     CreateCoredumpOnCrash, true, JVMFlag::DEFAULT,
 530                        "Create core/mini dump on VM fatal error");
 531 
 532 PRODUCT_FLAG(uint64_t, ErrorLogTimeout, 2 * 60, JVMFlag::RANGE,
 533                        "Timeout, in seconds, to limit the time spent on writing an "
 534                        "error log in case of a crash.");
 535    FLAG_RANGE(         ErrorLogTimeout, 0, (uint64_t)max_jlong/1000);
 536 
 537 PRODUCT_FLAG_PD(bool,  UseOSErrorReporting, JVMFlag::DEFAULT,
 538                        "Let VM fatal error propagate to the OS (ie. WER on Windows)");
 539 
 540 PRODUCT_FLAG(bool,     SuppressFatalErrorMessage, false, JVMFlag::DEFAULT,
 541                        "Report NO fatal error message (avoid deadlock)");
 542 
 543 PRODUCT_FLAG(ccstr,    OnError, "", JVMFlag::STRINGLIST,
 544                        "Run user-defined commands on fatal error; see VMError.cpp "
 545                        "for examples");
 546 
 547 PRODUCT_FLAG(ccstr,    OnOutOfMemoryError, "", JVMFlag::STRINGLIST,
 548                        "Run user-defined commands on first java.lang.OutOfMemoryError");
 549 
 550 PRODUCT_FLAG(bool,     HeapDumpBeforeFullGC, false, JVMFlag::MANAGEABLE,
 551                        "Dump heap to file before any major stop-the-world GC");
 552 
 553 PRODUCT_FLAG(bool,     HeapDumpAfterFullGC, false, JVMFlag::MANAGEABLE,
 554                        "Dump heap to file after any major stop-the-world GC");
 555 
 556 PRODUCT_FLAG(bool,     HeapDumpOnOutOfMemoryError, false, JVMFlag::MANAGEABLE,
 557                        "Dump heap to file when java.lang.OutOfMemoryError is thrown");
 558 
 559 PRODUCT_FLAG(ccstr,    HeapDumpPath, NULL, JVMFlag::MANAGEABLE,
 560                        "When HeapDumpOnOutOfMemoryError is on, the path (filename or "
 561                        "directory) of the dump file (defaults to java_pid<pid>.hprof "
 562                        "in the working directory)");
 563 
 564 DEVELOP_FLAG(bool,     BreakAtWarning, false, JVMFlag::DEFAULT,
 565                        "Execute breakpoint upon encountering VM warning");
 566 
 567 PRODUCT_FLAG(ccstr,    NativeMemoryTracking, "off", JVMFlag::DEFAULT,
 568                        "Native memory tracking options");
 569 
 570 PRODUCT_FLAG(bool,     PrintNMTStatistics, false, JVMFlag::DIAGNOSTIC,
 571                        "Print native memory tracking summary data if it is on");
 572 
 573 PRODUCT_FLAG(bool,     LogCompilation, false, JVMFlag::DIAGNOSTIC,
 574                        "Log compilation activity in detail to LogFile");
 575 
 576 PRODUCT_FLAG(bool,     PrintCompilation, false, JVMFlag::DEFAULT,
 577                        "Print compilations");
 578 
 579 PRODUCT_FLAG(bool,     PrintExtendedThreadInfo, false, JVMFlag::DEFAULT,
 580                        "Print more information in thread dump");
 581 
 582 PRODUCT_FLAG(intx,     ScavengeRootsInCode, 2, JVMFlag::DIAGNOSTIC | JVMFlag::RANGE,
 583                        "0: do not allow scavengable oops in the code cache; "
 584                        "1: allow scavenging from the code cache; "
 585                        "2: emit as many constants as the compiler can see");
 586    FLAG_RANGE(         ScavengeRootsInCode, 0, 2);
 587 
 588 PRODUCT_FLAG(bool,     AlwaysRestoreFPU, false, JVMFlag::DEFAULT,
 589                        "Restore the FPU control word after every JNI call (expensive)");
 590 
 591 PRODUCT_FLAG(bool,     PrintCompilation2, false, JVMFlag::DIAGNOSTIC,
 592                        "Print additional statistics per compilation");
 593 
 594 PRODUCT_FLAG(bool,     PrintAdapterHandlers, false, JVMFlag::DIAGNOSTIC,
 595                        "Print code generated for i2c/c2i adapters");
 596 
 597 PRODUCT_FLAG(bool,     VerifyAdapterCalls, trueInDebug, JVMFlag::DIAGNOSTIC,
 598                        "Verify that i2c/c2i adapters are called properly");
 599 
 600 DEVELOP_FLAG(bool,     VerifyAdapterSharing, false, JVMFlag::DEFAULT,
 601                        "Verify that the code for shared adapters is the equivalent");
 602 
 603 PRODUCT_FLAG(bool,     PrintAssembly, false, JVMFlag::DIAGNOSTIC,
 604                        "Print assembly code (using external disassembler.so)");
 605 
 606 PRODUCT_FLAG(ccstr,    PrintAssemblyOptions, NULL, JVMFlag::DIAGNOSTIC,
 607                        "Print options string passed to disassembler.so");
 608 
 609 NOTPROD_FLAG(bool,     PrintNMethodStatistics, false, JVMFlag::DEFAULT,
 610                        "Print a summary statistic for the generated nmethods");
 611 
 612 PRODUCT_FLAG(bool,     PrintNMethods, false, JVMFlag::DIAGNOSTIC,
 613                        "Print assembly code for nmethods when generated");
 614 
 615 PRODUCT_FLAG(bool,     PrintNativeNMethods, false, JVMFlag::DIAGNOSTIC,
 616                        "Print assembly code for native nmethods when generated");
 617 
 618 DEVELOP_FLAG(bool,     PrintDebugInfo, false, JVMFlag::DEFAULT,
 619                        "Print debug information for all nmethods when generated");
 620 
 621 DEVELOP_FLAG(bool,     PrintRelocations, false, JVMFlag::DEFAULT,
 622                        "Print relocation information for all nmethods when generated");
 623 
 624 DEVELOP_FLAG(bool,     PrintDependencies, false, JVMFlag::DEFAULT,
 625                        "Print dependency information for all nmethods when generated");
 626 
 627 DEVELOP_FLAG(bool,     PrintExceptionHandlers, false, JVMFlag::DEFAULT,
 628                        "Print exception handler tables for all nmethods when generated");
 629 
 630 DEVELOP_FLAG(bool,     StressCompiledExceptionHandlers, false, JVMFlag::DEFAULT,
 631                        "Exercise compiled exception handlers");
 632 
 633 DEVELOP_FLAG(bool,     InterceptOSException, false, JVMFlag::DEFAULT,
 634                        "Start debugger when an implicit OS (e.g. NULL) "
 635                        "exception happens");
 636 
 637 PRODUCT_FLAG(bool,     PrintCodeCache, false, JVMFlag::DEFAULT,
 638                        "Print the code cache memory usage when exiting");
 639 
 640 DEVELOP_FLAG(bool,     PrintCodeCache2, false, JVMFlag::DEFAULT,
 641                        "Print detailed usage information on the code cache when exiting");
 642 
 643 PRODUCT_FLAG(bool,     PrintCodeCacheOnCompilation, false, JVMFlag::DEFAULT,
 644                        "Print the code cache memory usage each time a method is "
 645                        "compiled");
 646 
 647 PRODUCT_FLAG(bool,     PrintCodeHeapAnalytics, false, JVMFlag::DIAGNOSTIC,
 648                        "Print code heap usage statistics on exit and on full condition");
 649 
 650 PRODUCT_FLAG(bool,     PrintStubCode, false, JVMFlag::DIAGNOSTIC,
 651                        "Print generated stub code");
 652 
 653 PRODUCT_FLAG(bool,     StackTraceInThrowable, true, JVMFlag::DEFAULT,
 654                        "Collect backtrace in throwable when exception happens");
 655 
 656 PRODUCT_FLAG(bool,     OmitStackTraceInFastThrow, true, JVMFlag::DEFAULT,
 657                        "Omit backtraces for some 'hot' exceptions in optimized code");
 658 
 659 PRODUCT_FLAG(bool,     ShowCodeDetailsInExceptionMessages, false, JVMFlag::MANAGEABLE,
 660                        "Show exception messages from RuntimeExceptions that contain "
 661                        "snippets of the failing code. Disable this to improve privacy.");
 662 
 663 PRODUCT_FLAG(bool,     PrintWarnings, true, JVMFlag::DEFAULT,
 664                        "Print JVM warnings to output stream");
 665 
 666 NOTPROD_FLAG(uintx,    WarnOnStalledSpinLock, 0, JVMFlag::DEFAULT,
 667                        "Print warnings for stalled SpinLocks");
 668 
 669 PRODUCT_FLAG(bool,     RegisterFinalizersAtInit, true, JVMFlag::DEFAULT,
 670                        "Register finalizable objects at end of Object.<init> or "
 671                        "after allocation");
 672 
 673 DEVELOP_FLAG(bool,     RegisterReferences, true, JVMFlag::DEFAULT,
 674                        "Tell whether the VM should register soft/weak/final/phantom "
 675                        "references");
 676 
 677 DEVELOP_FLAG(bool,     IgnoreRewrites, false, JVMFlag::DEFAULT,
 678                        "Suppress rewrites of bytecodes in the oopmap generator. "
 679                        "This is unsafe!");
 680 
 681 DEVELOP_FLAG(bool,     PrintCodeCacheExtension, false, JVMFlag::DEFAULT,
 682                        "Print extension of code cache");
 683 
 684 DEVELOP_FLAG(bool,     UsePrivilegedStack, true, JVMFlag::DEFAULT,
 685                        "Enable the security JVM functions");
 686 
 687 DEVELOP_FLAG(bool,     ProtectionDomainVerification, true, JVMFlag::DEFAULT,
 688                        "Verify protection domain before resolution in system dictionary");
 689 
 690 PRODUCT_FLAG(bool,     ClassUnloading, true, JVMFlag::DEFAULT,
 691                        "Do unloading of classes");
 692 
 693 PRODUCT_FLAG(bool,     ClassUnloadingWithConcurrentMark, true, JVMFlag::DEFAULT,
 694                        "Do unloading of classes with a concurrent marking cycle");
 695 
 696 DEVELOP_FLAG(bool,     DisableStartThread, false, JVMFlag::DEFAULT,
 697                        "Disable starting of additional Java threads "
 698                        "(for debugging only)");
 699 
 700 DEVELOP_FLAG(bool,     MemProfiling, false, JVMFlag::DEFAULT,
 701                        "Write memory usage profiling to log file");
 702 
 703 DEVELOP_FLAG(bool,     PrintSystemDictionaryAtExit, false, JVMFlag::DEFAULT,
 704                        "Print the system dictionary at exit");
 705 
 706 PRODUCT_FLAG(bool,     DynamicallyResizeSystemDictionaries, true, JVMFlag::DIAGNOSTIC,
 707                        "Dynamically resize system dictionaries as needed");
 708 
 709 PRODUCT_FLAG(bool,     AlwaysLockClassLoader, false, JVMFlag::DEFAULT,
 710                        "Require the VM to acquire the class loader lock before calling "
 711                        "loadClass() even for class loaders registering "
 712                        "as parallel capable");
 713 
 714 PRODUCT_FLAG(bool,     AllowParallelDefineClass, false, JVMFlag::DEFAULT,
 715                        "Allow parallel defineClass requests for class loaders "
 716                        "registering as parallel capable");
 717 
 718 PRODUCT_FLAG_PD(bool,  DontYieldALot, JVMFlag::DEFAULT,
 719                        "Throw away obvious excess yield calls");
 720 
 721 DEVELOP_FLAG(bool,     UseDetachedThreads, true, JVMFlag::DEFAULT,
 722                        "Use detached threads that are recycled upon termination "
 723                        "(for Solaris only)");
 724 
 725 PRODUCT_FLAG(bool,     DisablePrimordialThreadGuardPages, false, JVMFlag::EXPERIMENTAL,
 726                        "Disable the use of stack guard pages if the JVM is loaded "
 727                        "on the primordial process thread");
 728 
 729 PRODUCT_FLAG(bool,     UseLWPSynchronization, true, JVMFlag::DEFAULT,
 730                        "Use LWP-based instead of libthread-based synchronization "
 731                        "(SPARC only)");
 732 
 733 PRODUCT_FLAG(intx,     MonitorBound, 0, JVMFlag::RANGE,
 734                        "(Deprecated) Bound Monitor population");
 735    FLAG_RANGE(         MonitorBound, 0, max_jint);
 736 
 737 PRODUCT_FLAG(intx,     MonitorUsedDeflationThreshold, 90, JVMFlag::EXPERIMENTAL | JVMFlag::RANGE,
 738                        "Percentage of used monitors before triggering cleanup "
 739                        "safepoint which deflates monitors (0 is off). "
 740                        "The check is performed on GuaranteedSafepointInterval.");
 741    FLAG_RANGE(         MonitorUsedDeflationThreshold, 0, 100);
 742 
 743 PRODUCT_FLAG(intx,     hashCode, 5, JVMFlag::EXPERIMENTAL,
 744                        "(Unstable) select hashCode generation algorithm");
 745 
 746 PRODUCT_FLAG(bool,     FilterSpuriousWakeups, true, JVMFlag::DEFAULT,
 747                        "When true prevents OS-level spurious, or premature, wakeups "
 748                        "from Object.wait (Ignored for Windows)");
 749 
 750 DEVELOP_FLAG(bool,     UsePthreads, false, JVMFlag::DEFAULT,
 751                        "Use pthread-based instead of libthread-based synchronization "
 752                        "(SPARC only)");
 753 
 754 PRODUCT_FLAG(bool,     ReduceSignalUsage, false, JVMFlag::DEFAULT,
 755                        "Reduce the use of OS signals in Java and/or the VM");
 756 
 757 DEVELOP_FLAG(bool,     LoadLineNumberTables, true, JVMFlag::DEFAULT,
 758                        "Tell whether the class file parser loads line number tables");
 759 
 760 DEVELOP_FLAG(bool,     LoadLocalVariableTables, true, JVMFlag::DEFAULT,
 761                        "Tell whether the class file parser loads local variable tables");
 762 
 763 DEVELOP_FLAG(bool,     LoadLocalVariableTypeTables, true, JVMFlag::DEFAULT,
 764                        "Tell whether the class file parser loads local variable type"
 765                        "tables");
 766 
 767 PRODUCT_FLAG(bool,     AllowUserSignalHandlers, false, JVMFlag::DEFAULT,
 768                        "Do not complain if the application installs signal handlers "
 769                        "(Solaris & Linux only)");
 770 
 771 PRODUCT_FLAG(bool,     UseSignalChaining, true, JVMFlag::DEFAULT,
 772                        "Use signal-chaining to invoke signal handlers installed "
 773                        "by the application (Solaris & Linux only)");
 774 
 775 PRODUCT_FLAG(bool,     RestoreMXCSROnJNICalls, false, JVMFlag::DEFAULT,
 776                        "Restore MXCSR when returning from JNI calls");
 777 
 778 PRODUCT_FLAG(bool,     CheckJNICalls, false, JVMFlag::DEFAULT,
 779                        "Verify all arguments to JNI calls");
 780 
 781 PRODUCT_FLAG(bool,     UseFastJNIAccessors, true, JVMFlag::DEFAULT,
 782                        "Use optimized versions of Get<Primitive>Field");
 783 
 784 PRODUCT_FLAG(intx,     MaxJNILocalCapacity, 65536, JVMFlag::RANGE,
 785                        "Maximum allowable local JNI handle capacity to "
 786                        "EnsureLocalCapacity() and PushLocalFrame(), "
 787                        "where <= 0 is unlimited, default: 65536");
 788    FLAG_RANGE(         MaxJNILocalCapacity, min_intx, max_intx);
 789 
 790 PRODUCT_FLAG(bool,     EagerXrunInit, false, JVMFlag::DEFAULT,
 791                        "Eagerly initialize -Xrun libraries; allows startup profiling, "
 792                        "but not all -Xrun libraries may support the state of the VM "
 793                        "at this time");
 794 
 795 PRODUCT_FLAG(bool,     PreserveAllAnnotations, false, JVMFlag::DEFAULT,
 796                        "Preserve RuntimeInvisibleAnnotations as well "
 797                        "as RuntimeVisibleAnnotations");
 798 
 799 DEVELOP_FLAG(uintx,    PreallocatedOutOfMemoryErrorCount, 4, JVMFlag::DEFAULT,
 800                        "Number of OutOfMemoryErrors preallocated with backtrace");
 801 
 802 PRODUCT_FLAG(bool,     UseXMMForArrayCopy, false, JVMFlag::DEFAULT,
 803                        "Use SSE2 MOVQ instruction for Arraycopy");
 804 
 805 NOTPROD_FLAG(bool,     PrintFieldLayout, false, JVMFlag::DEFAULT,
 806                        "Print field layout for each class");
 807 
 808 
 809     //  Need to limit the extent of the padding to reasonable size.          
 810     //  8K is well beyond the reasonable HW cache line size, even with       
 811     //  aggressive prefetching, while still leaving the room for segregating 
 812     //  among the distinct pages.                                            
 813 PRODUCT_FLAG(intx,     ContendedPaddingWidth, 128, JVMFlag::RANGE | JVMFlag::CONSTRAINT,
 814                        "How many bytes to pad the fields/classes marked @Contended with");
 815    FLAG_RANGE(         ContendedPaddingWidth, 0, 8192);
 816    FLAG_CONSTRAINT(    ContendedPaddingWidth, (void*)ContendedPaddingWidthConstraintFunc, JVMFlag::AfterErgo);
 817 
 818 PRODUCT_FLAG(bool,     EnableContended, true, JVMFlag::DEFAULT,
 819                        "Enable @Contended annotation support");
 820 
 821 PRODUCT_FLAG(bool,     RestrictContended, true, JVMFlag::DEFAULT,
 822                        "Restrict @Contended to trusted classes");
 823 
 824 PRODUCT_FLAG(bool,     UseBiasedLocking, true, JVMFlag::DEFAULT,
 825                        "Enable biased locking in JVM");
 826 
 827 PRODUCT_FLAG(intx,     BiasedLockingStartupDelay, 0, JVMFlag::RANGE | JVMFlag::CONSTRAINT,
 828                        "Number of milliseconds to wait before enabling biased locking");
 829  //TODO: to avoid circular dependency, the min/max cannot be declared in header file
 830  //FLAG_RANGE(         BiasedLockingStartupDelay, 0, (intx)(max_jint-(max_jint%PeriodicTask::interval_gran)));
 831    FLAG_CONSTRAINT(    BiasedLockingStartupDelay, (void*)BiasedLockingStartupDelayFunc, JVMFlag::AfterErgo);
 832 
 833 PRODUCT_FLAG(bool,     PrintBiasedLockingStatistics, false, JVMFlag::DIAGNOSTIC,
 834                        "Print statistics of biased locking in JVM");
 835 
 836 PRODUCT_FLAG(intx,     BiasedLockingBulkRebiasThreshold, 20, JVMFlag::RANGE | JVMFlag::CONSTRAINT,
 837                        "Threshold of number of revocations per type to try to "
 838                        "rebias all objects in the heap of that type");
 839    FLAG_RANGE(         BiasedLockingBulkRebiasThreshold, 0, max_intx);
 840    FLAG_CONSTRAINT(    BiasedLockingBulkRebiasThreshold, (void*)BiasedLockingBulkRebiasThresholdFunc, JVMFlag::AfterErgo);
 841 
 842 PRODUCT_FLAG(intx,     BiasedLockingBulkRevokeThreshold, 40, JVMFlag::RANGE | JVMFlag::CONSTRAINT,
 843                        "Threshold of number of revocations per type to permanently "
 844                        "revoke biases of all objects in the heap of that type");
 845    FLAG_RANGE(         BiasedLockingBulkRevokeThreshold, 0, max_intx);
 846    FLAG_CONSTRAINT(    BiasedLockingBulkRevokeThreshold, (void*)BiasedLockingBulkRevokeThresholdFunc, JVMFlag::AfterErgo);
 847 
 848 PRODUCT_FLAG(intx,     BiasedLockingDecayTime, 25000, JVMFlag::RANGE | JVMFlag::CONSTRAINT,
 849                        "Decay time (in milliseconds) to re-enable bulk rebiasing of a "
 850                        "type after previous bulk rebias");
 851    FLAG_RANGE(         BiasedLockingDecayTime, 500, max_intx);
 852    FLAG_CONSTRAINT(    BiasedLockingDecayTime, (void*)BiasedLockingDecayTimeFunc, JVMFlag::AfterErgo);
 853 
 854 PRODUCT_FLAG(bool,     ExitOnOutOfMemoryError, false, JVMFlag::DEFAULT,
 855                        "JVM exits on the first occurrence of an out-of-memory error");
 856 
 857 PRODUCT_FLAG(bool,     CrashOnOutOfMemoryError, false, JVMFlag::DEFAULT,
 858                        "JVM aborts, producing an error log and core/mini dump, on the "
 859                        "first occurrence of an out-of-memory error");
 860 
 861 
 862     //  tracing 
 863 DEVELOP_FLAG(bool,     StressRewriter, false, JVMFlag::DEFAULT,
 864                        "Stress linktime bytecode rewriting");
 865 
 866 PRODUCT_FLAG(ccstr,    TraceJVMTI, NULL, JVMFlag::DEFAULT,
 867                        "Trace flags for JVMTI functions and events");
 868 
 869 
 870     //  This option can change an EMCP method into an obsolete method. 
 871     //  This can affect tests that except specific methods to be EMCP. 
 872     //  This option should be used with caution.                       
 873 PRODUCT_FLAG(bool,     StressLdcRewrite, false, JVMFlag::DEFAULT,
 874                        "Force ldc -> ldc_w rewrite during RedefineClasses");
 875 
 876 
 877     //  change to false by default sometime after Mustang 
 878 PRODUCT_FLAG(bool,     VerifyMergedCPBytecodes, true, JVMFlag::DEFAULT,
 879                        "Verify bytecodes after RedefineClasses constant pool merging");
 880 
 881 PRODUCT_FLAG(bool,     AllowRedefinitionToAddDeleteMethods, false, JVMFlag::DEFAULT,
 882                        "(Deprecated) Allow redefinition to add and delete private "
 883                        "static or final methods for compatibility with old releases");
 884 
 885 DEVELOP_FLAG(bool,     TraceBytecodes, false, JVMFlag::DEFAULT,
 886                        "Trace bytecode execution");
 887 
 888 DEVELOP_FLAG(bool,     TraceICs, false, JVMFlag::DEFAULT,
 889                        "Trace inline cache changes");
 890 
 891 NOTPROD_FLAG(bool,     TraceInvocationCounterOverflow, false, JVMFlag::DEFAULT,
 892                        "Trace method invocation counter overflow");
 893 
 894 DEVELOP_FLAG(bool,     TraceInlineCacheClearing, false, JVMFlag::DEFAULT,
 895                        "Trace clearing of inline caches in nmethods");
 896 
 897 DEVELOP_FLAG(bool,     TraceDependencies, false, JVMFlag::DEFAULT,
 898                        "Trace dependencies");
 899 
 900 DEVELOP_FLAG(bool,     VerifyDependencies, trueInDebug, JVMFlag::DEFAULT,
 901                        "Exercise and verify the compilation dependency mechanism");
 902 
 903 DEVELOP_FLAG(bool,     TraceNewOopMapGeneration, false, JVMFlag::DEFAULT,
 904                        "Trace OopMapGeneration");
 905 
 906 DEVELOP_FLAG(bool,     TraceNewOopMapGenerationDetailed, false, JVMFlag::DEFAULT,
 907                        "Trace OopMapGeneration: print detailed cell states");
 908 
 909 DEVELOP_FLAG(bool,     TimeOopMap, false, JVMFlag::DEFAULT,
 910                        "Time calls to GenerateOopMap::compute_map() in sum");
 911 
 912 DEVELOP_FLAG(bool,     TimeOopMap2, false, JVMFlag::DEFAULT,
 913                        "Time calls to GenerateOopMap::compute_map() individually");
 914 
 915 DEVELOP_FLAG(bool,     TraceOopMapRewrites, false, JVMFlag::DEFAULT,
 916                        "Trace rewriting of method oops during oop map generation");
 917 
 918 DEVELOP_FLAG(bool,     TraceICBuffer, false, JVMFlag::DEFAULT,
 919                        "Trace usage of IC buffer");
 920 
 921 DEVELOP_FLAG(bool,     TraceCompiledIC, false, JVMFlag::DEFAULT,
 922                        "Trace changes of compiled IC");
 923 
 924 DEVELOP_FLAG(bool,     FLSVerifyDictionary, false, JVMFlag::DEFAULT,
 925                        "Do lots of (expensive) FLS dictionary verification");
 926 
 927 DEVELOP_FLAG(bool,     CheckMemoryInitialization, false, JVMFlag::DEFAULT,
 928                        "Check memory initialization");
 929 
 930 PRODUCT_FLAG(uintx,    ProcessDistributionStride, 4, JVMFlag::RANGE,
 931                        "Stride through processors when distributing processes");
 932    FLAG_RANGE(         ProcessDistributionStride, 0, max_juint);
 933 
 934 DEVELOP_FLAG(bool,     TraceFinalizerRegistration, false, JVMFlag::DEFAULT,
 935                        "Trace registration of final references");
 936 
 937 PRODUCT_FLAG(bool,     IgnoreEmptyClassPaths, false, JVMFlag::DEFAULT,
 938                        "Ignore empty path elements in -classpath");
 939 
 940 PRODUCT_FLAG(size_t,   InitialBootClassLoaderMetaspaceSize, NOT_LP64(2200*K) LP64_ONLY(4*M), JVMFlag::RANGE | JVMFlag::CONSTRAINT,
 941                        "Initial size of the boot class loader data metaspace");
 942    FLAG_RANGE(         InitialBootClassLoaderMetaspaceSize, 30*K, max_uintx/BytesPerWord);
 943    FLAG_CONSTRAINT(    InitialBootClassLoaderMetaspaceSize, (void*)InitialBootClassLoaderMetaspaceSizeConstraintFunc, JVMFlag::AfterErgo);
 944 
 945 PRODUCT_FLAG(bool,     PrintHeapAtSIGBREAK, true, JVMFlag::DEFAULT,
 946                        "Print heap layout in response to SIGBREAK");
 947 
 948 PRODUCT_FLAG(bool,     PrintClassHistogram, false, JVMFlag::MANAGEABLE,
 949                        "Print a histogram of class instances");
 950 
 951 PRODUCT_FLAG(double,   ObjectCountCutOffPercent, 0.5, JVMFlag::EXPERIMENTAL | JVMFlag::RANGE,
 952                        "The percentage of the used heap that the instances of a class "
 953                        "must occupy for the class to generate a trace event");
 954    FLAG_RANGE(         ObjectCountCutOffPercent, 0.0, 100.0);
 955 
 956 
 957     //  JVMTI heap profiling 
 958 PRODUCT_FLAG(bool,     TraceJVMTIObjectTagging, false, JVMFlag::DIAGNOSTIC,
 959                        "Trace JVMTI object tagging calls");
 960 
 961 PRODUCT_FLAG(bool,     VerifyBeforeIteration, false, JVMFlag::DIAGNOSTIC,
 962                        "Verify memory system before JVMTI iteration");
 963 
 964 
 965     //  compiler interface 
 966 DEVELOP_FLAG(bool,     CIPrintCompilerName, false, JVMFlag::DEFAULT,
 967                        "when CIPrint is active, print the name of the active compiler");
 968 
 969 PRODUCT_FLAG(bool,     CIPrintCompileQueue, false, JVMFlag::DIAGNOSTIC,
 970                        "display the contents of the compile queue whenever a "
 971                        "compilation is enqueued");
 972 
 973 DEVELOP_FLAG(bool,     CIPrintRequests, false, JVMFlag::DEFAULT,
 974                        "display every request for compilation");
 975 
 976 PRODUCT_FLAG(bool,     CITime, false, JVMFlag::DEFAULT,
 977                        "collect timing information for compilation");
 978 
 979 DEVELOP_FLAG(bool,     CITimeVerbose, false, JVMFlag::DEFAULT,
 980                        "be more verbose in compilation timings");
 981 
 982 DEVELOP_FLAG(bool,     CITimeEach, false, JVMFlag::DEFAULT,
 983                        "display timing information after each successful compilation");
 984 
 985 DEVELOP_FLAG(bool,     CICountOSR, false, JVMFlag::DEFAULT,
 986                        "use a separate counter when assigning ids to osr compilations");
 987 
 988 DEVELOP_FLAG(bool,     CICompileNatives, true, JVMFlag::DEFAULT,
 989                        "compile native methods if supported by the compiler");
 990 
 991 DEVELOP_FLAG_PD(bool,  CICompileOSR, JVMFlag::DEFAULT,
 992                        "compile on stack replacement methods if supported by the "
 993                        "compiler");
 994 
 995 DEVELOP_FLAG(bool,     CIPrintMethodCodes, false, JVMFlag::DEFAULT,
 996                        "print method bytecodes of the compiled code");
 997 
 998 DEVELOP_FLAG(bool,     CIPrintTypeFlow, false, JVMFlag::DEFAULT,
 999                        "print the results of ciTypeFlow analysis");
1000 
1001 DEVELOP_FLAG(bool,     CITraceTypeFlow, false, JVMFlag::DEFAULT,
1002                        "detailed per-bytecode tracing of ciTypeFlow analysis");
1003 
1004 DEVELOP_FLAG(intx,     OSROnlyBCI, -1, JVMFlag::DEFAULT,
1005                        "OSR only at this bci.  Negative values mean exclude that bci");
1006 
1007 
1008     //  compiler 
1009     //  notice: the max range value here is max_jint, not max_intx  
1010     //  because of overflow issue                                   
1011 PRODUCT_FLAG(intx,     CICompilerCount, CI_COMPILER_COUNT, JVMFlag::RANGE | JVMFlag::CONSTRAINT,
1012                        "Number of compiler threads to run");
1013    FLAG_RANGE(         CICompilerCount, 0, max_jint);
1014    FLAG_CONSTRAINT(    CICompilerCount, (void*)CICompilerCountConstraintFunc, JVMFlag::AfterErgo);
1015 
1016 PRODUCT_FLAG(bool,     UseDynamicNumberOfCompilerThreads, true, JVMFlag::DEFAULT,
1017                        "Dynamically choose the number of parallel compiler threads");
1018 
1019 PRODUCT_FLAG(bool,     ReduceNumberOfCompilerThreads, true, JVMFlag::DIAGNOSTIC,
1020                        "Reduce the number of parallel compiler threads when they "
1021                        "are not used");
1022 
1023 PRODUCT_FLAG(bool,     TraceCompilerThreads, false, JVMFlag::DIAGNOSTIC,
1024                        "Trace creation and removal of compiler threads");
1025 
1026 DEVELOP_FLAG(bool,     InjectCompilerCreationFailure, false, JVMFlag::DEFAULT,
1027                        "Inject thread creation failures for "
1028                        "UseDynamicNumberOfCompilerThreads");
1029 
1030 DEVELOP_FLAG(bool,     UseStackBanging, true, JVMFlag::DEFAULT,
1031                        "use stack banging for stack overflow checks (required for "
1032                        "proper StackOverflow handling; disable only to measure cost "
1033                        "of stackbanging)");
1034 
1035 DEVELOP_FLAG(bool,     GenerateSynchronizationCode, true, JVMFlag::DEFAULT,
1036                        "generate locking/unlocking code for synchronized methods and "
1037                        "monitors");
1038 
1039 DEVELOP_FLAG(bool,     GenerateRangeChecks, true, JVMFlag::DEFAULT,
1040                        "Generate range checks for array accesses");
1041 
1042 PRODUCT_FLAG_PD(bool,  ImplicitNullChecks, JVMFlag::DIAGNOSTIC,
1043                        "Generate code for implicit null checks");
1044 
1045 PRODUCT_FLAG_PD(bool,  TrapBasedNullChecks, JVMFlag::DEFAULT,
1046                        "Generate code for null checks that uses a cmp and trap "
1047                        "instruction raising SIGTRAP.  This is only used if an access to"
1048                        "null (+offset) will not raise a SIGSEGV, i.e.,"
1049                        "ImplicitNullChecks don't work (PPC64).");
1050 
1051 PRODUCT_FLAG(bool,     EnableThreadSMRExtraValidityChecks, true, JVMFlag::DIAGNOSTIC,
1052                        "Enable Thread SMR extra validity checks");
1053 
1054 PRODUCT_FLAG(bool,     EnableThreadSMRStatistics, trueInDebug, JVMFlag::DIAGNOSTIC,
1055                        "Enable Thread SMR Statistics");
1056 
1057 PRODUCT_FLAG(bool,     UseNotificationThread, true, JVMFlag::DEFAULT,
1058                        "Use Notification Thread");
1059 
1060 PRODUCT_FLAG(bool,     Inline, true, JVMFlag::DEFAULT,
1061                        "Enable inlining");
1062 
1063 PRODUCT_FLAG(bool,     ClipInlining, true, JVMFlag::DEFAULT,
1064                        "Clip inlining if aggregate method exceeds DesiredMethodLimit");
1065 
1066 DEVELOP_FLAG(bool,     UseCHA, true, JVMFlag::DEFAULT,
1067                        "Enable CHA");
1068 
1069 PRODUCT_FLAG(bool,     UseTypeProfile, true, JVMFlag::DEFAULT,
1070                        "Check interpreter profile for historically monomorphic calls");
1071 
1072 PRODUCT_FLAG(bool,     PrintInlining, false, JVMFlag::DIAGNOSTIC,
1073                        "Print inlining optimizations");
1074 
1075 PRODUCT_FLAG(bool,     UsePopCountInstruction, false, JVMFlag::DEFAULT,
1076                        "Use population count instruction");
1077 
1078 DEVELOP_FLAG(bool,     EagerInitialization, false, JVMFlag::DEFAULT,
1079                        "Eagerly initialize classes if possible");
1080 
1081 PRODUCT_FLAG(bool,     LogTouchedMethods, false, JVMFlag::DIAGNOSTIC,
1082                        "Log methods which have been ever touched in runtime");
1083 
1084 PRODUCT_FLAG(bool,     PrintTouchedMethodsAtExit, false, JVMFlag::DIAGNOSTIC,
1085                        "Print all methods that have been ever touched in runtime");
1086 
1087 DEVELOP_FLAG(bool,     TraceMethodReplacement, false, JVMFlag::DEFAULT,
1088                        "Print when methods are replaced do to recompilation");
1089 
1090 DEVELOP_FLAG(bool,     PrintMethodFlushing, false, JVMFlag::DEFAULT,
1091                        "Print the nmethods being flushed");
1092 
1093 PRODUCT_FLAG(bool,     PrintMethodFlushingStatistics, false, JVMFlag::DIAGNOSTIC,
1094                        "print statistics about method flushing");
1095 
1096 PRODUCT_FLAG(intx,     HotMethodDetectionLimit, 100000, JVMFlag::DIAGNOSTIC | JVMFlag::RANGE,
1097                        "Number of compiled code invocations after which "
1098                        "the method is considered as hot by the flusher");
1099    FLAG_RANGE(         HotMethodDetectionLimit, 1, max_jint);
1100 
1101 PRODUCT_FLAG(intx,     MinPassesBeforeFlush, 10, JVMFlag::DIAGNOSTIC | JVMFlag::RANGE,
1102                        "Minimum number of sweeper passes before an nmethod "
1103                        "can be flushed");
1104    FLAG_RANGE(         MinPassesBeforeFlush, 0, max_intx);
1105 
1106 PRODUCT_FLAG(bool,     UseCodeAging, true, JVMFlag::DEFAULT,
1107                        "Insert counter to detect warm methods");
1108 
1109 PRODUCT_FLAG(bool,     StressCodeAging, false, JVMFlag::DIAGNOSTIC,
1110                        "Start with counters compiled in");
1111 
1112 DEVELOP_FLAG(bool,     StressCodeBuffers, false, JVMFlag::DEFAULT,
1113                        "Exercise code buffer expansion and other rare state changes");
1114 
1115 PRODUCT_FLAG(bool,     DebugNonSafepoints, trueInDebug, JVMFlag::DIAGNOSTIC,
1116                        "Generate extra debugging information for non-safepoints in "
1117                        "nmethods");
1118 
1119 PRODUCT_FLAG(bool,     PrintVMOptions, false, JVMFlag::DEFAULT,
1120                        "Print flags that appeared on the command line");
1121 
1122 PRODUCT_FLAG(bool,     IgnoreUnrecognizedVMOptions, false, JVMFlag::DEFAULT,
1123                        "Ignore unrecognized VM options");
1124 
1125 PRODUCT_FLAG(bool,     PrintCommandLineFlags, false, JVMFlag::DEFAULT,
1126                        "Print flags specified on command line or set by ergonomics");
1127 
1128 PRODUCT_FLAG(bool,     PrintFlagsInitial, false, JVMFlag::DEFAULT,
1129                        "Print all VM flags before argument processing and exit VM");
1130 
1131 PRODUCT_FLAG(bool,     PrintFlagsFinal, false, JVMFlag::DEFAULT,
1132                        "Print all VM flags after argument and ergonomic processing");
1133 
1134 NOTPROD_FLAG(bool,     PrintFlagsWithComments, false, JVMFlag::DEFAULT,
1135                        "Print all VM flags with default values and descriptions and "
1136                        "exit");
1137 
1138 PRODUCT_FLAG(bool,     PrintFlagsRanges, false, JVMFlag::DEFAULT,
1139                        "Print VM flags and their ranges");
1140 
1141 PRODUCT_FLAG(bool,     SerializeVMOutput, true, JVMFlag::DIAGNOSTIC,
1142                        "Use a mutex to serialize output to tty and LogFile");
1143 
1144 PRODUCT_FLAG(bool,     DisplayVMOutput, true, JVMFlag::DIAGNOSTIC,
1145                        "Display all VM output on the tty, independently of LogVMOutput");
1146 
1147 PRODUCT_FLAG(bool,     LogVMOutput, false, JVMFlag::DIAGNOSTIC,
1148                        "Save VM output to LogFile");
1149 
1150 PRODUCT_FLAG(ccstr,    LogFile, NULL, JVMFlag::DIAGNOSTIC,
1151                        "If LogVMOutput or LogCompilation is on, save VM output to "
1152                        "this file [default: ./hotspot_pid%p.log] (%p replaced with pid)");
1153 
1154 PRODUCT_FLAG(ccstr,    ErrorFile, NULL, JVMFlag::DEFAULT,
1155                        "If an error occurs, save the error data to this file "
1156                        "[default: ./hs_err_pid%p.log] (%p replaced with pid)");
1157 
1158 PRODUCT_FLAG(bool,     ExtensiveErrorReports, PRODUCT_ONLY(false) NOT_PRODUCT(true), JVMFlag::DEFAULT,
1159                        "Error reports are more extensive.");
1160 
1161 PRODUCT_FLAG(bool,     DisplayVMOutputToStderr, false, JVMFlag::DEFAULT,
1162                        "If DisplayVMOutput is true, display all VM output to stderr");
1163 
1164 PRODUCT_FLAG(bool,     DisplayVMOutputToStdout, false, JVMFlag::DEFAULT,
1165                        "If DisplayVMOutput is true, display all VM output to stdout");
1166 
1167 PRODUCT_FLAG(bool,     ErrorFileToStderr, false, JVMFlag::DEFAULT,
1168                        "If true, error data is printed to stderr instead of a file");
1169 
1170 PRODUCT_FLAG(bool,     ErrorFileToStdout, false, JVMFlag::DEFAULT,
1171                        "If true, error data is printed to stdout instead of a file");
1172 
1173 PRODUCT_FLAG(bool,     UseHeavyMonitors, false, JVMFlag::DEFAULT,
1174                        "use heavyweight instead of lightweight Java monitors");
1175 
1176 PRODUCT_FLAG(bool,     PrintStringTableStatistics, false, JVMFlag::DEFAULT,
1177                        "print statistics about the StringTable and SymbolTable");
1178 
1179 PRODUCT_FLAG(bool,     VerifyStringTableAtExit, false, JVMFlag::DIAGNOSTIC,
1180                        "verify StringTable contents at exit");
1181 
1182 NOTPROD_FLAG(bool,     PrintSymbolTableSizeHistogram, false, JVMFlag::DEFAULT,
1183                        "print histogram of the symbol table");
1184 
1185 NOTPROD_FLAG(bool,     ExitVMOnVerifyError, false, JVMFlag::DEFAULT,
1186                        "standard exit from VM if bytecode verify error "
1187                        "(only in debug mode)");
1188 
1189 PRODUCT_FLAG(ccstr,    AbortVMOnException, NULL, JVMFlag::DIAGNOSTIC,
1190                        "Call fatal if this exception is thrown.  Example: "
1191                        "java -XX:AbortVMOnException=java.lang.NullPointerException Foo");
1192 
1193 PRODUCT_FLAG(ccstr,    AbortVMOnExceptionMessage, NULL, JVMFlag::DIAGNOSTIC,
1194                        "Call fatal if the exception pointed by AbortVMOnException "
1195                        "has this message");
1196 
1197 DEVELOP_FLAG(bool,     DebugVtables, false, JVMFlag::DEFAULT,
1198                        "add debugging code to vtable dispatch");
1199 
1200 NOTPROD_FLAG(bool,     PrintVtableStats, false, JVMFlag::DEFAULT,
1201                        "print vtables stats at end of run");
1202 
1203 DEVELOP_FLAG(bool,     TraceCreateZombies, false, JVMFlag::DEFAULT,
1204                        "trace creation of zombie nmethods");
1205 
1206 PRODUCT_FLAG(bool,     RangeCheckElimination, true, JVMFlag::DEFAULT,
1207                        "Eliminate range checks");
1208 
1209 DEVELOP_FLAG_PD(bool,  UncommonNullCast, JVMFlag::DEFAULT,
1210                        "track occurrences of null in casts; adjust compiler tactics");
1211 
1212 DEVELOP_FLAG(bool,     TypeProfileCasts, true, JVMFlag::DEFAULT,
1213                        "treat casts like calls for purposes of type profiling");
1214 
1215 DEVELOP_FLAG(bool,     TraceLivenessGen, false, JVMFlag::DEFAULT,
1216                        "Trace the generation of liveness analysis information");
1217 
1218 NOTPROD_FLAG(bool,     TraceLivenessQuery, false, JVMFlag::DEFAULT,
1219                        "Trace queries of liveness analysis information");
1220 
1221 NOTPROD_FLAG(bool,     CollectIndexSetStatistics, false, JVMFlag::DEFAULT,
1222                        "Collect information about IndexSets");
1223 
1224 DEVELOP_FLAG(bool,     UseLoopSafepoints, true, JVMFlag::DEFAULT,
1225                        "Generate Safepoint nodes in every loop");
1226 
1227 DEVELOP_FLAG(intx,     FastAllocateSizeLimit, 128*K, JVMFlag::DEFAULT,
1228                        /* Note:  This value is zero mod 1<<13 for a cheap sparc set. */
1229                        "Inline allocations larger than this in doublewords must go slow");
1230 
1231 
1232     //  Note:  This value is zero mod 1<<13 for a cheap sparc set. 
1233 PRODUCT_FLAG_PD(bool,  CompactStrings, JVMFlag::DEFAULT,
1234                        "Enable Strings to use single byte chars in backing store");
1235 
1236 PRODUCT_FLAG_PD(uintx, TypeProfileLevel, JVMFlag::CONSTRAINT,
1237                        "=XYZ, with Z: Type profiling of arguments at call; "
1238                        "Y: Type profiling of return value at call; "
1239                        "X: Type profiling of parameters to methods; "
1240                        "X, Y and Z in 0=off ; 1=jsr292 only; 2=all methods");
1241    FLAG_CONSTRAINT(    TypeProfileLevel, (void*)TypeProfileLevelConstraintFunc, JVMFlag::AfterErgo);
1242 
1243 PRODUCT_FLAG(intx,     TypeProfileArgsLimit, 2, JVMFlag::RANGE,
1244                        "max number of call arguments to consider for type profiling");
1245    FLAG_RANGE(         TypeProfileArgsLimit, 0, 16);
1246 
1247 PRODUCT_FLAG(intx,     TypeProfileParmsLimit, 2, JVMFlag::RANGE,
1248                        "max number of incoming parameters to consider for type profiling"
1249                        ", -1 for all");
1250    FLAG_RANGE(         TypeProfileParmsLimit, -1, 64);
1251 
1252 
1253     //  statistics 
1254 DEVELOP_FLAG(bool,     CountCompiledCalls, false, JVMFlag::DEFAULT,
1255                        "Count method invocations");
1256 
1257 NOTPROD_FLAG(bool,     CountRuntimeCalls, false, JVMFlag::DEFAULT,
1258                        "Count VM runtime calls");
1259 
1260 DEVELOP_FLAG(bool,     CountJNICalls, false, JVMFlag::DEFAULT,
1261                        "Count jni method invocations");
1262 
1263 NOTPROD_FLAG(bool,     CountJVMCalls, false, JVMFlag::DEFAULT,
1264                        "Count jvm method invocations");
1265 
1266 NOTPROD_FLAG(bool,     CountRemovableExceptions, false, JVMFlag::DEFAULT,
1267                        "Count exceptions that could be replaced by branches due to "
1268                        "inlining");
1269 
1270 NOTPROD_FLAG(bool,     ICMissHistogram, false, JVMFlag::DEFAULT,
1271                        "Produce histogram of IC misses");
1272 
1273 
1274     //  interpreter 
1275 PRODUCT_FLAG_PD(bool,  RewriteBytecodes, JVMFlag::DEFAULT,
1276                        "Allow rewriting of bytecodes (bytecodes are not immutable)");
1277 
1278 PRODUCT_FLAG_PD(bool,  RewriteFrequentPairs, JVMFlag::DEFAULT,
1279                        "Rewrite frequently used bytecode pairs into a single bytecode");
1280 
1281 PRODUCT_FLAG(bool,     PrintInterpreter, false, JVMFlag::DIAGNOSTIC,
1282                        "Print the generated interpreter code");
1283 
1284 PRODUCT_FLAG(bool,     UseInterpreter, true, JVMFlag::DEFAULT,
1285                        "Use interpreter for non-compiled methods");
1286 
1287 DEVELOP_FLAG(bool,     UseFastSignatureHandlers, true, JVMFlag::DEFAULT,
1288                        "Use fast signature handlers for native calls");
1289 
1290 PRODUCT_FLAG(bool,     UseLoopCounter, true, JVMFlag::DEFAULT,
1291                        "Increment invocation counter on backward branch");
1292 
1293 PRODUCT_FLAG_PD(bool,  UseOnStackReplacement, JVMFlag::DEFAULT,
1294                        "Use on stack replacement, calls runtime if invoc. counter "
1295                        "overflows in loop");
1296 
1297 NOTPROD_FLAG(bool,     TraceOnStackReplacement, false, JVMFlag::DEFAULT,
1298                        "Trace on stack replacement");
1299 
1300 PRODUCT_FLAG_PD(bool,  PreferInterpreterNativeStubs, JVMFlag::DEFAULT,
1301                        "Use always interpreter stubs for native methods invoked via "
1302                        "interpreter");
1303 
1304 DEVELOP_FLAG(bool,     CountBytecodes, false, JVMFlag::DEFAULT,
1305                        "Count number of bytecodes executed");
1306 
1307 DEVELOP_FLAG(bool,     PrintBytecodeHistogram, false, JVMFlag::DEFAULT,
1308                        "Print histogram of the executed bytecodes");
1309 
1310 DEVELOP_FLAG(bool,     PrintBytecodePairHistogram, false, JVMFlag::DEFAULT,
1311                        "Print histogram of the executed bytecode pairs");
1312 
1313 PRODUCT_FLAG(bool,     PrintSignatureHandlers, false, JVMFlag::DIAGNOSTIC,
1314                        "Print code generated for native method signature handlers");
1315 
1316 DEVELOP_FLAG(bool,     VerifyOops, false, JVMFlag::DEFAULT,
1317                        "Do plausibility checks for oops");
1318 
1319 DEVELOP_FLAG(bool,     CheckUnhandledOops, false, JVMFlag::DEFAULT,
1320                        "Check for unhandled oops in VM code");
1321 
1322 DEVELOP_FLAG(bool,     VerifyJNIFields, trueInDebug, JVMFlag::DEFAULT,
1323                        "Verify jfieldIDs for instance fields");
1324 
1325 NOTPROD_FLAG(bool,     VerifyJNIEnvThread, false, JVMFlag::DEFAULT,
1326                        "Verify JNIEnv.thread == Thread::current() when entering VM "
1327                        "from JNI");
1328 
1329 DEVELOP_FLAG(bool,     VerifyFPU, false, JVMFlag::DEFAULT,
1330                        "Verify FPU state (check for NaN's, etc.)");
1331 
1332 DEVELOP_FLAG(bool,     VerifyThread, false, JVMFlag::DEFAULT,
1333                        "Watch the thread register for corruption (SPARC only)");
1334 
1335 DEVELOP_FLAG(bool,     VerifyActivationFrameSize, false, JVMFlag::DEFAULT,
1336                        "Verify that activation frame didn't become smaller than its "
1337                        "minimal size");
1338 
1339 DEVELOP_FLAG(bool,     TraceFrequencyInlining, false, JVMFlag::DEFAULT,
1340                        "Trace frequency based inlining");
1341 
1342 DEVELOP_FLAG_PD(bool,  InlineIntrinsics, JVMFlag::DEFAULT,
1343                        "Inline intrinsics that can be statically resolved");
1344 
1345 PRODUCT_FLAG_PD(bool,  ProfileInterpreter, JVMFlag::DEFAULT,
1346                        "Profile at the bytecode level during interpretation");
1347 
1348 DEVELOP_FLAG(bool,     TraceProfileInterpreter, false, JVMFlag::DEFAULT,
1349                        "Trace profiling at the bytecode level during interpretation. "
1350                        "This outputs the profiling information collected to improve "
1351                        "jit compilation.");
1352 
1353 DEVELOP_FLAG_PD(bool,  ProfileTraps, JVMFlag::DEFAULT,
1354                        "Profile deoptimization traps at the bytecode level");
1355 
1356 PRODUCT_FLAG(intx,     ProfileMaturityPercentage, 20, JVMFlag::RANGE,
1357                        "number of method invocations/branches (expressed as % of "
1358                        "CompileThreshold) before using the method's profile");
1359    FLAG_RANGE(         ProfileMaturityPercentage, 0, 100);
1360 
1361 PRODUCT_FLAG(bool,     PrintMethodData, false, JVMFlag::DIAGNOSTIC,
1362                        "Print the results of +ProfileInterpreter at end of run");
1363 
1364 DEVELOP_FLAG(bool,     VerifyDataPointer, trueInDebug, JVMFlag::DEFAULT,
1365                        "Verify the method data pointer during interpreter profiling");
1366 
1367 DEVELOP_FLAG(bool,     VerifyCompiledCode, false, JVMFlag::DEFAULT,
1368                        "Include miscellaneous runtime verifications in nmethod code; "
1369                        "default off because it disturbs nmethod size heuristics");
1370 
1371 NOTPROD_FLAG(bool,     CrashGCForDumpingJavaThread, false, JVMFlag::DEFAULT,
1372                        "Manually make GC thread crash then dump java stack trace;  "
1373                        "Test only");
1374 
1375 
1376     //  compilation 
1377 PRODUCT_FLAG(bool,     UseCompiler, true, JVMFlag::DEFAULT,
1378                        "Use Just-In-Time compilation");
1379 
1380 PRODUCT_FLAG(bool,     UseCounterDecay, true, JVMFlag::DEFAULT,
1381                        "Adjust recompilation counters");
1382 
1383 DEVELOP_FLAG(intx,     CounterHalfLifeTime, 30, JVMFlag::DEFAULT,
1384                        "Half-life time of invocation counters (in seconds)");
1385 
1386 DEVELOP_FLAG(intx,     CounterDecayMinIntervalLength, 500, JVMFlag::DEFAULT,
1387                        "The minimum interval (in milliseconds) between invocation of "
1388                        "CounterDecay");
1389 
1390 PRODUCT_FLAG(bool,     AlwaysCompileLoopMethods, false, JVMFlag::DEFAULT,
1391                        "When using recompilation, never interpret methods "
1392                        "containing loops");
1393 
1394 PRODUCT_FLAG(bool,     DontCompileHugeMethods, true, JVMFlag::DEFAULT,
1395                        "Do not compile methods > HugeMethodLimit");
1396 
1397 
1398     //  Bytecode escape analysis estimation. 
1399 PRODUCT_FLAG(bool,     EstimateArgEscape, true, JVMFlag::DEFAULT,
1400                        "Analyze bytecodes to estimate escape state of arguments");
1401 
1402 PRODUCT_FLAG(intx,     BCEATraceLevel, 0, JVMFlag::RANGE,
1403                        "How much tracing to do of bytecode escape analysis estimates "
1404                        "(0-3)");
1405    FLAG_RANGE(         BCEATraceLevel, 0, 3);
1406 
1407 PRODUCT_FLAG(intx,     MaxBCEAEstimateLevel, 5, JVMFlag::RANGE,
1408                        "Maximum number of nested calls that are analyzed by BC EA");
1409    FLAG_RANGE(         MaxBCEAEstimateLevel, 0, max_jint);
1410 
1411 PRODUCT_FLAG(intx,     MaxBCEAEstimateSize, 150, JVMFlag::RANGE,
1412                        "Maximum bytecode size of a method to be analyzed by BC EA");
1413    FLAG_RANGE(         MaxBCEAEstimateSize, 0, max_jint);
1414 
1415 PRODUCT_FLAG(intx,     AllocatePrefetchStyle, 1, JVMFlag::RANGE,
1416                        "0 = no prefetch, "
1417                        "1 = generate prefetch instructions for each allocation, "
1418                        "2 = use TLAB watermark to gate allocation prefetch, "
1419                        "3 = generate one prefetch instruction per cache line");
1420    FLAG_RANGE(         AllocatePrefetchStyle, 0, 3);
1421 
1422 PRODUCT_FLAG(intx,     AllocatePrefetchDistance, -1, JVMFlag::CONSTRAINT,
1423                        "Distance to prefetch ahead of allocation pointer. "
1424                        "-1: use system-specific value (automatically determined");
1425    FLAG_CONSTRAINT(    AllocatePrefetchDistance, (void*)AllocatePrefetchDistanceConstraintFunc, JVMFlag::AfterMemoryInit);
1426 
1427 PRODUCT_FLAG(intx,     AllocatePrefetchLines, 3, JVMFlag::RANGE,
1428                        "Number of lines to prefetch ahead of array allocation pointer");
1429    FLAG_RANGE(         AllocatePrefetchLines, 1, 64);
1430 
1431 PRODUCT_FLAG(intx,     AllocateInstancePrefetchLines, 1, JVMFlag::RANGE,
1432                        "Number of lines to prefetch ahead of instance allocation "
1433                        "pointer");
1434    FLAG_RANGE(         AllocateInstancePrefetchLines, 1, 64);
1435 
1436 PRODUCT_FLAG(intx,     AllocatePrefetchStepSize, 16, JVMFlag::RANGE | JVMFlag::CONSTRAINT,
1437                        "Step size in bytes of sequential prefetch instructions");
1438    FLAG_RANGE(         AllocatePrefetchStepSize, 1, 512);
1439    FLAG_CONSTRAINT(    AllocatePrefetchStepSize, (void*)AllocatePrefetchStepSizeConstraintFunc, JVMFlag::AfterMemoryInit);
1440 
1441 PRODUCT_FLAG(intx,     AllocatePrefetchInstr, 0, JVMFlag::CONSTRAINT,
1442                        "Select instruction to prefetch ahead of allocation pointer");
1443    FLAG_CONSTRAINT(    AllocatePrefetchInstr, (void*)AllocatePrefetchInstrConstraintFunc, JVMFlag::AfterMemoryInit);
1444 
1445 
1446     //  deoptimization 
1447 DEVELOP_FLAG(bool,     TraceDeoptimization, false, JVMFlag::DEFAULT,
1448                        "Trace deoptimization");
1449 
1450 DEVELOP_FLAG(bool,     PrintDeoptimizationDetails, false, JVMFlag::DEFAULT,
1451                        "Print more information about deoptimization");
1452 
1453 DEVELOP_FLAG(bool,     DebugDeoptimization, false, JVMFlag::DEFAULT,
1454                        "Tracing various information while debugging deoptimization");
1455 
1456 PRODUCT_FLAG(intx,     SelfDestructTimer, 0, JVMFlag::RANGE,
1457                        "Will cause VM to terminate after a given time (in minutes) "
1458                        "(0 means off)");
1459    FLAG_RANGE(         SelfDestructTimer, 0, max_intx);
1460 
1461 PRODUCT_FLAG(intx,     MaxJavaStackTraceDepth, 1024, JVMFlag::RANGE,
1462                        "The maximum number of lines in the stack trace for Java "
1463                        "exceptions (0 means all)");
1464    FLAG_RANGE(         MaxJavaStackTraceDepth, 0, max_jint/2);
1465 
1466 
1467     //  notice: the max range value here is max_jint, not max_intx  
1468     //  because of overflow issue                                   
1469 PRODUCT_FLAG(intx,     GuaranteedSafepointInterval, 1000, JVMFlag::DIAGNOSTIC | JVMFlag::RANGE,
1470                        "Guarantee a safepoint (at least) every so many milliseconds "
1471                        "(0 means none)");
1472    FLAG_RANGE(         GuaranteedSafepointInterval, 0, max_jint);
1473 
1474 PRODUCT_FLAG(intx,     SafepointTimeoutDelay, 10000, JVMFlag::RANGE,
1475                        "Delay in milliseconds for option SafepointTimeout");
1476    FLAG_RANGE(         SafepointTimeoutDelay, 0, max_intx LP64_ONLY(/MICROUNITS));
1477 
1478 PRODUCT_FLAG(intx,     NmethodSweepActivity, 10, JVMFlag::RANGE,
1479                        "Removes cold nmethods from code cache if > 0. Higher values "
1480                        "result in more aggressive sweeping");
1481    FLAG_RANGE(         NmethodSweepActivity, 0, 2000);
1482 
1483 NOTPROD_FLAG(bool,     LogSweeper, false, JVMFlag::DEFAULT,
1484                        "Keep a ring buffer of sweeper activity");
1485 
1486 NOTPROD_FLAG(intx,     SweeperLogEntries, 1024, JVMFlag::DEFAULT,
1487                        "Number of records in the ring buffer of sweeper activity");
1488 
1489 NOTPROD_FLAG(intx,     MemProfilingInterval, 500, JVMFlag::DEFAULT,
1490                        "Time between each invocation of the MemProfiler");
1491 
1492 DEVELOP_FLAG(intx,     MallocCatchPtr, -1, JVMFlag::DEFAULT,
1493                        "Hit breakpoint when mallocing/freeing this pointer");
1494 
1495 NOTPROD_FLAG(ccstr,    SuppressErrorAt, "", JVMFlag::STRINGLIST,
1496                        "List of assertions (file:line) to muzzle");
1497 
1498 DEVELOP_FLAG(intx,     StackPrintLimit, 100, JVMFlag::DEFAULT,
1499                        "number of stack frames to print in VM-level stack dump");
1500 
1501 NOTPROD_FLAG(intx,     MaxElementPrintSize, 256, JVMFlag::DEFAULT,
1502                        "maximum number of elements to print");
1503 
1504 NOTPROD_FLAG(intx,     MaxSubklassPrintSize, 4, JVMFlag::DEFAULT,
1505                        "maximum number of subklasses to print when printing klass");
1506 
1507 PRODUCT_FLAG(intx,     MaxInlineLevel, 15, JVMFlag::RANGE,
1508                        "maximum number of nested calls that are inlined");
1509    FLAG_RANGE(         MaxInlineLevel, 0, max_jint);
1510 
1511 PRODUCT_FLAG(intx,     MaxRecursiveInlineLevel, 1, JVMFlag::RANGE,
1512                        "maximum number of nested recursive calls that are inlined");
1513    FLAG_RANGE(         MaxRecursiveInlineLevel, 0, max_jint);
1514 
1515 DEVELOP_FLAG(intx,     MaxForceInlineLevel, 100, JVMFlag::RANGE,
1516                        "maximum number of nested calls that are forced for inlining "
1517                        "(using CompileCommand or marked w/ @ForceInline)");
1518    FLAG_RANGE(         MaxForceInlineLevel, 0, max_jint);
1519 
1520 PRODUCT_FLAG_PD(intx,  InlineSmallCode, JVMFlag::RANGE,
1521                        "Only inline already compiled methods if their code size is "
1522                        "less than this");
1523    FLAG_RANGE(         InlineSmallCode, 0, max_jint);
1524 
1525 PRODUCT_FLAG(intx,     MaxInlineSize, 35, JVMFlag::RANGE,
1526                        "The maximum bytecode size of a method to be inlined");
1527    FLAG_RANGE(         MaxInlineSize, 0, max_jint);
1528 
1529 PRODUCT_FLAG_PD(intx,  FreqInlineSize, JVMFlag::RANGE,
1530                        "The maximum bytecode size of a frequent method to be inlined");
1531    FLAG_RANGE(         FreqInlineSize, 0, max_jint);
1532 
1533 PRODUCT_FLAG(intx,     MaxTrivialSize, 6, JVMFlag::RANGE,
1534                        "The maximum bytecode size of a trivial method to be inlined");
1535    FLAG_RANGE(         MaxTrivialSize, 0, max_jint);
1536 
1537 PRODUCT_FLAG(intx,     MinInliningThreshold, 250, JVMFlag::RANGE,
1538                        "The minimum invocation count a method needs to have to be "
1539                        "inlined");
1540    FLAG_RANGE(         MinInliningThreshold, 0, max_jint);
1541 
1542 DEVELOP_FLAG(intx,     MethodHistogramCutoff, 100, JVMFlag::DEFAULT,
1543                        "The cutoff value for method invocation histogram (+CountCalls)");
1544 
1545 DEVELOP_FLAG(intx,     DontYieldALotInterval, 10, JVMFlag::DEFAULT,
1546                        "Interval between which yields will be dropped (milliseconds)");
1547 
1548 NOTPROD_FLAG(intx,     DeoptimizeALotInterval, 5, JVMFlag::DEFAULT,
1549                        "Number of exits until DeoptimizeALot kicks in");
1550 
1551 NOTPROD_FLAG(intx,     ZombieALotInterval, 5, JVMFlag::DEFAULT,
1552                        "Number of exits until ZombieALot kicks in");
1553 
1554 PRODUCT_FLAG(uintx,    MallocMaxTestWords, 0, JVMFlag::DIAGNOSTIC | JVMFlag::RANGE,
1555                        "If non-zero, maximum number of words that malloc/realloc can "
1556                        "allocate (for testing only)");
1557    FLAG_RANGE(         MallocMaxTestWords, 0, max_uintx);
1558 
1559 PRODUCT_FLAG(intx,     TypeProfileWidth, 2, JVMFlag::RANGE,
1560                        "Number of receiver types to record in call/cast profile");
1561    FLAG_RANGE(         TypeProfileWidth, 0, 8);
1562 
1563 DEVELOP_FLAG(intx,     BciProfileWidth, 2, JVMFlag::DEFAULT,
1564                        "Number of return bci's to record in ret profile");
1565 
1566 PRODUCT_FLAG(intx,     PerMethodRecompilationCutoff, 400, JVMFlag::RANGE,
1567                        "After recompiling N times, stay in the interpreter (-1=>'Inf')");
1568    FLAG_RANGE(         PerMethodRecompilationCutoff, -1, max_intx);
1569 
1570 PRODUCT_FLAG(intx,     PerBytecodeRecompilationCutoff, 200, JVMFlag::RANGE,
1571                        "Per-BCI limit on repeated recompilation (-1=>'Inf')");
1572    FLAG_RANGE(         PerBytecodeRecompilationCutoff, -1, max_intx);
1573 
1574 PRODUCT_FLAG(intx,     PerMethodTrapLimit, 100, JVMFlag::RANGE,
1575                        "Limit on traps (of one kind) in a method (includes inlines)");
1576    FLAG_RANGE(         PerMethodTrapLimit, 0, max_jint);
1577 
1578 PRODUCT_FLAG(intx,     PerMethodSpecTrapLimit, 5000, JVMFlag::EXPERIMENTAL | JVMFlag::RANGE,
1579                        "Limit on speculative traps (of one kind) in a method "
1580                        "(includes inlines)");
1581    FLAG_RANGE(         PerMethodSpecTrapLimit, 0, max_jint);
1582 
1583 PRODUCT_FLAG(intx,     PerBytecodeTrapLimit, 4, JVMFlag::RANGE,
1584                        "Limit on traps (of one kind) at a particular BCI");
1585    FLAG_RANGE(         PerBytecodeTrapLimit, 0, max_jint);
1586 
1587 PRODUCT_FLAG(intx,     SpecTrapLimitExtraEntries, 3, JVMFlag::EXPERIMENTAL,
1588                        "Extra method data trap entries for speculation");
1589 
1590 DEVELOP_FLAG(intx,     InlineFrequencyRatio, 20, JVMFlag::RANGE,
1591                        "Ratio of call site execution to caller method invocation");
1592    FLAG_RANGE(         InlineFrequencyRatio, 0, max_jint);
1593 
1594 PRODUCT_FLAG_PD(intx,  InlineFrequencyCount, JVMFlag::DIAGNOSTIC | JVMFlag::RANGE,
1595                        "Count of call site execution necessary to trigger frequent "
1596                        "inlining");
1597    FLAG_RANGE(         InlineFrequencyCount, 0, max_jint);
1598 
1599 DEVELOP_FLAG(intx,     InlineThrowCount, 50, JVMFlag::RANGE,
1600                        "Force inlining of interpreted methods that throw this often");
1601    FLAG_RANGE(         InlineThrowCount, 0, max_jint);
1602 
1603 DEVELOP_FLAG(intx,     InlineThrowMaxSize, 200, JVMFlag::RANGE,
1604                        "Force inlining of throwing methods smaller than this");
1605    FLAG_RANGE(         InlineThrowMaxSize, 0, max_jint);
1606 
1607 DEVELOP_FLAG(intx,     ProfilerNodeSize, 1024, JVMFlag::RANGE,
1608                        "Size in K to allocate for the Profile Nodes of each thread");
1609    FLAG_RANGE(         ProfilerNodeSize, 0, 1024);
1610 
1611 PRODUCT_FLAG_PD(size_t,  MetaspaceSize, JVMFlag::CONSTRAINT,
1612                        "Initial threshold (in bytes) at which a garbage collection "
1613                        "is done to reduce Metaspace usage");
1614    FLAG_CONSTRAINT(    MetaspaceSize, (void*)MetaspaceSizeConstraintFunc, JVMFlag::AfterErgo);
1615 
1616 PRODUCT_FLAG(size_t,   MaxMetaspaceSize, max_uintx, JVMFlag::CONSTRAINT,
1617                        "Maximum size of Metaspaces (in bytes)");
1618    FLAG_CONSTRAINT(    MaxMetaspaceSize, (void*)MaxMetaspaceSizeConstraintFunc, JVMFlag::AfterErgo);
1619 
1620 PRODUCT_FLAG(size_t,   CompressedClassSpaceSize, 1*G, JVMFlag::RANGE,
1621                        "Maximum size of class area in Metaspace when compressed "
1622                        "class pointers are used");
1623    FLAG_RANGE(         CompressedClassSpaceSize, 1*M, 3*G);
1624 
1625 PRODUCT_FLAG(uintx,    MinHeapFreeRatio, 40, JVMFlag::MANAGEABLE | JVMFlag::RANGE | JVMFlag::CONSTRAINT,
1626                        "The minimum percentage of heap free after GC to avoid expansion."
1627                        " For most GCs this applies to the old generation. In G1 and"
1628                        " ParallelGC it applies to the whole heap.");
1629    FLAG_RANGE(         MinHeapFreeRatio, 0, 100);
1630    FLAG_CONSTRAINT(    MinHeapFreeRatio, (void*)MinHeapFreeRatioConstraintFunc, JVMFlag::AfterErgo);
1631 
1632 PRODUCT_FLAG(uintx,    MaxHeapFreeRatio, 70, JVMFlag::MANAGEABLE | JVMFlag::RANGE | JVMFlag::CONSTRAINT,
1633                        "The maximum percentage of heap free after GC to avoid shrinking."
1634                        " For most GCs this applies to the old generation. In G1 and"
1635                        " ParallelGC it applies to the whole heap.");
1636    FLAG_RANGE(         MaxHeapFreeRatio, 0, 100);
1637    FLAG_CONSTRAINT(    MaxHeapFreeRatio, (void*)MaxHeapFreeRatioConstraintFunc, JVMFlag::AfterErgo);
1638 
1639 PRODUCT_FLAG(bool,     ShrinkHeapInSteps, true, JVMFlag::DEFAULT,
1640                        "When disabled, informs the GC to shrink the java heap directly"
1641                        " to the target size at the next full GC rather than requiring"
1642                        " smaller steps during multiple full GCs.");
1643 
1644 PRODUCT_FLAG(intx,     SoftRefLRUPolicyMSPerMB, 1000, JVMFlag::RANGE | JVMFlag::CONSTRAINT,
1645                        "Number of milliseconds per MB of free space in the heap");
1646    FLAG_RANGE(         SoftRefLRUPolicyMSPerMB, 0, max_intx);
1647    FLAG_CONSTRAINT(    SoftRefLRUPolicyMSPerMB, (void*)SoftRefLRUPolicyMSPerMBConstraintFunc, JVMFlag::AfterMemoryInit);
1648 
1649 PRODUCT_FLAG(size_t,   MinHeapDeltaBytes, ScaleForWordSize(128*K), JVMFlag::RANGE,
1650                        "The minimum change in heap space due to GC (in bytes)");
1651    FLAG_RANGE(         MinHeapDeltaBytes, 0, max_uintx);
1652 
1653 PRODUCT_FLAG(size_t,   MinMetaspaceExpansion, ScaleForWordSize(256*K), JVMFlag::RANGE,
1654                        "The minimum expansion of Metaspace (in bytes)");
1655    FLAG_RANGE(         MinMetaspaceExpansion, 0, max_uintx);
1656 
1657 PRODUCT_FLAG(uintx,    MaxMetaspaceFreeRatio, 70, JVMFlag::RANGE | JVMFlag::CONSTRAINT,
1658                        "The maximum percentage of Metaspace free after GC to avoid "
1659                        "shrinking");
1660    FLAG_RANGE(         MaxMetaspaceFreeRatio, 0, 100);
1661    FLAG_CONSTRAINT(    MaxMetaspaceFreeRatio, (void*)MaxMetaspaceFreeRatioConstraintFunc, JVMFlag::AfterErgo);
1662 
1663 PRODUCT_FLAG(uintx,    MinMetaspaceFreeRatio, 40, JVMFlag::RANGE | JVMFlag::CONSTRAINT,
1664                        "The minimum percentage of Metaspace free after GC to avoid "
1665                        "expansion");
1666    FLAG_RANGE(         MinMetaspaceFreeRatio, 0, 99);
1667    FLAG_CONSTRAINT(    MinMetaspaceFreeRatio, (void*)MinMetaspaceFreeRatioConstraintFunc, JVMFlag::AfterErgo);
1668 
1669 PRODUCT_FLAG(size_t,   MaxMetaspaceExpansion, ScaleForWordSize(4*M), JVMFlag::RANGE,
1670                        "The maximum expansion of Metaspace without full GC (in bytes)");
1671    FLAG_RANGE(         MaxMetaspaceExpansion, 0, max_uintx);
1672 
1673 
1674     //  stack parameters 
1675 PRODUCT_FLAG_PD(intx,  StackYellowPages, JVMFlag::RANGE,
1676                        "Number of yellow zone (recoverable overflows) pages of size "
1677                        "4KB. If pages are bigger yellow zone is aligned up.");
1678    FLAG_RANGE(         StackYellowPages, MIN_STACK_YELLOW_PAGES, (DEFAULT_STACK_YELLOW_PAGES+5));
1679 
1680 PRODUCT_FLAG_PD(intx,  StackRedPages, JVMFlag::RANGE,
1681                        "Number of red zone (unrecoverable overflows) pages of size "
1682                        "4KB. If pages are bigger red zone is aligned up.");
1683    FLAG_RANGE(         StackRedPages, MIN_STACK_RED_PAGES, (DEFAULT_STACK_RED_PAGES+2));
1684 
1685 PRODUCT_FLAG_PD(intx,  StackReservedPages, JVMFlag::RANGE,
1686                        "Number of reserved zone (reserved to annotated methods) pages"
1687                        " of size 4KB. If pages are bigger reserved zone is aligned up.");
1688    FLAG_RANGE(         StackReservedPages, MIN_STACK_RESERVED_PAGES, (DEFAULT_STACK_RESERVED_PAGES+10));
1689 
1690 PRODUCT_FLAG(bool,     RestrictReservedStack, true, JVMFlag::DEFAULT,
1691                        "Restrict @ReservedStackAccess to trusted classes");
1692 
1693 
1694     //  greater stack shadow pages can't generate instruction to bang stack 
1695 PRODUCT_FLAG_PD(intx,  StackShadowPages, JVMFlag::RANGE,
1696                        "Number of shadow zone (for overflow checking) pages of size "
1697                        "4KB. If pages are bigger shadow zone is aligned up. "
1698                        "This should exceed the depth of the VM and native call stack.");
1699    FLAG_RANGE(         StackShadowPages, MIN_STACK_SHADOW_PAGES, (DEFAULT_STACK_SHADOW_PAGES+30));
1700 
1701 PRODUCT_FLAG_PD(intx,  ThreadStackSize, JVMFlag::RANGE,
1702                        "Thread Stack Size (in Kbytes)");
1703    FLAG_RANGE(         ThreadStackSize, 0, 1 * M);
1704 
1705 PRODUCT_FLAG_PD(intx,  VMThreadStackSize, JVMFlag::RANGE,
1706                        "Non-Java Thread Stack Size (in Kbytes)");
1707    FLAG_RANGE(         VMThreadStackSize, 0, max_intx/(1 * K));
1708 
1709 PRODUCT_FLAG_PD(intx,  CompilerThreadStackSize, JVMFlag::RANGE,
1710                        "Compiler Thread Stack Size (in Kbytes)");
1711    FLAG_RANGE(         CompilerThreadStackSize, 0, max_intx/(1 * K));
1712 
1713 DEVELOP_FLAG_PD(size_t,  JVMInvokeMethodSlack, JVMFlag::DEFAULT,
1714                        "Stack space (bytes) required for JVM_InvokeMethod to complete");
1715 
1716 
1717     //  code cache parameters                                    
1718 DEVELOP_FLAG_PD(uintx, CodeCacheSegmentSize, JVMFlag::RANGE | JVMFlag::CONSTRAINT,
1719                        "Code cache segment size (in bytes) - smallest unit of "
1720                        "allocation");
1721    FLAG_RANGE(         CodeCacheSegmentSize, 1, 1024);
1722    FLAG_CONSTRAINT(    CodeCacheSegmentSize, (void*)CodeCacheSegmentSizeConstraintFunc, JVMFlag::AfterErgo);
1723 
1724 DEVELOP_FLAG_PD(intx,  CodeEntryAlignment, JVMFlag::CONSTRAINT,
1725                        "Code entry alignment for generated code (in bytes)");
1726    FLAG_CONSTRAINT(    CodeEntryAlignment, (void*)CodeEntryAlignmentConstraintFunc, JVMFlag::AfterErgo);
1727 
1728 PRODUCT_FLAG_PD(intx,  OptoLoopAlignment, JVMFlag::RANGE | JVMFlag::CONSTRAINT,
1729                        "Align inner loops to zero relative to this modulus");
1730    FLAG_RANGE(         OptoLoopAlignment, 1, 16);
1731    FLAG_CONSTRAINT(    OptoLoopAlignment, (void*)OptoLoopAlignmentConstraintFunc, JVMFlag::AfterErgo);
1732 
1733 PRODUCT_FLAG_PD(uintx, InitialCodeCacheSize, JVMFlag::RANGE,
1734                        "Initial code cache size (in bytes)");
1735    FLAG_CUSTOM_RANGE(  InitialCodeCacheSize, VMPageSize);
1736 
1737 DEVELOP_FLAG_PD(uintx, CodeCacheMinimumUseSpace, JVMFlag::RANGE,
1738                        "Minimum code cache size (in bytes) required to start VM.");
1739    FLAG_RANGE(         CodeCacheMinimumUseSpace, 0, max_uintx);
1740 
1741 PRODUCT_FLAG(bool,     SegmentedCodeCache, false, JVMFlag::DEFAULT,
1742                        "Use a segmented code cache");
1743 
1744 PRODUCT_FLAG_PD(uintx, ReservedCodeCacheSize, JVMFlag::RANGE,
1745                        "Reserved code cache size (in bytes) - maximum code cache size");
1746    FLAG_CUSTOM_RANGE(  ReservedCodeCacheSize, VMPageSize);
1747 
1748 PRODUCT_FLAG_PD(uintx, NonProfiledCodeHeapSize, JVMFlag::RANGE,
1749                        "Size of code heap with non-profiled methods (in bytes)");
1750    FLAG_RANGE(         NonProfiledCodeHeapSize, 0, max_uintx);
1751 
1752 PRODUCT_FLAG_PD(uintx, ProfiledCodeHeapSize, JVMFlag::RANGE,
1753                        "Size of code heap with profiled methods (in bytes)");
1754    FLAG_RANGE(         ProfiledCodeHeapSize, 0, max_uintx);
1755 
1756 PRODUCT_FLAG_PD(uintx, NonNMethodCodeHeapSize, JVMFlag::RANGE,
1757                        "Size of code heap with non-nmethods (in bytes)");
1758    FLAG_CUSTOM_RANGE(  NonNMethodCodeHeapSize, VMPageSize);
1759 
1760 PRODUCT_FLAG_PD(uintx, CodeCacheExpansionSize, JVMFlag::RANGE,
1761                        "Code cache expansion size (in bytes)");
1762    FLAG_RANGE(         CodeCacheExpansionSize, 32*K, max_uintx);
1763 
1764 PRODUCT_FLAG_PD(uintx, CodeCacheMinBlockLength, JVMFlag::DIAGNOSTIC | JVMFlag::RANGE,
1765                        "Minimum number of segments in a code cache block");
1766    FLAG_RANGE(         CodeCacheMinBlockLength, 1, 100);
1767 
1768 NOTPROD_FLAG(bool,     ExitOnFullCodeCache, false, JVMFlag::DEFAULT,
1769                        "Exit the VM if we fill the code cache");
1770 
1771 PRODUCT_FLAG(bool,     UseCodeCacheFlushing, true, JVMFlag::DEFAULT,
1772                        "Remove cold/old nmethods from the code cache");
1773 
1774 PRODUCT_FLAG(uintx,    StartAggressiveSweepingAt, 10, JVMFlag::RANGE,
1775                        "Start aggressive sweeping if X[%] of the code cache is free."
1776                        "Segmented code cache: X[%] of the non-profiled heap."
1777                        "Non-segmented code cache: X[%] of the total code cache");
1778    FLAG_RANGE(         StartAggressiveSweepingAt, 0, 100);
1779 
1780 
1781     //  AOT parameters 
1782 PRODUCT_FLAG(bool,     UseAOT, false, JVMFlag::EXPERIMENTAL,
1783                        "Use AOT compiled files");
1784 
1785 PRODUCT_FLAG(ccstr,    AOTLibrary, NULL, JVMFlag::EXPERIMENTAL | JVMFlag::STRINGLIST,
1786                        "AOT library");
1787 
1788 PRODUCT_FLAG(bool,     PrintAOT, false, JVMFlag::EXPERIMENTAL,
1789                        "Print used AOT klasses and methods");
1790 
1791 NOTPROD_FLAG(bool,     PrintAOTStatistics, false, JVMFlag::DEFAULT,
1792                        "Print AOT statistics");
1793 
1794 PRODUCT_FLAG(bool,     UseAOTStrictLoading, false, JVMFlag::DIAGNOSTIC,
1795                        "Exit the VM if any of the AOT libraries has invalid config");
1796 
1797 PRODUCT_FLAG(bool,     CalculateClassFingerprint, false, JVMFlag::DEFAULT,
1798                        "Calculate class fingerprint");
1799 
1800 
1801     //  interpreter debugging 
1802 DEVELOP_FLAG(intx,     BinarySwitchThreshold, 5, JVMFlag::DEFAULT,
1803                        "Minimal number of lookupswitch entries for rewriting to binary "
1804                        "switch");
1805 
1806 DEVELOP_FLAG(intx,     StopInterpreterAt, 0, JVMFlag::DEFAULT,
1807                        "Stop interpreter execution at specified bytecode number");
1808 
1809 DEVELOP_FLAG(intx,     TraceBytecodesAt, 0, JVMFlag::DEFAULT,
1810                        "Trace bytecodes starting with specified bytecode number");
1811 
1812 
1813     //  compiler interface 
1814 DEVELOP_FLAG(intx,     CIStart, 0, JVMFlag::DEFAULT,
1815                        "The id of the first compilation to permit");
1816 
1817 DEVELOP_FLAG(intx,     CIStop, max_jint, JVMFlag::DEFAULT,
1818                        "The id of the last compilation to permit");
1819 
1820 DEVELOP_FLAG(intx,     CIStartOSR, 0, JVMFlag::DEFAULT,
1821                        "The id of the first osr compilation to permit "
1822                        "(CICountOSR must be on)");
1823 
1824 DEVELOP_FLAG(intx,     CIStopOSR, max_jint, JVMFlag::DEFAULT,
1825                        "The id of the last osr compilation to permit "
1826                        "(CICountOSR must be on)");
1827 
1828 DEVELOP_FLAG(intx,     CIBreakAtOSR, -1, JVMFlag::DEFAULT,
1829                        "The id of osr compilation to break at");
1830 
1831 DEVELOP_FLAG(intx,     CIBreakAt, -1, JVMFlag::DEFAULT,
1832                        "The id of compilation to break at");
1833 
1834 PRODUCT_FLAG(ccstr,    CompileOnly, "", JVMFlag::STRINGLIST,
1835                        "List of methods (pkg/class.name) to restrict compilation to");
1836 
1837 PRODUCT_FLAG(ccstr,    CompileCommandFile, NULL, JVMFlag::DEFAULT,
1838                        "Read compiler commands from this file [.hotspot_compiler]");
1839 
1840 PRODUCT_FLAG(ccstr,    CompilerDirectivesFile, NULL, JVMFlag::DIAGNOSTIC,
1841                        "Read compiler directives from this file");
1842 
1843 PRODUCT_FLAG(ccstr,    CompileCommand, "", JVMFlag::STRINGLIST,
1844                        "Prepend to .hotspot_compiler; e.g. log,java/lang/String.<init>");
1845 
1846 DEVELOP_FLAG(bool,     ReplayCompiles, false, JVMFlag::DEFAULT,
1847                        "Enable replay of compilations from ReplayDataFile");
1848 
1849 PRODUCT_FLAG(ccstr,    ReplayDataFile, NULL, JVMFlag::DEFAULT,
1850                        "File containing compilation replay information"
1851                        "[default: ./replay_pid%p.log] (%p replaced with pid)");
1852 
1853 PRODUCT_FLAG(ccstr,    InlineDataFile, NULL, JVMFlag::DEFAULT,
1854                        "File containing inlining replay information"
1855                        "[default: ./inline_pid%p.log] (%p replaced with pid)");
1856 
1857 DEVELOP_FLAG(intx,     ReplaySuppressInitializers, 2, JVMFlag::RANGE,
1858                        "Control handling of class initialization during replay: "
1859                        "0 - don't do anything special; "
1860                        "1 - treat all class initializers as empty; "
1861                        "2 - treat class initializers for application classes as empty; "
1862                        "3 - allow all class initializers to run during bootstrap but "
1863                        "    pretend they are empty after starting replay");
1864    FLAG_RANGE(         ReplaySuppressInitializers, 0, 3);
1865 
1866 DEVELOP_FLAG(bool,     ReplayIgnoreInitErrors, false, JVMFlag::DEFAULT,
1867                        "Ignore exceptions thrown during initialization for replay");
1868 
1869 PRODUCT_FLAG(bool,     DumpReplayDataOnError, true, JVMFlag::DEFAULT,
1870                        "Record replay data for crashing compiler threads");
1871 
1872 PRODUCT_FLAG(bool,     CICompilerCountPerCPU, false, JVMFlag::DEFAULT,
1873                        "1 compiler thread for log(N CPUs)");
1874 
1875 NOTPROD_FLAG(intx,     CICrashAt, -1, JVMFlag::DEFAULT,
1876                        "id of compilation to trigger assert in compiler thread for "
1877                        "the purpose of testing, e.g. generation of replay data");
1878 
1879 NOTPROD_FLAG(bool,     CIObjectFactoryVerify, false, JVMFlag::DEFAULT,
1880                        "enable potentially expensive verification in ciObjectFactory");
1881 
1882 PRODUCT_FLAG(bool,     AbortVMOnCompilationFailure, false, JVMFlag::DIAGNOSTIC,
1883                        "Abort VM when method had failed to compile.");
1884 
1885 
1886     //  Priorities 
1887 PRODUCT_FLAG_PD(bool,  UseThreadPriorities, JVMFlag::DEFAULT,
1888                        "Use native thread priorities");
1889 
1890 PRODUCT_FLAG(intx,     ThreadPriorityPolicy, 0, JVMFlag::RANGE,
1891                        "0 : Normal.                                                     "
1892                        "    VM chooses priorities that are appropriate for normal       "
1893                        "    applications. On Solaris NORM_PRIORITY and above are mapped "
1894                        "    to normal native priority. Java priorities below "
1895                        "    NORM_PRIORITY map to lower native priority values. On       "
1896                        "    Windows applications are allowed to use higher native       "
1897                        "    priorities. However, with ThreadPriorityPolicy=0, VM will   "
1898                        "    not use the highest possible native priority,               "
1899                        "    THREAD_PRIORITY_TIME_CRITICAL, as it may interfere with     "
1900                        "    system threads. On Linux thread priorities are ignored      "
1901                        "    because the OS does not support static priority in          "
1902                        "    SCHED_OTHER scheduling class which is the only choice for   "
1903                        "    non-root, non-realtime applications.                        "
1904                        "1 : Aggressive.                                                 "
1905                        "    Java thread priorities map over to the entire range of      "
1906                        "    native thread priorities. Higher Java thread priorities map "
1907                        "    to higher native thread priorities. This policy should be   "
1908                        "    used with care, as sometimes it can cause performance       "
1909                        "    degradation in the application and/or the entire system. On "
1910                        "    Linux/BSD/macOS this policy requires root privilege or an   "
1911                        "    extended capability.");
1912    FLAG_RANGE(         ThreadPriorityPolicy, 0, 1);
1913 
1914 PRODUCT_FLAG(bool,     ThreadPriorityVerbose, false, JVMFlag::DEFAULT,
1915                        "Print priority changes");
1916 
1917 PRODUCT_FLAG(intx,     CompilerThreadPriority, -1, JVMFlag::RANGE | JVMFlag::CONSTRAINT,
1918                        "The native priority at which compiler threads should run "
1919                        "(-1 means no change)");
1920    FLAG_RANGE(         CompilerThreadPriority, min_jint, max_jint);
1921    FLAG_CONSTRAINT(    CompilerThreadPriority, (void*)CompilerThreadPriorityConstraintFunc, JVMFlag::AfterErgo);
1922 
1923 PRODUCT_FLAG(intx,     VMThreadPriority, -1, JVMFlag::RANGE,
1924                        "The native priority at which the VM thread should run "
1925                        "(-1 means no change)");
1926    FLAG_RANGE(         VMThreadPriority, -1, 127);
1927 
1928 PRODUCT_FLAG(intx,     JavaPriority1_To_OSPriority, -1, JVMFlag::RANGE,
1929                        "Map Java priorities to OS priorities");
1930    FLAG_RANGE(         JavaPriority1_To_OSPriority, -1, 127);
1931 
1932 PRODUCT_FLAG(intx,     JavaPriority2_To_OSPriority, -1, JVMFlag::RANGE,
1933                        "Map Java priorities to OS priorities");
1934    FLAG_RANGE(         JavaPriority2_To_OSPriority, -1, 127);
1935 
1936 PRODUCT_FLAG(intx,     JavaPriority3_To_OSPriority, -1, JVMFlag::RANGE,
1937                        "Map Java priorities to OS priorities");
1938    FLAG_RANGE(         JavaPriority3_To_OSPriority, -1, 127);
1939 
1940 PRODUCT_FLAG(intx,     JavaPriority4_To_OSPriority, -1, JVMFlag::RANGE,
1941                        "Map Java priorities to OS priorities");
1942    FLAG_RANGE(         JavaPriority4_To_OSPriority, -1, 127);
1943 
1944 PRODUCT_FLAG(intx,     JavaPriority5_To_OSPriority, -1, JVMFlag::RANGE,
1945                        "Map Java priorities to OS priorities");
1946    FLAG_RANGE(         JavaPriority5_To_OSPriority, -1, 127);
1947 
1948 PRODUCT_FLAG(intx,     JavaPriority6_To_OSPriority, -1, JVMFlag::RANGE,
1949                        "Map Java priorities to OS priorities");
1950    FLAG_RANGE(         JavaPriority6_To_OSPriority, -1, 127);
1951 
1952 PRODUCT_FLAG(intx,     JavaPriority7_To_OSPriority, -1, JVMFlag::RANGE,
1953                        "Map Java priorities to OS priorities");
1954    FLAG_RANGE(         JavaPriority7_To_OSPriority, -1, 127);
1955 
1956 PRODUCT_FLAG(intx,     JavaPriority8_To_OSPriority, -1, JVMFlag::RANGE,
1957                        "Map Java priorities to OS priorities");
1958    FLAG_RANGE(         JavaPriority8_To_OSPriority, -1, 127);
1959 
1960 PRODUCT_FLAG(intx,     JavaPriority9_To_OSPriority, -1, JVMFlag::RANGE,
1961                        "Map Java priorities to OS priorities");
1962    FLAG_RANGE(         JavaPriority9_To_OSPriority, -1, 127);
1963 
1964 PRODUCT_FLAG(intx,     JavaPriority10_To_OSPriority, -1, JVMFlag::RANGE,
1965                        "Map Java priorities to OS priorities");
1966    FLAG_RANGE(         JavaPriority10_To_OSPriority, -1, 127);
1967 
1968 PRODUCT_FLAG(bool,     UseCriticalJavaThreadPriority, false, JVMFlag::EXPERIMENTAL,
1969                        "Java thread priority 10 maps to critical scheduling priority");
1970 
1971 PRODUCT_FLAG(bool,     UseCriticalCompilerThreadPriority, false, JVMFlag::EXPERIMENTAL,
1972                        "Compiler thread(s) run at critical scheduling priority");
1973 
1974 DEVELOP_FLAG(intx,     NewCodeParameter, 0, JVMFlag::DEFAULT,
1975                        "Testing Only: Create a dedicated integer parameter before "
1976                        "putback");
1977 
1978 
1979     //  new oopmap storage allocation 
1980 DEVELOP_FLAG(intx,     MinOopMapAllocation, 8, JVMFlag::DEFAULT,
1981                        "Minimum number of OopMap entries in an OopMapSet");
1982 
1983 
1984     //  Background Compilation 
1985 DEVELOP_FLAG(intx,     LongCompileThreshold, 50, JVMFlag::DEFAULT,
1986                        "Used with +TraceLongCompiles");
1987 
1988 
1989     //  recompilation 
1990 PRODUCT_FLAG_PD(intx,  CompileThreshold, JVMFlag::CONSTRAINT,
1991                        "number of interpreted method invocations before (re-)compiling");
1992    FLAG_CONSTRAINT(    CompileThreshold, (void*)CompileThresholdConstraintFunc, JVMFlag::AfterErgo);
1993 
1994 PRODUCT_FLAG(double,   CompileThresholdScaling, 1.0, JVMFlag::RANGE,
1995                        "Factor to control when first compilation happens "
1996                        "(both with and without tiered compilation): "
1997                        "values greater than 1.0 delay counter overflow, "
1998                        "values between 0 and 1.0 rush counter overflow, "
1999                        "value of 1.0 leaves compilation thresholds unchanged "
2000                        "value of 0.0 is equivalent to -Xint. "
2001                        ""
2002                        "Flag can be set as per-method option. "
2003                        "If a value is specified for a method, compilation thresholds "
2004                        "for that method are scaled by both the value of the global flag "
2005                        "and the value of the per-method flag.");
2006    FLAG_RANGE(         CompileThresholdScaling, 0.0, DBL_MAX);
2007 
2008 PRODUCT_FLAG(intx,     Tier0InvokeNotifyFreqLog, 7, JVMFlag::RANGE,
2009                        "Interpreter (tier 0) invocation notification frequency");
2010    FLAG_RANGE(         Tier0InvokeNotifyFreqLog, 0, 30);
2011 
2012 PRODUCT_FLAG(intx,     Tier2InvokeNotifyFreqLog, 11, JVMFlag::RANGE,
2013                        "C1 without MDO (tier 2) invocation notification frequency");
2014    FLAG_RANGE(         Tier2InvokeNotifyFreqLog, 0, 30);
2015 
2016 PRODUCT_FLAG(intx,     Tier3InvokeNotifyFreqLog, 10, JVMFlag::RANGE,
2017                        "C1 with MDO profiling (tier 3) invocation notification "
2018                        "frequency");
2019    FLAG_RANGE(         Tier3InvokeNotifyFreqLog, 0, 30);
2020 
2021 PRODUCT_FLAG(intx,     Tier23InlineeNotifyFreqLog, 20, JVMFlag::RANGE,
2022                        "Inlinee invocation (tiers 2 and 3) notification frequency");
2023    FLAG_RANGE(         Tier23InlineeNotifyFreqLog, 0, 30);
2024 
2025 PRODUCT_FLAG(intx,     Tier0BackedgeNotifyFreqLog, 10, JVMFlag::RANGE,
2026                        "Interpreter (tier 0) invocation notification frequency");
2027    FLAG_RANGE(         Tier0BackedgeNotifyFreqLog, 0, 30);
2028 
2029 PRODUCT_FLAG(intx,     Tier2BackedgeNotifyFreqLog, 14, JVMFlag::RANGE,
2030                        "C1 without MDO (tier 2) invocation notification frequency");
2031    FLAG_RANGE(         Tier2BackedgeNotifyFreqLog, 0, 30);
2032 
2033 PRODUCT_FLAG(intx,     Tier3BackedgeNotifyFreqLog, 13, JVMFlag::RANGE,
2034                        "C1 with MDO profiling (tier 3) invocation notification "
2035                        "frequency");
2036    FLAG_RANGE(         Tier3BackedgeNotifyFreqLog, 0, 30);
2037 
2038 PRODUCT_FLAG(intx,     Tier2CompileThreshold, 0, JVMFlag::RANGE,
2039                        "threshold at which tier 2 compilation is invoked");
2040    FLAG_RANGE(         Tier2CompileThreshold, 0, max_jint);
2041 
2042 PRODUCT_FLAG(intx,     Tier2BackEdgeThreshold, 0, JVMFlag::RANGE,
2043                        "Back edge threshold at which tier 2 compilation is invoked");
2044    FLAG_RANGE(         Tier2BackEdgeThreshold, 0, max_jint);
2045 
2046 PRODUCT_FLAG(intx,     Tier3InvocationThreshold, 200, JVMFlag::RANGE,
2047                        "Compile if number of method invocations crosses this "
2048                        "threshold");
2049    FLAG_RANGE(         Tier3InvocationThreshold, 0, max_jint);
2050 
2051 PRODUCT_FLAG(intx,     Tier3MinInvocationThreshold, 100, JVMFlag::RANGE,
2052                        "Minimum invocation to compile at tier 3");
2053    FLAG_RANGE(         Tier3MinInvocationThreshold, 0, max_jint);
2054 
2055 PRODUCT_FLAG(intx,     Tier3CompileThreshold, 2000, JVMFlag::RANGE,
2056                        "Threshold at which tier 3 compilation is invoked (invocation "
2057                        "minimum must be satisfied)");
2058    FLAG_RANGE(         Tier3CompileThreshold, 0, max_jint);
2059 
2060 PRODUCT_FLAG(intx,     Tier3BackEdgeThreshold, 60000, JVMFlag::RANGE,
2061                        "Back edge threshold at which tier 3 OSR compilation is invoked");
2062    FLAG_RANGE(         Tier3BackEdgeThreshold, 0, max_jint);
2063 
2064 PRODUCT_FLAG(intx,     Tier3AOTInvocationThreshold, 10000, JVMFlag::RANGE,
2065                        "Compile if number of method invocations crosses this "
2066                        "threshold if coming from AOT");
2067    FLAG_RANGE(         Tier3AOTInvocationThreshold, 0, max_jint);
2068 
2069 PRODUCT_FLAG(intx,     Tier3AOTMinInvocationThreshold, 1000, JVMFlag::RANGE,
2070                        "Minimum invocation to compile at tier 3 if coming from AOT");
2071    FLAG_RANGE(         Tier3AOTMinInvocationThreshold, 0, max_jint);
2072 
2073 PRODUCT_FLAG(intx,     Tier3AOTCompileThreshold, 15000, JVMFlag::RANGE,
2074                        "Threshold at which tier 3 compilation is invoked (invocation "
2075                        "minimum must be satisfied) if coming from AOT");
2076    FLAG_RANGE(         Tier3AOTCompileThreshold, 0, max_jint);
2077 
2078 PRODUCT_FLAG(intx,     Tier3AOTBackEdgeThreshold, 120000, JVMFlag::RANGE,
2079                        "Back edge threshold at which tier 3 OSR compilation is invoked "
2080                        "if coming from AOT");
2081    FLAG_RANGE(         Tier3AOTBackEdgeThreshold, 0, max_jint);
2082 
2083 PRODUCT_FLAG(intx,     Tier0AOTInvocationThreshold, 200, JVMFlag::DIAGNOSTIC | JVMFlag::RANGE,
2084                        "Switch to interpreter to profile if the number of method "
2085                        "invocations crosses this threshold if coming from AOT "
2086                        "(applicable only with "
2087                        "CompilationMode=high-only|high-only-quick-internal)");
2088    FLAG_RANGE(         Tier0AOTInvocationThreshold, 0, max_jint);
2089 
2090 PRODUCT_FLAG(intx,     Tier0AOTMinInvocationThreshold, 100, JVMFlag::DIAGNOSTIC | JVMFlag::RANGE,
2091                        "Minimum number of invocations to switch to interpreter "
2092                        "to profile if coming from AOT "
2093                        "(applicable only with "
2094                        "CompilationMode=high-only|high-only-quick-internal)");
2095    FLAG_RANGE(         Tier0AOTMinInvocationThreshold, 0, max_jint);
2096 
2097 PRODUCT_FLAG(intx,     Tier0AOTCompileThreshold, 2000, JVMFlag::DIAGNOSTIC | JVMFlag::RANGE,
2098                        "Threshold at which to switch to interpreter to profile "
2099                        "if coming from AOT "
2100                        "(invocation minimum must be satisfied, "
2101                        "applicable only with "
2102                        "CompilationMode=high-only|high-only-quick-internal)");
2103    FLAG_RANGE(         Tier0AOTCompileThreshold, 0, max_jint);
2104 
2105 PRODUCT_FLAG(intx,     Tier0AOTBackEdgeThreshold, 60000, JVMFlag::DIAGNOSTIC | JVMFlag::RANGE,
2106                        "Back edge threshold at which to switch to interpreter "
2107                        "to profile if coming from AOT "
2108                        "(applicable only with "
2109                        "CompilationMode=high-only|high-only-quick-internal)");
2110    FLAG_RANGE(         Tier0AOTBackEdgeThreshold, 0, max_jint);
2111 
2112 PRODUCT_FLAG(intx,     Tier4InvocationThreshold, 5000, JVMFlag::RANGE,
2113                        "Compile if number of method invocations crosses this "
2114                        "threshold");
2115    FLAG_RANGE(         Tier4InvocationThreshold, 0, max_jint);
2116 
2117 PRODUCT_FLAG(intx,     Tier4MinInvocationThreshold, 600, JVMFlag::RANGE,
2118                        "Minimum invocation to compile at tier 4");
2119    FLAG_RANGE(         Tier4MinInvocationThreshold, 0, max_jint);
2120 
2121 PRODUCT_FLAG(intx,     Tier4CompileThreshold, 15000, JVMFlag::RANGE,
2122                        "Threshold at which tier 4 compilation is invoked (invocation "
2123                        "minimum must be satisfied)");
2124    FLAG_RANGE(         Tier4CompileThreshold, 0, max_jint);
2125 
2126 PRODUCT_FLAG(intx,     Tier4BackEdgeThreshold, 40000, JVMFlag::RANGE,
2127                        "Back edge threshold at which tier 4 OSR compilation is invoked");
2128    FLAG_RANGE(         Tier4BackEdgeThreshold, 0, max_jint);
2129 
2130 PRODUCT_FLAG(intx,     Tier40InvocationThreshold, 5000, JVMFlag::DIAGNOSTIC | JVMFlag::RANGE,
2131                        "Compile if number of method invocations crosses this "
2132                        "threshold (applicable only with "
2133                        "CompilationMode=high-only|high-only-quick-internal)");
2134    FLAG_RANGE(         Tier40InvocationThreshold, 0, max_jint);
2135 
2136 PRODUCT_FLAG(intx,     Tier40MinInvocationThreshold, 600, JVMFlag::DIAGNOSTIC | JVMFlag::RANGE,
2137                        "Minimum number of invocations to compile at tier 4 "
2138                        "(applicable only with "
2139                        "CompilationMode=high-only|high-only-quick-internal)");
2140    FLAG_RANGE(         Tier40MinInvocationThreshold, 0, max_jint);
2141 
2142 PRODUCT_FLAG(intx,     Tier40CompileThreshold, 10000, JVMFlag::DIAGNOSTIC | JVMFlag::RANGE,
2143                        "Threshold at which tier 4 compilation is invoked (invocation "
2144                        "minimum must be satisfied, applicable only with "
2145                        "CompilationMode=high-only|high-only-quick-internal)");
2146    FLAG_RANGE(         Tier40CompileThreshold, 0, max_jint);
2147 
2148 PRODUCT_FLAG(intx,     Tier40BackEdgeThreshold, 15000, JVMFlag::DIAGNOSTIC | JVMFlag::RANGE,
2149                        "Back edge threshold at which tier 4 OSR compilation is invoked "
2150                        "(applicable only with "
2151                        "CompilationMode=high-only|high-only-quick-internal)");
2152    FLAG_RANGE(         Tier40BackEdgeThreshold, 0, max_jint);
2153 
2154 PRODUCT_FLAG(intx,     Tier0Delay, 5, JVMFlag::DIAGNOSTIC | JVMFlag::RANGE,
2155                        "If C2 queue size grows over this amount per compiler thread "
2156                        "do not start profiling in the interpreter "
2157                        "(applicable only with "
2158                        "CompilationMode=high-only|high-only-quick-internal)");
2159    FLAG_RANGE(         Tier0Delay, 0, max_jint);
2160 
2161 PRODUCT_FLAG(intx,     Tier3DelayOn, 5, JVMFlag::RANGE,
2162                        "If C2 queue size grows over this amount per compiler thread "
2163                        "stop compiling at tier 3 and start compiling at tier 2");
2164    FLAG_RANGE(         Tier3DelayOn, 0, max_jint);
2165 
2166 PRODUCT_FLAG(intx,     Tier3DelayOff, 2, JVMFlag::RANGE,
2167                        "If C2 queue size is less than this amount per compiler thread "
2168                        "allow methods compiled at tier 2 transition to tier 3");
2169    FLAG_RANGE(         Tier3DelayOff, 0, max_jint);
2170 
2171 PRODUCT_FLAG(intx,     Tier3LoadFeedback, 5, JVMFlag::RANGE,
2172                        "Tier 3 thresholds will increase twofold when C1 queue size "
2173                        "reaches this amount per compiler thread");
2174    FLAG_RANGE(         Tier3LoadFeedback, 0, max_jint);
2175 
2176 PRODUCT_FLAG(intx,     Tier4LoadFeedback, 3, JVMFlag::RANGE,
2177                        "Tier 4 thresholds will increase twofold when C2 queue size "
2178                        "reaches this amount per compiler thread");
2179    FLAG_RANGE(         Tier4LoadFeedback, 0, max_jint);
2180 
2181 PRODUCT_FLAG(intx,     TieredCompileTaskTimeout, 50, JVMFlag::RANGE,
2182                        "Kill compile task if method was not used within "
2183                        "given timeout in milliseconds");
2184    FLAG_RANGE(         TieredCompileTaskTimeout, 0, max_intx);
2185 
2186 PRODUCT_FLAG(intx,     TieredStopAtLevel, 4, JVMFlag::RANGE,
2187                        "Stop at given compilation level");
2188    FLAG_RANGE(         TieredStopAtLevel, 0, 4);
2189 
2190 PRODUCT_FLAG(intx,     Tier0ProfilingStartPercentage, 200, JVMFlag::RANGE,
2191                        "Start profiling in interpreter if the counters exceed tier 3 "
2192                        "thresholds (tier 4 thresholds with "
2193                        "CompilationMode=high-only|high-only-quick-internal)"
2194                        "by the specified percentage");
2195    FLAG_RANGE(         Tier0ProfilingStartPercentage, 0, max_jint);
2196 
2197 PRODUCT_FLAG(uintx,    IncreaseFirstTierCompileThresholdAt, 50, JVMFlag::RANGE,
2198                        "Increase the compile threshold for C1 compilation if the code "
2199                        "cache is filled by the specified percentage");
2200    FLAG_RANGE(         IncreaseFirstTierCompileThresholdAt, 0, 99);
2201 
2202 PRODUCT_FLAG(intx,     TieredRateUpdateMinTime, 1, JVMFlag::RANGE,
2203                        "Minimum rate sampling interval (in milliseconds)");
2204    FLAG_RANGE(         TieredRateUpdateMinTime, 0, max_intx);
2205 
2206 PRODUCT_FLAG(intx,     TieredRateUpdateMaxTime, 25, JVMFlag::RANGE,
2207                        "Maximum rate sampling interval (in milliseconds)");
2208    FLAG_RANGE(         TieredRateUpdateMaxTime, 0, max_intx);
2209 
2210 PRODUCT_FLAG(ccstr,    CompilationMode, "default", JVMFlag::DEFAULT,
2211                        "Compilation modes: "
2212                        "default: normal tiered compilation; "
2213                        "quick-only: C1-only mode; "
2214                        "high-only: C2/JVMCI-only mode; "
2215                        "high-only-quick-internal: C2/JVMCI-only mode, "
2216                        "with JVMCI compiler compiled with C1.");
2217 
2218 PRODUCT_FLAG_PD(bool,  TieredCompilation, JVMFlag::DEFAULT,
2219                        "Enable tiered compilation");
2220 
2221 PRODUCT_FLAG(bool,     PrintTieredEvents, false, JVMFlag::DEFAULT,
2222                        "Print tiered events notifications");
2223 
2224 PRODUCT_FLAG_PD(intx,  OnStackReplacePercentage, JVMFlag::CONSTRAINT,
2225                        "NON_TIERED number of method invocations/branches (expressed as "
2226                        "% of CompileThreshold) before (re-)compiling OSR code");
2227    FLAG_CONSTRAINT(    OnStackReplacePercentage, (void*)OnStackReplacePercentageConstraintFunc, JVMFlag::AfterErgo);
2228 
2229 PRODUCT_FLAG(intx,     InterpreterProfilePercentage, 33, JVMFlag::RANGE,
2230                        "NON_TIERED number of method invocations/branches (expressed as "
2231                        "% of CompileThreshold) before profiling in the interpreter");
2232    FLAG_RANGE(         InterpreterProfilePercentage, 0, 100);
2233 
2234 DEVELOP_FLAG(intx,     DesiredMethodLimit, 8000, JVMFlag::DEFAULT,
2235                        "The desired maximum method size (in bytecodes) after inlining");
2236 
2237 DEVELOP_FLAG(intx,     HugeMethodLimit, 8000, JVMFlag::DEFAULT,
2238                        "Don't compile methods larger than this if "
2239                        "+DontCompileHugeMethods");
2240 
2241 
2242     //  Properties for Java libraries  
2243 PRODUCT_FLAG(uint64_t, MaxDirectMemorySize, 0, JVMFlag::RANGE,
2244                        "Maximum total size of NIO direct-buffer allocations");
2245    FLAG_RANGE(         MaxDirectMemorySize, 0, max_jlong);
2246 
2247 
2248     //  Flags used for temporary code during development  
2249 PRODUCT_FLAG(bool,     UseNewCode, false, JVMFlag::DIAGNOSTIC,
2250                        "Testing Only: Use the new version while testing");
2251 
2252 PRODUCT_FLAG(bool,     UseNewCode2, false, JVMFlag::DIAGNOSTIC,
2253                        "Testing Only: Use the new version while testing");
2254 
2255 PRODUCT_FLAG(bool,     UseNewCode3, false, JVMFlag::DIAGNOSTIC,
2256                        "Testing Only: Use the new version while testing");
2257 
2258 
2259     //  flags for performance data collection 
2260 PRODUCT_FLAG(bool,     UsePerfData, true, JVMFlag::DEFAULT,
2261                        "Flag to disable jvmstat instrumentation for performance testing "
2262                        "and problem isolation purposes");
2263 
2264 PRODUCT_FLAG(bool,     PerfDataSaveToFile, false, JVMFlag::DEFAULT,
2265                        "Save PerfData memory to hsperfdata_<pid> file on exit");
2266 
2267 PRODUCT_FLAG(ccstr,    PerfDataSaveFile, NULL, JVMFlag::DEFAULT,
2268                        "Save PerfData memory to the specified absolute pathname. "
2269                        "The string %p in the file name (if present) "
2270                        "will be replaced by pid");
2271 
2272 PRODUCT_FLAG(intx,     PerfDataSamplingInterval, 50, JVMFlag::RANGE | JVMFlag::CONSTRAINT,
2273                        "Data sampling interval (in milliseconds)");
2274  //TODO: to avoid circular dependency, the min/max cannot be declared in header file
2275  //FLAG_RANGE(         PerfDataSamplingInterval, PeriodicTask::min_interval, max_jint);
2276    FLAG_CONSTRAINT(    PerfDataSamplingInterval, (void*)PerfDataSamplingIntervalFunc, JVMFlag::AfterErgo);
2277 
2278 PRODUCT_FLAG(bool,     PerfDisableSharedMem, false, JVMFlag::DEFAULT,
2279                        "Store performance data in standard memory");
2280 
2281 PRODUCT_FLAG(intx,     PerfDataMemorySize, 32*K, JVMFlag::RANGE,
2282                        "Size of performance data memory region. Will be rounded "
2283                        "up to a multiple of the native os page size.");
2284    FLAG_RANGE(         PerfDataMemorySize, 128, 32*64*K);
2285 
2286 PRODUCT_FLAG(intx,     PerfMaxStringConstLength, 1024, JVMFlag::RANGE,
2287                        "Maximum PerfStringConstant string length before truncation");
2288    FLAG_RANGE(         PerfMaxStringConstLength, 32, 32*K);
2289 
2290 PRODUCT_FLAG(bool,     PerfAllowAtExitRegistration, false, JVMFlag::DEFAULT,
2291                        "Allow registration of atexit() methods");
2292 
2293 PRODUCT_FLAG(bool,     PerfBypassFileSystemCheck, false, JVMFlag::DEFAULT,
2294                        "Bypass Win32 file system criteria checks (Windows Only)");
2295 
2296 PRODUCT_FLAG(intx,     UnguardOnExecutionViolation, 0, JVMFlag::RANGE,
2297                        "Unguard page and retry on no-execute fault (Win32 only) "
2298                        "0=off, 1=conservative, 2=aggressive");
2299    FLAG_RANGE(         UnguardOnExecutionViolation, 0, 2);
2300 
2301 
2302     //  Serviceability Support 
2303 PRODUCT_FLAG(bool,     ManagementServer, false, JVMFlag::DEFAULT,
2304                        "Create JMX Management Server");
2305 
2306 PRODUCT_FLAG(bool,     DisableAttachMechanism, false, JVMFlag::DEFAULT,
2307                        "Disable mechanism that allows tools to attach to this VM");
2308 
2309 PRODUCT_FLAG(bool,     StartAttachListener, false, JVMFlag::DEFAULT,
2310                        "Always start Attach Listener at VM startup");
2311 
2312 PRODUCT_FLAG(bool,     EnableDynamicAgentLoading, true, JVMFlag::DEFAULT,
2313                        "Allow tools to load agents with the attach mechanism");
2314 
2315 PRODUCT_FLAG(bool,     PrintConcurrentLocks, false, JVMFlag::MANAGEABLE,
2316                        "Print java.util.concurrent locks in thread dump");
2317 
2318 
2319     //  Shared spaces 
2320 PRODUCT_FLAG(bool,     UseSharedSpaces, true, JVMFlag::DEFAULT,
2321                        "Use shared spaces for metadata");
2322 
2323 PRODUCT_FLAG(bool,     VerifySharedSpaces, false, JVMFlag::DEFAULT,
2324                        "Verify integrity of shared spaces");
2325 
2326 PRODUCT_FLAG(bool,     RequireSharedSpaces, false, JVMFlag::DEFAULT,
2327                        "Require shared spaces for metadata");
2328 
2329 PRODUCT_FLAG(bool,     DumpSharedSpaces, false, JVMFlag::DEFAULT,
2330                        "Special mode: JVM reads a class list, loads classes, builds "
2331                        "shared spaces, and dumps the shared spaces to a file to be "
2332                        "used in future JVM runs");
2333 
2334 PRODUCT_FLAG(bool,     DynamicDumpSharedSpaces, false, JVMFlag::DEFAULT,
2335                        "Dynamic archive");
2336 
2337 PRODUCT_FLAG(bool,     PrintSharedArchiveAndExit, false, JVMFlag::DEFAULT,
2338                        "Print shared archive file contents");
2339 
2340 PRODUCT_FLAG(bool,     PrintSharedDictionary, false, JVMFlag::DEFAULT,
2341                        "If PrintSharedArchiveAndExit is true, also print the shared "
2342                        "dictionary");
2343 
2344 PRODUCT_FLAG(size_t,   SharedBaseAddress, LP64_ONLY(32*G)NOT_LP64(LINUX_ONLY(2*G) NOT_LINUX(0)), JVMFlag::RANGE,
2345                        "Address to allocate shared memory region for class data");
2346    FLAG_RANGE(         SharedBaseAddress, 0, SIZE_MAX);
2347 
2348 PRODUCT_FLAG(ccstr,    SharedArchiveConfigFile, NULL, JVMFlag::DEFAULT,
2349                        "Data to add to the CDS archive file");
2350 
2351 PRODUCT_FLAG(uintx,    SharedSymbolTableBucketSize, 4, JVMFlag::RANGE,
2352                        "Average number of symbols per bucket in shared table");
2353    FLAG_RANGE(         SharedSymbolTableBucketSize, 2, 246);
2354 
2355 PRODUCT_FLAG(bool,     AllowArchivingWithJavaAgent, false, JVMFlag::DIAGNOSTIC,
2356                        "Allow Java agent to be run with CDS dumping");
2357 
2358 PRODUCT_FLAG(bool,     PrintMethodHandleStubs, false, JVMFlag::DIAGNOSTIC,
2359                        "Print generated stub code for method handles");
2360 
2361 DEVELOP_FLAG(bool,     TraceMethodHandles, false, JVMFlag::DEFAULT,
2362                        "trace internal method handle operations");
2363 
2364 PRODUCT_FLAG(bool,     VerifyMethodHandles, trueInDebug, JVMFlag::DIAGNOSTIC,
2365                        "perform extra checks when constructing method handles");
2366 
2367 PRODUCT_FLAG(bool,     ShowHiddenFrames, false, JVMFlag::DIAGNOSTIC,
2368                        "show method handle implementation frames (usually hidden)");
2369 
2370 PRODUCT_FLAG(bool,     TrustFinalNonStaticFields, false, JVMFlag::EXPERIMENTAL,
2371                        "trust final non-static declarations for constant folding");
2372 
2373 PRODUCT_FLAG(bool,     FoldStableValues, true, JVMFlag::DIAGNOSTIC,
2374                        "Optimize loads from stable fields (marked w/ @Stable)");
2375 
2376 DEVELOP_FLAG(bool,     TraceInvokeDynamic, false, JVMFlag::DEFAULT,
2377                        "trace internal invoke dynamic operations");
2378 
2379 PRODUCT_FLAG(int,      UseBootstrapCallInfo, 1, JVMFlag::DIAGNOSTIC,
2380                        "0: when resolving InDy or ConDy, force all BSM arguments to be "
2381                        "resolved before the bootstrap method is called; 1: when a BSM "
2382                        "that may accept a BootstrapCallInfo is detected, use that API "
2383                        "to pass BSM arguments, which allows the BSM to delay their "
2384                        "resolution; 2+: stress test the BCI API by calling more BSMs "
2385                        "via that API, instead of with the eagerly-resolved array.");
2386 
2387 PRODUCT_FLAG(bool,     PauseAtStartup, false, JVMFlag::DIAGNOSTIC,
2388                        "Causes the VM to pause at startup time and wait for the pause "
2389                        "file to be removed (default: ./vm.paused.<pid>)");
2390 
2391 PRODUCT_FLAG(ccstr,    PauseAtStartupFile, NULL, JVMFlag::DIAGNOSTIC,
2392                        "The file to create and for whose removal to await when pausing "
2393                        "at startup. (default: ./vm.paused.<pid>)");
2394 
2395 PRODUCT_FLAG(bool,     PauseAtExit, false, JVMFlag::DIAGNOSTIC,
2396                        "Pause and wait for keypress on exit if a debugger is attached");
2397 
2398 PRODUCT_FLAG(bool,     ExtendedDTraceProbes, false, JVMFlag::DEFAULT,
2399                        "Enable performance-impacting dtrace probes");
2400 
2401 PRODUCT_FLAG(bool,     DTraceMethodProbes, false, JVMFlag::DEFAULT,
2402                        "Enable dtrace probes for method-entry and method-exit");
2403 
2404 PRODUCT_FLAG(bool,     DTraceAllocProbes, false, JVMFlag::DEFAULT,
2405                        "Enable dtrace probes for object allocation");
2406 
2407 PRODUCT_FLAG(bool,     DTraceMonitorProbes, false, JVMFlag::DEFAULT,
2408                        "Enable dtrace probes for monitor events");
2409 
2410 PRODUCT_FLAG(bool,     RelaxAccessControlCheck, false, JVMFlag::DEFAULT,
2411                        "Relax the access control checks in the verifier");
2412 
2413 PRODUCT_FLAG(uintx,    StringTableSize, defaultStringTableSize, JVMFlag::RANGE,
2414                        "Number of buckets in the interned String table "
2415                        "(will be rounded to nearest higher power of 2)");
2416    FLAG_RANGE(         StringTableSize, minimumStringTableSize, 16777216ul);
2417 
2418 PRODUCT_FLAG(uintx,    SymbolTableSize, defaultSymbolTableSize, JVMFlag::EXPERIMENTAL | JVMFlag::RANGE,
2419                        "Number of buckets in the JVM internal Symbol table");
2420    FLAG_RANGE(         SymbolTableSize, minimumSymbolTableSize, 16777216ul);
2421 
2422 PRODUCT_FLAG(bool,     UseStringDeduplication, false, JVMFlag::DEFAULT,
2423                        "Use string deduplication");
2424 
2425 PRODUCT_FLAG(uintx,    StringDeduplicationAgeThreshold, 3, JVMFlag::RANGE,
2426                        "A string must reach this age (or be promoted to an old region) "
2427                        "to be considered for deduplication");
2428  //TODO: to avoid circular dependency, the min/max cannot be declared in header file
2429  //FLAG_RANGE(         StringDeduplicationAgeThreshold, 1, markWord::max_age);
2430 
2431 PRODUCT_FLAG(bool,     StringDeduplicationResizeALot, false, JVMFlag::DIAGNOSTIC,
2432                        "Force table resize every time the table is scanned");
2433 
2434 PRODUCT_FLAG(bool,     StringDeduplicationRehashALot, false, JVMFlag::DIAGNOSTIC,
2435                        "Force table rehash every time the table is scanned");
2436 
2437 PRODUCT_FLAG(bool,     WhiteBoxAPI, false, JVMFlag::DIAGNOSTIC,
2438                        "Enable internal testing APIs");
2439 
2440 PRODUCT_FLAG(intx,     SurvivorAlignmentInBytes, 0, JVMFlag::EXPERIMENTAL | JVMFlag::RANGE | JVMFlag::CONSTRAINT,
2441                        "Default survivor space alignment in bytes");
2442    FLAG_RANGE(         SurvivorAlignmentInBytes, 8, 256);
2443    FLAG_CONSTRAINT(    SurvivorAlignmentInBytes, (void*)SurvivorAlignmentInBytesConstraintFunc, JVMFlag::AfterErgo);
2444 
2445 PRODUCT_FLAG(ccstr,    DumpLoadedClassList, NULL, JVMFlag::DEFAULT,
2446                        "Dump the names all loaded classes, that could be stored into "
2447                        "the CDS archive, in the specified file");
2448 
2449 PRODUCT_FLAG(ccstr,    SharedClassListFile, NULL, JVMFlag::DEFAULT,
2450                        "Override the default CDS class list");
2451 
2452 PRODUCT_FLAG(ccstr,    SharedArchiveFile, NULL, JVMFlag::DEFAULT,
2453                        "Override the default location of the CDS archive file");
2454 
2455 PRODUCT_FLAG(ccstr,    ArchiveClassesAtExit, NULL, JVMFlag::DEFAULT,
2456                        "The path and name of the dynamic archive file");
2457 
2458 PRODUCT_FLAG(ccstr,    ExtraSharedClassListFile, NULL, JVMFlag::DEFAULT,
2459                        "Extra classlist for building the CDS archive file");
2460 
2461 PRODUCT_FLAG(intx,     ArchiveRelocationMode, 0, JVMFlag::DIAGNOSTIC | JVMFlag::RANGE,
2462                        "(0) first map at preferred address, and if "
2463                        "unsuccessful, map at alternative address (default); "
2464                        "(1) always map at alternative address; "
2465                        "(2) always map at preferred address, and if unsuccessful, "
2466                        "do not map the archive");
2467    FLAG_RANGE(         ArchiveRelocationMode, 0, 2);
2468 
2469 PRODUCT_FLAG(size_t,   ArrayAllocatorMallocLimit, SOLARIS_ONLY(64*K) NOT_SOLARIS((size_t)-1), JVMFlag::EXPERIMENTAL,
2470                        "Allocation less than this value will be allocated "
2471                        "using malloc. Larger allocations will use mmap.");
2472 
2473 PRODUCT_FLAG(bool,     AlwaysAtomicAccesses, false, JVMFlag::EXPERIMENTAL,
2474                        "Accesses to all variables should always be atomic");
2475 
2476 PRODUCT_FLAG(bool,     UseUnalignedAccesses, false, JVMFlag::DIAGNOSTIC,
2477                        "Use unaligned memory accesses in Unsafe");
2478 
2479 PRODUCT_FLAG_PD(bool,  PreserveFramePointer, JVMFlag::DEFAULT,
2480                        "Use the FP register for holding the frame pointer "
2481                        "and not as a general purpose register.");
2482 
2483 PRODUCT_FLAG(bool,     CheckIntrinsics, true, JVMFlag::DIAGNOSTIC,
2484                        "When a class C is loaded, check that "
2485                        "(1) all intrinsics defined by the VM for class C are present "
2486                        "in the loaded class file and are marked with the "
2487                        "@HotSpotIntrinsicCandidate annotation, that "
2488                        "(2) there is an intrinsic registered for all loaded methods "
2489                        "that are annotated with the @HotSpotIntrinsicCandidate "
2490                        "annotation, and that "
2491                        "(3) no orphan methods exist for class C (i.e., methods for "
2492                        "which the VM declares an intrinsic but that are not declared "
2493                        "in the loaded class C. "
2494                        "Check (3) is available only in debug builds.");
2495 
2496 PRODUCT_FLAG_PD(intx,  InitArrayShortSize, JVMFlag::DIAGNOSTIC | JVMFlag::RANGE | JVMFlag::CONSTRAINT,
2497                        "Threshold small size (in bytes) for clearing arrays. "
2498                        "Anything this size or smaller may get converted to discrete "
2499                        "scalar stores.");
2500    FLAG_RANGE(         InitArrayShortSize, 0, max_intx);
2501    FLAG_CONSTRAINT(    InitArrayShortSize, (void*)InitArrayShortSizeConstraintFunc, JVMFlag::AfterErgo);
2502 
2503 PRODUCT_FLAG(bool,     CompilerDirectivesIgnoreCompileCommands, false, JVMFlag::DIAGNOSTIC,
2504                        "Disable backwards compatibility for compile commands.");
2505 
2506 PRODUCT_FLAG(bool,     CompilerDirectivesPrint, false, JVMFlag::DIAGNOSTIC,
2507                        "Print compiler directives on installation.");
2508 
2509 PRODUCT_FLAG(int,      CompilerDirectivesLimit, 50, JVMFlag::DIAGNOSTIC,
2510                        "Limit on number of compiler directives.");
2511 
2512 PRODUCT_FLAG(ccstr,    AllocateHeapAt, NULL, JVMFlag::DEFAULT,
2513                        "Path to the directoy where a temporary file will be created "
2514                        "to use as the backing store for Java Heap.");
2515 
2516 PRODUCT_FLAG(ccstr,    AllocateOldGenAt, NULL, JVMFlag::EXPERIMENTAL,
2517                        "Path to the directoy where a temporary file will be "
2518                        "created to use as the backing store for old generation."
2519                        "File of size Xmx is pre-allocated for performance reason, so"
2520                        "we need that much space available");
2521 
2522 DEVELOP_FLAG(int,      VerifyMetaspaceInterval, DEBUG_ONLY(500) NOT_DEBUG(0), JVMFlag::DEFAULT,
2523                        "Run periodic metaspace verifications (0 - none, "
2524                        "1 - always, >1 every nth interval)");
2525 
2526 PRODUCT_FLAG(bool,     ShowRegistersOnAssert, true, JVMFlag::DIAGNOSTIC,
2527                        "On internal errors, include registers in error report.");
2528 
2529 PRODUCT_FLAG(bool,     UseSwitchProfiling, true, JVMFlag::DIAGNOSTIC,
2530                        "leverage profiling for table/lookup switch");
2531 
2532 DEVELOP_FLAG(bool,     TraceMemoryWriteback, false, JVMFlag::DEFAULT,
2533                        "Trace memory writeback operations");
2534 
2535 JFR_ONLY(PRODUCT_FLAG(bool,     FlightRecorder, false, JVMFlag::DEFAULT,
2536                        "(Deprecated) Enable Flight Recorder");)
2537 
2538 JFR_ONLY(PRODUCT_FLAG(ccstr,    FlightRecorderOptions, NULL, JVMFlag::DEFAULT,
2539                        "Flight Recorder options");)
2540 
2541 JFR_ONLY(PRODUCT_FLAG(ccstr,    StartFlightRecording, NULL, JVMFlag::DEFAULT,
2542                        "Start flight recording with options");)
2543 
2544 PRODUCT_FLAG(bool,     UseFastUnorderedTimeStamps, false, JVMFlag::EXPERIMENTAL,
2545                        "Use platform unstable time where supported for timestamps only");
2546 
2547 PRODUCT_FLAG(bool,     UseNewFieldLayout, true, JVMFlag::DEFAULT,
2548                        "(Deprecated) Use new algorithm to compute field layouts");
2549 
2550 PRODUCT_FLAG(bool,     UseEmptySlotsInSupers, true, JVMFlag::DEFAULT,
2551                        "Allow allocating fields in empty slots of super-classes");
2552 
2553 
2554 #ifdef _LP64
2555 PRODUCT_FLAG(bool,     UseCompressedOops, false, JVMFlag::LP64,
2556                        "Use 32-bit object references in 64-bit VM. "
2557                        "lp64_product means flag is always constant in 32 bit VM");
2558 
2559 PRODUCT_FLAG(bool,     UseCompressedClassPointers, false, JVMFlag::LP64,
2560                        "Use 32-bit class pointers in 64-bit VM. "
2561                        "lp64_product means flag is always constant in 32 bit VM");
2562 
2563 PRODUCT_FLAG(intx,     ObjectAlignmentInBytes, 8, JVMFlag::LP64 | JVMFlag::RANGE | JVMFlag::CONSTRAINT,
2564                        "Default object alignment in bytes, 8 is minimum");
2565    FLAG_RANGE(         ObjectAlignmentInBytes, 8, 256);
2566    FLAG_CONSTRAINT(    ObjectAlignmentInBytes, (void*)ObjectAlignmentInBytesConstraintFunc, JVMFlag::AtParse);
2567 
2568 #elif defined(IS_DECLARING_FLAG)
2569 const bool UseCompressedOops = false; // !JVMFlag::LP64
2570 const bool UseCompressedClassPointers = false; // !JVMFlag::LP64
2571 const intx ObjectAlignmentInBytes = 8; // !JVMFlag::LP64
2572 #endif // _LP64
2573 
2574 #endif // SHARE_RUNTIME_GLOBALS_HPP