VM Options Explorer - GraalVM native-image EE JDK16

Use a different policy for approximating the incomplete profiling information.

Minimum number of contexts to use for expansion. Increasing this will determine that more code is hot, which may improve 
performance and increase image size.

Perform method inlining in the AOT compiled native image.

The minimal percentage of the total time that has to be spent in a method invoked from a calling-context to consider 
them as hot.

Minimum number of hot contexts to use in the initial expansion. 

Whether to print the hot compilation units.

Use expansion inlining during AOT compilation.

Enable use of priority inlining during AOT compilation.

Perform trivial method inlining in the AOT compiled native image.

Generate verify oop checks in AOT code.

Prefix that is added to the names of API functions. 

Enables instruction profiling on assembler level. Valid values are a comma separated list of supported instructions. 
Compare with subclasses of Assembler.InstructionCounter.

Abort VM with SIGILL if benchmark counters controlled by the (Generic|Timed|Benchmark)DynamicCounters.

Overwrites the available number of processors provided by the OS. Any value <= 0 means using the processor count from 
the OS.

Make all hosted charsets available at run time.

Make all supported providers returned by FileSystemProvider.installedProviders() available at run time.

Value /=(,)* updates  to export  to , 
regardless of module declaration.  can be ALL-UNNAMED to export to all unnamed modules.

Value /=(,)* updates  to open  to , 
regardless of module declaration.

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.

Comma-separated list of additional security service types (fully qualified class names) for automatic registration. Note 
that these must be JCA compliant.

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.

Model all array type flows using a unique elements type flow abstraction.

The size of an aligned chunk. 

Number of cache lines to load after the object address using prefetch instructions. 

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.

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.

Number of cache lines to load after the array allocation using prefetch instructions. 

Sets the step size (in bytes) for sequential prefetch instructions. 

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.

Bytes that can be allocated before (re-)querying the physical memory size.

The minimum size in bytes required for printing an allocation profiling entry. 

Enable runtime profiling of allocation.

A context sensitive heap means that each heap allocated object is modeled by using at least the allocation site.

Allow MethodTypeFlow to see @Fold methods.

Allow image building with an incomplete class path: report type resolution errors at run time when they are accessed the 
first time, instead of during image building.

Enable support for reading Java modules (jimage format) and the jrt:// file system. Requires java.home to be set at 
runtime.

Enables features that allow the VM to be inspected during runtime.

Threshold for number of points with inaccurate profiles. 

Unconditionally inline intrinsics.

Force all freshly committed pages to be pre-touched.

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).

The maximum size of type and method profiles returned by the static analysis. -1 indicates no limitation. 

Analysis results statistics file.

Enable the auxiliary engine cache features at runtime.

The base target spending used to estimate the inlining threshold; the higher, the likelier it is to inline. 

Use a cutoff to print only most significant counters.

Dump dynamic counters.

Dump static counters.

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.

Turn on the benchmark counters. The format of this option is:.

Enable LLVM bitcode optimizations.

Do not compile anything on bootstrap but just initialize the compiler.

Maximum time in minutes to spend bootstrapping (0 to disable this limit). 

Ratio of the maximum compilation rate below which the bootstrap compilation rate must not fall (0 or less disables 
monitoring).

Enable native intrinsics for BouncyCastle.

Break chained phis.

Directory where information generated by the CAnnotation Processor are cached. 

Provide custom C compiler option used for query code compilation. 

Provide custom path to C compiler used for query code compilation and linking.

Search path for C libraries passed to the linker (list of comma-separated directories). 

Comma separated list of CPU features that will be used for image generation. The specific options available are platform 
dependent. For AMD64, SSE and SSE2 are enabled by default. Available features are: CX8, CMOV, FXSR, HT, MMX,
AMD_3DNOW_PREFETCH, SSE3, SSSE3, SSE4A, SSE4_1, SSE4_2, POPCNT, LZCNT, TSC, TSCINV, AVX, AVX2, AES, ERMS, CLMUL, BMI1,
BMI2, RTM, ADX, AVX512F, AVX512DQ, AVX512PF, AVX512ER, AVX512CD, AVX512BW, AVX512VL, SHA, FMA. On AArch64, no features
are enabled by default. Available features are: FP, ASIMD, EVTSTRM, AES, PMULL, SHA1, SHA2, CRC32, LSE, STXR_PREFETCH,
A53MAC.

C standard to use in header files. Possible values are: [C89, C99, C11]. 

Controls the maximum number of compiler nodes that can appear in the call graph. 

Controls the maximum size of the call graph before ceasing inlining. 

Reduces the likelihood of exploring call graph subtrees that are large. 

Exclude virtual nodes when dumping canonical text for graphs.

Exclude virtual nodes when dumping canonical text for graphs.

Attempts to remove object identity hashes when dumping canonical text for graphs.

Test whether a thread's recurring callback is pending on each transition from native code to Java.

Check if native-toolchain is known to work with native-image.

A comma-separated list of classes appended with their initialization strategy (':build_time', ':rerun', or ':run_time'). 

Class containing the default entry point method. Optional if --shared is used. 

Clear the debug metrics after bootstrap.

Alignment of AOT and JIT compiled code in bytes. 

Count accesses to the image and runtime code info table.

Statistics about code and deoptimization information.

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.

Determines if a full GC collects the young generation separately or together with the old generation.

Treat compilation bailouts like compilation failures.

The number of compilations allowed for any method before the VM exits (a value of 0 means there is no limit). 

Exclude certain phases from compilation, either unconditionally or with a method filter.

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.

Specifies the action to take when compilation fails. [Extra help available] 

Size of the reserved address space of each compilation isolate (0: default for new isolates). 

Interval in seconds between a watch dog reporting stack traces for long running compilations.

Delay in seconds before watch dog monitoring a compilation (0 disables monitoring). 

In tiered mode compile Graal and JVMCI using optimized first tier code.

Activate runtime compilation in separate isolates (enable support during image build with option 
SupportCompileInIsolates).

Create one reusable isolate per compilation thread as opposed to one isolate per compilation (enable through 
CompileInIsolates).

Backend used by the compiler. 

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.

