Skip to content

Instantly share code, notes, and snippets.

@katrinafyi
Last active October 19, 2023 06:12
Show Gist options
  • Save katrinafyi/151e9ffb423b1a68b9407d2d86b8aef8 to your computer and use it in GitHub Desktop.
Save katrinafyi/151e9ffb423b1a68b9407d2d86b8aef8 to your computer and use it in GitHub Desktop.
all options for Graal native-image.

compile to javac

pushd ~/progs/graal/compiler/; javac ./src/jdk.internal.vm.compiler.test/src/org/graalvm/compiler/core/test/ArrayBoundsCheckEliminationTestCases.java -d .; popd

build native image and dump graphs

mx native-image --no-fallback -cp ../compiler/./mxbuild/jdk17/jdk.internal.vm.compiler.test/bin/ org.graalvm.compiler.core.test.ArrayBoundsCheckEliminationTestCases -H:Dump= -H:MethodFilter='ArrayBoundsCheckEliminationTestCases.*' -H:NumberOfThreads=4 -H:-ReduceDCE -H:-AOTInline -H:-AOTTrivialInline -H:PrintGraph=File

graal native-image options

mx native-image --expert-options-all | xclip -selection clipboard
  -H:±AOTInline                                Deprecated. Default: + (enabled).
  -H:±AOTTrivialInline                         Perform trivial method inlining in the AOT compiled native image. Default: + (enabled).
  -H:APIFunctionPrefix="graal_"                Prefix that is added to the names of API functions.
  -H:±AbortOnBenchmarkCounterOverflow          Abort VM with SIGILL if benchmark counters controlled by the (Generic|Timed|Benchmark)DynamicCounters. Default: -
                                               (disabled). [Extra help available]
  -H:±AddAllCharsets                           Make all hosted charsets available at run time. Default: - (disabled).
  -H:±AddAllFileSystemProviders                Make all supported providers returned by FileSystemProvider.installedProviders() available at run time. Default: +
                                               (enabled).
  -H:AddExports=<string>*                      Value <module>/<package>=<target-module>(,<target-module>)* updates <module> to export <package> to <target-module>,
                                               regardless of module declaration. <target-module> can be ALL-UNNAMED to export to all unnamed modules.
  -H:AddOpens=<string>*                        Value <module>/<package>=<target-module>(,<target-module>)* updates <module> to open <package> to <target-module>,
                                               regardless of module declaration.
  -H:AddReads=<string>*                        Value <module>=<target-module>(,<target-module>)* updates <module> to read <target-module>, regardless of module
                                               declaration. <target-module> can be ALL-UNNAMED to read all unnamed modules.
  -H:AdditionalSecurityProviders=<string>*     Comma-separated list of additional security provider fully qualified class names to mark as used.Note that this option
                                               is only necessary if you use custom engine classes not available in JCA that are not JCA compliant.
  -H:AdditionalSecurityServiceTypes=<string>*  Comma-separated list of additional security service types (fully qualified class names) for automatic registration. Note
                                               that these must be JCA compliant.
  -H:AggregatedMetricsFile=...                 File to which aggregated metrics are dumped at shutdown. A CSV format is used if the file ends with .csv otherwise a
                                               more human readable format is used. If not specified, metrics are dumped to the console. Default: None
  -H:±AliasArrayTypeFlows                      Model all array type flows using a unique elements type flow abstraction. Default: + (enabled).
  -H:AlignedHeapChunkSize=524288               The size of an aligned chunk. Serial and epsilon GC only.
  -H:AllocateInstancePrefetchLines=1           Number of cache lines to load after the object address using prefetch instructions.
  -H:AllocatePrefetchDistance=192              Sets the size (in bytes) of the prefetch distance for object allocation. Memory about to be written with the value of
                                               new objects is prefetched up to this distance starting from the address of the last allocated object. Each Java thread
                                               has its own allocation point.
  -H:AllocatePrefetchInstr=0                   Sets the prefetch instruction to prefetch ahead of the allocation pointer. Possible values are from 0 to 3. The actual
                                               instructions behind the values depend on the platform.
  -H:AllocatePrefetchLines=4                   Number of cache lines to load after the array allocation using prefetch instructions.
  -H:AllocatePrefetchStepSize=64               Sets the step size (in bytes) for sequential prefetch instructions.
  -H:AllocatePrefetchStyle=1                   Generated code style for prefetch instructions: for 0 or less no prefetch instructions are generated and for 1 or more
                                               prefetch instructions are introduced after each allocation.
  -H:AllocationBeforePhysicalMemorySize=1048576
                                               Bytes that can be allocated before (re-)querying the physical memory size. Serial and epsilon GC only.
  -H:±AllocationProfiling                      Enable runtime profiling of allocation. Default: - (disabled).
  -H:±AllocationSiteSensitiveHeap              A context sensitive heap means that each heap allocated object is modeled by using at least the allocation site.
                                               Default: - (disabled).
  -H:±AllowDeprecatedAutomaticFeature          Allow using deprecated @AutomaticFeature annotation. If set to false, an error is shown instead of a warning. Default: +
                                               (enabled).
  -H:±AllowDeprecatedBuilderClassesOnImageClasspath
                                               Instead of abort, only warn if image builder classes are found on the image class-path. Default: - (disabled).
  -H:±AllowDeprecatedInitializeAllClassesAtBuildTime
                                               Instead of abort, only warn if --initialize-at-build-time= is used. Default: - (disabled).
  -H:±AllowFoldMethods                         Allow MethodTypeFlow to see @Fold methods. Default: - (disabled).
  -H:±AllowIncompleteClasspath                 Deprecated. Default: - (disabled).
  -H:±AllowJRTFileSystem                       Enable support for reading Java modules (jimage format) and the jrt:// file system. Requires java.home to be set at
                                               runtime. Default: - (disabled).
  -H:±AllowVMInspection                        Enables features that allow the VM to be inspected during run time. Default: - (disabled).
  -H:±AllowVMInternalThreads                   Determines if VM internal threads (e.g., a dedicated VM operation or reference handling thread) are allowed in this
                                               image. Default: + (enabled).
  -H:±AlwaysInlineIntrinsics                   Unconditionally inline intrinsics. Default: - (disabled).
  -H:±AlwaysInlineVTableStubs                  Default: - (disabled).
  -H:AnalysisContextSensitivity="insens"       Controls the static analysis context sensitivity. Available values: insens (context insensitive analysis), allocsens
                                               (context insensitive analysis, context insensitive heap, allocation site sensitive heap), _1obj (1 object sensitive
                                               analysis with a context insensitive heap), _2obj1h (2 object sensitive with a 1 context sensitive heap).
  -H:AnalysisSizeCutoff=8                      The maximum size of type and method profiles returned by the static analysis. -1 indicates no limitation.
  -H:ArrayRegionEqualsConstantLimit=4096       Array region equality checks will be evaluated at compile time if the receiver is a constant and its length is smaller
                                               than this value.
  -H:±AssertInitializationSpecifiedForAllClasses
                                               Assert class initialization is specified for all classes. Default: - (disabled).
  -H:±BenchmarkCounterPrintingCutoff           Use a cutoff to print only most significant counters. Default: + (enabled).
  -H:±BenchmarkCountersDumpDynamic             Dump dynamic counters. Default: + (enabled).
  -H:±BenchmarkCountersDumpStatic              Dump static counters. Default: - (disabled).
  -H:BenchmarkCountersFile=...                 File to which benchmark counters are dumped. A CSV format is used if the file ends with .csv otherwise a more human
                                               readable format is used. The fields in the CSV format are: category, group, name, value. Default: None
  -H:BenchmarkDynamicCounters=...              Turn on the benchmark counters. The format of this option is:. Default: None [Extra help available]
  -H:±BitcodeOptimizations                     Enable LLVM bitcode optimizations. Default: - (disabled).
  -H:±BootstrapInitializeOnly                  Do not compile anything on bootstrap but just initialize the compiler. Default: - (disabled).
  -H:BootstrapTimeout=15.0                     Maximum time in minutes to spend bootstrapping (0 to disable this limit).
  -H:BootstrapWatchDogCriticalRateRatio=0.25   Ratio of the maximum compilation rate below which the bootstrap compilation rate must not fall (0 or less disables
                                               monitoring).
  -H:±BuildOutputBreakdowns                    Show code and heap breakdowns as part of the build output. Default: + (enabled).
  -H:±BuildOutputColorful                      Colorize build output (enabled by default if colors are supported by terminal). Default: - (disabled).
  -H:±BuildOutputGCWarnings                    Print GC warnings as part of build output. Default: + (enabled).
  -H:BuildOutputJSONFile=<path>*               Print build output statistics as JSON to the specified file. The output conforms to the JSON schema located at:
                                               docs/reference-manual/native-image/assets/build-output-schema-v0.9.2.json.
  -H:±BuildOutputLinks                         Show links in build output (defaults to the value of BuildOutputColorful). Default: - (disabled).
  -H:±BuildOutputPrefix                        Prefix build output with '<pid>:<image name>'. Default: - (disabled).
  -H:±BuildOutputProgress                      Report progress in build output (default is adaptive). Default: - (disabled).
  -H:±BuildOutputRecommendations               Show recommendations as part of the build output. Default: + (enabled).
  -H:±BuildOutputSilent                        Silence build output. Default: - (disabled).
  -H:CAPCacheDir=""                            Directory where information generated by the CAnnotation Processor are cached.
  -H:CCompilerOption=<string>*                 Provide custom C compiler option used for query code compilation.
  -H:CCompilerPath=...                         Provide custom path to C compiler used for query code compilation and linking. Default: None
  -H:CLibraryPath=<path>*                      Search path for C libraries passed to the linker (list of comma-separated directories).
  -H:CPUFeatures=<string>*                     Comma separated list of CPU features that will be enabled while building the target executable, irrespective of whether
                                               they are supported by the hosted environment. Note that enabling features not present within the target environment may
                                               result in application crashes. The specific options available are target platform dependent. See --list-cpu-features
                                               for feature list. These features are in addition to -march.
  -H:CStandard="C89"                           C standard to use in header files. Possible values are 'C89', 'C99', and 'C11'.
  -H:±CanonicalGraphStringsCheckConstants      Exclude virtual nodes when dumping canonical text for graphs. Default: - (disabled).
  -H:±CanonicalGraphStringsExcludeVirtuals     Exclude virtual nodes when dumping canonical text for graphs. Default: + (enabled).
  -H:±CanonicalGraphStringsRemoveIdentities    Attempts to remove object identity hashes when dumping canonical text for graphs. Default: + (enabled).
  -H:CheckBootModuleDependencies=1             Temporary option to disable checking of image builder module dependencies or increasing its verbosity.
  -H:±CheckIsolateThreadAtEntry                At CEntryPoints check that the passed IsolateThread is valid. Default: - (disabled).
  -H:±CheckRecurringCallbackOnNativeToJavaTransition
                                               Test whether a thread's recurring callback is pending on each transition from native code to Java. Default: -
                                               (disabled).
  -H:±CheckToolchain                           Check if native-toolchain is known to work with native-image. Default: + (enabled).
  -H:Class=""                                  Class containing the default entry point method. Optional if --shared is used.
  -H:ClassInitialization=<string>*             A comma-separated list of classes appended with their initialization strategy (':build_time', ':rerun', or ':run_time').
  -H:±ClearMetricsAfterBootstrap               Clear the debug metrics after bootstrap. Default: - (disabled).
  -H:CodeAlignment=16                          Alignment of AOT and JIT compiled code in bytes.
  -H:±CodeCacheCounters                        Count accesses to the image and runtime code info table. Default: - (disabled).
  -H:±CodeInfoEncoderCounters                  Statistics about code and deoptimization information. Default: - (disabled).
  -H:CodeInfoIndexGranularity=256              The granularity of the index for looking up code metadata. Should be a power of 2. Larger values make the index smaller,
                                               but access slower.
  -H:±CollectImageBuildStatistics              Collect information during image build about devirtualized invokes and bytecode exceptions. Default: - (disabled).
  -H:±CompilationBailoutAsFailure              Treat compilation bailouts like compilation failures. Default: - (disabled).
  -H:CompilationCountLimit=0                   The number of compilations allowed for any method before the VM exits (a value of 0 means there is no limit).
  -H:CompilationExcludePhases=...              Exclude certain phases from compilation, either unconditionally or with a method filter. Multiple exclusions can be
                                               specified separated by ':'. Phase names are matched as substrings, e.g.:
                                               CompilationExcludePhases=PartialEscape:Loop=A.*,B.foo excludes PartialEscapePhase from all compilations and any phase
                                               containing 'Loop' in its name from compilations of all methods in class A and of method B.foo. Default: None
  -H:CompilationExpirationPeriod=300.0         Time limit in seconds before a compilation expires (0 to disable the limit). A non-zero value for this option is doubled
                                               if assertions are enabled and quadrupled if DetailedAsserts is true.
  -H:CompilationFailureAction=Silent           Specifies the action to take when compilation fails. [Extra help available]
  -H:CompilationWatchDogStartDelay=0           Delay in seconds before watch dog monitors a compilation (0 disables monitoring).
  -H:CompilationWatchDogVMExitDelay=0          Number of seconds after which a compilation appearing to make no progress causes the VM to exit (0 disables VM exiting).
  -H:±CompileGraalWithC1Only                   In tiered mode compile Graal and JVMCI using optimized first tier code. Default: + (enabled).
  -H:CompilerBackend="lir"                     Backend used by the compiler.
  -H:CompilerConfiguration=...                 Names the compiler configuration to use. If omitted, the compiler configuration with the highest auto-selection priority
                                               is used. To see the set of available configurations, supply the value 'help' to this option. Default: None
  -H:±ConditionalElimination                   Default: + (enabled).
  -H:±ConditionalEliminationBeforeAnalysis     Run conditional elimination before static analysis. Default: + (enabled).
  -H:ConditionalEliminationMaxIterations=4     
  -H:ConfigurationFileDirectories=<path>*      Directories directly containing configuration files for dynamic features at runtime.
  -H:ConfigurationResourceRoots=<string>*      Resource path above configuration resources for dynamic features at runtime.
  -H:±ConfigureReflectionMetadata              Enable runtime instantiation of reflection objects for non-invoked methods. Default: + (enabled).
  -H:ContendedPaddingWidth=128                 How many bytes to pad fields and classes marked @Contended with.
  -H:±CopyLanguageResources                    Automatically copy the necessary language resources to the resources/languages directory next to the produced
                                               image.Language resources for each language are specified in the native-image-resources.filelist file located in the
                                               language home directory.If there is no native-image-resources.filelist file in the language home directory or the file
                                               is empty, then no resources are copied. Default: + (enabled).
  -H:Count=...                                 Pattern for specifying scopes in which counters are enabled. See the Dump option for the pattern syntax. An empty value
                                               enables all counters unconditionally. Default: None
  -H:±CountWriteBarriers                       Instrument write barriers with counters. Serial GC only. Default: - (disabled).
  -H:Counters=...                              Comma separated names of counters that are enabled irrespective of the value for Count option. An empty value enables
                                               all counters unconditionally. Default: None
  -H:CrashAt=...                               Pattern for method(s) that will trigger an exception when compiled. This option exists to test handling compilation
                                               crashes gracefully. See the MethodFilter option for the pattern syntax. A ':Bailout' suffix will raise a bailout
                                               exception and a ':PermanentBailout' suffix will raise a permanent bailout exception. Default: None
  -H:±CreateJvmShim                            Create a `jvm` shim for native libraries that link against that library. Default: - (disabled).
  -H:CustomLD=""                               Path to a custom ld binary for LLVM linking.
  -H:±DashboardAll                             In the dashboard dump, include all available information about the native image (this takes precedence over more
                                               specific flags). Default: - (disabled).
  -H:±DashboardBgv                             Set dashboard to use BGV format for dump. Default: + (enabled).
  -H:±DashboardCode                            In the dashboard dump, include the breakdown of the code size across different packages. Default: - (disabled).
  -H:DashboardDump=...                         Enable dashboard dumps to the specified file. Default: None
  -H:±DashboardHeap                            In the dashboard dump, include the breakdown of the object sizes in the heap across different classes. Default: -
                                               (disabled).
  -H:±DashboardJson                            Set dashboard to use JSON format for dump. Default: - (disabled).
  -H:±DashboardPointsTo                        In the dashboard dump, include the information about the points-to analysis. Default: - (disabled).
  -H:±DashboardPretty                          Set dashboard to use pretty print in JSON format. Default: - (disabled).
  -H:±DeadlockWatchdogExitOnTimeout            Exit the image builder VM after printing call stacks. Default: + (enabled).
  -H:DeadlockWatchdogInterval=10               The interval in minutes between watchdog checks (0 disables the watchdog).
  -H:DebugCodeInfoMaxDepth=2147483647          Specify maximum inlining depth to consider when building DebugCodeInfo.
  -H:±DebugCodeInfoUseSourceMappings           Do not use SourceMappings for generating DebugCodeInfo (i.e. only use Infopoints). Default: - (disabled).
  -H:DebugInfoSourceCacheRoot="sources"        Directory under which to create source file cache for Application or GraalVM classes.
  -H:DebugInfoSourceSearchPath=<path>*         Search path for source files for application or GraalVM classes (list of comma-separated directories or jar files).
  -H:±DebugStubsAndSnippets                    Enable debug output for stub code generation and snippet preparation. Default: - (disabled).
  -H:DefaultCharset="UTF-8"                    Default charset of the image, by the default it is the same as the default charset of the image builder.
  -H:DefaultLocale="en-AU"                     Default locale of the image, by the default it is the same as the default locale of the image builder.
  -H:DefaultLoopFrequency=100.0                Default frequency for loops with unknown local frequency.
  -H:DefaultUnswitchFactor=0.7                 Default unswitching factor for control split node with unkown profile data.
  -H:±DeleteLocalSymbols                       Use linker option to remove all local symbols from image. Default: + (enabled).
  -H:±DeoptALot                                Default: - (disabled).
  -H:±DeoptAfterOSR                            Deoptimize OSR compiled code when the OSR entry loop is finished if there is no mature profile available for the rest of
                                               the method. Default: + (enabled).
  -H:±DeoptimizeAll                            Compiles all methods as deoptimization targets for testing. Default: - (disabled).
  -H:DeoptsToDisableOptimisticOptimization=40  
  -H:±DetailedAsserts                          Enable expensive assertions if normal assertions (i.e. -ea or -esa) are enabled. Default: - (disabled).
  -H:±DetectUserDirectoriesInImageHeap         When set to true, the image generator verifies that the image heap does not contain a home directory as a substring.
                                               Default: - (disabled).
  -H:DiagnoseDumpLevel=3                       Specify the dump level if CompilationFailureAction#Diagnose is used.See CompilationFailureAction for details.
                                               file:doc-files/CompilationFailureActionHelp.txt.
  -H:DiagnosticBufferSize=30                   Specifies the number of entries that diagnostic buffers have.
  -H:DiagnosticsDir=<path>*                    Sets the dir where diagnostic information is dumped.
  -H:±DiagnosticsMode                          Enables the diagnostic mode. Default: - (disabled).
  -H:±DisableABCE                              Disable array bounds check elimations. Default: + (enabled).
  -H:±DisableIntercept                         Disable intercepting exceptions in debug scopes. Default: - (disabled).
  -H:DisableIntrinsics=...                     Disable intrinsics matching the given method filter (see MethodFilter option for details). For example,
                                               'DisableIntrinsics=String.equals' disables intrinsics for any method named 'equals' in a class whose simple name is
                                               'String'. You can append ':verbose' at the end of the filter value to print out disabled intrinsics as they are
                                               encountered during compilation (e.g., 'String.equals:verbose'). Default: None
  -H:±DisableTypeIdResultVerification          For internal purposes only. Disables type id result verification even when running with assertions enabled. Default: +
                                               (enabled).
  -H:DisableURLProtocols=<string>*             List of comma separated URL protocols that must never be included.
  -H:Dump=...                                  Filter pattern for specifying scopes in which dumping is enabled. Default: None [Extra help available]
  -H:±DumpAfterEveryBCI                        Dump the current graph after every bci to IGV. Default: - (disabled).
  -H:±DumpEndVersusExitLoopFrequencies         Debug flag to dump loop frequency differences computed based on loop end or exit nodes.If the frequencies diverge a lot,
                                               this may indicate missing profiles on control flowinside the loop body. Default: - (disabled).
  -H:±DumpFoldedReflectionElements             Dump folded reflection elements. Default: - (disabled).
  -H:DumpHeap=<string>*                        Dump the heap at a specific time during image building.The option accepts a list of comma separated phases, any of:
                                               during-analysis, after-analysis, before-compilation.
  -H:DumpLLVMStackMap=...                      Dump contents of the generated stackmap to the specified file. Default: None
  -H:±DumpOnError                              Send compiler IR to dump handlers on error. Default: - (disabled).
  -H:DumpOnPhaseChange=...                     Dump a before and after graph if the named phase changes the graph.%nThe argument is substring matched against the
                                               simple name of the phase class. Default: None
  -H:DumpPath="graal_dumps"                    The directory where various Graal dump files are written.
  -H:±DumpRuntimeCompilationOnSignal           Dumps all runtime compiled methods on SIGUSR2. Default: - (disabled).
  -H:±DumpTargetInfo                           Show native-toolchain information and image-build settings. Default: - (disabled).
  -H:±DumpThreadStacksOnSignal                 Dumps all thread stacktraces on SIGQUIT/SIGBREAK. Default: - (disabled).
  -H:±DumpingErrorsAreFatal                    Treat any exceptions during dumping as fatal. Default: - (disabled).
  -H:±DynamicCountersPrintGroupSeparator       Use grouping separators for number printing. Default: + (enabled).
  -H:DynamicProxyConfigurationFiles=<path>*    One or several (comma-separated) paths to JSON files that specify lists of interfaces that define Java proxy classes.
                                               [Extra help available]
  -H:DynamicProxyConfigurationResources=<string>*
                                               Resources describing program elements to be made available for reflection (see ProxyConfigurationFiles).
  -H:±DynamicProxyTracing                      Enable trace logging for dynamic proxy. Default: - (disabled).
  -H:±EagerSnippets                            Eagerly construct extra snippet info. Default: - (disabled).
  -H:±EarlyCodeEmissionOrder                   Enable early code emission order computation instead of late code emission order computation. Default: - (disabled).
  -H:±EarlyGVN                                 Perform early global value numbering. Default: + (enabled).
  -H:±EarlyLICM                                Perform early loop invariant code motion. Default: + (enabled).
  -H:±EmitStringSubstitutions                  Emit substitutions for String methods. Default: + (enabled).
  -H:±EnableAllSecurityServices                Add all security service classes to the generated image. Default: - (disabled).
  -H:±EnableLoggingFeature                     Enable the feature that provides support for logging. Default: + (enabled).
  -H:EnableMonitoringFeatures=<string>*        Enable monitoring features that allow the VM to be inspected at run time. Comma-separated list can contain 'heapdump',
                                               'jfr', 'jvmstat', 'jmxserver' (experimental), 'jmxclient' (experimental), or 'all' (deprecated behavior: defaults to
                                               'all' if no argument is provided). For example: '--enable-monitoring=heapdump,jfr'.
  -H:±EnableSecurityServicesFeature            Enable automatic registration of security services. Default: + (enabled).
  -H:EnableURLProtocols=<string>*              List of comma separated URL protocols to enable.
  -H:±EnableWildcardExpansion                  Enable wildcard expansion in command line arguments on Windows. Default: + (enabled).
  -H:±EnforceMaxRuntimeCompileMethods          Enforce checking of maximum number of methods allowed for runtime compilation. Useful for checking in the gate that the
                                               number of methods does not go up without a good reason. Default: - (disabled).
  -H:EntryPointNamePrefix=""                   Prefix that is added to the names of entry point methods.
  -H:ErrorFile="svm_err_b_%t_pid%p.md"         If an error occurs, save a build error report to this file [default: svm_err_b_%t_pid%p.md] (%p replaced with pid, %t
                                               with timestamp).).
  -H:±EscapeAnalysisBeforeAnalysis             Run partial escape analysis on compiler graphs before static analysis. Default: + (enabled).
  -H:EscapeAnalysisIterations=2                
  -H:EscapeAnalysisLoopCutoff=20               
  -H:EscapeAnalyzeOnly=...                     Default: None
  -H:ExactFullUnrollMaxNodes=800               
  -H:ExactPartialUnrollMaxNodes=200            
  -H:ExcludeResources=<string>*                Regexp to match names of resources to be excluded from the image.
  -H:±ExhaustiveHeapScan                       Scan all objects reachable from roots for analysis. By default false. Default: - (disabled).
  -H:±ExitAfterAnalysis                        Exit after analysis. Default: - (disabled).
  -H:±ExitAfterCAPCache                        Exit image generation after C Annotation Processor Cache creation. Default: - (disabled).
  -H:±ExitAfterQueryCodeGeneration             Output query code for target platform without executing it. Default: - (disabled).
  -H:±ExitAfterRelocatableImageWrite           Exit after writing relocatable file. Default: - (disabled).
  -H:ExpectedEdenSize=33554432                 Soft upper limit for used eden size. The hinted GC will be performed if the used eden size exceeds this value.
  -H:±ExtendedAsserts                          Enable extended asserts which slow down analysis. Default: - (disabled).
  -H:±FailedLoopExplosionIsFatal               Do not bail out but throw an exception on failed loop explosion. Default: - (disabled).
  -H:FallbackExecutorClasspath=...             Internal option used to specify Classpath for FallbackExecutor. Default: None
  -H:FallbackExecutorJavaArg=<string>*         Internal option used to specify java arguments for FallbackExecutor.
  -H:FallbackExecutorMainClass=...             Internal option used to specify MainClass for FallbackExecutor. Default: None
  -H:FallbackExecutorSystemProperty=<string>*  Internal option used to specify system properties for FallbackExecutor.
  -H:FallbackThreshold=5                       Define when fallback-image generation should be used.
  -H:Features=<string>*                        A comma-separated list of fully qualified Feature implementation classes.
  -H:±FloatingDivNodes                         Try to float non-constant division operations to expose global value numbering of divisions. Default: + (enabled).
  -H:±FoldSecurityManagerGetter                Fold SecurityManager getter. Default: + (enabled).
  -H:±ForceAdversarialLayout                   Place N-byte constants in the data section such that they are misaligned with respect to N*2. For example, place 4 byte
                                               constants at offset 4, 12 or 20, etc. This layout is used to detect instructions that load constants with alignment
                                               smaller than the fetch size. For instance, an XORPS instruction that does a 16-byte fetch of a 4-byte float not aligned
                                               to 16 bytes will cause a segfault. Default: - (disabled).
  -H:±ForceExplicitReachabilityFence           Force an explicit compiler node for Reference.reachabilityFence, instead of relying on FrameState liveness. Default: -
                                               (disabled).
  -H:±ForceNoROSectionRelocations              Use only a writable native image heap (requires ld.gold linker). Default: - (disabled).
  -H:±FullUnroll                               Default: + (enabled).
  -H:FullUnrollCodeSizeBudgetFactorForLargeGraphs=2.0
                                               Maximum factor by which full unrolling can increase code size for large graphs. The FullUnrollSmallGraphThreshold option
                                               determines which graphs are small.
  -H:FullUnrollCodeSizeBudgetFactorForSmallGraphs=10.0
                                               Maximum factor by which full unrolling can increase code size for small graphs. The FullUnrollSmallGraphThreshold option
                                               determines which graphs are small.
  -H:FullUnrollConstantCompareBoost=15         
  -H:FullUnrollMaxApplication=60               
  -H:FullUnrollMaxIterations=600               
  -H:FullUnrollMaxNodes=400                    
  -H:FullUnrollSmallGraphThreshold=1000        The threshold in terms of NodeSize for a graph to be considered small for the purpose of full unrolling. Applied in
                                               conjunction with the FullUnrollCodeSizeBudgetFactorForSmallGraphs and FullUnrollCodeSizeBudgetFactorForLargeGraphs
                                               options.
  -H:GCDebugStartCycle=-1                      Start tracing compiled GC barriers after N garbage collections (disabled if N <= 0).
  -H:±GatherSafepointStatistics                Gather statistics about each safepoint. Default: - (disabled).
  -H:±GenLoopSafepoints                        Default: + (enabled).
  -H:±GenerateBuildArtifactsFile               Create a build-artifacts.json file in the build directory. The output conforms to the JSON schema located at:
                                               docs/reference-manual/native-image/assets/build-artifacts-schema-v0.9.0.json. Default: - (disabled).
  -H:GenerateDebugInfo=0                       Insert debug info into the generated native image or library.
  -H:±GenericDynamicCounters                   Turn on the benchmark counters, and displays the results on VM shutdown. Default: - (disabled).
  -H:±GraalArithmeticStubs                     Use Graal arithmetic stubs instead of HotSpot stubs where possible. Default: + (enabled).
  -H:GraalCompileOnly=...                      A filter applied to a method the VM has selected for compilation by Graal. A method not matching the filter is
                                               redirected to a lower tier compiler. The filter format is the same as for the MethodFilter option. Default: None
  -H:GraphCompressionThreshold=70              Graal graph compression is performed when percent of live nodes falls below this value.
  -H:±GreyToBlackObjRefDemographics            Develop demographics of the object references visited. Serial GC only. Default: - (disabled).
  -H:±GuardPriorities                          Default: + (enabled).
  -H:HeapChunkHeaderPadding=0                  Number of bytes at the beginning of each heap chunk that are not used for payload data, i.e., can be freely used as
                                               metadata by the heap chunk provider. Serial and epsilon GC only.
  -H:HeapVerifierVerbosity=0                   Control heap verifier verbosity level: 0 - quiet, 1 - info, 2 - warning, 3 - all.
  -H:HotCodeMinSelfTime=0.001                  Minimal self time for a compilation unit to be considered hot globally.
  -H:±HotSpotDeoptExplicitExceptions           Testing only option that forces deopts for exception throws. Default: - (disabled).
  -H:±HotSpotPostOnExceptions                  Testing only option that forces deopts for exception throws. Default: - (disabled).
  -H:±HotSpotPrintInlining                     Print inlining optimizations. Default: - (disabled).
  -H:±HybridStaticContext                      Enable hybrid context for static methods, i.e. uses invocation site as context for static methods. Default: -
                                               (disabled).
  -H:±ImageHeapCardMarking                     Enables card marking for image heap objects, which arranges them in chunks. Automatically enabled when supported. Serial
                                               GC only. 
  -H:ImageObjectTreeExpandRoots=""             Override the default suppression of specified roots. See: Reports.md.
  -H:ImageObjectTreeExpandTypes=""             Override the default suppression of specified types. See: Reports.md.
  -H:ImageObjectTreeSuppressRoots=""           Suppress the expansion of specified roots. See: Reports.md.
  -H:ImageObjectTreeSuppressTypes=""           Suppress the expansion of specified types. See: Reports.md.
  -H:ImageSymbolsPrefix=""                     Common prefix used by method symbols in image.
  -H:±IncludeAllLocales                        Make all hosted locales available at run time. Default: - (disabled).
  -H:±IncludeAllTimeZones                      When true, all time zones will be pre-initialized in the image. Default: - (disabled).
  -H:±IncludeDebugHelperMethods                Determines if debugging-specific helper methods are embedded into the image. Those methods can be called directly from
                                               the debugger to obtain or print additional information. Default: - (disabled).
  -H:IncludeLLVMDebugInfo=0                    Include debugging info in the generated image (for LLVM backend).
  -H:IncludeLocales=<string>*                  Comma separated list of locales to be included into the image. The default locale is included in the list automatically
                                               if not present.
  -H:±IncludeMethodData                        Include a list of methods included in the image for runtime inspection. Default: + (enabled).
  -H:±IncludeNodeSourcePositions               Track NodeSourcePositions during runtime-compilation. Default: - (disabled).
  -H:IncludeResourceBundles=<string>*          Comma separated list of bundles to be included into the image.
  -H:IncludeResources=<string>*                Regexp to match names of resources to be included in the image.
  -H:IncludeTimeZones=""                       The time zones, in addition to the default zone of the host, that will be pre-initialized in the image.
  -H:InitialCollectionPolicy="Adaptive"        The garbage collection policy, either Adaptive (default) or BySpaceAndTime. Serial GC only.
  -H:InjectedCompilationDelay=0                The number of seconds by which to slow down each compilation. The compilations slowed down can be restricted with
                                               MethodFilter. This option exists to test the compilation watchdog.
  -H:±Inline                                   Enable inlining. Default: + (enabled).
  -H:±InlineBeforeAnalysis                     Inline methods before static analysis. Default: + (enabled).
  -H:InlineBeforeAnalysisAllowedDepth=20       Maximum number of invokes for method inlined before static analysis.
  -H:InlineBeforeAnalysisAllowedInvokes=1      Maximum number of invokes for method inlined before static analysis.
  -H:InlineBeforeAnalysisAllowedNodes=1        Maximum number of computation nodes for method inlined before static analysis.
  -H:±InlineDuringParsing                      Inlines trivial methods during bytecode parsing. Default: + (enabled).
  -H:InlineDuringParsingMaxDepth=10            Maximum depth when inlining during bytecode parsing.
  -H:±InlineEverything                         Default: - (disabled).
  -H:±InlineGraalStubs                         Embed all the emitted code for Graal-generated stubs. Default: - (disabled).
  -H:±InlineMegamorphicCalls                   Inline calls with megamorphic type profile (i.e., not all types could be recorded). Default: + (enabled).
  -H:±InlineMonomorphicCalls                   Inline calls with monomorphic type profile. Default: + (enabled).
  -H:±InlinePartialIntrinsicExitDuringParsing  Inlines partial intrinsic exits during bytecode parsing when possible. A partial intrinsic exit is a call within an
                                               intrinsic to the method being intrinsified and denotes semantics of the original method that the intrinsic does not
                                               support. Default: + (enabled).
  -H:±InlinePolymorphicCalls                   Inline calls with polymorphic type profile. Default: + (enabled).
  -H:±InlineVTableStubs                        Default: + (enabled).
  -H:InliningDepthError=1000                   Maximum inlining depth during partial evaluation before reporting an infinite recursion.
  -H:InspectServerContentPath="inspect"        Path to the contents of the Inspect web server.
  -H:±InstallExitHandlers                      Provide java.lang.Terminator exit handlers. Default: - (disabled).
  -H:±InterceptBailout                         Intercept also bailout exceptions. Default: - (disabled).
  -H:±InternalSymbolsAreGlobal                 Compatibility option to make symbols used for the image heap global. Using global symbols is problematic for shared
                                               libraries because the loader implicitly changes the value when the symbol is already defined in the executable loading
                                               the library. Setting this option to true preserves the broken behavior of old Native Image versions. Default: -
                                               (disabled).
  -H:InternalThreadStackSize=2097152           The size of each internal thread stack, in bytes.
  -H:±Intrinsify                               Use compiler intrinsifications. Default: + (enabled).
  -H:IsolatedLoopHeaderAlignment=32            Alignment in bytes for loop header blocks that have no fall through paths.
  -H:IterativePeelingLimit=2                   Allow iterative peeling of loops up to this many times (each time the peeling phase runs).
  -H:±JNI                                      Enable Java Native Interface (JNI) support. Default: + (enabled).
  -H:JNIConfigurationFiles=<path>*             Files describing program elements to be made accessible via JNI (for syntax, see ReflectionConfigurationFiles).
  -H:JNIConfigurationResources=<string>*       Resources describing program elements to be made accessible via JNI (see JNIConfigurationFiles).
  -H:±JNIExportSymbols                         Export Invocation API symbols. Default: + (enabled).
  -H:±JNIVerboseLookupErrors                   Report information about known JNI elements when lookup fails. Default: - (disabled).
  -H:±LIRDynMoveProfileMethod                  Enable dynamic move profiling per method. Default: - (disabled).
  -H:LIRInstructionVerifierPath=...            Path to jar file containing LIR instruction verifier. Default: None
  -H:±LIROptConstantLoadOptimization           Enable constant load optimization. 
  -H:±LIROptControlFlowOptimizer               
  -H:±LIROptEdgeMoveOptimizer                  
  -H:±LIROptLSRAEliminateSpillMoves            Enable spill move elimination. 
  -H:±LIROptLSRAOptimizeSpillPosition          Enable spill position optimization. 
  -H:±LIROptLSStackSlotAllocator               Use linear scan stack slot allocation. 
  -H:±LIROptNullCheckOptimizer                 
  -H:±LIROptRedundantMoveElimination           
  -H:±LIROptStackMoveOptimizer                 
  -H:±LIROptimization                          Enable LIR level optimizations. Default: + (enabled).
  -H:±LIRProfileMethods                        Enables profiling of methods. Default: - (disabled).
  -H:±LIRProfileMoves                          Enables profiling of move types on LIR level. Move types are for example stores (register to stack), constant loads
                                               (constant to register) or copies (register to register). Default: - (disabled).
  -H:LLVMDataSectionBatchSizeFactor=10         Factor used to multiply the page size of the machine to obtain the data section batch size.
  -H:LLVMMaxFunctionsPerBatch=1000             Maximum size of batches used for LLVM compilation. 0 means a single batch, 1 means all functions separately.
  -H:±LSRAOptSplitOnly                         LSRA optimization: Only split but do not reassign. Default: - (disabled).
  -H:±LSRAOptimization                         Enable LSRA optimization. Default: - (disabled).
  -H:LargeArrayThreshold=131072                The size at or above which an array will be allocated in its own unaligned chunk. Serial and epsilon GC only.
  -H:LimitInlinedInvokes=5.0                   
  -H:±LimitObjectArrayLength                   Enable a limit for the number of objects recorded for each type of a type state before disabling heap sensitivity for
                                               that type. The analysis must be heap sensitive. Default: - (disabled).
  -H:LinkAtBuildTime=<string>*                 Require types to be fully defined at image build-time. If used without args, all classes in scope of the option are
                                               required to be fully defined. [Extra help available]
  -H:LinkAtBuildTimePaths=<string>*            Require all types in given class or module-path entries to be fully defined at image build-time. [Extra help available]
  -H:LinkerRPath=<string>*                     Path passed to the linker as the -rpath (list of comma-separated directories).
  -H:±ListCPUFeatures                          Show CPU features specific to the target platform and exit. Default: - (disabled).
  -H:±ListMetrics                              Lists on the console at VM shutdown the metric names available to the Timers, Counters and MemUseTrackers options. Note
                                               that this only lists the metrics that were initialized during the VM execution and so will not include metrics for
                                               compiler code that is not executed. Default: - (disabled).
  -H:±ListModules                              List observable modules and exit. Default: - (disabled).
  -H:±LoadExceptionObjectInVM                  Use a VM runtime call to load and clear the exception object from the thread at the start of a compiled exception
                                               handler. Default: - (disabled).
  -H:LoadProfiles=...                          Load per compilation profile information. Default: None
  -H:LocalizationCompressBundles=<string>*     Regular expressions matching which bundles should be compressed.
  -H:±LocalizationCompressInParallel           Compress the bundles in parallel. Default: + (enabled).
  -H:±LocalizationOptimizedMode                Optimize the resource bundle lookup using a simple map. Default: - (disabled).
  -H:±LocalizationSubstituteLoadLookup         Store the resource bundle content more efficiently in the fallback mode. Default: + (enabled).
  -H:Log=...                                   Pattern for specifying scopes in which logging is enabled. See the Dump option for the pattern syntax. Default: None
  -H:LogFile=...                               File to which logging is sent.  A %p in the name will be replaced with a string identifying the process, usually the
                                               process id and %t will be replaced by System.currentTimeMillis(). If the current runtime is in an isolate, then %i will
                                               be replaced by '<isolate id>' otherwise %i is removed. An %I is the same as %i except that the replacement is '<isolate
                                               id>@<isolate address>'. Using %o as filename sends logging to System.out whereas %e sends logging to System.err.
                                               Default: None
  -H:±LogVerbose                               Enable more verbose log output when available. Default: - (disabled).
  -H:LoopExitVsLoopEndFrequencyDiff=1000.0     Scaling factor of frequency difference computed based on loop ends or exits.
  -H:LoopHeaderAlignment=16                    Alignment in bytes for loop header blocks.
  -H:LoopMaxUnswitch=3                         
  -H:±LoopPeeling                              Default: + (enabled).
  -H:±LoopPredication                          Hoists array bounds checks out of simple loops. This is ignored if SpeculativeGuardMovement is enabled. Default: +
                                               (enabled).
  -H:±LoopPredicationMainPath                  Restricts LoopPredication to only focus on array bounds checks that dominate the back edge of a loop. Default: +
                                               (enabled).
  -H:±LoopUnswitch                             Default: + (enabled).
  -H:LoopUnswitchFrequencyBoost=20.0           Number of nodes allowed for a loop unswitching per loop frequency. The number of nodes allowed for the unswitching is
                                               proportional to the relative frequency of the loop by this constant.
  -H:LoopUnswitchFrequencyMaxFactor=0.95       Maximun value for the frequency factor of an invariant.
  -H:LoopUnswitchFrequencyMinFactor=0.05       Minimum value for the frequency factor of an invariant.
  -H:LoopUnswitchMaxIncrease=2000              Maximum loop unswitching code size increase in nodes.
  -H:LoopUnswitchMinSplitFrequency=1.0         Lower bound for the minimun frequency of an invariant condition to be unswitched.
  -H:LoopUnswitchTrivial=20                    Number of nodes allowed for a loop unswitching regardless of the loop frequency.
  -H:±MatchExpressions                         Allow backend to match complex expressions. Default: + (enabled).
  -H:MaxCallingContextDepth=0                  The maximum length of the methods context chains.
  -H:MaxCallingContextWidth=0                  The maximum number of contexts to record for a method. It only affects the analysis when the max and min calling context
                                               depth are different.
  -H:MaxCompilationProblemsPerAction=2         The maximum number of compilation failures to handle with the action specified by CompilationFailureAction before
                                               changing to a less verbose action. This does not apply to the ExitVM action.
  -H:MaxConstantObjectsPerType=0               The maximum number of constant objects recorded for each type before merging the constants into one unique constant
                                               object per type. If the value is 0 there is no limit.
  -H:MaxDuplicationFactor=2.0                  Max amount of extra effort to expend handling irreducible loops. A value <= 1 disables support for irreducible loops.
  -H:MaxHeapContextDepth=0                     The maximum length of the context used to model a heap object in addition to the allocation site; used only when
                                               ContextSensitiveHeap is enabled.
  -H:MaxHeapContextWidth=0                     The maximum number of contexts to record for a heap object.  It only affects the analysis when the max and min calling
                                               context depth are different.
  -H:MaxInvokesInTrivialMethod=1               Maximum number of invokes in a method so that it is considered trivial (for testing only).
  -H:MaxNodesAfterTrivialInlining=2147483647   The maximum number of nodes in a graph allowed after trivial inlining.
  -H:MaxNodesInTrivialLeafMethod=40            Maximum number of nodes in a method so that it is considered trivial, if it does not have any invokes.
  -H:MaxNodesInTrivialMethod=20                Maximum number of nodes in a method so that it is considered trivial.
  -H:MaxObjectSetSize=100                      The maximum number of objects recorded for each type of a type state before disabling heap sensitivity for that type.
                                               The analysis must be heap sensitive. It has a minimum value of 1.
  -H:MaxReachableTypes=-1                      Maximum number of types allowed in the image. Used for tests where small number of types is necessary.
  -H:MaxRuntimeCompileMethods=<string>*        Maximum number of methods allowed for runtime compilation.
  -H:MaxSurvivorSpaces=...                     Maximum number of survivor spaces. Serial GC only. Default: None
  -H:MaxTemplatesPerSnippet=50                 
  -H:MaxUnrolledObjectZeroingStores=8          Define the maximum number of stores for which the loop that zeroes out objects is unrolled.
  -H:MaxUnswitchSuccessors=64                  Maximum number of split successors before aborting unswitching.
  -H:MaximumDesiredSize=20000                  Maximum desired size of the compiler graph in nodes.
  -H:MaximumEscapeAnalysisArrayLength=128      The maximum length of an array that will be escape analyzed.
  -H:MaximumInliningSize=300                   Inlining is explored up to this number of nodes in the graph for each call site.
  -H:MaximumLoopExplosionCount=10000           Max number of loop explosions per method.
  -H:MaximumRecursiveInlining=5                Maximum level of recursive inlining.
  -H:MegamorphicInliningMinMethodProbability=0.33
                                               Minimum probability for methods to be inlined for megamorphic type profiles.
  -H:MemUseTrackers=...                        Comma separated names of memory usage trackers that are enabled irrespective of the value for TrackMemUse option. An
                                               empty value enables all memory usage trackers unconditionally. Default: None
  -H:Method="main"                             Name of the main entry point method. Optional if --shared is used.
  -H:MethodFilter=...                          Pattern for matching methods. The syntax for a pattern is:. Default: None [Extra help available]
  -H:±MethodFilterRootOnly                     Only check MethodFilter against the root method in the context if true, otherwise check all methods. Default: -
                                               (disabled).
  -H:MethodInlineBailoutLimit=5000             Per-compilation method inlining exploration limit before giving up (use 0 to disable).
  -H:MetricsFile=...                           File to which metrics are dumped per compilation. Default: None [Extra help available]
  -H:MicroArchitecture=...                     Generate instructions for a specific machine type. Defaults to 'x86-64-v3' on AMD64 and 'armv8-a' on AArch64. Use
                                               -march=compatibility for best compatibility, or -march=native for best performance if the native executable is deployed
                                               on the same machine or on a machine with the same CPU features. To list all available machine types, use -march=list.
                                               Default: None
  -H:MinCallingContextDepth=0                  The minimum length of the methods context chains.
  -H:MinHeapContextDepth=0                     The minimum length of the context used to model a heap object in addition to the allocation site; used only when
                                               ContextSensitiveHeap is enabled.
  -H:MinimalBulkZeroingSize=2048               If applicable, use bulk zeroing instructions when the zeroing size in bytes exceeds this threshold.
  -H:MinimalGraphNodeSizeCheckSize=1000        Minimal size in NodeSize to check the graph size increases of phases.
  -H:MinimumPeelFrequency=0.35                 
  -H:MissingRegistrationReportingMode=Throw    Select the mode in which the missing reflection registrations will be reported. [Extra help available]
  -H:Module=""                                 Module containing the class that contains the main entry point. Optional if --shared is used.
  -H:±MoveGuardsUpwards                        Move guard nodes to earlier places in the dominator tree if all successors of basic block share a common guard
                                               condition. Default: + (enabled).
  -H:±MultiThreaded                            Enable support for threads and and thread-local variables (disable for single-threaded implementation). Default: +
                                               (enabled).
  -H:NDCV=0                                    Run level for NoDeadCodeVerifyHandler (0 = off, 1 = info, 2 = verbose, 3 = fatal).
  -H:Name=""                                   Name of the output file to be generated.
  -H:±NativeArchitecture                       Uses the native architecture, i.e., the architecture of a machine that builds an image. Default: - (disabled).
  -H:NativeLinkerOption=<string>*              Pass the provided raw option that will be appended to the linker command to produce the final binary. The possible
                                               options are platform specific and passed through without any validation.
  -H:NeverInline=<string>*                     Pattern for disabling inlining of methods during image generation. [Extra help available]
  -H:±NewCAPCache                              Create a C Annotation Processor Cache. Will erase any previous cache at that same location. Default: - (disabled).
  -H:NumberOfAnalysisThreads=-1                The number of threads to use for analysis during native image generation. The number must be smaller than the
                                               NumberOfThreads.
  -H:NumberOfThreads=8                         The maximum number of threads to use concurrently during native image generation.
  -H:ObjdumpExecutables=...                    Comma separated list of candidate GNU objdump executables. If not specified, disassembling via GNU objdump is disabled.
                                               Otherwise, the first existing executable in the list is used. Default: None
  -H:±OmitHotExceptionStacktrace               Default: - (disabled).
  -H:±OmitInlinedMethodDebugLineInfo           Omit generation of DebugLineInfo originating from inlined methods. Default: - (disabled).
  -H:±OptAssumptions                           Default: + (enabled).
  -H:±OptConvertDeoptsToGuards                 Default: + (enabled).
  -H:±OptDeoptimizationGrouping                Default: + (enabled).
  -H:±OptDevirtualizeInvokesOptimistically     Default: + (enabled).
  -H:±OptEarlyReadElimination                  Default: + (enabled).
  -H:±OptEliminateGuards                       Default: + (enabled).
  -H:±OptFloatingReads                         Default: + (enabled).
  -H:±OptImplicitNullChecks                    Default: + (enabled).
  -H:±OptReadElimination                       Default: + (enabled).
  -H:±OptScheduleOutOfLoops                    Default: + (enabled).
  -H:±OptStaticFinalFieldFolding               Optimize static final fields that get a constant assigned in the class initializer. Default: + (enabled).
  -H:OptimizationLog=...                       Enable the structured optimization log and specify where it is printed. Default: None [Extra help available]
  -H:OptimizationLogPath=...                   Path to the directory where the optimization log is saved if OptimizationLog is set to Directory. Directories are
                                               created if they do no exist. Default: None
  -H:Optimize="2"                              Control code optimizations: b - optimize for fastest build time, 0 - no optimizations, 1 - basic optimizations, 2 -
                                               advanced optimizations, 3 - all optimizations for best performance.
  -H:±OptimizeReturnedParameter                Analysis: Detect methods that return one of their parameters and hardwire the parameter straight to the return. Default:
                                               + (enabled).
  -H:±OverrideProfiles                         Allow multiple compilations of the same method by overriding existing profiles. Default: - (disabled).
  -H:PageSize=0                                Define PageSize of a machine that runs the image. The default = 0 (== same as host machine page size).
  -H:±ParseOnce                                When true, compiler graphs are parsed only once before static analysis. When false, compiler graphs are parsed for
                                               static analysis and again for AOT compilation. Default: + (enabled).
  -H:±ParseOnceJIT                             When true, each compiler graph version (DeoptTarget, AOT, JIT) needed for runtime compilation will be separately
                                               analyzed during static analysis.When false, only one version of the compiler graph (AOT) will be used in static
                                               analysis, and then three new versions will be parsed for compilation. Default: - (disabled).
  -H:±ParseRuntimeOptions                      Parse and consume standard options and system properties from the command line arguments when the VM is created.
                                               Default: + (enabled).
  -H:ParsingContextMaxDepth=100                Limit the parsing context depth. Default value is arbitrary set at 100.
  -H:±PartialEscapeAnalysis                    Default: + (enabled).
  -H:±PartialUnroll                            Default: + (enabled).
  -H:Path=...                                  Directory of the image file to be generated. Default: None
  -H:±PeelALot                                 Default: - (disabled).
  -H:±PerfDataMemoryMappedFile                 Determines if the collected performance data should be written to a memory-mapped file so that it can be accessed by
                                               external tools. Default: + (enabled).
  -H:±PinnedObjectAddressing                   Allows the addresses of pinned objects to be passed to other code. Default: + (enabled).
  -H:±PlatformInterfaceCompatibilityMode       Enable the behavior of old GraalVM versions. When enabled, interfaces not available for the current platform are
                                               filtered. Default: - (disabled).
  -H:PredefinedClassesConfigurationFiles=<path>*
                                               Files describing predefined classes that can be loaded at runtime.
  -H:PredefinedClassesConfigurationResources=<string>*
                                               Resources describing predefined classes that can be loaded at runtime.
  -H:±PreferUnsignedComparison                 Rewrite signed comparisons to unsigned ones if the result is equal. Default: + (enabled).
  -H:±PreserveFramePointer                     Saves stack base pointer on the stack on method entry. Default: - (disabled).
  -H:±PrintAOTCompilation                      Print logging information during compilation. Default: - (disabled).
  -H:±PrintAnalysisCallTree                    Print analysis call tree, a breadth-first tree reduction of the call graph. Default: - (disabled).
  -H:PrintAnalysisCallTreeType=TXT             Change the output format of the analysis call tree, available options are TXT and CSV. See: Reports.md.
  -H:±PrintAnalysisStatistics                  Print analysis results statistics. Default: - (disabled).
  -H:±PrintBBInfo                              Enables dumping of basic blocks relative PC and frequencies in the dump directory. Default: - (disabled).
  -H:±PrintBackendCFG                          Enable dumping scheduled HIR, LIR, register allocation and code generation info to the C1Visualizer. Default: -
                                               (disabled).
  -H:±PrintBlockMapping                        Enable dumping CFG built during initial BciBlockMapping. Default: - (disabled).
  -H:±PrintCallEdges                           Print call edges with other analysis results statistics. Default: - (disabled).
  -H:PrintCanonicalGraphStringFlavor=0         Choose format used when dumping canonical text for graphs: 0 gives a scheduled graph (better for spotting changes
                                               involving the schedule) while 1 gives a CFG containing expressions rooted at fixed nodes (better for spotting small
                                               structure differences).
  -H:±PrintCanonicalGraphStrings               Enable dumping canonical text from for graphs. Default: - (disabled).
  -H:±PrintClassInitialization                 Prints class initialization info for all classes detected by analysis. Default: - (disabled).
  -H:±PrintCompilation                         Print an informational line to the console for each completed compilation. Default: - (disabled).
  -H:±PrintFeatures                            Print a list of active features. Default: - (disabled).
  -H:PrintFlags=...                            Show available options based on comma-separated option-types (allowed categories: User, Expert, Debug). Default: None
  -H:PrintFlagsWithExtraHelp=...               Print extra help, if available, based on comma-separated option names. Pass * to show all options that contain extra
                                               help. Default: None
  -H:PrintGraph=File                           Where IdealGraphVisualizer graph dumps triggered by Dump or DumpOnError should be written. [Extra help available]
  -H:±PrintGraphFile                           Setting to true sets PrintGraph=file, setting to false sets PrintGraph=network. Default: + (enabled).
  -H:PrintGraphHost="127.0.0.1"                Host part of the address to which graphs are dumped.
  -H:PrintGraphPort=4445                       Port part of the address to which graphs are dumped in binary format.
  -H:±PrintGraphStateDiff                      Prints the difference in the graph state caused by each phase of the suite. Default: - (disabled).
  -H:±PrintGraphWithSchedule                   Schedule graphs as they are dumped. Default: - (disabled).
  -H:±PrintHeapHistogram                       Print class statistics of native image heap. Default: - (disabled).
  -H:±PrintIRWithLIR                           Print HIR along side LIR as the latter is generated. Default: - (disabled).
  -H:±PrintImageElementSizes                   Print the sizes of the elements of the built image. Default: - (disabled).
  -H:±PrintImageHeapConnectedComponents        A native-image run with the flag `-H:+PrintImageHeapConnectedComponents` will create reports that can help us debug
                                               which objects got into the native image heap and why. A component represents a set of objects in the image heap.
                                               Default: - (disabled). [Extra help available]
  -H:±PrintImageHeapPartitionSizes             Print the sizes of the native image heap as the image is built. Default: - (disabled).
  -H:±PrintImageObjectTree                     Print image object hierarchy. Default: - (disabled).
  -H:±PrintJNIMethods                          Print JNI methods added to generated image. Default: - (disabled).
  -H:±PrintLIRWithAssembly                     Include the LIR as comments with the final assembly. Default: - (disabled).
  -H:±PrintLoweringScheduleToTTY               Print schedule result pre lowering to TTY. Default: - (disabled).
  -H:±PrintMethodHistogram                     Print statistics of methods in native image heap. Default: - (disabled).
  -H:±PrintPointsToStatistics                  Report analysis statistics. Default: - (disabled).
  -H:±PrintProfileLoading                      Print to stdout when a profile is loaded. Default: - (disabled).
  -H:±PrintProfilingInformation                Print profiling information when parsing a method's bytecode. Default: - (disabled).
  -H:±PrintRestrictHeapAccessPath              Print path for @RestrictHeapAccess warnings. Default: + (enabled).
  -H:±PrintRestrictHeapAccessWarnings          Print warnings for @RestrictHeapAccess annotations. Default: + (enabled).
  -H:±PrintRuntimeCompilationCallTree          Print call tree of methods reachable for runtime compilation. Default: - (disabled).
  -H:±PrintRuntimeCompileMethods               Print methods available for runtime compilation. Default: - (disabled).
  -H:±PrintStaticTruffleBoundaries             Print truffle boundaries found during the analysis. Default: - (disabled).
  -H:±PrintSynchronizedAnalysis                Print types used for Java synchronization. Default: - (disabled).
  -H:±PrintUninterruptibleCalleeDOTGraph       Print (to stderr) a DOT graph of the @Uninterruptible annotations. Default: - (disabled).
  -H:±PrintUniverse                            Print information about classes, methods, and fields that are present in the native image. Default: - (disabled).
  -H:±PrintUnmodifiedGraphs                    Dump a graph even if it has not changed since it was last dumped.  Change detection is based on adding and deleting
                                               nodes or changing inputs. Default: + (enabled).
  -H:±ProfileAllocations                       Enable profiling of allocation sites. Default: - (disabled).
  -H:ProfileAllocationsContext=AllocatingMethod
                                               Control the naming and granularity of the counters when using ProfileAllocations. [Extra help available]
  -H:±ProfileAnalysisOperations                Track the progress of the static analysis. Default: - (disabled).
  -H:±ProfileCompiledMethods                   Default: - (disabled).
  -H:±ProfileConstantObjects                   Track the creation of constant objects. Default: - (disabled).
  -H:±ProfileDeoptimization                    Print logging information during object file writing. Default: - (disabled).
  -H:ProfileMethodFilter=...                   Restrict saving or loading of profiles based on this filter. See the MethodFilter option for the pattern syntax.
                                               Default: None
  -H:±ProfileMonitors                          Enable profiling of monitor operations. Default: - (disabled).
  -H:QueryCodeDir=""                           Directory where query code for target platform should be output.
  -H:±RawConditionalElimination                Default: + (enabled).
  -H:ReadEliminationMaxLoopVisits=5            
  -H:±ReassociateExpressions                   Re-associate loop invariants and constants. Default: + (enabled).
  -H:±ReduceDCE                                Disable optional dead code eliminations. Default: + (enabled).
  -H:ReflectionConfigurationFiles=<path>*      One or several (comma-separated) paths to JSON files that specify which program elements should be made available via
                                               reflection. [Extra help available]
  -H:ReflectionConfigurationResources=<string>*
                                               Resources describing program elements to be made available for reflection (see ReflectionConfigurationFiles).
  -H:±ReflectionPluginTracing                  Enable trace logging for reflection plugins. Default: - (disabled).
  -H:RegisterPressure=...                      Comma separated list of registers that register allocation is limited to. Default: None
  -H:±RelaxTypeFlowStateConstraints            Allow a type flow state to contain types not compatible with its declared type. Default: + (enabled).
  -H:±RemoveLoopSafepoints                     Remove safepoints on counted loop ends. Default: + (enabled).
  -H:±RemoveNeverExecutedCode                  Default: + (enabled).
  -H:±RemoveSaturatedTypeFlows                 Enable the type flow saturation analysis performance optimization. Default: + (enabled).
  -H:±RemoveUnneededDeoptSupport               Remove Deopt(Entries,Anchors,Proxies) determined to be unneeded after the runtime compiled graphs have been finalized.
                                               Default: - (disabled).
  -H:±RemoveUnusedSymbols                      Use linker option to prevent unreferenced symbols in image. Default: + (enabled).
  -H:±ReplaceInputsWithConstantsBasedOnStamps  Default: + (enabled).
  -H:ReportAnalysisForbiddenType=<string>*     Report error if <typename>[:<UsageKind>{,<UsageKind>}] is discovered during analysis (valid values for UsageKind:
                                               InHeap, Allocated, Reachable).
  -H:±ReportExceptionStackTraces               Show exception stack traces for exceptions during image building.). Default: - (disabled).
  -H:±ReportPerformedSubstitutions             Report performed substitutions. Default: - (disabled).
  -H:±ReportUnsafeOffsetWarnings               Print unsafe operation offset warnings.). Default: - (disabled).
  -H:±ReportUnsupportedElementsAtRuntime       Report usage of unsupported methods and fields at run time when they are accessed the first time, instead of as an error
                                               during image building. Default: - (disabled).
  -H:ResourceConfigurationFiles=<path>*        Files describing Java resources to be included in the image.
  -H:ResourceConfigurationResources=<string>*  Resources describing Java resources to be included in the image.
  -H:±ReturnAfterAnalysis                      Return after analysis. Default: - (disabled).
  -H:±RunMainInNewThread                       Initializes and runs main entry point in a new native thread. Default: - (disabled).
  -H:±RunReachabilityHandlersConcurrently      Run reachability handlers concurrently during analysis. Default: + (enabled).
  -H:RuntimeAssertions=<string>*               Enable or disable Java assert statements at run time.
  -H:RuntimeCheckedCPUFeatures=<string>*       Comma separated list of CPU features that will be enabled for runtime checks. The native image may check at run time if
                                               such features are supported by the target CPU, and can optimize certain operations based on this information. If a
                                               feature is not supported at run time, a less optimized variant will be executed. Because of the presence of multiple
                                               code variants, enabling runtime features can result in larger executables. To completely turn off runtime checked CPU
                                               features, set this option to the empty string. The specific options available are target platform dependent. See
                                               --list-cpu-features for feature list. The default values are: AMD64: 'AVX,AVX2'; AArch64: ''.
  -H:±RuntimeCompilationInlineBeforeAnalysis   Perform InlineBeforeAnalysis on runtime compiled methods. Default: + (enabled).
  -H:±RuntimeSystemAssertions                  Enable or disable Java system assertions at run time. Default: - (disabled).
  -H:SafepointSamplerStats=""                  Dump some stats about the safepoint sampler into a file on this path.
  -H:±SaveProfiles                             Save per compilation profile information. Default: - (disabled).
  -H:SaveProfilesPath=...                      Path for saving compilation profiles. If the value is omitted the debug dump path will be used. Default: None
  -H:±ScanObjectsParallel                      Object scanning in parallel. Default: + (enabled).
  -H:SerializationConfigurationFiles=<path>*   One or several (comma-separated) paths to JSON files that specify lists of serialization configurations. [Extra help
                                               available]
  -H:SerializationConfigurationResources=<string>*
                                               Resources describing program elements to be made available for serialization (see SerializationConfigurationFiles).
  -H:SerializationDenyConfigurationFiles=<path>*
                                               One or several (comma-separated) paths to JSON files that specify lists of serialization configurations. [Extra help
                                               available]
  -H:SerializationDenyConfigurationResources=<string>*
                                               Resources describing program elements that must not be made available for serialization.
  -H:ServiceLoaderFeatureExcludeServiceProviders=<string>*
                                               Comma-separated list of service providers that should be excluded.
  -H:ServiceLoaderFeatureExcludeServices=<string>*
                                               Comma-separated list of services that should be excluded.
  -H:±SharedLibrary                            Build shared library. Default: - (disabled).
  -H:ShowConfiguration=none                    Writes to the VM log information about the compiler configuration selected.
  -H:±ShowDumpFiles                            Print the name of each dump file path as it's created. Default: - (disabled).
  -H:±ShowSubstitutionSourceInfo               Controls whether the source position information of snippets and method substitutions are exposed to HotSpot.  Can be
                                               useful when profiling to get more precise position information. Default: - (disabled).
  -H:±SignalHandlerBasedExecutionSampler       Determines if JFR uses a signal handler for execution sampling. Default: - (disabled).
  -H:±SimpleFastInflatedLocking                Handle simple cases for inflated monitors in the fast-path. Default: + (enabled).
  -H:±SimulateClassInitializer                 Simulate the effects of class initializer at image build time, to avoid class initialization at run time. Default: +
                                               (enabled).
  -H:±SimulateClassInitializerCollectAllReasons
                                               Configuration for SimulateClassInitializer: Collect all reasons why a class initializer cannot be simulated. Default: -
                                               (disabled).
  -H:SimulateClassInitializerMaxAllocatedBytes=40000
                                               Configuration for SimulateClassInitializer: Maximum number of bytes allocated in the image heap for each class
                                               initializer.
  -H:SimulateClassInitializerMaxInlineDepth=200
                                               Configuration for SimulateClassInitializer: Maximum inlining depth during simulation.
  -H:SimulateClassInitializerMaxLoopIterations=2000
                                               Configuration for SimulateClassInitializer: Maximum number of loop iterations that are unrolled during simulation.
  -H:SmallCompiledLowLevelGraphSize=330        If the previous low-level graph size of the method exceeds the threshold, it is not inlined.
  -H:±SnippetCounters                          Enable counters for various paths in snippets. Default: - (disabled).
  -H:SoftRefLRUPolicyMSPerMB=1000              This number of milliseconds multiplied by the free heap memory in MByte is the time span for which a soft reference will
                                               keep its referent alive after its last access. Serial GC only.
  -H:±SourceLevelDebug                         Preserve the local variable information for every Java source line to allow line-by-line stepping in the debugger. Allow
                                               the lookup of Java-level method information, e.g., in stack traces. Default: - (disabled).
  -H:SourceLevelDebugFilter=<string>*          Constrain debug info generation to the comma-separated list of package prefixes given to this option.
  -H:±SpawnIsolates                            Support multiple isolates. Default: + (enabled).
  -H:SpectrePHTBarriers=None                   Select a strategy to mitigate speculative bounds check bypass (aka Spectre-PHT or Spectre V1). [Extra help available]
  -H:±SpectrePHTIndexMasking                   Mask indices to scope access to allocation size after bounds check. Default: - (disabled).
  -H:±SpeculativeExecutionBarriers             Stop speculative execution on all branch targets with execution barrier instructions. Default: - (disabled).
  -H:±SpeculativeGuardMovement                 Move loop invariant guards (e.g., array bounds checks) out of loops. Default: + (enabled).
  -H:StackRedZoneSize=8192                     Size (in bytes) of the red zone reserved at the end of the stack. This stack space can only be used by critical VM code
                                               and C code, e.g., to report fatal errors.
  -H:±StackTrace                               Deprecated, has no effect. Default: + (enabled).
  -H:StackYellowZoneSize=32768                 Size (in bytes) of the yellow zone reserved at the end of the stack. This stack space is reserved for VM use and cannot
                                               be used by the application.
  -H:±StaticExecutable                         Build statically linked executable (requires static libc and zlib). Default: - (disabled).
  -H:±StaticExecutableWithDynamicLibC          Builds a statically linked executable with libc dynamically linked. Default: - (disabled).
  -H:±StrengthenGraphWithConstants             Perform constant folding in StrengthenGraphs. Default: + (enabled).
  -H:±StressExplicitExceptionCode              Stress the code emitting explicit exception throwing code. Default: - (disabled).
  -H:±StressInvokeWithExceptionNode            Stress the code emitting invokes with explicit exception edges. Default: - (disabled).
  -H:±StressTestEarlyReads                     Stress the code by emitting reads at earliest instead of latest point. Default: - (disabled).
  -H:±StrictConfiguration                      Causes unknown attributes in configuration objects to abort the image build instead of emitting a warning. Default: -
                                               (disabled).
  -H:±StrictDeoptInsertionChecks               Perform checks that guards and deopts aren't introduced in graphs that should handle exceptions explicitly. Default: -
                                               (disabled).
  -H:±StrictProfiles                           Throw an error if an attempt is made to overwrite/update a profile loaded from disk. Default: + (enabled).
  -H:±StrictQueryCodeCompilation               Use strict checks when performing query code compilation. Default: + (enabled).
  -H:StringIndexOfConstantLimit=4096           String.indexOf invocations will be evaluated at compile time if the receiver is a constant and its length is smaller
                                               than this value.
  -H:±StripDebugInfo                           Use a separate file for debug info. Default: + (enabled).
  -H:±SupportCompileInIsolates                 Support runtime compilation in separate isolates (enable at runtime with option CompileInIsolates). 
  -H:±SupportJsrBytecodes                      Default: + (enabled).
  -H:±SupportOSRWithLocks                      Support OSR compilations with locks. If DeoptAfterOSR is true we can per definition not have unbalanced enter/exits
                                               mappings. If DeoptAfterOSR is false insert artificial monitor enters after the OSRStart to have balanced enter/exits in
                                               the graph. Default: + (enabled).
  -H:±SupportPredefinedClasses                 Enable support for predefining additional classes. Default: + (enabled).
  -H:±SupportRecurringCallback                 Support a per-thread timer that is called at a specific interval. Default: + (enabled).
  -H:±SuppressStderr                           Suppress console error output for unittests. Default: - (disabled).
  -H:±SuppressStdout                           Suppress console normal output for unittests. Default: - (disabled).
  -H:SystemicCompilationFailureRate=1          Compilation failure rate indicating a systemic compilation problem that will issue a warning. The value is made absolute
                                               and clamped to produce P, a value between 0 and 100. Systemic failure is detected if the percent of failing
                                               compilations in a sliding time window >= P. A negative value will cause the VM to exit after issuing the warning. Set
                                               to 0 to disable systemic compilation problem detection.
  -H:TargetPlatform=""                         Selects native-image compilation target (in <OS>-<architecture> format). Defaults to host's OS-architecture pair.
  -H:TempDirectory=<path>*                     Directory for temporary files generated during native image generation. If this option is specified, the temporary files
                                               are not deleted so that you can inspect them after native image generation.
  -H:ThrowMissingRegistrationErrors=<string>*  Throw Native Image-specific errors when trying to access an element that has not been registered. [Extra help available]
  -H:ThrowMissingRegistrationErrorsPaths=<string>*
                                               Trigger missing registration errors from all types in the given class or module-path entries. [Extra help available]
  -H:±ThrowUnsafeOffsetErrors                  Throw unsafe operation offset errors.). Default: + (enabled).
  -H:Time=...                                  Pattern for specifying scopes in which timing is enabled. See the Dump option for the pattern syntax. An empty value
                                               enables all timers unconditionally. Default: None
  -H:TimedDynamicCounters=-1                   Turn on the benchmark counters, and displays the results every n milliseconds.
  -H:Timers=...                                Comma separated names of timers that are enabled irrespective of the value for Time option. An empty value enables all
                                               timers unconditionally. Default: None
  -H:TraceBytecodeParserLevel=0                The trace level for the bytecode parser. A value of 1 enables instruction tracing and any greater value emits a frame
                                               state trace just prior to each instruction trace.Instruction tracing output from multiple compiler threads will be
                                               interleaved so use of this option make most sense for single threaded compilation. The MethodFilter option can be used
                                               to refine tracing to selected methods.
  -H:TraceClassInitialization=<string>*        Comma-separated list of fully-qualified class names that class initialization is traced for.
  -H:±TraceEscapeAnalysis                      Default: - (disabled).
  -H:±TraceExceptionHandlerStub                Trace execution of stub used to handle an exception thrown by a callee. Default: - (disabled).
  -H:±TraceInlineDuringParsing                 Traces inlining performed during bytecode parsing. Default: - (disabled).
  -H:±TraceInlining                            Enable tracing of inlining decisions. Default: - (disabled). [Extra help available]
  -H:±TraceInliningForStubsAndSnippets         Enable inlining decision tracing in stubs and snippets. Default: - (disabled).
  -H:TraceLIRGeneratorLevel=0                  The trace level for the LIR generator.
  -H:±TraceLocalizationFeature                 When enabled, localization feature details are printed. Default: - (disabled).
  -H:±TraceLoggingFeature                      When enabled, logging feature details are printed. Default: - (disabled).
  -H:TraceMonitorsMethodFilter=...             Trace monitor operations in methods whose fully qualified name contains this substring. Default: None
  -H:TraceMonitorsTypeFilter=...               Trace monitor operations on objects whose type contains this substring. Default: None
  -H:±TraceNativeToolUsage                     Trace all native tool invocations as part of image building. Default: - (disabled).
  -H:TraceObjectInstantiation=<string>*        Comma-separated list of fully-qualified class names that object instantiation is traced for.
  -H:±TraceParserPlugins                       Traces use of plugins during bytecode parsing. Default: - (disabled).
  -H:±TraceSecurityServices                    Enable tracing of security services automatic registration. Default: - (disabled).
  -H:±TraceUnwindStub                          Trace execution of the stub that routes an exception to a handler in the calling frame. Default: - (disabled).
  -H:±TraceVMOperations                        Trace VMOperation execution. Default: - (disabled).
  -H:±TrackAccessChain                         Track the callers for methods and accessing methods for fields. Default: - (disabled).
  -H:±TrackInputFlows                          Track the input for type flows. Default: - (disabled).
  -H:TrackMemUse=...                           Pattern for specifying scopes in which memory use tracking is enabled. See the Dump option for the pattern syntax. An
                                               empty value enables all memory use trackers unconditionally. Default: None
  -H:±TrackNodeInsertion                       Track source stack trace where a node was inserted into the graph. Default: - (disabled).
  -H:±TrackNodeSourcePosition                  Track the NodeSourcePosition. Default: - (disabled).
  -H:±TreatRuntimeCodeInfoReferencesAsWeak     Determines if references from runtime-compiled code to Java heap objects should be treated as strong or weak. Default: +
                                               (enabled).
  -H:TrivialInliningSize=10                    Graphs with less than this number of nodes are trivial and therefore always inlined.
  -H:±TruffleCheckBlackListedMethods           Fail if a method known as not suitable for partial evaluation is reachable for runtime compilation. Default: +
                                               (enabled).
  -H:±TruffleCheckBlockListMethods             Fail if a method known as not suitable for partial evaluation is reachable for runtime compilation. Default: +
                                               (enabled).
  -H:±TruffleCheckFrameImplementation          Enforce that the Truffle runtime provides the only implementation of Frame. Default: + (enabled).
  -H:±TruffleCheckNeverPartOfCompilation       Check that CompilerAsserts.neverPartOfCompilation is not reachable for runtime compilation. Default: + (enabled).
  -H:±TruffleCheckPreinitializedFiles          Check that context pre-initialization does not introduce absolute TruffleFiles into the image heap. Default: +
                                               (enabled).
  -H:TruffleCompilerConfiguration=...          Select a compiler configuration for Truffle compilation (default: use Graal system compiler configuration). Default:
                                               None
  -H:±TruffleHostInlining                      Whether Truffle host inlining is enabled. Default: + (enabled).
  -H:TruffleHostInliningBaseBudget=5000        Maximum budget for Truffle host inlining for runtime compiled methods.
  -H:TruffleHostInliningByteCodeInterpreterBudget=100000
                                               Maximum budget for Truffle host inlining for runtime compiled methods with a BytecodeInterpreterSwitch annotation.
  -H:TruffleHostInliningMaxExplorationDepth=1000
                                               Determines the maximum call depth for exploration during host inlining.
  -H:TruffleHostInliningMaxSubtreeInvokes=20   Maximum number of subtree invokes for a subtree to get inlined until it is considered too complex.
  -H:TruffleHostInliningMinFrequency=0.001     Minimum relative frequency for calls to get inlined. Default 0.001 on HotSpot and no minimum frequency on SVM.
  -H:±TruffleHostInliningPrintExplored         When logging is activated for this phase enables printing of only explored, but ultimately not inlined call trees.
                                               Default: - (disabled).
  -H:±TruffleImmutableFrameFields              Whether Truffle should mark final frame fields as immutable. Default: + (enabled).
  -H:±TruffleInlineDuringParsing               Inline trivial methods in Truffle graphs during native image generation. Default: + (enabled).
  -H:±TruffleMultiThreaded                     Enable support for Truffle background compilation. Default: + (enabled).
  -H:±TrufflePropagateCompilationErrors        Propagate Truffle compilation errors. Default: - (disabled).
  -H:±TruffleTrustedNonNullCast                Whether Truffle trusted non-null casts are enabled. Default: + (enabled).
  -H:±TruffleTrustedTypeCast                   Whether Truffle trusted type casts are enabled. Default: + (enabled).
  -H:±TrustFinalDefaultFields                  Determines whether to treat final fields with default values as constant. Default: + (enabled).
  -H:TypeCheckMaxHints=2                       The maximum number of profiled types that will be used when compiling a profiled type check. Note that
                                               TypeCheckMinProfileHitProbability also influences whether profiling info is used in compiled type checks.
  -H:TypeCheckMinProfileHitProbability=0.5     If the probability that a type check will hit one the profiled types (up to TypeCheckMaxHints) is below this value, the
                                               type check will be compiled without profiling info.
  -H:TypeFlowSaturationCutoff=20               The maximum number of types recorded in a type flow. -1 indicates no limitation.
  -H:±UnresolvedIsError                        Report unresolved elements as errors. Default: + (enabled).
  -H:UnrollMaxIterations=16                    
  -H:UnsafeAutomaticSubstitutionsLogLevel=1    Unsafe automatic substitutions logging level: Disabled=0, Basic=1, Info=2, Debug=3.).
  -H:±UnsafeOffsetWarningsAreFatal             Print unsafe operation offset warnings.). Default: - (disabled).
  -H:±UseApplicationCodeSourceLocation         Return the application path as the Class.getProtectionDomain().getCodeSource().getLocation() for all classes that have
                                               no explicit ProtectionDomain. 
  -H:±UseBranchesWithin32ByteBoundary          Force branch instructions to align with 32-bytes boundary, to mitigate the jcc erratum. See
                                               https://www.intel.com/content/dam/support/us/en/documents/processors/mitigations-jump-conditional-code-erratum.pdf for
                                               more details. If not set explicitly, the default value will be determined according to the CPU model. Default: -
                                               (disabled).
  -H:±UseCAPCache                              Indicate the C Annotation Processor to use previously cached native information when generating C Type information.
                                               Default: - (disabled).
  -H:±UseCalleeSavedRegisters                  Use callee saved registers to reduce spilling for low-frequency calls to stubs (if callee saved registers are supported
                                               by the architecture). Default: + (enabled).
  -H:±UseCompilationStatistics                 Enables CompilationStatistics. Default: - (disabled).
  -H:±UseContainerSupport                      Enable detection and runtime container configuration support. Default: + (enabled).
  -H:±UseDedicatedVMOperationThread            Determines if VM operations should be executed in a dedicated thread. Default: - (disabled).
  -H:±UseDeprecatedOldClassInitialization      Use the old class initialization strategy that does not allow all classes to be used at image build time. Default: -
                                               (disabled).
  -H:±UseDirectCallTrampolinesALot             Force many trampolines to be needed for inter-method calls. Normally trampolines are only used when a method destination
                                               is outside the range of a pc-relative branch instruction. Default: - (disabled).
  -H:±UseEpsilonGC                             Use a no-op GC. Default: - (disabled).
  -H:±UseExceptionProbability                  Default: + (enabled).
  -H:±UseExperimentalReachabilityAnalysis      Use experimental Reachability Analysis instead of points-to. Default: - (disabled).
  -H:±UseImagebuildDebugSections               Emit debuginfo debug.svm.imagebuild.* sections with detailed image-build options. Default: + (enabled).
  -H:±UseLLVMDataSection                       Use LLVM to emit data section. Default: - (disabled).
  -H:UseLibC=...                               Selects the libc implementation to use. Available implementations: glibc, musl, bionic. Default: None
  -H:±UseLoopEndFrequencies                    Derive loop frequencies only from backedge frequencies instead of from loop exit frequencies. Default: - (disabled).
  -H:±UseLoopLimitChecks                       Default: + (enabled).
  -H:±UseNullRegion                            Determines if a null region is present between the heap base and the image heap. Default: + (enabled).
  -H:±UseReachabilityMethodSummaries           Use method summaries for Reachability Analysis. Default: - (disabled).
  -H:±UseRememberedSet                         Determines if a remembered sets is used, which is necessary for collecting the young and old generation independently.
                                               Default: + (enabled).
  -H:±UseSerialGC                              Use a serial GC. Default: + (enabled).
  -H:±UseServiceLoaderFeature                  Automatically register services for run-time lookup using ServiceLoader. Default: + (enabled).
  -H:±UseSnippetGraphCache                     Use a cache for snippet graphs. Default: + (enabled).
  -H:±UseSnippetTemplateCache                  Use a LRU cache for snippet templates. Default: + (enabled).
  -H:±UseTrappingNullChecks                    Use traps for null checks instead of explicit null-checks. Default: + (enabled).
  -H:±UseTypeCheckHints                        Default: + (enabled).
  -H:UsedEdenProportionThreshold=0.75          Ratio of used bytes to total allocated bytes for eden space. Setting it to a smaller value will trade more triggered
                                               hinted GCs for less resident set size.
  -H:Verify=...                                Pattern for specifying scopes in which logging is enabled. See the Dump option for the pattern syntax. Default: None
  -H:±VerifyAfterGC                            Verify the heap after doing a garbage collection if VerifyHeap is enabled. Serial GC only. Default: + (enabled).
  -H:±VerifyBalancedMonitors                   Emit extra code to dynamically check monitor operations are balanced. Default: - (disabled).
  -H:±VerifyBeforeGC                           Verify the heap before doing a garbage collection if VerifyHeap is enabled. Serial GC only. Default: + (enabled).
  -H:±VerifyDeoptimizationEntryPoints          Verify that all possible deoptimization entry points have been properly compiled and registered in the metadata.
                                               Default: - (disabled).
  -H:±VerifyGraalGraphEdges                    Perform expensive verification of graph inputs, usages, successors and predecessors. Default: - (disabled).
  -H:±VerifyGraalGraphs                        Verify graphs often during compilation when assertions are turned on. Default: + (enabled).
  -H:±VerifyGraalPhasesSize                    Verify before - after relation of the relative, computed, code size of a graph. Default: - (disabled).
  -H:±VerifyHeap                               Verify the heap before and after each collection. Default: - (disabled).
  -H:±VerifyHeapAtReturn                       Perform platform dependent validation of the Java heap at returns. Default: - (disabled).
  -H:±VerifyKillCFGUnusedNodes                 Verify that there are no new unused nodes when performing killCFG. Default: - (disabled).
  -H:±VerifyNamingConventions                  Verify naming conventions during image construction. Default: - (disabled).
  -H:±VerifyPhases                             Default: - (disabled).
  -H:±VerifyReferences                         Verify all object references if VerifyHeap is enabled. Serial GC only. Default: + (enabled).
  -H:±VerifyReferencesPointIntoValidChunk      Verify that object references point into valid heap chunks if VerifyHeap is enabled. Serial GC only. Default: -
                                               (disabled).
  -H:±VerifyRememberedSet                      Verify the remembered set if VerifyHeap is enabled. Serial GC only. Default: + (enabled).
  -H:±VerifyTypes                              Verify type states computed by the static analysis at run time. This is useful when diagnosing problems in the static
                                               analysis, but reduces peak performance significantly. Default: - (disabled).
  -H:±VerifyWriteBarriers                      Verify write barriers. Serial GC only. Default: - (disabled).
  -H:±WarnAboutCodeSignatureMismatch           Print to stdout when a compilation performed with different profiles generates different backend code. Default: +
                                               (enabled).
  -H:±WarnAboutGraphSignatureMismatch          Print to stdout when a compilation performed with different profiles generates different frontend IR. Default: +
                                               (enabled).
  -H:±WarnAboutNotCachedLoadedAccess           Print to stdout when requesting profiling info not present in a loaded profile. Default: + (enabled).
  -H:±WarnMissingIntrinsic                     Print a warning when a missing intrinsic is seen. Default: - (disabled).
  -H:±ZapChunks                                Fill unused memory chunks with a sentinel value. Serial and epsilon GC only. Default: - (disabled).
  -H:±ZapConsumedHeapChunks                    After use, Fill memory chunks with a sentinel value. Serial and epsilon GC only. Default: - (disabled).
  -H:±ZapProducedHeapChunks                    Before use, fill memory chunks with a sentinel value. Serial and epsilon GC only. Default: - (disabled).
  -H:±ZapStackOnMethodEntry                    Default: - (disabled).
  -R:±AbortOnBenchmarkCounterOverflow          Abort VM with SIGILL if benchmark counters controlled by the (Generic|Timed|Benchmark)DynamicCounters. Default: -
                                               (disabled). [Extra help available]
  -R:ActiveProcessorCount=-1                   Overwrites the available number of processors provided by the OS. Any value <= 0 means using the processor count from
                                               the OS.
  -R:AggregatedMetricsFile=...                 File to which aggregated metrics are dumped at shutdown. A CSV format is used if the file ends with .csv otherwise a
                                               more human readable format is used. If not specified, metrics are dumped to the console. Default: None
  -R:±AliasArrayTypeFlows                      Model all array type flows using a unique elements type flow abstraction. Default: + (enabled).
  -R:AllocationProfilingThreshold=1048576      The minimum size in bytes required for printing an allocation profiling entry.
  -R:±AllocationSiteSensitiveHeap              A context sensitive heap means that each heap allocated object is modeled by using at least the allocation site.
                                               Default: - (disabled).
  -R:±AlwaysInlineIntrinsics                   Unconditionally inline intrinsics. Default: - (disabled).
  -R:±AlwaysInlineVTableStubs                  Default: - (disabled).
  -R:AnalysisContextSensitivity="insens"       Controls the static analysis context sensitivity. Available values: insens (context insensitive analysis), allocsens
                                               (context insensitive analysis, context insensitive heap, allocation site sensitive heap), _1obj (1 object sensitive
                                               analysis with a context insensitive heap), _2obj1h (2 object sensitive with a 1 context sensitive heap).
  -R:AnalysisSizeCutoff=8                      The maximum size of type and method profiles returned by the static analysis. -1 indicates no limitation.
  -R:ArrayRegionEqualsConstantLimit=4096       Array region equality checks will be evaluated at compile time if the receiver is a constant and its length is smaller
                                               than this value.
  -R:±AutomaticReferenceHandling               Determines if the reference handling is executed automatically or manually. Default: + (enabled).
  -R:±BenchmarkCounterPrintingCutoff           Use a cutoff to print only most significant counters. Default: + (enabled).
  -R:±BenchmarkCountersDumpDynamic             Dump dynamic counters. Default: + (enabled).
  -R:±BenchmarkCountersDumpStatic              Dump static counters. Default: - (disabled).
  -R:BenchmarkCountersFile=...                 File to which benchmark counters are dumped. A CSV format is used if the file ends with .csv otherwise a more human
                                               readable format is used. The fields in the CSV format are: category, group, name, value. Default: None
  -R:BenchmarkDynamicCounters=...              Turn on the benchmark counters. The format of this option is:. Default: None [Extra help available]
  -R:±BootstrapInitializeOnly                  Do not compile anything on bootstrap but just initialize the compiler. Default: - (disabled).
  -R:BootstrapTimeout=15.0                     Maximum time in minutes to spend bootstrapping (0 to disable this limit).
  -R:BootstrapWatchDogCriticalRateRatio=0.25   Ratio of the maximum compilation rate below which the bootstrap compilation rate must not fall (0 or less disables
                                               monitoring).
  -R:±CanonicalGraphStringsCheckConstants      Exclude virtual nodes when dumping canonical text for graphs. Default: - (disabled).
  -R:±CanonicalGraphStringsExcludeVirtuals     Exclude virtual nodes when dumping canonical text for graphs. Default: + (enabled).
  -R:±CanonicalGraphStringsRemoveIdentities    Attempts to remove object identity hashes when dumping canonical text for graphs. Default: + (enabled).
  -R:±ClearMetricsAfterBootstrap               Clear the debug metrics after bootstrap. Default: - (disabled).
  -R:±CollectImageBuildStatistics              Collect information during image build about devirtualized invokes and bytecode exceptions. Default: - (disabled).
  -R:±CollectYoungGenerationSeparately         Determines if a full GC collects the young generation separately or together with the old generation. Serial GC only. 
  -R:±CompilationBailoutAsFailure              Treat compilation bailouts like compilation failures. Default: - (disabled).
  -R:CompilationCountLimit=0                   The number of compilations allowed for any method before the VM exits (a value of 0 means there is no limit).
  -R:CompilationExcludePhases=...              Exclude certain phases from compilation, either unconditionally or with a method filter. Multiple exclusions can be
                                               specified separated by ':'. Phase names are matched as substrings, e.g.:
                                               CompilationExcludePhases=PartialEscape:Loop=A.*,B.foo excludes PartialEscapePhase from all compilations and any phase
                                               containing 'Loop' in its name from compilations of all methods in class A and of method B.foo. Default: None
  -R:CompilationExpirationPeriod=300.0         Time limit in seconds before a compilation expires (0 to disable the limit). A non-zero value for this option is doubled
                                               if assertions are enabled and quadrupled if DetailedAsserts is true.
  -R:CompilationFailureAction=Silent           Specifies the action to take when compilation fails. [Extra help available]
  -R:CompilationIsolateAddressSpaceSize=0      Size of the reserved address space of each compilation isolate (0: default for new isolates).
  -R:CompilationWatchDogStartDelay=0           Delay in seconds before watch dog monitors a compilation (0 disables monitoring).
  -R:CompilationWatchDogVMExitDelay=0          Number of seconds after which a compilation appearing to make no progress causes the VM to exit (0 disables VM exiting).
  -R:±CompileGraalWithC1Only                   In tiered mode compile Graal and JVMCI using optimized first tier code. Default: + (enabled).
  -R:±CompileInIsolates                        Activate runtime compilation in separate isolates (enable support during image build with option
                                               SupportCompileInIsolates). Default: + (enabled).
  -R:CompilerConfiguration=...                 Names the compiler configuration to use. If omitted, the compiler configuration with the highest auto-selection priority
                                               is used. To see the set of available configurations, supply the value 'help' to this option. Default: None
  -R:±ConditionalElimination                   Default: + (enabled).
  -R:±ConditionalEliminationBeforeAnalysis     Run conditional elimination before static analysis. Default: + (enabled).
  -R:ConditionalEliminationMaxIterations=4     
  -R:Count=...                                 Pattern for specifying scopes in which counters are enabled. See the Dump option for the pattern syntax. An empty value
                                               enables all counters unconditionally. Default: None
  -R:Counters=...                              Comma separated names of counters that are enabled irrespective of the value for Count option. An empty value enables
                                               all counters unconditionally. Default: None
  -R:CrashAt=...                               Pattern for method(s) that will trigger an exception when compiled. This option exists to test handling compilation
                                               crashes gracefully. See the MethodFilter option for the pattern syntax. A ':Bailout' suffix will raise a bailout
                                               exception and a ':PermanentBailout' suffix will raise a permanent bailout exception. Default: None
  -R:±DebugStubsAndSnippets                    Enable debug output for stub code generation and snippet preparation. Default: - (disabled).
  -R:DefaultLoopFrequency=100.0                Default frequency for loops with unknown local frequency.
  -R:DefaultUnswitchFactor=0.7                 Default unswitching factor for control split node with unkown profile data.
  -R:±DeoptALot                                Default: - (disabled).
  -R:±DeoptAfterOSR                            Deoptimize OSR compiled code when the OSR entry loop is finished if there is no mature profile available for the rest of
                                               the method. Default: + (enabled).
  -R:DeoptsToDisableOptimisticOptimization=40  
  -R:±DetailedAsserts                          Enable expensive assertions if normal assertions (i.e. -ea or -esa) are enabled. Default: - (disabled).
  -R:DiagnoseDumpLevel=3                       Specify the dump level if CompilationFailureAction#Diagnose is used.See CompilationFailureAction for details.
                                               file:doc-files/CompilationFailureActionHelp.txt.
  -R:DiagnosticDetails=""                      Specifies how many details are printed for certain diagnostic thunks, e.g.: 'DumpThreads:1,DumpRegisters:2'. A value of
                                               1 will result in the maximum amount of information, higher values will print less information. By default, the most
                                               detailed output is enabled for all diagnostic thunks. Wildcards (*) are supported in the name of the diagnostic thunk.
  -R:±DisableABCE                              Disable array bounds check elimations. Default: + (enabled).
  -R:±DisableExplicitGC                        Ignore calls to System.gc(). Default: - (disabled).
  -R:±DisableIntercept                         Disable intercepting exceptions in debug scopes. Default: - (disabled).
  -R:DisableIntrinsics=...                     Disable intrinsics matching the given method filter (see MethodFilter option for details). For example,
                                               'DisableIntrinsics=String.equals' disables intrinsics for any method named 'equals' in a class whose simple name is
                                               'String'. You can append ':verbose' at the end of the filter value to print out disabled intrinsics as they are
                                               encountered during compilation (e.g., 'String.equals:verbose'). Default: None
  -R:Dump=...                                  Filter pattern for specifying scopes in which dumping is enabled. Default: None [Extra help available]
  -R:±DumpAfterEveryBCI                        Dump the current graph after every bci to IGV. Default: - (disabled).
  -R:±DumpEndVersusExitLoopFrequencies         Debug flag to dump loop frequency differences computed based on loop end or exit nodes.If the frequencies diverge a lot,
                                               this may indicate missing profiles on control flowinside the loop body. Default: - (disabled).
  -R:±DumpHeapAndExit                          Create a heap dump and exit. Default: - (disabled).
  -R:±DumpOnError                              Send compiler IR to dump handlers on error. Default: - (disabled).
  -R:DumpOnPhaseChange=...                     Dump a before and after graph if the named phase changes the graph.%nThe argument is substring matched against the
                                               simple name of the phase class. Default: None
  -R:DumpPath="graal_dumps"                    The directory where various Graal dump files are written.
  -R:±DumpingErrorsAreFatal                    Treat any exceptions during dumping as fatal. Default: - (disabled).
  -R:±DynamicCountersPrintGroupSeparator       Use grouping separators for number printing. Default: + (enabled).
  -R:±EagerSnippets                            Eagerly construct extra snippet info. Default: - (disabled).
  -R:±EarlyCodeEmissionOrder                   Enable early code emission order computation instead of late code emission order computation. Default: - (disabled).
  -R:±EarlyGVN                                 Perform early global value numbering. Default: + (enabled).
  -R:±EarlyLICM                                Perform early loop invariant code motion. Default: + (enabled).
  -R:±EmitStringSubstitutions                  Emit substitutions for String methods. Default: + (enabled).
  -R:±EnableSignalHandling                     Enables signal handling. 
  -R:±EscapeAnalysisBeforeAnalysis             Run partial escape analysis on compiler graphs before static analysis. Default: + (enabled).
  -R:EscapeAnalysisIterations=2                
  -R:EscapeAnalysisLoopCutoff=20               
  -R:EscapeAnalyzeOnly=...                     Default: None
  -R:ExactFullUnrollMaxNodes=800               
  -R:ExactPartialUnrollMaxNodes=200            
  -R:±ExhaustiveHeapScan                       Scan all objects reachable from roots for analysis. By default false. Default: - (disabled).
  -R:±ExitOnOutOfMemoryError                   Exit on the first occurrence of an out-of-memory error that is thrown because the Java heap is out of memory. Default: -
                                               (disabled).
  -R:±ExtendedAsserts                          Enable extended asserts which slow down analysis. Default: - (disabled).
  -R:±FailedLoopExplosionIsFatal               Do not bail out but throw an exception on failed loop explosion. Default: - (disabled).
  -R:FallbackExecutorRuntimeJavaArg=<string>*  Internal option used to specify runtime java arguments for FallbackExecutor.
  -R:±FlightRecorder                           Enable Java Flight Recorder. Default: - (disabled).
  -R:FlightRecorderLogging="all=warning"       Usage: -XX:FlightRecorderLogging=[tag1[+tag2...][*][=level][,...]]. [Extra help available]
  -R:±FloatingDivNodes                         Try to float non-constant division operations to expose global value numbering of divisions. Default: + (enabled).
  -R:±ForceAdversarialLayout                   Place N-byte constants in the data section such that they are misaligned with respect to N*2. For example, place 4 byte
                                               constants at offset 4, 12 or 20, etc. This layout is used to detect instructions that load constants with alignment
                                               smaller than the fetch size. For instance, an XORPS instruction that does a 16-byte fetch of a 4-byte float not aligned
                                               to 16 bytes will cause a segfault. Default: - (disabled).
  -R:±ForceDumpGraphsBeforeCompilation         Force-dump graphs before compilation. Default: - (disabled).
  -R:±ForceExplicitReachabilityFence           Force an explicit compiler node for Reference.reachabilityFence, instead of relying on FrameState liveness. Default: -
                                               (disabled).
  -R:±FullUnroll                               Default: + (enabled).
  -R:FullUnrollCodeSizeBudgetFactorForLargeGraphs=2.0
                                               Maximum factor by which full unrolling can increase code size for large graphs. The FullUnrollSmallGraphThreshold option
                                               determines which graphs are small.
  -R:FullUnrollCodeSizeBudgetFactorForSmallGraphs=10.0
                                               Maximum factor by which full unrolling can increase code size for small graphs. The FullUnrollSmallGraphThreshold option
                                               determines which graphs are small.
  -R:FullUnrollConstantCompareBoost=15         
  -R:FullUnrollMaxApplication=60               
  -R:FullUnrollMaxIterations=600               
  -R:FullUnrollMaxNodes=400                    
  -R:FullUnrollSmallGraphThreshold=1000        The threshold in terms of NodeSize for a graph to be considered small for the purpose of full unrolling. Applied in
                                               conjunction with the FullUnrollCodeSizeBudgetFactorForSmallGraphs and FullUnrollCodeSizeBudgetFactorForLargeGraphs
                                               options.
  -R:GCDebugStartCycle=-1                      Start tracing compiled GC barriers after N garbage collections (disabled if N <= 0).
  -R:±GenLoopSafepoints                        Default: + (enabled).
  -R:±GenericDynamicCounters                   Turn on the benchmark counters, and displays the results on VM shutdown. Default: - (disabled).
  -R:±GraalArithmeticStubs                     Use Graal arithmetic stubs instead of HotSpot stubs where possible. Default: + (enabled).
  -R:GraalCompileOnly=...                      A filter applied to a method the VM has selected for compilation by Graal. A method not matching the filter is
                                               redirected to a lower tier compiler. The filter format is the same as for the MethodFilter option. Default: None
  -R:GraphCompressionThreshold=70              Graal graph compression is performed when percent of live nodes falls below this value.
  -R:±GuardPriorities                          Default: + (enabled).
  -R:HeapDumpPath=""                           The path (filename or directory) where heap dumps are created (defaults to the working directory).
  -R:HeapVerifierVerbosity=0                   Control heap verifier verbosity level: 0 - quiet, 1 - info, 2 - warning, 3 - all.
  -R:HotCodeMinSelfTime=0.001                  Minimal self time for a compilation unit to be considered hot globally.
  -R:±HotSpotDeoptExplicitExceptions           Testing only option that forces deopts for exception throws. Default: - (disabled).
  -R:±HotSpotPostOnExceptions                  Testing only option that forces deopts for exception throws. Default: - (disabled).
  -R:±HotSpotPrintInlining                     Print inlining optimizations. Default: - (disabled).
  -R:±HybridStaticContext                      Enable hybrid context for static methods, i.e. uses invocation site as context for static methods. Default: -
                                               (disabled).
  -R:ImageObjectTreeExpandRoots=""             Override the default suppression of specified roots. See: Reports.md.
  -R:ImageObjectTreeExpandTypes=""             Override the default suppression of specified types. See: Reports.md.
  -R:ImageObjectTreeSuppressRoots=""           Suppress the expansion of specified roots. See: Reports.md.
  -R:ImageObjectTreeSuppressTypes=""           Suppress the expansion of specified types. See: Reports.md.
  -R:InjectedCompilationDelay=0                The number of seconds by which to slow down each compilation. The compilations slowed down can be restricted with
                                               MethodFilter. This option exists to test the compilation watchdog.
  -R:±Inline                                   Enable inlining. Default: + (enabled).
  -R:±InlineBeforeAnalysis                     Inline methods before static analysis. Default: + (enabled).
  -R:±InlineDuringParsing                      Inlines trivial methods during bytecode parsing. Default: + (enabled).
  -R:InlineDuringParsingMaxDepth=10            Maximum depth when inlining during bytecode parsing.
  -R:±InlineEverything                         Default: - (disabled).
  -R:±InlineGraalStubs                         Embed all the emitted code for Graal-generated stubs. Default: - (disabled).
  -R:±InlineMegamorphicCalls                   Inline calls with megamorphic type profile (i.e., not all types could be recorded). Default: + (enabled).
  -R:±InlineMonomorphicCalls                   Inline calls with monomorphic type profile. Default: + (enabled).
  -R:±InlinePartialIntrinsicExitDuringParsing  Inlines partial intrinsic exits during bytecode parsing when possible. A partial intrinsic exit is a call within an
                                               intrinsic to the method being intrinsified and denotes semantics of the original method that the intrinsic does not
                                               support. Default: + (enabled).
  -R:±InlinePolymorphicCalls                   Inline calls with polymorphic type profile. Default: + (enabled).
  -R:±InlineVTableStubs                        Default: + (enabled).
  -R:InliningDepthError=1000                   Maximum inlining depth during partial evaluation before reporting an infinite recursion.
  -R:InspectServerContentPath="inspect"        Path to the contents of the Inspect web server.
  -R:±InstallSegfaultHandler                   Install segfault handler that prints register contents and full Java stacktrace. Default: enabled for an executable,
                                               disabled for a shared library, disabled when EnableSignalHandling is disabled. 
  -R:±InterceptBailout                         Intercept also bailout exceptions. Default: - (disabled).
  -R:±Intrinsify                               Use compiler intrinsifications. Default: + (enabled).
  -R:IsolatedLoopHeaderAlignment=32            Alignment in bytes for loop header blocks that have no fall through paths.
  -R:IterativePeelingLimit=2                   Allow iterative peeling of loops up to this many times (each time the peeling phase runs).
  -R:±LIRDynMoveProfileMethod                  Enable dynamic move profiling per method. Default: - (disabled).
  -R:LIRInstructionVerifierPath=...            Path to jar file containing LIR instruction verifier. Default: None
  -R:±LIROptConstantLoadOptimization           Enable constant load optimization. 
  -R:±LIROptControlFlowOptimizer               
  -R:±LIROptEdgeMoveOptimizer                  
  -R:±LIROptLSRAEliminateSpillMoves            Enable spill move elimination. 
  -R:±LIROptLSRAOptimizeSpillPosition          Enable spill position optimization. 
  -R:±LIROptLSStackSlotAllocator               Use linear scan stack slot allocation. 
  -R:±LIROptNullCheckOptimizer                 
  -R:±LIROptRedundantMoveElimination           
  -R:±LIROptStackMoveOptimizer                 
  -R:±LIROptimization                          Enable LIR level optimizations. Default: + (enabled).
  -R:±LIRProfileMethods                        Enables profiling of methods. Default: - (disabled).
  -R:±LIRProfileMoves                          Enables profiling of move types on LIR level. Move types are for example stores (register to stack), constant loads
                                               (constant to register) or copies (register to register). Default: - (disabled).
  -R:±LSRAOptSplitOnly                         LSRA optimization: Only split but do not reassign. Default: - (disabled).
  -R:±LSRAOptimization                         Enable LSRA optimization. Default: - (disabled).
  -R:LimitInlinedInvokes=5.0                   
  -R:±LimitObjectArrayLength                   Enable a limit for the number of objects recorded for each type of a type state before disabling heap sensitivity for
                                               that type. The analysis must be heap sensitive. Default: - (disabled).
  -R:±ListMetrics                              Lists on the console at VM shutdown the metric names available to the Timers, Counters and MemUseTrackers options. Note
                                               that this only lists the metrics that were initialized during the VM execution and so will not include metrics for
                                               compiler code that is not executed. Default: - (disabled).
  -R:±LoadExceptionObjectInVM                  Use a VM runtime call to load and clear the exception object from the thread at the start of a compiled exception
                                               handler. Default: - (disabled).
  -R:LoadProfiles=...                          Load per compilation profile information. Default: None
  -R:Log=...                                   Pattern for specifying scopes in which logging is enabled. See the Dump option for the pattern syntax. Default: None
  -R:LogFile=...                               File to which logging is sent.  A %p in the name will be replaced with a string identifying the process, usually the
                                               process id and %t will be replaced by System.currentTimeMillis(). If the current runtime is in an isolate, then %i will
                                               be replaced by '<isolate id>' otherwise %i is removed. An %I is the same as %i except that the replacement is '<isolate
                                               id>@<isolate address>'. Using %o as filename sends logging to System.out whereas %e sends logging to System.err.
                                               Default: None
  -R:±LogVerbose                               Enable more verbose log output when available. Default: - (disabled).
  -R:LoopExitVsLoopEndFrequencyDiff=1000.0     Scaling factor of frequency difference computed based on loop ends or exits.
  -R:LoopHeaderAlignment=16                    Alignment in bytes for loop header blocks.
  -R:LoopMaxUnswitch=3                         
  -R:±LoopOnFatalError                         Execute an endless loop before printing diagnostics for a fatal error. Default: - (disabled).
  -R:±LoopPeeling                              Default: + (enabled).
  -R:±LoopPredication                          Hoists array bounds checks out of simple loops. This is ignored if SpeculativeGuardMovement is enabled. Default: +
                                               (enabled).
  -R:±LoopPredicationMainPath                  Restricts LoopPredication to only focus on array bounds checks that dominate the back edge of a loop. Default: +
                                               (enabled).
  -R:±LoopUnswitch                             Default: + (enabled).
  -R:LoopUnswitchFrequencyBoost=20.0           Number of nodes allowed for a loop unswitching per loop frequency. The number of nodes allowed for the unswitching is
                                               proportional to the relative frequency of the loop by this constant.
  -R:LoopUnswitchFrequencyMaxFactor=0.95       Maximun value for the frequency factor of an invariant.
  -R:LoopUnswitchFrequencyMinFactor=0.05       Minimum value for the frequency factor of an invariant.
  -R:LoopUnswitchMaxIncrease=2000              Maximum loop unswitching code size increase in nodes.
  -R:LoopUnswitchMinSplitFrequency=1.0         Lower bound for the minimun frequency of an invariant condition to be unswitched.
  -R:LoopUnswitchTrivial=20                    Number of nodes allowed for a loop unswitching regardless of the loop frequency.
  -R:±MatchExpressions                         Allow backend to match complex expressions. Default: + (enabled).
  -R:MaxCallingContextDepth=0                  The maximum length of the methods context chains.
  -R:MaxCallingContextWidth=0                  The maximum number of contexts to record for a method. It only affects the analysis when the max and min calling context
                                               depth are different.
  -R:MaxCompilationProblemsPerAction=2         The maximum number of compilation failures to handle with the action specified by CompilationFailureAction before
                                               changing to a less verbose action. This does not apply to the ExitVM action.
  -R:MaxConstantObjectsPerType=0               The maximum number of constant objects recorded for each type before merging the constants into one unique constant
                                               object per type. If the value is 0 there is no limit.
  -R:MaxDirectMemorySize=0                     Maximum total size of NIO direct-buffer allocations.
  -R:MaxDuplicationFactor=2.0                  Max amount of extra effort to expend handling irreducible loops. A value <= 1 disables support for irreducible loops.
  -R:MaxHeapContextDepth=0                     The maximum length of the context used to model a heap object in addition to the allocation site; used only when
                                               ContextSensitiveHeap is enabled.
  -R:MaxHeapContextWidth=0                     The maximum number of contexts to record for a heap object.  It only affects the analysis when the max and min calling
                                               context depth are different.
  -R:MaxHeapFree=0                             The maximum free bytes reserved for allocations, in bytes (0 for automatic according to GC policy). Serial GC only.
  -R:MaxHeapSize=0                             The maximum heap size at run-time, in bytes.
  -R:MaxJavaStackTraceDepth=1024               The maximum number of lines in the stack trace for Java exceptions (0 means all).
  -R:MaxNewSize=0                              The maximum size of the young generation at run-time, in bytes.
  -R:MaxObjectSetSize=100                      The maximum number of objects recorded for each type of a type state before disabling heap sensitivity for that type.
                                               The analysis must be heap sensitive. It has a minimum value of 1.
  -R:MaxTemplatesPerSnippet=50                 
  -R:MaxUnswitchSuccessors=64                  Maximum number of split successors before aborting unswitching.
  -R:MaximumDesiredSize=20000                  Maximum desired size of the compiler graph in nodes.
  -R:MaximumEscapeAnalysisArrayLength=128      The maximum length of an array that will be escape analyzed.
  -R:MaximumHeapSizePercent=80                 The maximum heap size as percent of physical memory. Serial and epsilon GC only.
  -R:MaximumInliningSize=300                   Inlining is explored up to this number of nodes in the graph for each call site.
  -R:MaximumLoopExplosionCount=10000           Max number of loop explosions per method.
  -R:MaximumRecursiveInlining=5                Maximum level of recursive inlining.
  -R:MaximumYoungGenerationSizePercent=10      The maximum size of the young generation as a percentage of the maximum heap size. Serial and epsilon GC only.
  -R:MegamorphicInliningMinMethodProbability=0.33
                                               Minimum probability for methods to be inlined for megamorphic type profiles.
  -R:MemUseTrackers=...                        Comma separated names of memory usage trackers that are enabled irrespective of the value for TrackMemUse option. An
                                               empty value enables all memory usage trackers unconditionally. Default: None
  -R:MethodFilter=...                          Pattern for matching methods. The syntax for a pattern is:. Default: None [Extra help available]
  -R:±MethodFilterRootOnly                     Only check MethodFilter against the root method in the context if true, otherwise check all methods. Default: -
                                               (disabled).
  -R:MethodInlineBailoutLimit=5000             Per-compilation method inlining exploration limit before giving up (use 0 to disable).
  -R:MetricsFile=...                           File to which metrics are dumped per compilation. Default: None [Extra help available]
  -R:MinCallingContextDepth=0                  The minimum length of the methods context chains.
  -R:MinHeapContextDepth=0                     The minimum length of the context used to model a heap object in addition to the allocation site; used only when
                                               ContextSensitiveHeap is enabled.
  -R:MinHeapSize=0                             The minimum heap size at run-time, in bytes.
  -R:MinimalBulkZeroingSize=2048               If applicable, use bulk zeroing instructions when the zeroing size in bytes exceeds this threshold.
  -R:MinimalGraphNodeSizeCheckSize=1000        Minimal size in NodeSize to check the graph size increases of phases.
  -R:MinimumPeelFrequency=0.35                 
  -R:±MoveGuardsUpwards                        Move guard nodes to earlier places in the dominator tree if all successors of basic block share a common guard
                                               condition. Default: + (enabled).
  -R:NDCV=0                                    Run level for NoDeadCodeVerifyHandler (0 = off, 1 = info, 2 = verbose, 3 = fatal).
  -R:ObjdumpExecutables=...                    Comma separated list of candidate GNU objdump executables. If not specified, disassembling via GNU objdump is disabled.
                                               Otherwise, the first existing executable in the list is used. Default: None
  -R:±OmitHotExceptionStacktrace               Default: - (disabled).
  -R:±OptAssumptions                           Default: + (enabled).
  -R:±OptConvertDeoptsToGuards                 Default: + (enabled).
  -R:±OptDeoptimizationGrouping                Default: + (enabled).
  -R:±OptDevirtualizeInvokesOptimistically     Default: + (enabled).
  -R:±OptEarlyReadElimination                  Default: + (enabled).
  -R:±OptEliminateGuards                       Default: + (enabled).
  -R:±OptFloatingReads                         Default: + (enabled).
  -R:±OptImplicitNullChecks                    Default: + (enabled).
  -R:±OptReadElimination                       Default: + (enabled).
  -R:±OptScheduleOutOfLoops                    Default: + (enabled).
  -R:OptimizationLog=...                       Enable the structured optimization log and specify where it is printed. Default: None [Extra help available]
  -R:OptimizationLogPath=...                   Path to the directory where the optimization log is saved if OptimizationLog is set to Directory. Directories are
                                               created if they do no exist. Default: None
  -R:±OptimizeReturnedParameter                Analysis: Detect methods that return one of their parameters and hardwire the parameter straight to the return. Default:
                                               + (enabled).
  -R:±OverrideProfiles                         Allow multiple compilations of the same method by overriding existing profiles. Default: - (disabled).
  -R:ParsingContextMaxDepth=100                Limit the parsing context depth. Default value is arbitrary set at 100.
  -R:±PartialEscapeAnalysis                    Default: + (enabled).
  -R:±PartialUnroll                            Default: + (enabled).
  -R:±PeelALot                                 Default: - (disabled).
  -R:PercentTimeInIncrementalCollection=50     Percentage of total collection time that should be spent on young generation collections. Serial GC with collection
                                               policy 'BySpaceAndTime' only.
  -R:PerfDataMemorySize=32768                  Size of performance data memory region. Will be rounded up to a multiple of the native os page size.
  -R:PerfDataSamplingInterval=200              Jvmstat instrumentation sampling interval (in milliseconds).
  -R:PerfMaxStringConstLength=1024             Maximum PerfStringConstant string length before truncation.
  -R:±PreferUnsignedComparison                 Rewrite signed comparisons to unsigned ones if the result is equal. Default: + (enabled).
  -R:±PrintAnalysisCallTree                    Print analysis call tree, a breadth-first tree reduction of the call graph. Default: - (disabled).
  -R:PrintAnalysisCallTreeType=TXT             Change the output format of the analysis call tree, available options are TXT and CSV. See: Reports.md.
  -R:±PrintAnalysisStatistics                  Print analysis results statistics. Default: - (disabled).
  -R:±PrintBBInfo                              Enables dumping of basic blocks relative PC and frequencies in the dump directory. Default: - (disabled).
  -R:±PrintBackendCFG                          Enable dumping scheduled HIR, LIR, register allocation and code generation info to the C1Visualizer. Default: -
                                               (disabled).
  -R:±PrintBlockMapping                        Enable dumping CFG built during initial BciBlockMapping. Default: - (disabled).
  -R:±PrintCallEdges                           Print call edges with other analysis results statistics. Default: - (disabled).
  -R:PrintCanonicalGraphStringFlavor=0         Choose format used when dumping canonical text for graphs: 0 gives a scheduled graph (better for spotting changes
                                               involving the schedule) while 1 gives a CFG containing expressions rooted at fixed nodes (better for spotting small
                                               structure differences).
  -R:±PrintCanonicalGraphStrings               Enable dumping canonical text from for graphs. Default: - (disabled).
  -R:±PrintCompilation                         Print an informational line to the console for each completed compilation. Default: - (disabled).
  -R:±PrintDetailedAllocationProfiling         Print detailed information for each allocation site. Default: + (enabled).
  -R:PrintFlags=...                            Show available options based on comma-separated option-types (allowed categories: User, Expert, Debug). Default: None
  -R:PrintFlagsWithExtraHelp=...               Print extra help, if available, based on comma-separated option names. Pass * to show all options that contain extra
                                               help. Default: None
  -R:±PrintGC                                  Print summary GC information after each collection. Default: - (disabled).
  -R:±PrintGCSummary                           Print summary GC information after application main method returns. Serial GC only. Default: - (disabled).
  -R:±PrintGCTimeStamps                        Print a time stamp at each collection, if +PrintGC or +VerboseGC. Serial GC only. Default: - (disabled).
  -R:±PrintGCTimes                             Print the time for each of the phases of each collection, if +VerboseGC. Serial GC only. Default: - (disabled).
  -R:PrintGraph=File                           Where IdealGraphVisualizer graph dumps triggered by Dump or DumpOnError should be written. [Extra help available]
  -R:±PrintGraphFile                           Setting to true sets PrintGraph=file, setting to false sets PrintGraph=network. Default: + (enabled).
  -R:PrintGraphHost="127.0.0.1"                Host part of the address to which graphs are dumped.
  -R:PrintGraphPort=4445                       Port part of the address to which graphs are dumped in binary format.
  -R:±PrintGraphStateDiff                      Prints the difference in the graph state caused by each phase of the suite. Default: - (disabled).
  -R:±PrintGraphWithSchedule                   Schedule graphs as they are dumped. Default: - (disabled).
  -R:±PrintHeapShape                           Print the shape of the heap before and after each collection, if +VerboseGC. Serial GC only. Default: - (disabled).
  -R:±PrintIRWithLIR                           Print HIR along side LIR as the latter is generated. Default: - (disabled).
  -R:±PrintImageObjectTree                     Print image object hierarchy. Default: - (disabled).
  -R:±PrintLIRWithAssembly                     Include the LIR as comments with the final assembly. Default: - (disabled).
  -R:±PrintLoweringScheduleToTTY               Print schedule result pre lowering to TTY. Default: - (disabled).
  -R:±PrintPointsToStatistics                  Report analysis statistics. Default: - (disabled).
  -R:±PrintProfileLoading                      Print to stdout when a profile is loaded. Default: - (disabled).
  -R:±PrintProfilingInformation                Print profiling information when parsing a method's bytecode. Default: - (disabled).
  -R:±PrintSynchronizedAnalysis                Print types used for Java synchronization. Default: - (disabled).
  -R:±PrintUnmodifiedGraphs                    Dump a graph even if it has not changed since it was last dumped.  Change detection is based on adding and deleting
                                               nodes or changing inputs. Default: + (enabled).
  -R:±ProfileAllocations                       Enable profiling of allocation sites. Default: - (disabled).
  -R:ProfileAllocationsContext=AllocatingMethod
                                               Control the naming and granularity of the counters when using ProfileAllocations. [Extra help available]
  -R:±ProfileAnalysisOperations                Track the progress of the static analysis. Default: - (disabled).
  -R:±ProfileCompiledMethods                   Default: - (disabled).
  -R:±ProfileConstantObjects                   Track the creation of constant objects. Default: - (disabled).
  -R:ProfileMethodFilter=...                   Restrict saving or loading of profiles based on this filter. See the MethodFilter option for the pattern syntax.
                                               Default: None
  -R:±ProfileMonitors                          Enable profiling of monitor operations. Default: - (disabled).
  -R:±RawConditionalElimination                Default: + (enabled).
  -R:ReadEliminationMaxLoopVisits=5            
  -R:±ReassociateExpressions                   Re-associate loop invariants and constants. Default: + (enabled).
  -R:±ReduceDCE                                Disable optional dead code eliminations. Default: + (enabled).
  -R:RegisterPressure=...                      Comma separated list of registers that register allocation is limited to. Default: None
  -R:±RelaxTypeFlowStateConstraints            Allow a type flow state to contain types not compatible with its declared type. Default: + (enabled).
  -R:±RemoveLoopSafepoints                     Remove safepoints on counted loop ends. Default: + (enabled).
  -R:±RemoveNeverExecutedCode                  Default: + (enabled).
  -R:±RemoveSaturatedTypeFlows                 Enable the type flow saturation analysis performance optimization. Default: + (enabled).
  -R:±ReplaceInputsWithConstantsBasedOnStamps  Default: + (enabled).
  -R:SafepointPromptnessFailureNanos=0         Exit the VM if I can not come to a safepoint in this many nanoseconds. 0 implies forever.
  -R:SafepointPromptnessWarningNanos=0         Print a warning if I can not come to a safepoint in this many nanoseconds. 0 implies forever.
  -R:±SaveProfiles                             Save per compilation profile information. Default: - (disabled).
  -R:SaveProfilesPath=...                      Path for saving compilation profiles. If the value is omitted the debug dump path will be used. Default: None
  -R:±ScanObjectsParallel                      Object scanning in parallel. Default: + (enabled).
  -R:ShowConfiguration=none                    Writes to the VM log information about the compiler configuration selected.
  -R:±ShowDumpFiles                            Print the name of each dump file path as it's created. Default: - (disabled).
  -R:±ShowSubstitutionSourceInfo               Controls whether the source position information of snippets and method substitutions are exposed to HotSpot.  Can be
                                               useful when profiling to get more precise position information. Default: - (disabled).
  -R:±SimpleFastInflatedLocking                Handle simple cases for inflated monitors in the fast-path. Default: + (enabled).
  -R:SmallCompiledLowLevelGraphSize=330        If the previous low-level graph size of the method exceeds the threshold, it is not inlined.
  -R:±SnippetCounters                          Enable counters for various paths in snippets. Default: - (disabled).
  -R:SpectrePHTBarriers=None                   Select a strategy to mitigate speculative bounds check bypass (aka Spectre-PHT or Spectre V1). [Extra help available]
  -R:±SpectrePHTIndexMasking                   Mask indices to scope access to allocation size after bounds check. Default: - (disabled).
  -R:±SpeculativeExecutionBarriers             Stop speculative execution on all branch targets with execution barrier instructions. Default: - (disabled).
  -R:±SpeculativeGuardMovement                 Move loop invariant guards (e.g., array bounds checks) out of loops. Default: + (enabled).
  -R:StackSize=0                               The size of each thread stack at run-time, in bytes.
  -R:StartFlightRecording=""                   Start flight recording with options.
  -R:±StrengthenGraphWithConstants             Perform constant folding in StrengthenGraphs. Default: + (enabled).
  -R:±StressExplicitExceptionCode              Stress the code emitting explicit exception throwing code. Default: - (disabled).
  -R:±StressInvokeWithExceptionNode            Stress the code emitting invokes with explicit exception edges. Default: - (disabled).
  -R:±StressTestEarlyReads                     Stress the code by emitting reads at earliest instead of latest point. Default: - (disabled).
  -R:±StrictDeoptInsertionChecks               Perform checks that guards and deopts aren't introduced in graphs that should handle exceptions explicitly. Default: -
                                               (disabled).
  -R:±StrictProfiles                           Throw an error if an attempt is made to overwrite/update a profile loaded from disk. Default: + (enabled).
  -R:StringIndexOfConstantLimit=4096           String.indexOf invocations will be evaluated at compile time if the receiver is a constant and its length is smaller
                                               than this value.
  -R:±SupportJsrBytecodes                      Default: + (enabled).
  -R:±SupportOSRWithLocks                      Support OSR compilations with locks. If DeoptAfterOSR is true we can per definition not have unbalanced enter/exits
                                               mappings. If DeoptAfterOSR is false insert artificial monitor enters after the OSRStart to have balanced enter/exits in
                                               the graph. Default: + (enabled).
  -R:SystemicCompilationFailureRate=1          Compilation failure rate indicating a systemic compilation problem that will issue a warning. The value is made absolute
                                               and clamped to produce P, a value between 0 and 100. Systemic failure is detected if the percent of failing
                                               compilations in a sliding time window >= P. A negative value will cause the VM to exit after issuing the warning. Set
                                               to 0 to disable systemic compilation problem detection.
  -R:TearDownFailureNanos=0                    The number of nanoseconds before tearing down an isolate gives a failure message.  0 implies no message.
  -R:TearDownWarningNanos=0                    The number of nanoseconds before and between which tearing down an isolate gives a warning message.  0 implies no
                                               warning.
  -R:Time=...                                  Pattern for specifying scopes in which timing is enabled. See the Dump option for the pattern syntax. An empty value
                                               enables all timers unconditionally. Default: None
  -R:TimedDynamicCounters=-1                   Turn on the benchmark counters, and displays the results every n milliseconds.
  -R:Timers=...                                Comma separated names of timers that are enabled irrespective of the value for Time option. An empty value enables all
                                               timers unconditionally. Default: None
  -R:TraceBytecodeParserLevel=0                The trace level for the bytecode parser. A value of 1 enables instruction tracing and any greater value emits a frame
                                               state trace just prior to each instruction trace.Instruction tracing output from multiple compiler threads will be
                                               interleaved so use of this option make most sense for single threaded compilation. The MethodFilter option can be used
                                               to refine tracing to selected methods.
  -R:±TraceCodeCache                           Print logging information for runtime code cache modifications. Default: - (disabled).
  -R:±TraceDeoptimization                      Print logging information for every deoptimization. Default: - (disabled).
  -R:±TraceDeoptimizationDetails               Print verbose logging information for every deoptimization. Default: - (disabled).
  -R:±TraceEscapeAnalysis                      Default: - (disabled).
  -R:±TraceExceptionHandlerStub                Trace execution of stub used to handle an exception thrown by a callee. Default: - (disabled).
  -R:±TraceHeapChunks                          Trace heap chunks during collections, if +VerboseGC and +PrintHeapShape. Serial GC only. Default: - (disabled).
  -R:±TraceInlineDuringParsing                 Traces inlining performed during bytecode parsing. Default: - (disabled).
  -R:±TraceInlining                            Enable tracing of inlining decisions. Default: - (disabled). [Extra help available]
  -R:±TraceInliningForStubsAndSnippets         Enable inlining decision tracing in stubs and snippets. Default: - (disabled).
  -R:TraceLIRGeneratorLevel=0                  The trace level for the LIR generator.
  -R:TraceMonitorsMethodFilter=...             Trace monitor operations in methods whose fully qualified name contains this substring. Default: None
  -R:TraceMonitorsTypeFilter=...               Trace monitor operations on objects whose type contains this substring. Default: None
  -R:±TraceParserPlugins                       Traces use of plugins during bytecode parsing. Default: - (disabled).
  -R:±TraceUnwindStub                          Trace execution of the stub that routes an exception to a handler in the calling frame. Default: - (disabled).
  -R:±TrackAccessChain                         Track the callers for methods and accessing methods for fields. Default: - (disabled).
  -R:±TrackInputFlows                          Track the input for type flows. Default: - (disabled).
  -R:TrackMemUse=...                           Pattern for specifying scopes in which memory use tracking is enabled. See the Dump option for the pattern syntax. An
                                               empty value enables all memory use trackers unconditionally. Default: None
  -R:±TrackNodeInsertion                       Track source stack trace where a node was inserted into the graph. Default: - (disabled).
  -R:±TrackNodeSourcePosition                  Track the NodeSourcePosition. Default: - (disabled).
  -R:TrivialInliningSize=10                    Graphs with less than this number of nodes are trivial and therefore always inlined.
  -R:TruffleCompilerConfiguration=...          Select a compiler configuration for Truffle compilation (default: use Graal system compiler configuration). Default:
                                               None
  -R:±TruffleHostInlining                      Whether Truffle host inlining is enabled. Default: + (enabled).
  -R:TruffleHostInliningBaseBudget=5000        Maximum budget for Truffle host inlining for runtime compiled methods.
  -R:TruffleHostInliningByteCodeInterpreterBudget=100000
                                               Maximum budget for Truffle host inlining for runtime compiled methods with a BytecodeInterpreterSwitch annotation.
  -R:TruffleHostInliningMaxExplorationDepth=1000
                                               Determines the maximum call depth for exploration during host inlining.
  -R:TruffleHostInliningMaxSubtreeInvokes=20   Maximum number of subtree invokes for a subtree to get inlined until it is considered too complex.
  -R:TruffleHostInliningMinFrequency=0.001     Minimum relative frequency for calls to get inlined. Default 0.001 on HotSpot and no minimum frequency on SVM.
  -R:±TruffleHostInliningPrintExplored         When logging is activated for this phase enables printing of only explored, but ultimately not inlined call trees.
                                               Default: - (disabled).
  -R:±TruffleImmutableFrameFields              Whether Truffle should mark final frame fields as immutable. Default: + (enabled).
  -R:±TruffleTrustedNonNullCast                Whether Truffle trusted non-null casts are enabled. Default: + (enabled).
  -R:±TruffleTrustedTypeCast                   Whether Truffle trusted type casts are enabled. Default: + (enabled).
  -R:±TrustFinalDefaultFields                  Determines whether to treat final fields with default values as constant. Default: + (enabled).
  -R:TypeCheckMaxHints=2                       The maximum number of profiled types that will be used when compiling a profiled type check. Note that
                                               TypeCheckMinProfileHitProbability also influences whether profiling info is used in compiled type checks.
  -R:TypeCheckMinProfileHitProbability=0.5     If the probability that a type check will hit one the profiled types (up to TypeCheckMaxHints) is below this value, the
                                               type check will be compiled without profiling info.
  -R:TypeFlowSaturationCutoff=20               The maximum number of types recorded in a type flow. -1 indicates no limitation.
  -R:±UnresolvedIsError                        Report unresolved elements as errors. Default: + (enabled).
  -R:UnrollMaxIterations=16                    
  -R:±UseBranchesWithin32ByteBoundary          Force branch instructions to align with 32-bytes boundary, to mitigate the jcc erratum. See
                                               https://www.intel.com/content/dam/support/us/en/documents/processors/mitigations-jump-conditional-code-erratum.pdf for
                                               more details. If not set explicitly, the default value will be determined according to the CPU model. Default: -
                                               (disabled).
  -R:±UseCompilationStatistics                 Enables CompilationStatistics. Default: - (disabled).
  -R:±UseExceptionProbability                  Default: + (enabled).
  -R:±UseExperimentalReachabilityAnalysis      Use experimental Reachability Analysis instead of points-to. Default: - (disabled).
  -R:±UseLoopEndFrequencies                    Derive loop frequencies only from backedge frequencies instead of from loop exit frequencies. Default: - (disabled).
  -R:±UseLoopLimitChecks                       Default: + (enabled).
  -R:±UsePerfData                              Flag to disable jvmstat instrumentation for performance testing. Default: + (enabled).
  -R:±UseReachabilityMethodSummaries           Use method summaries for Reachability Analysis. Default: - (disabled).
  -R:±UseSnippetGraphCache                     Use a cache for snippet graphs. Default: + (enabled).
  -R:±UseSnippetTemplateCache                  Use a LRU cache for snippet templates. Default: + (enabled).
  -R:±UseTrappingNullChecks                    Use traps for null checks instead of explicit null-checks. Default: + (enabled).
  -R:±UseTypeCheckHints                        Default: + (enabled).
  -R:±VerboseGC                                Print more information about the heap before and after each collection. Default: - (disabled).
  -R:Verify=...                                Pattern for specifying scopes in which logging is enabled. See the Dump option for the pattern syntax. Default: None
  -R:±VerifyBalancedMonitors                   Emit extra code to dynamically check monitor operations are balanced. Default: - (disabled).
  -R:±VerifyGraalGraphEdges                    Perform expensive verification of graph inputs, usages, successors and predecessors. Default: - (disabled).
  -R:±VerifyGraalGraphs                        Verify graphs often during compilation when assertions are turned on. Default: + (enabled).
  -R:±VerifyGraalPhasesSize                    Verify before - after relation of the relative, computed, code size of a graph. Default: - (disabled).
  -R:±VerifyHeapAtReturn                       Perform platform dependent validation of the Java heap at returns. Default: - (disabled).
  -R:±VerifyKillCFGUnusedNodes                 Verify that there are no new unused nodes when performing killCFG. Default: - (disabled).
  -R:±VerifyPhases                             Default: - (disabled).
  -R:±WarnAboutCodeSignatureMismatch           Print to stdout when a compilation performed with different profiles generates different backend code. Default: +
                                               (enabled).
  -R:±WarnAboutGraphSignatureMismatch          Print to stdout when a compilation performed with different profiles generates different frontend IR. Default: +
                                               (enabled).
  -R:±WarnAboutNotCachedLoadedAccess           Print to stdout when requesting profiling info not present in a loaded profile. Default: + (enabled).
  -R:±WarnMissingIntrinsic                     Print a warning when a missing intrinsic is seen. Default: - (disabled).
  -R:±WriteableCodeCache                       Allocate code cache with write access, allowing inlining of objects. Default: - (disabled).
  -R:±ZapStackOnMethodEntry                    Default: - (disabled).

graal jit compiler options

mx unittest  -XX:+JVMCIPrintProperties
[JVMCI properties]
jvmci.Compiler = null                                                     [String]
          Selects the system compiler. This must match the getCompilerName() value returned by a jdk.vm.ci.runtime.JVMCICompilerFactory provider. An empty string or the value "null" selects a compiler that will raise an exception upon receiving a compilation request.
jvmci.InitTimer = false                                                  [Boolean]
          Specifies if initialization timing is enabled.
jvmci.ForceTranslateFailure = null                                        [String]
          Forces HotSpotJVMCIRuntime.translate to throw an exception in the context of the peer runtime. The value is a filter that can restrict the forced failure to matching translated objects. See HotSpotJVMCIRuntime.postTranslation for more details. This option exists soley to test correct handling of translation failure.
jvmci.PrintConfig = false                                                [Boolean]
          Prints VM configuration available via JVMCI.
jvmci.AuditHandles = false                                               [Boolean]
          Record stack trace along with scoped foreign object reference wrappers to debug issue with a wrapper being used after its scope has closed.
jvmci.TraceMethodDataFilter = null                                        [String]
          Enables tracing of profiling info when read by JVMCI.
          Empty value: trace all methods
          Non-empty value: trace methods whose fully qualified name contains the value.