Controls the likelihood of exploring subtrees that already have a lot of code during inlining. 

Number of threads concurrent gc will use. 

Directories directly containing configuration files for dynamic features at runtime. 

Resource path above configuration resources for dynamic features at runtime. 

Consider the vectorizability of loop during the duplication of a merge inside a loop.There are rare cases where 
duplication can destroy vectorization.

PullThroughPhiOptimization: Abstract cost for the creation of a new live value: new values can have a negativeimpact on 
register allocation, therefore we penalize it.

PullThroughPhiOptimization: Cost/Benefit heuristic for EE floating node duplication: reduce cost by a constant factor 
when comparing with relative benefit.

Instrument write barriers with counters.

Pattern for specifying scopes in which counters are enabled. See the Dump option for the pattern syntax. An empty value 
enables all counters unconditionally.

Comma separated names of counters that are enabled irrespective of the value for Count option. An empty value enables 
all counters unconditionally.

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.

Path to a custom ld binary for LLVM linking. 

Controls the likelihood of further exploring subtrees with a lot of code during inlining. 

In the dashboard dump, include all available information about the native image (this takes precedence over more 
specific flags).

Set dashboard to use BGV format for dump.

In the dashboard dump, include the breakdown of the code size across different packages.

Enable dashboard dumps to the specified file.

In the dashboard dump, include the breakdown of the object sizes in the heap across different classes.

Set dashboard to use JSON format for dump.

In the dashboard dump, include the information about the points-to analysis.

Set dashboard to use pretty print in JSON format.

Exit the image builder VM after printing call stacks.

The interval in minutes between watchdog checks (0 disables the watchdog). 

Directory under which to create source file cache for Application or GraalVM classes. 

Search path for source files for Application or GraalVM classes (list of comma-separated directories or jar files). 

Debug simulation synonyms during simulation-based loop peeling.

Enable debug output for stub code generation and snippet preparation.

Control debug information output: 0 - no debuginfo, 1 - AOT code debuginfo, 2 - AOT and runtime code debuginfo. 

Default locale of the image, by the default it is the same as the default locale of the image builder. 

Use linker option to remove all local symbols from image.

Deoptimize OSR compiled code when the OSR entry loop is finished if there is no mature profile available for the rest of 
the method.

Compiles all methods as deoptimization targets for testing.

Enable expensive assertions if normal assertions (i.e. -ea or -esa) are enabled.

When set to true, the image generator verifies that the image heap does not contain a home directory as a substring.

Specify the DumpLevel if CompilationFailureAction#Diagnose is used.See CompilationFailureAction for details. 
file:doc-files/CompilationFailureActionHelp.txt.

Ignore calls to System.gc().

Disable intercepting exceptions in debug scopes.

For internal purposes only. Disables type id result verification even when running with assertions enabled.

Analysis: Detect methods that return one of their parameters and hardwire the parameter straight to the return.

Dump the current graph after every bci to IGV.

Dump the heap at a specific time during image building.The option accepts a list of comma separated phases, any of: 
after-analysis, before-compilation.

Dump contents of the generated stackmap to the specified file.

Send compiler IR to dump handlers on error.

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.

The directory where various Graal dump files are written. 

Visualize the code marked as hot using sketches.

Show native-toolchain information and image-build settings.

Dumps all thread stacktraces on SIGQUIT/SIGBREAK.

Filter pattern for specifying scopes in which dumping is enabled.

Treat any exceptions during dumping as fatal.

Perform Duplications as long as there is any sane improvement.

When enabled, some limited amount of duplication will be performed in order compile code containing irreducible loops.

Percentage in node cost graph size for the late duplication budget. Computed relative to the methods code size. 

Percentage in node cost graph size for the duplication budget. Computed relative to the methods code size. 

Cost/Benefit heuristic for EE simulation-based code duplication: reduce cost by a constant factor when comparing with 
relative benefit.

Ignore low frequency branches during duplication. 

Use grouping separators for number printing.

One or several (comma-separated) paths to JSON files that specify lists of interfaces that define Java proxy classes. 
[Extra help available]

Resources describing program elements to be made available for reflection (see ProxyConfigurationFiles).

Enable trace logging for dynamic proxy.

Eagerly construct extra snippet info.

Emit substitutions for String methods.

Add all security service classes to the generated image.

Enable the feature that provides support for logging.

Enables context sensitivity in PGO.

Enable automatic registration of security services.

Enables the signal API (sun.misc.Signal or jdk.internal.misc.Signal). Defaults to false for shared library and true for 
executables.

List of comma separated URL protocols to enable. 

Enable wildcard expansion in command line arguments on Windows.

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.

Try to eliminate array clone operations by handling clone operations in early read elimination.

Run more read eliminations early in the compilation pipeline.

Enable EE version of partial loop unrolling that considers more loop shapes for unrolling.

Prefix that is added to the names of entry point methods. 

Maximum ergonomically set heap size (in bytes); zero means use MaxRAM * MaxRAMPercentage / 100. 

Exclude compilations that MethodFilter.match this string from the duplication optimization.

Regexp to match names of resources to be excluded from the image. 

Scan all objects reachable from roots for analysis. By default false.

Exit after analysis.

Exit image generation after C Annotation Processor Cache creation.

Output query code for target platform without executing it.

Exit after writing relocatable file.

Alias for CompilationFailureAction=ExitVM.

The inertia at which the expand-all proximity bonus decreases with the number of yet unexpanded nodes. 

The decrease in call graph expansion pressure when there are few call nodes left to explore. 

The slowness at which the expansion pressure grows with code size; the higher it is, the slower the pressure growth. 

The extra slowness at which the expansion pressure grows with the code size, for each extra invoke node. 

The max slowness at which the expansion pressure grows with the code size. 

A System.gc() request invokes a concurrent collection.

Enable extended asserts which slow down analysis.

Enable support for linux-specific headers.

Do not bail out but throw an exception on failed loop explosion.

Internal option used to specify Classpath for FallbackExecutor.

Internal option used to specify java arguments for FallbackExecutor. 

Internal option used to specify MainClass for FallbackExecutor.