jvmci.UseProfilingInformation = true                                     [Boolean]
          
[Graal properties]
graal.AbortOnBenchmarkCounterOverflow = false                            [Boolean]
          Abort VM with SIGILL if benchmark counters controlled by the
          (Generic|Timed|Benchmark)DynamicCounters
          option overflow.  WARNING: No descriptive error message will be printed! In
          case of an overflow, manual inspection of the emitted code is required.
graal.AggregatedMetricsFile = null                                        [String]
          File to which aggregated metrics are dumped at shutdown. A CSV format
          is used if the file ends with .csv otherwise a more human readable
          format is used. If not specified, metrics are dumped to the console.
graal.AlwaysInlineIntrinsics = false                                     [Boolean]
          Unconditionally inline intrinsics
graal.AlwaysInlineVTableStubs = false                                    [Boolean]
graal.ArrayRegionEqualsConstantLimit = 4096                              [Integer]
          Array region equality checks will be evaluated at compile time if the
          receiver is a constant and its length is smaller than this value.
graal.BenchmarkCounterPrintingCutoff = true                              [Boolean]
          Use a cutoff to print only most significant counters.
graal.BenchmarkCountersDumpDynamic = true                                [Boolean]
          Dump dynamic counters
graal.BenchmarkCountersDumpStatic = false                                [Boolean]
          Dump static counters
graal.BenchmarkCountersFile = null                                        [String]
          File to which benchmark counters are dumped. A CSV format is used if
          the file ends with .csv otherwise a more human readable format is used.
          The fields in the CSV format are: category, group, name, value
graal.BenchmarkDynamicCounters = null                                     [String]
          Turn on the benchmark counters. The format of this option is:
          
            (err|out),start pattern,end pattern
            
          Start counting when the start pattern matches on the given stream and stop when the end pattern occurs.
          You can use "~" to match 1 or more digits.
          Examples:
          
            err, starting =====, PASSED in
            out,Iteration ~ (~s) begins:,Iteration ~ (~s) ends:
            
          The first pattern matches DaCapo output and the second matches SPECjvm2008 output.
          
          As a more detailed example, here are the options to use for getting statistics
          about allocations within the DaCapo pmd benchmark:
          
            -XX:JVMCICounterSize=<value> -XX:-JVMCICountersExcludeCompiler \
            -Dgraal.BenchmarkDynamicCounters="err, starting ====, PASSED in " \
            -Dgraal.ProfileAllocations=true
            
          The JVMCICounterSize value depends on the granularity of the profiling -
          10000 should be sufficient. Omit JVMCICountersExcludeCompiler to exclude
          counting allocations on the compiler threads.
          The counters can be further configured by the ProfileAllocationsContext option.
          
          We highly recommend the use of -Dgraal.AbortOnBenchmarkCounterOverflow=true to
          detect counter overflows eagerly.