Internal option used to specify runtime java arguments for FallbackExecutor. 

Internal option used to specify system properties for FallbackExecutor. 

Define when fallback-image generation should be used. 

A comma-separated list of fully qualified Feature implementation classes. 

Usage: -XX:FlightRecorderLogging=[tag1[+tag2...][*][=level][,...]]. [Extra help available] 

Enable Java Flight Recorder.

Fold SecurityManager getter.

Force-dump graphs before compilation.

Consider methods for guard hoisting loop duplication even if not using PGO.

Use only a writable native image heap (requires ld.gold linker).

Force partial unrolling of loops if at all possible.

Perform full unrolling as a Partial Escape Analysis Cleanup.

Target duration of individual concurrent marking steps in milliseconds. 

The threshold that defines (>=) a hot card. 

Log base 2 of the length of conc RS hot-card cache. 

The number of update buffers that are left in the queue by the concurrent processing threads. Will be selected 
ergonomically by default.

Maximum number of enqueued update buffers before mutator threads start processing new ones instead of enqueueing them. 
Will be selected ergonomically by default.

The last concurrent refinement thread wakes up every specified number of milliseconds to do miscellaneous work. 

The number of parallel rem set update threads. Will be set ergonomically by default. 

Each time the rset update queue increases by this amount activate the next refinement thread if available. The actual 
step size will be selected ergonomically by default, with this value used to determine a lower bound.

Number of enqueued update buffers that will trigger concurrent processing. Will be selected ergonomically by default. 

Confidence level for MMU/pause predictions. 

Specifies the debug level of the linked G1 GC [product, fastdebug, or debug]. 

Size of the G1 regions in bytes. Supported values are 1, 2, 4, 8, 16, or 32M. 

Amount of space, expressed as a percentage of the heap size, that G1 is willing not to collect to avoid expensive GCs. 

The target number of mixed GCs after a marking cycle. 

Number of milliseconds after a previous GC to wait before triggering a periodic gc. A value of zero disables 
periodically enforced gc cycles.

Determines the kind of periodic GC. Set to true to have G1 perform a concurrent GC as periodic GC, otherwise use a STW 
Full GC.

Maximum recent system wide load as returned by the 1m value of getloadavg() at which G1 triggers a periodic GC. A load 
above this value cancels a given periodic GC. A value of zero disables this check.

Max number of regions for which we keep bitmaps. Will be set ergonomically by default. 

Max number of entries per region in a sparse table. Will be set ergonomically by default. 

A target percentage of time that is allowed to be spend on process RS update buffers during the collection pause. 

The number of discovered reference objects to process before draining concurrent marking work queues. 

It determines the minimum reserve we should have in the heap to minimize the probability of promotion failure. 

Before enqueueing them, each mutator thread tries to do some filtering on the SATB buffers it generates. If 
post-filtering the percentage of retained entries is over this threshold the buffer will be enqueued for processing. A
value of 0 specifies that mutator threads should not do such filtering.

Number of entries in an SATB log buffer. 

Size of an update buffer. 

Select green, yellow and red zones adaptively to meet the the pause requirements.

Adaptively adjust the initiating heap occupancy from the initial value of InitiatingHeapOccupancyPercent. The policy 
attempts to start marking in time based on application behavior.

Verifies the consistency of the marking bitmaps.

Verify the code root lists attached to each heap region.

If true, perform verification of each heap region's remembered set when verifying the heap during a full GC.

Start tracing compiled GC barriers after N garbage collections (disabled if N <= 0). 

Number of entries we will try to leave on the stack during parallel gc. 

Time slice for MMU specification. 

Adaptive size policy application time to GC time ratio. 

Gather statistics about each safepoint.

Insert debug info into the generated native image or library. 

Generate position independent code.

Generate debuginfo for runtime-compiled code.

Turn on the benchmark counters, and displays the results on VM shutdown.

Use Graal arithmetic stubs instead of HotSpot stubs where possible.

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 graph compression is performed when percent of live nodes falls below this value. 

Develop demographics of the object references visited.

Length of GreyToBlackObjectVisitor history for diagnostics. 0 implies no history is kept.

Duplicate only loops up to this estimated size. 

Duplicate only loops with at least this frequency.

Duplicate only loops in methods executed at least this number of times. 

Duplicate certain loops and eliminate their guards.

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.

Size of heap (bytes) per GC thread used in calculating the number of GC threads. 

Enable EE partial unrolling in high tier.

BaseTargetSpending value for the hot compilations. 

CompilerNodePenaltyCoefficient value for the hot compilations.

CutoffCodeSizePenaltyCoefficient value for the hot compilations.

ExpansionInertiaBaseValue value for the hot compilations.

LargeChildrenCountPenaltyCoefficient value for the hot compilations.

MaxPolymorphicDispatches value for the hot compilations. 

MinPolymorphicDispatchProbability value for the hot compilations.

RelativeBenefitInliningCoefficient value for the hot compilations.

SmallRootIrPenaltyCoefficient value for the hot compilations.

TypicalGraphSizeInvokeBonus value for the hot compilations.

TypicalGraphSize value for the hot compilations. 

Indicates whether a compilation unit is frequently invoked.

Testing only option that forces deopts for exception throws.

Testing only option that forces deopts for exception throws.

Print inlining optimizations.

The minimal percentage of the time spent in the method invoked from the specific calling-context compared to the total 
time spent.

Enable hybrid context for static methods, i.e. uses invocation site as context for static methods.

Ignore duplications with a bad benefit cost relation.

Enables card marking for image heap objects, which arranges them in chunks. Automatically enabled when supported. 

Override the default suppression of specified roots. See: Reports.md. 

Override the default suppression of specified types. See: Reports.md. 

Suppress the expansion of specified roots. See: Reports.md. 

Suppress the expansion of specified types. See: Reports.md. 

Common prefix used by method symbols in image. 

Try to avoid emitting code where patching is required.

Make all hosted locales available at run time.

When true, all time zones will be pre-initialized in the image.

Include debugging info in the generated image (for LLVM backend). 

Comma separated list of locales to be included into the image. The default locale is included in the list automatically 
if not present.

Track NodeSourcePositions during runtime-compilation.

Comma separated list of bundles to be included into the image. 

Regexp to match names of resources to be included in the image. 

The time zones, in addition to the default zone of the host, that will be pre-initialized in the image. 

The initial garbage collection policy, as a fully-qualified class name (might require quotes or escaping).

Initial heap size (in bytes); zero means use ergonomics. 

Percentage of real memory used for initial heap size. 

The percent occupancy (IHOP) of the current old generation capacity above which a concurrent mark cycle will be 
initiated. Its value may change over time if adaptive IHOP is enabled, otherwise the value remains constant. In the
latter case a value of 0 will result as frequent as possible concurrent marking cycles. A value of 100 disables
concurrent marking. Fragmentation waste in the old generation is not considered free space in this calculation.

The bonus applied to call nodes that can be fully inlined. 

Inline everything previously explored.

Maximum number of invokes for method inlined before static analysis. 

Maximum number of invokes for method inlined before static analysis. 

Maximum number of computation nodes for method inlined before static analysis. 

Maximum depth when inlining. 

Experimental: Inline methods before static analysis.

Maximum depth when inlining during bytecode parsing. 

Inlines trivial methods during bytecode parsing.

Inlines intrinsic methods during bytecode parsing.

Inline calls with megamorphic type profile (i.e., not all types could be recorded).

Inline calls with monomorphic type profile.

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.

Inline calls with polymorphic type profile.

Enable inlining.

Controls the maximum number of compiler nodes that can be inlined into the compiled method. 

The coefficient used to compute the inlining threshold; the higher, the more to inline. 

Maximum inlining depth during partial evaluation before reporting an infinite recursion. 

Do not unroll the main loop, only create pre-main-post.

Inspect analysis graphs.

Path to the contents of the Inspect web server. 

Provide java.lang.Terminator exit handlers for executable images.

Install segfault handler that prints register contents and full Java stacktrace.

Intercept also bailout exceptions.

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.

Use compiler intrinsifications.

Files describing program elements to be made accessible via JNI (for syntax, see ReflectionConfigurationFiles). 

Resources describing program elements to be made accessible via JNI (see JNIConfigurationFiles). 

Export Invocation API symbols.

Report information about known JNI elements when lookup fails.

Enable Java Native Interface (JNI) support.

Enable dynamic move profiling per method.

Enable constant load optimization. 

Enable spill move elimination. 

Enable spill position optimization. 

Use linear scan stack slot allocation. 

Enable LIR level optimiztations.

Enables profiling of methods.

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).

Maximum size of batches used for LLVM compilation. 0 means a single batch, 1 means all functions separately. 

LSRA optimization: Only split but do not reassign.

Enable LSRA optimization.

The size at or above which an array will be allocated in its own unaligned chunk. 0 implies (AlignedHeapChunkSize / 8). 

Reduces the likelihood of exploring call graphs that have a lot of children below the root.

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.

Path passed to the linker as the -rpath (list of comma-separated directories). 

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.

Use a VM runtime call to load and clear the exception object from the thread at the start of a compiled exception 
handler.

Regular expressions matching which bundles should be compressed. 

Compress the bundles in parallel.

Optimize the resource bundle lookup using a simple map.

Store the resource bundle content more efficiently in the fallback mode.

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 '' otherwise %i is removed. An %I is the same as %i except that the replacement is '@'. Using %o as filename sends logging to System.out whereas %e sends logging to System.err.

Enable more verbose log output when available.

Pattern for specifying scopes in which logging is enabled. See the Dump option for the pattern syntax.

Alignment in bytes for loop header blocks. 

Restricts LoopPredication to only focus on array bounds checks that dominate the back edge of a loop.

Hoists array bounds checks out of simple loops. This is ignored if SpeculativeGuardMovement is enabled.

Maximum size of marking stack. 

Size of marking stack. 

Allow backend to match complex expressions.

The maximum length of the methods context chains. 

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.

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.

The maximum number of constant objects recorded for each type before merging the constants into one unique constant 
object per type. The analysis must be heap sensitive. It has a minimum value of 1.

Upper bound on the number of cpu locals per counter. It has to be a power of 2. 

Maximum total size of NIO direct-buffer allocations. 

How much duplication can happen because of irreducible loops before bailing out. 

Adaptive size policy maximum GC pause time goal in millisecond, or the maximum GC time per MMU time slice. 

Maximum node cost graph size for duplication. If a graph is bigger duplication will stop. 

The maximum length of the context used to model a heap object in addition to the allocation site; used only when 
ContextSensitiveHeap is enabled.

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.

The maximum heap size at run-time, in bytes. 

Maximum number of invokes in a method so that it is considered trivial (for testing only). 

The maximum number of lines in the stack trace for Java exceptions (0 means all). 

Abstract measure of the cost of branch misprediction. Higher values make generation of conditional moves more likely. 

The maximum size of the young generation at run-time, in bytes. 

Maximum number of nodes in a method so that it is considered trivial, if it does not have any invokes. 

Maximum number of nodes in a method so that it is considered trivial. 

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.

The maximum number of dispatches in guarded polymorphic inlining. 

Max number of precise inlining peeling iterations. 

Maximum percentage of real memory used for maximum heap size. 

Real memory size (in bytes) used to set maximum heap size. 

Maximum number of types allowed in the image. Used for tests where small number of types is necessary. 

Maximum number of methods allowed for runtime compilation. 

Maximum simulation-duplication iterations of the duplication optimization per invocation. 

Maximum number of survivor spaces. 

Maximum value for tenuring threshold. 

Maximum recursive locking depth for thin locks. 

Define the maximum number of stores for which the loop that zeroes out objects is unrolled. 

Maximum number of unrolled alignment instructions. 

Maximum length of linear-code vector operations. 

Maximum desired size of the compiler graph in nodes. 

The maximum length of an array that will be escape analyzed. 

The maximum heap size as percent of physical memory. 

Inlining is explored up to this number of nodes in the graph for each call site. 

Max number of loop explosions per method. 

Maximum level of recursive inlining. 

PullThroughPhiOptimization: Maximum number of algorithm iterations per optimization invocation. 