graal.BootstrapInitializeOnly = false                                    [Boolean]
          Do not compile anything on bootstrap but just initialize the compiler.
graal.BootstrapTimeout = 15.0                                             [Double]
          Maximum time in minutes to spend bootstrapping (0 to disable this
          limit).
graal.BootstrapWatchDogCriticalRateRatio = 0.25                           [Double]
          Ratio of the maximum compilation rate below which the bootstrap
          compilation rate must not fall (0 or less disables monitoring).
graal.BoundsCheckElimination = true                                      [Boolean]
graal.CanonicalGraphStringsCheckConstants = false                        [Boolean]
          Exclude virtual nodes when dumping canonical text for graphs.
graal.CanonicalGraphStringsExcludeVirtuals = true                        [Boolean]
          Exclude virtual nodes when dumping canonical text for graphs.
graal.CanonicalGraphStringsRemoveIdentities = true                       [Boolean]
          Attempts to remove object identity hashes when dumping canonical text
          for graphs.
graal.ClearMetricsAfterBootstrap = false                                 [Boolean]
          Clear the debug metrics after bootstrap.
graal.CompilationBailoutAsFailure = false                                [Boolean]
          Treat compilation bailouts like compilation failures.
graal.CompilationCountLimit = 0                                          [Integer]
          The number of compilations allowed for any method before the VM exits
          (a value of 0 means there is no limit).