The maximum size of the young generation as a percentage of the maximum heap size. 

Minimum probability for methods to be inlined for megamorphic type profiles.

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.

Only check MethodFilter against the root method in the context if true, otherwise check all methods.

Pattern for matching methods. The syntax for a pattern is:.

Per-compilation method inlining exploration limit before giving up (use 0 to disable). 

Name of the main entry point method. Optional if --shared is used. 

File to which metrics are dumped per compilation.

Enable EE partial unrolling in mid tier.

PullThroughPhiOptimization: Ignore low frequency branches during duplication. 

The minimum length of the methods context chains. 

The minimum length of the context used to model a heap object in addition to the allocation site; used only when 
ContextSensitiveHeap is enabled.

The minimum change in heap space due to GC (in bytes). 

The minimum percentage of heap free after GC to avoid expansion. 

The minimum heap size at run-time, in bytes. 

The minimum probability for using a dispatch in guarded polymorphic inlining. 

Minimum percentage of real memory used for maximum heap size on systems with small physical memory size. 

Minimum allowed TLAB size (in bytes). 

Break chained phis.

If applicable, use bulk zeroing instructions when the zeroing size in bytes exceeds this threshold. 

Try to reduce duplication code size to the minimal amount of code.

Module containing the class that contains the main entry point. Optional if --shared is used. 

Move guard nodes to earlier places in the dominator tree if all successors of basic block share a common guard 
condition.

Cost/Benefit heuristic for EE unrolling: If a loop has multiple exits, cost is increased by this value for every sinking 
loop exit.

Cost/Benefit heuristic for EE unrolling: If a loop has multiple exits, cost is increased by this value for every 
none-sinking loop exit.

Enable support for threads and and thread-local variables (disable for single-threaded implementation).

Run level for NoDeadCodeVerifyHandler (0 = off, 1 = info, 2 = verbose, 3 = fatal). 

Name of the output file to be generated. 

Overrides CPUFeatures and uses the native architecture, i.e., the architecture of a machine that builds an image. 
NativeArchitecture takes precedence over CPUFeatures.

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.

Pattern for disabling inlining of methods during image generation. [Extra help available] 

Create a C Annotation Processor Cache. Will erase any previous cache at that same location.

Ratio of old/new generation sizes. 

Initial new generation size (in bytes). 

Counts the number of instances of each node class.

Benefit boost for strip mined non counted loops. 

Force non-counted strip mining for all loops (also counted ones), test flag only.

The max number of iterations the counted inner loop takes. If -1, the frequency of the loopwill be used to derive an 
inner frequency.

If NonCountedStripMiningInnerLoopTrips == -1: Maximum loop trips for strip mined non-counted loops.

Minimal loop frequency to consider a non-counted loop for strip mining. 

If NonCountedStripMiningInnerLoopTrips == -1: Minimum loop trips for strip mined non-counted loops.

Try to reuse pre-existing induction variables inside non-counted loops for the strip-mined loop's exit check.

Number of contiguous identical compiler thread stack traces allowed before the VM exits on the basis of a stuck 
compilation.

The number of threads to use for analysis during native image generation. The number must be smaller than the 
NumberOfThreads.

The maximum number of threads to use concurrently during native image generation. 

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.

Files describing Java fields that have value semantics.

Resources describing Java fields that have value semantics.

Enable object inlining.

Experimental: Inline methods which folds to constant during parsing before the static analysis.

Size of old gen promotion LAB's (in HeapWords). 

Initial tenured generation size (in bytes). 

Omit generation of DebugLineInfo originating from inlined methods.

Optimize simple if branches with conditional moves.

Optimize address operations that involve image heap constants.

Try to create more precise loop limit stamps based on dominating guards.

Inject stamps on induction variables.

Propagate equality into dominated nodes.

Optimize static final fields that get a constant assigned in the class initializer.

Dump graphs to help debug operation.

Dump graphs to help debug operation.

Optimize StringBuilder construction.

Eliminate redundant write barriers.

Perform write sinking.

Enable access node optimizations for loops.

Control native-image code optimizations: 0 - no optimizations, 1 - basic optimizations, 2 - aggressive optimizations. 

Dump information for Profile Guided Optimizations (true or file name).

Collect PGO counters, and verify that they match the path-profile counters.

Replace PGO profiling counters with path-profiling counters.

Percentage (0-100) used to weight the current sample when computing exponentially decaying average for ResizePLAB. 

Define PageSize of a machine that runs the image. The default = 0 (== same as host machine page size). 

Scan a subset of object array and push remainder, if array is bigger than this. 

Wasted fraction of parallel allocation buffer. 

Number of parallel threads parallel gc will use. 

Enable balancing of reference processing queues.

Enable parallel reference processing whenever possible.

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.

Parse and consume standard options and system properties from the command line arguments when the VM is created.

Enable partial redundancy elimination.

Cost/Benefit heuristic for EE unrolling in high tier: reduce cost by a constant factor when comparing with relative
benefit.

Cost/Benefit heuristic for EE unrolling in mid tier: reduce cost by a constant factor when comparing with relative 
benefit.

Maximum number of iterations to unroll for a high tier main loop. 

Maximum number of iterations to unroll for a mid tier main loop. 

Maximum node cost size of a loop to be considered for high tier unrolling. 

Maximum node cost size of a loop to be considered for mid tier tier unrolling. 

Minimal loop frequency to consider a loop for partial unrolling. 

The limit on the number of paths at control-flow merges. Decreasing this value reduces the number of paths, but also 
shortens them.

Dump information for path profile (null or file name). If set to null, then dumping is disabled.

Maximum acceptable number of paths coming from the inbound of a merge if both of them are frequent. 

If some block's relative frequency drops below this number times the maximum relative frequency in the graph, then the 
block is considered infrequent.

If the ratio of the merge's frequency with its inbound's frequency is greater than this threshold, then the inbound is 
considered infrequent.

Maximum number of counters to use in path profiling for all instrumented methods. 

Enable or disable the path-profiling algorithm. If it enables it, it also allows to select which mode to execute. 

Controls whether the path-regeneration algorithm is executed.

Directory of the image file to be generated.

Try to peel inverted loops without protection to make them counted.

Minimal loop frequency necessary to consider peeling. 

Increase the cost of duplicating control flow splits inside loops if they are not foldable.The generally tend to 
complicate control flow and generate worse code in the backend.

Percentage of total collection time that should be spent on young generation collections. 

Size of performance data memory region. Will be rounded up to a multiple of the native os page size. 

Jvmstat instrumentation sampling interval (in milliseconds). 

Maximum PerfStringConstant string length before truncation. 

Minimal loop frequency to consider a loop for inverted phi minifaction. 

Enable the behavior of old GraalVM versions. When enabled, interfaces not available for the current platform are 
filtered.

Per-thread chunk size for parallel memory pre-touch. 

Files describing predefined classes that can be loaded at runtime.

Resources describing predefined classes that can be loaded at runtime.

Calculate the container CPU availability based on the value of quotas (if set), when true. Otherwise, use the CPU shares 
value, provided it is less than quota.

How far ahead to prefetch destination area (<= 0 means off). 

How far ahead to prefetch scan area (<= 0 means off). 

Saves stack base pointer on the stack on method entry.

Print logging information during compilation.

Print analysis call tree, a breadth-first tree reduction of the call graph.

Print analysis results statistics.

Enable dumping LIR, register allocation and code generation info to the C1Visualizer.

Enable dumping CFG built during initial BciBlockMapping.

Enable dumping to the C1Visualizer. Enabling this option implies PrintBackendCFG.

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).

Enable dumping canonical text from for graphs.

Prints class initialization info for all classes detected by analysis.

Print an informational line to the console for each completed compilation.

Print detailed information for each allocation site.

Print features-specific information.

Print extra help, if available, based on comma-separated option names. Pass * to show all options that contain extra 
help.

Show available options based on comma-separated option-types (allowed categories: User, Expert, Debug).

Print summary GC information after application main method returns.

Print a time stamp at each collection, if +PrintGC or +VerboseGC.

Print the time for each of the phases of each collection, if +VerboseGC.

Print summary GC information after each collection.

Setting to true sets PrintGraph=file, setting to false sets PrintGraph=network.

Host part of the address to which graphs are dumped. 

Port part of the address to which graphs are dumped in binary format. 

Schedule graphs as they are dumped.

Where IdealGraphVisualizer graph dumps triggered by Dump or DumpOnError should be written. [Extra help available] 

Print class statistics of native image heap.

Print the shape of the heap before and after each collection, if +VerboseGC.

Print HIR along side LIR as the latter is generated.

Print the sizes of the elements of the built image.

Print the sizes of the native image heap as the image is built.

Print image object hierarchy.

Print JNI methods added to generated image.

Include the LIR as comments with the final assembly.

Print statistics of methods in native image heap.

Print hit, miss and partial match counts after comparision with collected profiles. It is used for testing.

Report analysis statistics.

Print profiling information when parsing a method's bytecode.

Print path for @RestrictHeapAccess warnings.

Print warnings for @RestrictHeapAccess annotations.

Print call tree of methods available for runtime compilation.

Print truffle boundaries found during the analysis.

Print types used for Java synchronization.

Print (to stderr) a DOT graph of the @Uninterruptible annotations.

Print information about classes, methods, and fields that are present in the native image.

The policy to use, must be empty for automatic resolution. 

Comma-separated list of analysis policies for exploring the methods in the call graph and for inlining, empty for no
policy.

Control probabilistic profiling on AMD64.

Control the naming and granularity of the counters when using ProfileAllocations. [Extra help available]

Enable profiling of allocation sites.

Track the progress of the static analysis.

Emit profiling of backedges.

Track the creation of constant objects.

Print logging information during object file writing.

Integer greater than zero representing the duration in seconds that will be used to trigger a profile capture. Any 
integer less than one disables periodic dumps.

Emit profiling of invokes.

Enable profiling of monitor operations.

Excludes time spent in invoked methods; measures total time including subcalls when turned off.

Profile simple methods.

Instrument AOT compiled code to collect data for profile-guided optimization into default.iprof file.

Value should point to a profile dump file. 

A comma-separated list of files from which to read the data collected for profile-guided optimization of AOT compiled 
code (reads from default.iprof if nothing is specified).

Lower bound for point hit count when compared to collected profiles. It is used for testing. 

Maximum depth of dependency when propagating equals property. 

Enable support for Memory Protection Keys.

PullThroughPhiOptimization: Percentage in node cost graph size for the floating node duplication budget. Computed 
relative to the method's graph size.

Directory where query code for target platform should be output. 

Number of times an allocation that queues behind a GC will retry before printing a warning. 

Chose the scheduling strategy for inserting the read proxies. 

Re-associate loop invariants and constants.

Disable optional dead code eliminations.

Select type of reference discovery policy: reference-based(0) or referent-based(1). 

One or several (comma-separated) paths to JSON files that specify which program elements should be made available via 
reflection. [Extra help available]

Resources describing program elements to be made available for reflection (see ReflectionConfigurationFiles).

Enable trace logging for reflection plugins.

Comma separated list of registers that register allocation is limited to.

The coefficient used to compute the inlining threshold; the higher, the hard to inline. 

Allow a type flow state to contain types not compatible with its declared type.

Enable the type flow saturation analysis performance optimization.

Use linker option to prevent unreferenced symbols in image.

Report error if [:{,}] is discovered during analysis (valid values for UsageKind: 
InHeap, Allocated, Reachable).

Show exception stack traces for exceptions during image building.).

Report performed substitutions.

Print unsafe operation offset warnings.).

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.

Size in bytes of an address space to reserve for auxiliary images. 

Dynamically resize (survivor space) promotion LAB's.

Dynamically resize TLAB size for threads.

Files describing Java resources to be included in the image. 

Resources describing Java resources to be included in the image. 

Try avoid unrolling vectorizable loops.

Return after analysis.

Return special registers from functions in LLVM bitcode. This may decrease performance if the target doesn't support 
returning multiple values from a function.

Enable or disable Java assert statements at run time. 

Provide debuginfo for runtime-compiled code.