graal.CompilationExcludePhases = null                                     [String]
          Exclude certain phases from compilation, either unconditionally or with
          a method filter. Multiple exclusions can be specified separated by ':'.
          Phase names are matched as substrings, e.g.:
          CompilationExcludePhases=PartialEscape:Loop=A.*,B.foo excludes
          PartialEscapePhase from all compilations and any phase containing
          'Loop' in its name from compilations of all methods in class A and of
          method B.foo.
graal.CompilationExpirationPeriod = 300.0                                 [Double]
          Time limit in seconds before a compilation expires (0 to disable the
          limit). A non-zero value for this option is doubled if assertions are
          enabled and quadrupled if DetailedAsserts is true.
graal.CompilationFailureAction := Diagnose                                [String]
          Specifies the action to take when compilation fails.
          
          The accepted values are:
              Silent  - Print nothing to the console.
               Print  - Print a stack trace to the console.
            Diagnose* - Retry the compilation with extra diagnostics.
              ExitVM  - Same as Diagnose except that the VM process exits after retrying.
              
          * If "Diagnose" is set compilation will be retried with extra diagnostics enabled including dumping (see file:doc-files/DumpHelp.txt). 
            In such a scenario DiagnoseDumpLevel can be used to specify the dump level (DebugContext dump levels) accordingly.
                
graal.CompilationWatchDogStartDelay = 0                                  [Integer]
          Delay in seconds before watch dog monitors a compilation (0 disables
          monitoring).
graal.CompilationWatchDogVMExitDelay = 0                                 [Integer]
          Number of seconds after which a compilation appearing to make no
          progress causes the VM to exit (0 disables VM exiting).
graal.CompileGraalWithC1Only = true                                      [Boolean]
          In tiered mode compile Graal and JVMCI using optimized first tier code.
graal.CompilerConfiguration = null                                        [String]
          Names the compiler configuration to use. If omitted, the compiler
          configuration with the highest auto-selection priority is used. To see
          the set of available configurations, supply the value 'help' to this
          option.
graal.ConditionalElimination = true                                      [Boolean]
graal.ConditionalEliminationMaxIterations = 4                            [Integer]
graal.Count = null                                                        [String]
          Pattern for specifying scopes in which counters are enabled. See the
          Dump option for the pattern syntax. An empty value enables all counters
          unconditionally.
graal.Counters = null                                                     [String]
          Comma separated names of counters that are enabled irrespective of the
          value for Count option. An empty value enables all counters
          unconditionally.
graal.CrashAt = null                                                      [String]
          Pattern for method(s) that will trigger an exception when compiled.
          This option exists to test handling compilation crashes gracefully. See
          the MethodFilter option for the pattern syntax. A ':Bailout' suffix
          will raise a bailout exception and a ':PermanentBailout' suffix will
          raise a permanent bailout exception.
graal.DebugStubsAndSnippets = false                                      [Boolean]
          Enable debug output for stub code generation and snippet preparation.
graal.DefaultLoopFrequency = 100.0                                        [Double]
          Default frequency for loops with unknown local frequency.
graal.DefaultUnswitchFactor = 0.7                                         [Double]
          Default unswitching factor for control split node with unkown profile
          data.
graal.DeoptALot = false                                                  [Boolean]
graal.DeoptAfterOSR = true                                               [Boolean]
          Deoptimize OSR compiled code when the OSR entry loop is finished if
          there is no mature profile available for the rest of the method.
graal.DeoptsToDisableOptimisticOptimization = 40                         [Integer]
graal.DetailedAsserts = false                                            [Boolean]
          Enable expensive assertions if normal assertions (i.e. -ea or -esa) are
          enabled.
graal.DiagnoseDumpLevel = 3                                              [Integer]
          Specify the dump level if CompilationFailureAction#Diagnose is used.See
          CompilationFailureAction for details.
          file:doc-files/CompilationFailureActionHelp.txt
graal.DisableABCE = true                                                 [Boolean]
          Disable array bounds check elimations
graal.DisableIntercept = false                                           [Boolean]
          Disable intercepting exceptions in debug scopes.
graal.DisableIntrinsics = null                                            [String]
          Disable intrinsics matching the given method filter (see MethodFilter
          option for details). For example, 'DisableIntrinsics=String.equals'
          disables intrinsics for any method named 'equals' in a class whose
          simple name is 'String'. You can append ':verbose' at the end of the
          filter value to print out disabled intrinsics as they are encountered
          during compilation (e.g., 'String.equals:verbose').
graal.Dump = null                                                         [String]
          Filter pattern for specifying scopes in which dumping is enabled.
          
          A filter is a list of comma-separated terms of the form:
           
            <pattern>[:<level>]
           
          If <pattern> contains a "*" or "?" character, it is interpreted as a glob pattern.
          Otherwise, it is interpreted as a substring. If <pattern> is empty, it
          matches every scope. If :<level> is omitted, it defaults to 1. The term
          ~<pattern> is a shorthand for <pattern>:0 to disable a debug facility for a pattern.
          
          The default log level is 0 (disabled). Terms with an empty pattern set
          the default log level to the specified value. The last
          matching term with a non-empty pattern selects the level specified. If
          no term matches, the log level is the default level. A filter with no
          terms matches every scope with a log level of 1.
          
          Examples of debug filters:
          --------- 
            (empty string)
          
            Matches any scope with level 1.
          --------- 
            :1
          
            Matches any scope with level 1.
          --------- 
            *
          
            Matches any scope with level 1.
          --------- 
            CodeGen,CodeInstall
          
            Matches scopes containing "CodeGen" or "CodeInstall", both with level 1.
          --------- 
            CodeGen:2,CodeInstall:1
          
            Matches scopes containing "CodeGen" with level 2, or "CodeInstall" with level 1.
          ---------
            Outer:2,Inner:0}
          
            Matches scopes containing "Outer" with log level 2, or "Inner" with log level 0. If the scope
            name contains both patterns then the log level will be 0. This is useful for silencing subscopes.
          ---------
            :1,Dead:2
          
            Matches scopes containing "Dead" with level 2, and all other scopes with level 1.
          --------- 
            Dead:0,:1
          
            Matches all scopes with level 1, except those containing "Dead".   Note that the location of
            the :1 doesn't matter since it's specifying the default log level so it's the same as
            specifying :1,Dead:0.
          --------- 
            Code*
          
            Matches scopes starting with "Code" with level 1.
          --------- 
            Code,~Dead
          
            Matches scopes containing "Code" but not "Dead", with level 1.
graal.DumpAfterEveryBCI = false                                          [Boolean]
          Dump the current graph after every bci to IGV.
graal.DumpEndVersusExitLoopFrequencies = false                           [Boolean]
          Debug flag to dump loop frequency differences computed based on loop
          end or exit nodes.If the frequencies diverge a lot, this may indicate
          missing profiles on control flowinside the loop body.
graal.DumpOnError := true                                                [Boolean]
          Send compiler IR to dump handlers on error.
graal.DumpOnPhaseChange = null                                            [String]
          Dump a before and after graph if the named phase changes the
          graph.%nThe argument is substring matched against the simple name of
          the phase class
graal.DumpPath = "graal_dumps"                                            [String]
          The directory where various Graal dump files are written.
graal.DumpingErrorsAreFatal = false                                      [Boolean]
          Treat any exceptions during dumping as fatal.
graal.DynamicCountersPrintGroupSeparator = true                          [Boolean]
          Use grouping separators for number printing
graal.EagerSnippets = false                                              [Boolean]
          Eagerly construct extra snippet info.
graal.EarlyCodeEmissionOrder = false                                     [Boolean]
          Enable early code emission order computation instead of late code
          emission order computation
graal.EarlyGVN = true                                                    [Boolean]
          Perform early global value numbering.
graal.EarlyLICM = true                                                   [Boolean]
          Perform early loop invariant code motion.
graal.EmitStringSubstitutions = true                                     [Boolean]
          Emit substitutions for String methods
graal.EscapeAnalysisIterations = 2                                       [Integer]
graal.EscapeAnalysisLoopCutoff = 20                                      [Integer]
graal.EscapeAnalyzeOnly = null                                            [String]
graal.ExactFullUnrollMaxNodes = 800                                      [Integer]
graal.ExactPartialUnrollMaxNodes = 200                                   [Integer]
graal.FailedLoopExplosionIsFatal = false                                 [Boolean]
          Do not bail out but throw an exception on failed loop explosion.
graal.FloatingDivNodes = true                                            [Boolean]
          Try to float non-constant division operations to expose global value
          numbering of divisions.
graal.ForceAdversarialLayout = false                                     [Boolean]
          Place N-byte constants in the data section such that they are
          misaligned with respect to N*2. For example, place 4 byte constants at
          offset 4, 12 or 20, etc. This layout is used to detect instructions
          that load constants with alignment smaller than the fetch size. For
          instance, an XORPS instruction that does a 16-byte fetch of a 4-byte
          float not aligned to 16 bytes will cause a segfault.
graal.ForceExplicitReachabilityFence = false                             [Boolean]
          Force an explicit compiler node for Reference.reachabilityFence,
          instead of relying on FrameState liveness
graal.FullUnroll = true                                                  [Boolean]
graal.FullUnrollCodeSizeBudgetFactorForLargeGraphs = 2.0                  [Double]
          Maximum factor by which full unrolling can increase code size for large
          graphs. The FullUnrollSmallGraphThreshold option determines which
          graphs are small
graal.FullUnrollCodeSizeBudgetFactorForSmallGraphs = 10.0                 [Double]
          Maximum factor by which full unrolling can increase code size for small
          graphs. The FullUnrollSmallGraphThreshold option determines which
          graphs are small
graal.FullUnrollConstantCompareBoost = 15                                [Integer]
graal.FullUnrollMaxApplication = 60                                      [Integer]
graal.FullUnrollMaxIterations = 600                                      [Integer]
graal.FullUnrollMaxNodes = 400                                           [Integer]
graal.FullUnrollSmallGraphThreshold = 1000                               [Integer]
          The threshold in terms of NodeSize for a graph to be considered small
          for the purpose of full unrolling. Applied in conjunction with the
          FullUnrollCodeSizeBudgetFactorForSmallGraphs and
          FullUnrollCodeSizeBudgetFactorForLargeGraphs options.
graal.GCDebugStartCycle = -1                                             [Integer]
          Start tracing compiled GC barriers after N garbage collections
          (disabled if N <= 0).
graal.GenLoopSafepoints = true                                           [Boolean]
graal.GenericDynamicCounters = false                                     [Boolean]
          Turn on the benchmark counters, and displays the results on VM shutdown
graal.GraalArithmeticStubs = true                                        [Boolean]
          Use Graal arithmetic stubs instead of HotSpot stubs where possible
graal.GraalCompileOnly = null                                             [String]
          A filter applied to a method the VM has selected for compilation by
          Graal. A method not matching the filter is redirected to a lower tier
          compiler. The filter format is the same as for the MethodFilter option.
graal.GraphCompressionThreshold = 70                                     [Integer]
          Graal graph compression is performed when percent of live nodes falls
          below this value
graal.GuardPriorities = true                                             [Boolean]
graal.HotCodeMinSelfTime = 0.001                                          [Double]
          Minimal self time for a compilation unit to be considered hot globally.
graal.HotSpotDeoptExplicitExceptions = false                             [Boolean]
          Testing only option that forces deopts for exception throws
graal.HotSpotPostOnExceptions = false                                    [Boolean]
          Testing only option that forces deopts for exception throws
graal.HotSpotPrintInlining = false                                       [Boolean]
          Print inlining optimizations
graal.InjectedCompilationDelay = 0                                       [Integer]
          The number of seconds by which to slow down each compilation. The
          compilations slowed down can be restricted with MethodFilter. This
          option exists to test the compilation watchdog.
graal.Inline = true                                                      [Boolean]
          Enable inlining
graal.InlineDuringParsing = true                                         [Boolean]
          Inlines trivial methods during bytecode parsing.
graal.InlineDuringParsingMaxDepth = 10                                   [Integer]
          Maximum depth when inlining during bytecode parsing.
graal.InlineEverything = false                                           [Boolean]
graal.InlineGraalStubs = false                                           [Boolean]
          Embed all the emitted code for Graal-generated stubs.
graal.InlineMegamorphicCalls = true                                      [Boolean]
          Inline calls with megamorphic type profile (i.e., not all types could
          be recorded).
graal.InlineMonomorphicCalls = true                                      [Boolean]
          Inline calls with monomorphic type profile.
graal.InlinePartialIntrinsicExitDuringParsing = true                     [Boolean]
          Inlines partial intrinsic exits during bytecode parsing when possible.
          A partial intrinsic exit is a call within an intrinsic to the method
          being intrinsified and denotes semantics of the original method that
          the intrinsic does not support.
graal.InlinePolymorphicCalls = true                                      [Boolean]
          Inline calls with polymorphic type profile.
graal.InlineVTableStubs = true                                           [Boolean]
graal.InliningDepthError = 1000                                          [Integer]
          Maximum inlining depth during partial evaluation before reporting an
          infinite recursion
graal.InterceptBailout = false                                           [Boolean]
          Intercept also bailout exceptions
graal.Intrinsify = true                                                  [Boolean]
          Use compiler intrinsifications.
graal.IsolatedLoopHeaderAlignment = 32                                   [Integer]
          Alignment in bytes for loop header blocks that have no fall through
          paths.
graal.IterativePeelingLimit = 2                                          [Integer]
          Allow iterative peeling of loops up to this many times (each time the
          peeling phase runs).
graal.LIRDynMoveProfileMethod = false                                    [Boolean]
          Enable dynamic move profiling per method.
graal.LIRInstructionVerifierPath = null                                   [String]
          Path to jar file containing LIR instruction verifier.
graal.LIROptConstantLoadOptimization = true                              [Boolean]
          Enable constant load optimization.
graal.LIROptControlFlowOptimizer = true                                  [Boolean]
graal.LIROptEdgeMoveOptimizer = true                                     [Boolean]
graal.LIROptLSRAEliminateSpillMoves = true                               [Boolean]
          Enable spill move elimination.
graal.LIROptLSRAOptimizeSpillPosition = true                             [Boolean]
          Enable spill position optimization
graal.LIROptLSStackSlotAllocator = true                                  [Boolean]
          Use linear scan stack slot allocation.
graal.LIROptNullCheckOptimizer = true                                    [Boolean]
graal.LIROptRedundantMoveElimination = true                              [Boolean]
graal.LIROptStackMoveOptimizer = true                                    [Boolean]
graal.LIROptimization = true                                             [Boolean]
          Enable LIR level optimizations.
graal.LIRProfileMethods = false                                          [Boolean]
          Enables profiling of methods.
graal.LIRProfileMoves = false                                            [Boolean]
          Enables profiling of move types on LIR level. Move types are for
          example stores (register to stack), constant loads (constant to
          register) or copies (register to register).
graal.LSRAOptSplitOnly = false                                           [Boolean]
          LSRA optimization: Only split but do not reassign
graal.LSRAOptimization = false                                           [Boolean]
          Enable LSRA optimization
graal.LimitInlinedInvokes = 5.0                                           [Double]
graal.ListMetrics = false                                                [Boolean]
          Lists on the console at VM shutdown the metric names available to the
          Timers, Counters and MemUseTrackers options. Note that this only lists
          the metrics that were initialized during the VM execution and so will
          not include metrics for compiler code that is not executed.
graal.LoadExceptionObjectInVM = false                                    [Boolean]
          Use a VM runtime call to load and clear the exception object from the
          thread at the start of a compiled exception handler.
graal.LoadProfiles = null                                                 [String]
          Load per compilation profile information.
graal.Log = null                                                          [String]
          Pattern for specifying scopes in which logging is enabled. See the Dump
          option for the pattern syntax.
graal.LogFile = null                                                      [String]
          File to which logging is sent. A %p in the name will be replaced with a
          string identifying the process, usually the process id and %t will be
          replaced by System.currentTimeMillis(). If the current runtime is in an
          isolate, then %i will be replaced by '<isolate id>' otherwise %i is
          removed. An %I is the same as %i except that the replacement is
          '<isolate id>@<isolate address>'. Using %o as filename sends logging to
          System.out whereas %e sends logging to System.err.
graal.LogVerbose = false                                                 [Boolean]
          Enable more verbose log output when available
graal.LoopExitVsLoopEndFrequencyDiff = 1000.0                             [Double]
          Scaling factor of frequency difference computed based on loop ends or
          exits
graal.LoopHeaderAlignment = 16                                           [Integer]
          Alignment in bytes for loop header blocks.
graal.LoopMaxUnswitch = 3                                                [Integer]
graal.LoopPeeling = true                                                 [Boolean]
graal.LoopPredication = true                                             [Boolean]
          Hoists array bounds checks out of simple loops. This is ignored if
          SpeculativeGuardMovement is enabled.
graal.LoopPredicationMainPath = true                                     [Boolean]
          Restricts LoopPredication to only focus on array bounds checks that
          dominate the back edge of a loop.
graal.LoopUnswitch = true                                                [Boolean]
graal.LoopUnswitchFrequencyBoost = 20.0                                   [Double]
          Number of nodes allowed for a loop unswitching per loop frequency. The
          number of nodes allowed for the unswitching is proportional to the
          relative frequency of the loop by this constant.
graal.LoopUnswitchFrequencyMaxFactor = 0.95                               [Double]
          Maximun value for the frequency factor of an invariant.
graal.LoopUnswitchFrequencyMinFactor = 0.05                               [Double]
          Minimum value for the frequency factor of an invariant.
graal.LoopUnswitchMaxIncrease = 2000                                     [Integer]
          Maximum loop unswitching code size increase in nodes.
graal.LoopUnswitchMinSplitFrequency = 1.0                                 [Double]
          Lower bound for the minimun frequency of an invariant condition to be
          unswitched.
graal.LoopUnswitchTrivial = 20                                           [Integer]
          Number of nodes allowed for a loop unswitching regardless of the loop
          frequency.
graal.MatchExpressions = true                                            [Boolean]
          Allow backend to match complex expressions.
graal.MaxCompilationProblemsPerAction = 2                                [Integer]
          The maximum number of compilation failures to handle with the action
          specified by CompilationFailureAction before changing to a less verbose
          action. This does not apply to the ExitVM action.
graal.MaxDuplicationFactor = 2.0                                          [Double]
          Max amount of extra effort to expend handling irreducible loops. A
          value <= 1 disables support for irreducible loops.
graal.MaxTemplatesPerSnippet = 50                                        [Integer]
graal.MaxUnswitchSuccessors = 64                                         [Integer]
          Maximum number of split successors before aborting unswitching.
graal.MaximumDesiredSize = 20000                                         [Integer]
          Maximum desired size of the compiler graph in nodes.
graal.MaximumEscapeAnalysisArrayLength = 128                             [Integer]
          The maximum length of an array that will be escape analyzed.
graal.MaximumInliningSize = 300                                          [Integer]
          Inlining is explored up to this number of nodes in the graph for each
          call site.
graal.MaximumLoopExplosionCount = 10000                                  [Integer]
          Max number of loop explosions per method.
graal.MaximumRecursiveInlining = 5                                       [Integer]
          Maximum level of recursive inlining.
graal.MegamorphicInliningMinMethodProbability = 0.33                      [Double]
          Minimum probability for methods to be inlined for megamorphic type
          profiles.