Directory where Java source-files will be placed for the debugger.

Enable or disable Java system assertions at run time.

Allow SIMDVectorization to vectorize load to store opportunities when there are no matching SIMD operations between lad 
and store.

Enable matching of singleton groups to increase corner-case matching.

Set the number of dominating and dominated blocks scanned per block. 

Exit the VM if I can not come to a safepoint in this many nanoseconds. 0 implies forever. 

Print a warning if I can not come to a safepoint in this many nanoseconds. 0 implies forever. 

Object scanning in parallel.

Simulation can either only process fixed nodes or schedule the graph and also process floating nodes.

One or several (comma-separated) paths to JSON files that specify lists of serialization configurations. [Extra help 
available]

Resources describing program elements to be made available for serialization (see SerializationConfigurationFiles).

One or several (comma-separated) paths to JSON files that specify lists of serialization configurations. [Extra help
available]

Resources describing program elements that must not be made available for serialization.

Comma-separated list of service providers that should be excluded.

Comma-separated list of services that should be excluded.

Build shared library.

Writes to the VM log information about the compiler configuration selected. 

Print the name of each dump file path as it's created.

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.

Handle simple cases for inflated monitors in the fast-path.

Maximum number of calls in a simple method. 

Maximum number of nodes in a graph for a simple method. 

Maximum number of indirect calls in a simple moethod. 

Use DBDS algorithm to simulate the impact of peeling on a loop.

Ignore low frequency branches during simulation.

If the previous low-level graph size of the method exceeds the threshold, it is not inlined. 

Reduces the likelihood of exploring call graphs with IR size much larger than the root. 

Enable counters for various paths in snippets.

Number of milliseconds per MB of free space in the heap. 

Constrain debug info generation to the comma-separated list of package prefixes given to this option. 

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.

List of used-defined paths (separated by the system's path-separator character) in addition to automatic 
SourceSearchPath detection.

Support multiple isolates. 

Select a strategy to mitigate speculative bounds check bypass (aka Spectre-PHT or Spectre V1). [Extra help available] 

Mask indices to scope access to allocation size after bounds check.

Move loop invariant guards (e.g., array bounds checks) out of loops.

Speculates that arrays have exact type to optimize store checks.

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.

The size of each thread stack at run-time, in bytes. 

Provide method names for stack traces.

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.

Start flight recording with options. 

Builds a statically linked executable with libc dynamically linked.

Build statically linked executable (requires static libc and zlib).

Stress the code emitting explicit exception throwing code.

Stress the code emitting invokes with explicit exception edges.

Stress the code by emitting reads at earliest instead of latest point.

Use strict checks when performing query code compilation.

String.indexOf invocations will be evaluated at compile time if the receiver is a constant and its length is lower than 
this value.

Strip debug info from the image.

Comma-separated list of file names with declarative substitutions. 

Comma-separated list of resource file names with declarative substitutions. 

Support runtime compilation in separate isolates (enable at runtime with option CompileInIsolates). 

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.

Support a per-thread timer that is called at a specific interval.

Suppress console error output for unittests.

Suppress console normal output for unittests.

Ratio of eden/survivor space size. 

Allocation averaging weight. 

Maximum TLAB waste at a refill (internal fragmentation). 

Starting TLAB size (in bytes); zero means set ergonomically. 

Increment allowed waste at slow allocation. 

Percentage of Eden that can be wasted. 

Target wasted space in last buffer as percent of overall allocation. 

Selects native-image compilation target (in - format). Defaults to host's OS-architecture pair. 

Desired percentage of survivor space used after scavenge. 

The number of nanoseconds before tearing down an isolate gives a failure message. 0 implies no message. 

The number of nanoseconds before and between which tearing down an isolate gives a warning message. 0 implies no 
warning.

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.

Throw unsafe operation offset errors.).

Backedge notification frequency. 

Backedge profile probability. 

Inlinee invocation notification frequency (-1 means count, but do not notify). 

Invocation notification frequency. 

Invocation profile probability. 

Do profiling and callbacks to tiered runtime.

Profile method execution 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.

Turn on the benchmark counters, and displays the results every n milliseconds. 

Comma separated names of timers that are enabled irrespective of the value for Time option. An empty value enables all 
timers unconditionally.

Enables detailed tracing of auxiliary image events.

Enables detailed tracing of auxiliary image events.

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.

Comma-separated list of fully-qualified class names that class initialization is traced for. 

Print logging information for runtime code cache modifications.

Print verbose logging information for every deoptimization.

Print logging information for every deoptimization.

Trace execution of stub used to handle an exception thrown by a callee.

Trace heap chunks during collections, if +VerboseGC and +PrintHeapShape.

Traces inlining performed during bytecode parsing.

Enable inlining decision tracing in stubs and snippets.

Enable tracing of inlining decisions.

The trace level for the LIR generator. 

When enabled, localization feature details are printed.

When enabled, logging feature details are printed.

Trace monitor operations in methods whose fully qualified name contains this substring.

Trace monitor operations on objects whose type contains this substring.

Trace all native tool invocations as part of image building.

Comma-separated list of fully-qualified class names that object instantiation is traced for. 

Traces use of plugins during bytecode parsing.

Enable tracing of security services automatic registration.

When enabled, each service loader resource and class will be printed out to standard output.

Trace execution of the stub that routes an exception to a handler in the calling frame.

Trace VMOperation execution.

Track the callers for methods and accessing methods for fields.

Enable (if Count is enabled) graph size tracking during every duplication iteration.

Track inlining statistics (inlining duration, call tree size, compiler node counts, and the number of callsites). One 
of: none, interactive.

Track the input for type flows.

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.

Track source stack trace where a node was inserted into the graph.

Track the NodeSourcePosition.

Determines if references from runtime-compiled code to Java heap objects should be treated as strong or weak.

Graphs with less than this number of nodes are trivial and therefore always inlined. 

Loop peeling will consider any loop with a size (in terms of estimated machine instructions) below this value to be a 
prime candidate for peeling. Larger loops will only be considered for peeling if the simulated benefit of peeling is
relatively high. The larger the loop, the greater the expected benefit has to be.

Fail if a method known as not suitable for partial evaluation is reachable for runtime compilation.

Enforce that the Truffle runtime provides the only implementation of Frame.

Check that CompilerAsserts.neverPartOfCompilation is not reachable for runtime compilation.

Select a compiler configuration for Truffle compilation (default: use Graal system compiler configuration).

Inline trivial methods in Truffle graphs during native image generation.

Enable support for Truffle background compilation.

Propagate Truffle compilation errors.

Determines whether to treat final fields with default values as constant.

PullThroughPhiOptimization: Enable floating node duplication over multiple phi nodes at once.

PullThroughPhiOptimization: Enable floating node duplication over phis where the target node has different phis as 
input.

Increases or decreases the time spent exploring inlining opportunities under the assumption that more time results in 
better peak performance and less time reduces time to reach (a lower) peak performance. The value of the option is
clamped between -1 and 1 inclusive. Anything below 0, reduces the exploration time and anything above 0 increases
exploration time. Note that this option is only a heuristic and should be tuned for any specific application.

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.

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.

How many levels of inputs to print. A value of 0 prints only the target flow. 

How many levels of outputs to print. A value of 0 prints only the target flow. 

The maximum number of types recorded in a type flow. -1 indicates no limitation. 

Denotes the call graph size that is considered medium size. 

The increase in estimated typical graph size after inlining, per each extra invoke. 

The maximum in estimated inlined typical graph size. 

The typical graph size at which inlining pressure must start growing. 

Report unresolved elements as errors.

Unroll empty loops.

Unroll inverted (tail counted) loops.

Unroll loops with multiple loop ends.

Unroll loops with multiple loop exits.

Unsafe automatic substitutions logging level: Disabled=0, Basic=1, Info=2, Debug=3.). 

Print unsafe operation offset warnings.).

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.

Indicate the C Annotation Processor to use previously cached native information when generating C Type information.

Use callee saved registers to reduce spilling for low-frequency calls to stubs (if callee saved registers are supported 
by the architecture).

Enables CompilationStatistics.

Use bit-shifting to enlarge the address range with narrow references.

Use compressed references (32-bit instead of 64-bit references to Java objects).

Enable detection and runtime container configuration support.

Determines if VM operations should be executed in a dedicated thread.

Dynamically choose the number of threads up to a maximum of ParallelGCThreads parallel collectors will use for garbage 
collection work.

Encode and decode snippets and substitutions before parsing to test libgraal code path. This option is ignored in the 
context of libgraal.

Use a no-op GC.

Determines if the G1 garbage collector should be used.

Use Graal-generated stubs for complicated LIR operations instead of embedding all the emitted code.

Turn on graph caching.

Emit debuginfo debug.svm.imagebuild.* sections with detailed image-build options.

Embed python helper in binary.

Selects the libc implementation to use. Available implementations: glibc, musl, bionic.

Build with Loom JDK.

Use thin locking fast path in snippets.

Use PartialEscapeSelectiveInliningPhase to give PartialEscape phase more opportunities.

Flag to disable jvmstat instrumentation for performance testing.

Use priority-based inlining.

Populate reference queues in a separate thread rather than after a garbage collection.

Determines if a remembered sets is used, which is necessary for collecting the young and old generation independently.

Use a serial GC.

Automatically register services for run-time lookup using ServiceLoader.

Use a cache for snippet graphs.

Use a LRU cache for snippet templates.

Determines if the string inlining optimization should be used.

Use thread-local object allocation.

Use thin locking to optimize monitor operations.

Use traps for null checks instead of explicit null-checks.

Use typed unboxed arguments for Truffle compilations.

Use typed unboxed return value for Truffle compilations.

Use absolute path for source-filenames in VTune events.

Path to VTune installation (usually /opt/intel/vtune_amplifier). 

Only generate SIMD loops for vector folds expected to iterate at least this many times. 

Enable vectorized array copy intrinsics.

Unroll vectorized loops. 

Enable vectorization.

Enable vectorized array initialization.

Enable vectorization of conditional code.

Enable vectorization of loops with conditional deopts before writes.

Enable vectorization of loops implementing a higher-order 'fold' function.

Enable vectorization of vector gather operations.

Enable vectorization of hashCode patterns.

Enable vectorization of loops.

Enable vectorization of loops implementing a higher-order 'map' function.

Enable vectorization of loops with negative strides.

Enable detection of SIMD patterns.

Enable vectorization of loops with safepoints.

Enable vectorization of sequence values.

Print more information about the heap before and after each collection.

Value should point to a file where we dump the output of the verification phase if mismatches were encountered.

Verify memory system after GC.

Emit extra code to dynamically check monitor operations are balanced.

Verify memory system before GC.

Verify that all possible deoptimization entry points have been properly compiled and registered in the metadata.

Verify memory system during GC (between phases).

GC invoke count where +VerifyHeap kicks in. 

Perform expensive verification of graph inputs, usages, successors and predecessors.

Verify graphs often during compilation when assertions are turned on.

Verify before - after relation of the relative, computed, code size of a graph.

Perform platform dependent validation of the Java heap at returns.

Verify the heap before and after each collection.

Verify that there are no new unused nodes when performing killCFG.

Run expensive checks to verify the graph after loop vectorization.

Verify naming conventions during image construction.

Turn on a verification phase to check all probabilities injected in nodes match profiles.

Verify all object references if VerifyHeap is enabled.

Verify the remembered set if VerifyHeap is enabled.

Verify GC remembered sets.

Add code to verify that eliminated barriers weren't needed.

Pattern for specifying scopes in which logging is enabled. See the Dump option for the pattern syntax.

Build the native image for a virtualized environment. The argument is a path to a JSON file that specifies the 
virtualized environment properties.

Allocate code cache with write access, allowing inlining of objects.

Size of young gen promotion LAB's (in HeapWords). 

Fill unused memory chunks with a sentinel value.

After use, Fill memory chunks with a sentinel value.

Before use, fill memory chunks with a sentinel value.

Zero out the newly created TLAB. Default: - (disabled). 
[total]:   2,415.17 ms,  0.96 GB