graal.MemUseTrackers = null                                               [String]
          Comma separated names of memory usage trackers that are enabled
          irrespective of the value for TrackMemUse option. An empty value
          enables all memory usage trackers unconditionally.
graal.MethodFilter = null                                                 [String]
          Pattern for matching methods. The syntax for a pattern is:
          
            SourcePatterns = SourcePattern ["," SourcePatterns] .
            SourcePattern = [ "~" ] [ Class "." ] method [ "(" [ Parameter { ";" Parameter } ] ")" ] .
            Parameter = Class | "int" | "long" | "float" | "double" | "short" | "char" | "boolean" .
            Class = { package "." } class .
          
          Glob pattern matching (*, ?) is allowed in all parts of the source pattern.
          The "~" prefix negates the pattern.
          
          Positive patterns are joined by an "or" operator: "A,B" matches anything
          matched by "A" or "B". Negative patterns are joined by "and not": "~A,~B"
          matches anything not matched by "A" and not matched by "B". "A,~B,~C,D"
          matches anything matched by "A" or "D" and not matched by "B" and not
          matched by "C".
          
          A set of patterns containing negative patterns but no positive ones contains
          an implicit positive "*" pattern: "~A,~B" is equivalent to "*,~A,~B".
          
          Examples of method filters:
          ---------
            *
          
            Matches all methods in all classes.
          ---------
            canonical(CanonicalizerTool;LogicNode;LogicNode)
          
            Matches all methods named "canonical", with the first parameter of type
            "CanonicalizerTool", and the second and third parameters of type
            "LogicNode".
            The packages of the parameter types are irrelevant.
          ---------
            arraycopy(Object;;;;)
          
            Matches all methods named "arraycopy", with the first parameter
            of type "Object", and four more parameters of any type. The
            packages of the parameter types are irrelevant.
          ---------
            List.set
          
            Matches all methods named "set" in a class whose simple name is "List".
          ---------
            *List.set
          
            Matches all methods named "set" in a class whose simple name ends with "List".
          ---------
            org.graalvm.compiler.nodes.PhiNode.*
          
            Matches all methods in the class "org.graalvm.compiler.nodes.PhiNode".
          ---------
            org.graalvm.compiler.nodes.*.canonical
          
            Matches all methods named "canonical" in classes in the package
            "org.graalvm.compiler.nodes".
          ---------
            arraycopy,toString
          
            Matches all methods named "arraycopy" or "toString", meaning that ',' acts
            as an "or" operator.
          ---------
            java.util.*.*.,~java.util.*Array*.*
            java.util.*.*.,~*Array*.*
          
            These patterns are equivalent and match all methods in the package
            "java.util" except for classes that have "Array" in their name.
          ---------
            ~java.util.*.*
          
            Matches all methods in all classes in all packages except for anything in
            the "java.util" package.
graal.MethodFilterRootOnly = false                                       [Boolean]
          Only check MethodFilter against the root method in the context if true,
          otherwise check all methods
graal.MethodInlineBailoutLimit = 5000                                    [Integer]
          Per-compilation method inlining exploration limit before giving up (use
          0 to disable)
graal.MetricsFile = null                                                  [String]
          File to which metrics are dumped per compilation.
          A CSV format is used if the file ends with .csv otherwise a more
          human readable format is used. The fields in the CSV format are:
                     compilable - method being compiled
            compilable_identity - identity hash code of compilable
                 compilation_nr - where this compilation lies in the ordered
                                  sequence of all compilations identified by
                                  compilable_identity
                 compilation_id - runtime issued identifier for the compilation
                    metric_name - name of metric
                   metric_value - value of metric
graal.MinimalBulkZeroingSize = 2048                                      [Integer]
          If applicable, use bulk zeroing instructions when the zeroing size in
          bytes exceeds this threshold.
graal.MinimalGraphNodeSizeCheckSize = 1000                               [Integer]
          Minimal size in NodeSize to check the graph size increases of phases.
graal.MinimumPeelFrequency = 0.35                                          [Float]
graal.MoveGuardsUpwards = true                                           [Boolean]
          Move guard nodes to earlier places in the dominator tree if all
          successors of basic block share a common guard condition.
graal.NDCV = 0                                                           [Integer]
          Run level for NoDeadCodeVerifyHandler (0 = off, 1 = info, 2 = verbose,
          3 = fatal)
graal.ObjdumpExecutables := "objdump,gobjdump"                            [String]
          Comma separated list of candidate GNU objdump executables. If not
          specified, disassembling via GNU objdump is disabled. Otherwise, the
          first existing executable in the list is used.
graal.OmitHotExceptionStacktrace = false                                 [Boolean]
graal.OptAssumptions = true                                              [Boolean]
graal.OptConvertDeoptsToGuards = true                                    [Boolean]
graal.OptDeoptimizationGrouping = true                                   [Boolean]
graal.OptDevirtualizeInvokesOptimistically = true                        [Boolean]
graal.OptEarlyReadElimination = true                                     [Boolean]
graal.OptEliminateGuards = true                                          [Boolean]
graal.OptFloatingReads = true                                            [Boolean]
graal.OptImplicitNullChecks = true                                       [Boolean]
graal.OptReadElimination = true                                          [Boolean]
graal.OptScheduleOutOfLoops = true                                       [Boolean]
graal.OptimizationLog = null                                         [EconomicSet]
          Enable the structured optimization log and specify where it is printed.
          The accepted values are:
            Directory - Format the structured optimization log as JSON and print it to files in a directory.
                        The directory is specified by OptimizationLogPath. If OptimizationLogPath is not set,
                        the target directory is DumpPath/optimization_log.
               Stdout - Print the structured optimization log to the standard output.
                 Dump - Dump optimization trees for IdealGraphVisualizer according to the PrintGraph option.
          It is possible to specify multiple comma-separated values.
graal.OptimizationLogPath = null                                          [String]
          Path to the directory where the optimization log is saved if
          OptimizationLog is set to Directory. Directories are created if they do
          no exist.
graal.OverrideProfiles = false                                           [Boolean]
          Allow multiple compilations of the same method by overriding existing
          profiles.
graal.PartialEscapeAnalysis = true                                       [Boolean]
graal.PartialUnroll = true                                               [Boolean]
graal.PeelALot = false                                                   [Boolean]
graal.PreferUnsignedComparison = true                                    [Boolean]
          Rewrite signed comparisons to unsigned ones if the result is equal.
graal.PrintBBInfo = false                                                [Boolean]
          Enables dumping of basic blocks relative PC and frequencies in the dump
          directory.
graal.PrintBackendCFG = false                                            [Boolean]
          Enable dumping scheduled HIR, LIR, register allocation and code
          generation info to the C1Visualizer.
graal.PrintBlockMapping = false                                          [Boolean]
          Enable dumping CFG built during initial BciBlockMapping
graal.PrintCanonicalGraphStringFlavor = 0                                [Integer]
          Choose format used when dumping canonical text for graphs: 0 gives a
          scheduled graph (better for spotting changes involving the schedule)
          while 1 gives a CFG containing expressions rooted at fixed nodes
          (better for spotting small structure differences)
graal.PrintCanonicalGraphStrings = false                                 [Boolean]
          Enable dumping canonical text from for graphs.
graal.PrintCompilation = false                                           [Boolean]
          Print an informational line to the console for each completed
          compilation.
graal.PrintGraph := Network                                               [String]
          Where IdealGraphVisualizer graph dumps triggered by Dump or DumpOnError
          should be written.
          The accepted values are:
                File - Dump IGV graphs to the local file system (see DumpPath).
             Network - Dump IGV graphs to the network destination specified by PrintGraphHost and PrintGraphPort.
                       If a network connection cannot be opened, dumping falls back to file dumping. 
             Disable - Do not dump IGV graphs.
graal.PrintGraphFile = true                                              [Boolean]
          Setting to true sets PrintGraph=file, setting to false sets
          PrintGraph=network
graal.PrintGraphHost = "127.0.0.1"                                        [String]
          Host part of the address to which graphs are dumped.
graal.PrintGraphPort = 4445                                              [Integer]
          Port part of the address to which graphs are dumped in binary format.
graal.PrintGraphStateDiff = false                                        [Boolean]
          Prints the difference in the graph state caused by each phase of the
          suite.
graal.PrintGraphWithSchedule = false                                     [Boolean]
          Schedule graphs as they are dumped.
graal.PrintIRWithLIR = false                                             [Boolean]
          Print HIR along side LIR as the latter is generated
graal.PrintLIRWithAssembly = false                                       [Boolean]
          Include the LIR as comments with the final assembly.
graal.PrintLoweringScheduleToTTY = false                                 [Boolean]
          Print schedule result pre lowering to TTY.
graal.PrintProfileLoading = false                                        [Boolean]
          Print to stdout when a profile is loaded.
graal.PrintProfilingInformation = false                                  [Boolean]
          Print profiling information when parsing a method's bytecode
graal.PrintUnmodifiedGraphs = true                                       [Boolean]
          Dump a graph even if it has not changed since it was last dumped.
          Change detection is based on adding and deleting nodes or changing
          inputs.
graal.ProfileAllocations = false                                         [Boolean]
          Enable profiling of allocation sites.
graal.ProfileAllocationsContext = AllocatingMethod                        [String]
          Control the naming and granularity of the counters when using
          ProfileAllocations.
          The accepted values are:
                  AllocatingMethod - a counter per method
                   InstanceOrArray - one counter for all instance allocations and
                                     one counter for all array allocations 
                     AllocatedType - one counter per allocated type
            AllocatedTypesInMethod - one counter per allocated type, per method
           
graal.ProfileCompiledMethods = false                                     [Boolean]
graal.ProfileMethodFilter = null                                          [String]
          Restrict saving or loading of profiles based on this filter. See the
          MethodFilter option for the pattern syntax.
graal.ProfileMonitors = false                                            [Boolean]
          Enable profiling of monitor operations.
graal.RawConditionalElimination = true                                   [Boolean]
graal.ReadEliminationMaxLoopVisits = 5                                   [Integer]
graal.ReassociateExpressions = true                                      [Boolean]
          Re-associate loop invariants and constants.
graal.ReduceDCE = true                                                   [Boolean]
          Disable optional dead code eliminations
graal.RegisterPressure = null                                             [String]
          Comma separated list of registers that register allocation is limited
          to.
graal.RemoveLoopSafepoints = true                                        [Boolean]
          Remove safepoints on counted loop ends.
graal.RemoveNeverExecutedCode = true                                     [Boolean]
graal.ReplaceInputsWithConstantsBasedOnStamps = true                     [Boolean]
graal.SaveProfiles = false                                               [Boolean]
          Save per compilation profile information.
graal.SaveProfilesPath = null                                             [String]
          Path for saving compilation profiles. If the value is omitted the debug
          dump path will be used.
graal.ShowConfiguration = none                                            [String]
          Writes to the VM log information about the compiler configuration
          selected.
graal.ShowDumpFiles := true                                              [Boolean]
          Print the name of each dump file path as it's created.
graal.ShowSubstitutionSourceInfo = false                                 [Boolean]
          Controls whether the source position information of snippets and method
          substitutions are exposed to HotSpot. Can be useful when profiling to
          get more precise position information.
graal.SimpleFastInflatedLocking = true                                   [Boolean]
          Handle simple cases for inflated monitors in the fast-path.
graal.SmallCompiledLowLevelGraphSize = 330                               [Integer]
          If the previous low-level graph size of the method exceeds the
          threshold, it is not inlined.
graal.SnippetCounters = false                                            [Boolean]
          Enable counters for various paths in snippets.
graal.SpectrePHTBarriers = None                                           [String]
          Select a strategy to mitigate speculative bounds check bypass (aka
          Spectre-PHT or Spectre V1).
          This is an experimental option - execution of untrusted code is not supported by GraalVM CE.
          The accepted values are:
                            None - No mitigations are used in JIT compiled code.
                      AllTargets - Speculative execution on all branch targets is
                                   stopped using speculative execution barrier instructions.
                                   This option is equivalent to setting SpeculativeExecutionBarriers to true.
                    GuardTargets - Branch targets relevant to Java memory safety are instrumented
                                   with barrier instructions. This option has less performance impact
                                   than AllTargets. 
            NonDeoptGuardTargets - Same as GuardTargets, except that branches which deoptimize are not
                                   protected since they can not be executed repeatedly and are thus less
                                   likely to be successfully exploited in an attack.
          
                                   
          Note that all modes except "None" will also instrument branch target blocks containing UNSAFE memory accesses
          with barrier instructions.
graal.SpectrePHTIndexMasking = false                                     [Boolean]
          Mask indices to scope access to allocation size after bounds check.
graal.SpeculativeExecutionBarriers = false                               [Boolean]
          Stop speculative execution on all branch targets with execution barrier
          instructions.
graal.SpeculativeGuardMovement = true                                    [Boolean]
          Move loop invariant guards (e.g., array bounds checks) out of loops.
graal.StressExplicitExceptionCode = false                                [Boolean]
          Stress the code emitting explicit exception throwing code.
graal.StressInvokeWithExceptionNode = false                              [Boolean]
          Stress the code emitting invokes with explicit exception edges.
graal.StressTestEarlyReads = false                                       [Boolean]
          Stress the code by emitting reads at earliest instead of latest point.
graal.StrictDeoptInsertionChecks = false                                 [Boolean]
          Perform checks that guards and deopts aren't introduced in graphs that
          should handle exceptions explicitly
graal.StrictProfiles = true                                              [Boolean]
          Throw an error if an attempt is made to overwrite/update a profile
          loaded from disk.
graal.StringIndexOfConstantLimit = 4096                                  [Integer]
          String.indexOf invocations will be evaluated at compile time if the
          receiver is a constant and its length is smaller than this value.
graal.SupportJsrBytecodes = true                                         [Boolean]
graal.SupportOSRWithLocks = true                                         [Boolean]
          Support OSR compilations with locks. If DeoptAfterOSR is true we can
          per definition not have unbalanced enter/exits mappings. If
          DeoptAfterOSR is false insert artificial monitor enters after the
          OSRStart to have balanced enter/exits in the graph.
graal.SystemicCompilationFailureRate = 1                                 [Integer]
          Compilation failure rate indicating a systemic compilation problem that
          will issue a warning. The value is made absolute and clamped to produce
          P, a value between 0 and 100. Systemic failure is detected if the
          percent of failing compilations in a sliding time window >= P. A
          negative value will cause the VM to exit after issuing the warning. Set
          to 0 to disable systemic compilation problem detection.
graal.Time = null                                                         [String]
          Pattern for specifying scopes in which timing is enabled. See the Dump
          option for the pattern syntax. An empty value enables all timers
          unconditionally.
graal.TimedDynamicCounters = -1                                          [Integer]
          Turn on the benchmark counters, and displays the results every n
          milliseconds
graal.Timers = null                                                       [String]
          Comma separated names of timers that are enabled irrespective of the
          value for Time option. An empty value enables all timers
          unconditionally.
graal.TraceBytecodeParserLevel = 0                                       [Integer]
          The trace level for the bytecode parser. A value of 1 enables
          instruction tracing and any greater value emits a frame state trace
          just prior to each instruction trace.Instruction tracing output from
          multiple compiler threads will be interleaved so use of this option
          make most sense for single threaded compilation. The MethodFilter
          option can be used to refine tracing to selected methods.
graal.TraceEscapeAnalysis = false                                        [Boolean]
graal.TraceExceptionHandlerStub = false                                  [Boolean]
          Trace execution of stub used to handle an exception thrown by a callee.
graal.TraceInlineDuringParsing = false                                   [Boolean]
          Traces inlining performed during bytecode parsing.
graal.TraceInlining = false                                              [Boolean]
          Enable tracing of inlining decisions.
          Output format:
            compilation of 'Signature of the compilation root method':
              at 'Signature of the root method' ['Bytecode index']: <'Phase'> 'Child method signature': 'Decision made about this callsite'
                at 'Signature of the child method' ['Bytecode index']: 
                   |--<'Phase 1'> 'Grandchild method signature': 'First decision made about this callsite'
                   \--<'Phase 2'> 'Grandchild method signature': 'Second decision made about this callsite'
                at 'Signature of the child method' ['Bytecode index']: <'Phase'> 'Another grandchild method signature': 'The only decision made about this callsite.'
graal.TraceInliningForStubsAndSnippets = false                           [Boolean]
          Enable inlining decision tracing in stubs and snippets.
graal.TraceLIRGeneratorLevel = 0                                         [Integer]
          The trace level for the LIR generator
graal.TraceMonitorsMethodFilter = null                                    [String]
          Trace monitor operations in methods whose fully qualified name contains
          this substring.
graal.TraceMonitorsTypeFilter = null                                      [String]
          Trace monitor operations on objects whose type contains this substring.
graal.TraceParserPlugins = false                                         [Boolean]
          Traces use of plugins during bytecode parsing.
graal.TraceUnwindStub = false                                            [Boolean]
          Trace execution of the stub that routes an exception to a handler in
          the calling frame.
graal.TrackMemUse = null                                                  [String]
          Pattern for specifying scopes in which memory use tracking is enabled.
          See the Dump option for the pattern syntax. An empty value enables all
          memory use trackers unconditionally.
graal.TrackNodeInsertion = false                                         [Boolean]
          Track source stack trace where a node was inserted into the graph.
graal.TrackNodeSourcePosition := true                                    [Boolean]
          Track the NodeSourcePosition.
graal.TrivialInliningSize = 10                                           [Integer]
          Graphs with less than this number of nodes are trivial and therefore
          always inlined.
graal.TruffleCompilerConfiguration = null                                 [String]
          Select a compiler configuration for Truffle compilation (default: use
          Graal system compiler configuration).
graal.TruffleHostInlining = true                                         [Boolean]
          Whether Truffle host inlining is enabled.
graal.TruffleHostInliningBaseBudget = 5000                               [Integer]
          Maximum budget for Truffle host inlining for runtime compiled methods.
graal.TruffleHostInliningByteCodeInterpreterBudget = 100000              [Integer]
          Maximum budget for Truffle host inlining for runtime compiled methods
          with a BytecodeInterpreterSwitch annotation.
graal.TruffleHostInliningMaxExplorationDepth = 1000                      [Integer]
          Determines the maximum call depth for exploration during host inlining.
graal.TruffleHostInliningMaxSubtreeInvokes = 20                          [Integer]
          Maximum number of subtree invokes for a subtree to get inlined until it
          is considered too complex.
graal.TruffleHostInliningMinFrequency = 0.001                             [Double]
          Minimum relative frequency for calls to get inlined. Default 0.001 on
          HotSpot and no minimum frequency on SVM.
graal.TruffleHostInliningPrintExplored = false                           [Boolean]
          When logging is activated for this phase enables printing of only
          explored, but ultimately not inlined call trees.
graal.TruffleImmutableFrameFields = true                                 [Boolean]
          Whether Truffle should mark final frame fields as immutable.
graal.TruffleTrustedNonNullCast = true                                   [Boolean]
          Whether Truffle trusted non-null casts are enabled.
graal.TruffleTrustedTypeCast = true                                      [Boolean]
          Whether Truffle trusted type casts are enabled.
graal.TrustFinalDefaultFields = true                                     [Boolean]
          Determines whether to treat final fields with default values as
          constant.
graal.TypeCheckMaxHints = 2                                              [Integer]
          The maximum number of profiled types that will be used when compiling a
          profiled type check. Note that TypeCheckMinProfileHitProbability also
          influences whether profiling info is used in compiled type checks.
graal.TypeCheckMinProfileHitProbability = 0.5                             [Double]
          If the probability that a type check will hit one the profiled types
          (up to TypeCheckMaxHints) is below this value, the type check will be
          compiled without profiling info
graal.UnrollMaxIterations = 16                                           [Integer]
graal.UseBranchesWithin32ByteBoundary = false                            [Boolean]
          Force branch instructions to align with 32-bytes boundary, to mitigate
          the jcc erratum. See
          https://www.intel.com/content/dam/support/us/en/documents/processors/mitigations-jump-conditional-code-erratum.pdf
          for more details. If not set explicitly, the default value will be
          determined according to the CPU model.
graal.UseCompilationStatistics = false                                   [Boolean]
          Enables CompilationStatistics.
graal.UseExceptionProbability = true                                     [Boolean]
graal.UseLoopEndFrequencies = false                                      [Boolean]
          Derive loop frequencies only from backedge frequencies instead of from
          loop exit frequencies.
graal.UseLoopLimitChecks = true                                          [Boolean]
graal.UseSnippetGraphCache = true                                        [Boolean]
          Use a cache for snippet graphs.
graal.UseSnippetTemplateCache = true                                     [Boolean]
          Use a LRU cache for snippet templates.
graal.UseTrappingNullChecks = true                                       [Boolean]
          Use traps for null checks instead of explicit null-checks
graal.UseTypeCheckHints = true                                           [Boolean]
graal.Verify = null                                                       [String]
          Pattern for specifying scopes in which logging is enabled. See the Dump
          option for the pattern syntax.
graal.VerifyBalancedMonitors = false                                     [Boolean]
          Emit extra code to dynamically check monitor operations are balanced.
graal.VerifyGraalGraphEdges = false                                      [Boolean]
          Perform expensive verification of graph inputs, usages, successors and
          predecessors
graal.VerifyGraalGraphs = true                                           [Boolean]
          Verify graphs often during compilation when assertions are turned on
graal.VerifyGraalPhasesSize = false                                      [Boolean]
          Verify before - after relation of the relative, computed, code size of
          a graph
graal.VerifyHeapAtReturn = false                                         [Boolean]
          Perform platform dependent validation of the Java heap at returns
graal.VerifyKillCFGUnusedNodes = false                                   [Boolean]
          Verify that there are no new unused nodes when performing killCFG
graal.VerifyPhases = false                                               [Boolean]
graal.WarnAboutCodeSignatureMismatch = true                              [Boolean]
          Print to stdout when a compilation performed with different profiles
          generates different backend code.
graal.WarnAboutGraphSignatureMismatch = true                             [Boolean]
          Print to stdout when a compilation performed with different profiles
          generates different frontend IR.
graal.WarnAboutNotCachedLoadedAccess = true                              [Boolean]
          Print to stdout when requesting profiling info not present in a loaded
          profile.
graal.WarnMissingIntrinsic = false                                       [Boolean]
          Print a warning when a missing intrinsic is seen.
graal.ZapStackOnMethodEntry = false                                      [Boolean]
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment