VM Options Explorer - GraalVM native-image JDK24

Deprecated.

Enable use of priority inlining during AOT compilation.

Perform trivial method inlining in the AOT compiled native image.

Prefix that is added to the names of API functions. 

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

Print a trace and abort the build process if any field matching the specified pattern becomes reachable. 

Print a trace and abort the build process if any method matching the specified pattern becomes reachable. 

Throws an exception on potential type conflict during heap persisting if enabled.

Print a trace and abort the build process if any type matching the specified pattern becomes reachable. 

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.

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

Add additional header bytes to each object, for diagnostic purposes. 

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.

A comma-separated list of file paths containing the adopted profiles. We profile frequently used code (e.g., the Java 
standard library), and cache collected profiles. Adopted profiles then enable the PGO without the profiling. .

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. Serial and epsilon GC only. 

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.

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 using deprecated @AutomaticFeature annotation. If set to false, an error is shown instead of a warning.

Instead of abort, only warn if image builder classes are found on the image class-path.

Instead of abort, only warn if --initialize-at-build-time= is used.

Allow MethodTypeFlow to see @Fold methods.

Deprecated.

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

Allow all instantiated types to be allocated via Unsafe.allocateInstance().

Enables features that allow the VM to be inspected during run time.

Determines if VM internal threads (e.g., a dedicated VM operation or reference handling thread) are allowed in this 
image.

Unconditionally inline intrinsics.

Force all freshly committed pages to be pre-touched. G1 GC only.

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. 

Mark singleton as application layer only. 

Evaluates array region equality checks at compile time if the receiver is a constant and the length of the array is less 
than this value.

Force use of slow path for assembly GC barriers. Intended for debugging only.

Use generated assembly for GC barriers if supported by the platform.

Assert class initialization is specified for all classes.

Assume all int loops, no matter how complex, finish quickly and arethus short running.

Only print diagnostic output that is async signal safe.

Determines if the reference handling is executed automatically or manually.

Automatic unsafe field value transformation logging level: Disabled=0, Basic=1, Info=2, Debug=3.). 

Enable the auxiliary engine cache features at runtime.

Size in bytes of the auxiliary image. 

Path to the auxiliary image.

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

Blinds constants in code with a random key.

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

Break chained phis.

Show code and heap breakdowns as part of the build output.

Color build output (enabled by default if colors are supported by terminal).

Print GC warnings as part of build output.

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.3.json.

Show links in build output (defaults to the value of BuildOutputColorful).

Internal option to forward the value of NATIVE_IMAGE_OPTIONS.

Deprecated, option no longer has any effect.

Report progress in build output (default is adaptive).

Show recommendations as part of the build output.

Silence build output.

Include mapped machine code size breakdown in the Build Report (only available when node source position tracking is 
enabled).

Create a Native Image Build Report.

Determine if the optimizer should run aggressive optimizations on cold code (rarely executed code during the PGO run).

Perform more aggressive optimization on compilation units deemed to be hot.

Apply sampling based profiles to candidates for inlining before doing the inlining.

Maximum number of invocations of a non-sampled method beyond which that method will be considered cold. Will result in 
less optimizations performed on such compilation units.

Apply a bonus to the priority of hot cutoff nodes during exploration. Set to 0 to disable. 

Apply a bonus to the priority of hot nodes during inlining. Set to 0 to disable. 

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.

Whether to print the hot compilation units.

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.

Options for configuring control flow integrity (CFI) enforcement. [Extra help available] 

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

Perform CMove transformation on every IfNode possible.

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.

C standard to use in header files. Possible values are 'C89', 'C99', and '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.

Verify if the current graph state allows GVN to be performed.

Temporary option to disable checking of image builder module dependencies or increasing its verbosity. 

At CEntryPoints check that the passed IsolateThread is valid.

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.

Clamp the ML-inferred profiles.

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

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

Clear the debug metrics after bootstrap.

Use the closed type world dynamic hub representation. This is only allowed when the option ClosedTypeWorld is also set 
to true.

Assume new types cannot be added after analysis.

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.

When code-section layout optimization is on, specify size of the graph used for closest-is-best algorithm.

When code-section layout optimization is on, define if a size limit within closest-is-best algorithm is used.

Enable code-section layout optimization when writing the native image (optimization valid only with --pgo).

Collect information during image build about devirtualized invokes and bytecode exceptions.

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

Color build output ('always', 'never', or 'auto'). 

Collect old generation by compacting in-place instead of copying. Serial GC only.

Treats compilation bailouts as 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. 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.

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. Must be 0 or >= 0.001.

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

Options that are passed to each compilation isolate. Individual arguments are separated by spaces. Arguments that 
contain spaces need to be enclosed by single quotes.

Time limit in seconds before a compilation expires (0 to disable the limit) because no progress was made in the 
compiler. Must be 0 or >= 0.001.

Delay in seconds before compilation progress detection starts. Must be 0 or >= 0.001.

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

Number of seconds after which a compilation appearing to make no progress causes the VM to exit (0 disables VM exiting). 

If in tiered mode, compiles 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, uses the compiler configuration with the greatest auto-selection 
priority. To see available configurations, use the value 'help'.

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

Number of concurrent GC threads G1 will use. 

Run conditional elimination before static analysis.

Eliminates redundant conditional expressions and statements where possible. This can improve performance because fewer 
logic instructions have to be executed.

Directories directly containing configuration files for dynamic features at runtime. 

Resource path above configuration resources for dynamic features at runtime. 

Enable runtime instantiation of reflection objects for non-invoked methods.

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

How many bytes to pad fields and classes marked @Contended with. 

Use PGO sampling data to do context aware inlining.

Automatically copy the necessary language resources to the resources directory next to the produced image.

Return copies of primitive element arrays when referencing them from native code.

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

See CostReductionFactor. 

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

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

See CountedStripMiningBudget. 

Code size budget of the strip mining transformation in terms of NodeCostSize. 

The max number of iterations the counted inner loop takes. 

Print counter phi values on each outer and inner loop iteration.

Minimal frequency to consider a loop for strip mining. 

Code size in NodeSize defining when code size heuristics starts capping strip mining.

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

If non-zero, converts an exception triggered by the CrashAt option into a fatal error if a non-null pointer was passed 
in the _fatal option to JNI_CreateJavaVM. The value of this option is the number of milliseconds to sleep before
calling _fatal. This option exists for the purpose of testing fatal error handling in libgraal.

Replaces first exception thrown by the CrashAt option with an OutOfMemoryError. Subsequently CrashAt exceptions are 
suppressed. This option exists to test HeapDumpOnOutOfMemoryError. See the MethodFilter option for the pattern syntax.

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.

Create a `jvm` shim for native libraries that link against that library.

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

Specify maximum inlining depth to consider when building DebugCodeInfo. 

Do not use SourceMappings for generating DebugCodeInfo (i.e. only use Infopoints).

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.

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

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

Default frequency for loops with unknown local frequency. 

Default unswitching factor for control split node with unknown profile data. 

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.

Specifies the number of deoptimizations allowed per compilation unit until optimistic optimizations are disabled. 

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

Applies counted loop optimization to tail-counted loops.

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

Devirtualizes callees that are hot.

Option values to use during a retry compilation triggered by CompilationFailureAction=Diagnose or 
CompilationFailureAction=ExitVM. If the value starts with a non-letter character, that character is used as the
separator between options instead of a space. For example: "DiagnoseOptions=@Log=Inlining@LogFile=/path/with space.".

Specifies the number of entries that diagnostic buffers have. 

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.

Sets the dir where diagnostic information is dumped. 

Enables the diagnostic mode.

Ignore calls to System.gc().

Disable intercepting exceptions in debug scopes.

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

Disable the substitutions matched by the option value. A value can be a fully qualified method name with parameter list, 
a fully qualified method name without parameter list, or a fully qualified type name. When multiple methods match a
value, then all matching substitutions are disabled.

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

List of comma separated URL protocols that must never be included. 

Do not move allocations when the parser encounters allocations covered by an exception handler for OutOfMemoryError.

Dump the current graph after every bci to IGV.

Dump lowering after every node to igv.

Gather statistics on local variables and their lifetimes relative to FrameStates.

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.

Dump folded reflection elements.

Create a heap dump and exit.

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.

Dump options that must be passed during isolate creation and not set later.

Dump a JSON array containing all methods included in the image and exit.

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.

Dump all graphs for outlined String, StringBuilder, and StringBuffer aggregations.

The directory where various Graal dump files are written. 

Dumps all runtime compiled methods on SIGUSR2.

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.

Performs Duplications as long as there is any sane improvement.

Enable or Disable the Hot method duplication phase.

See DuplicationBudgetFactor. 

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

Specifies the percentage in node cost graph size for the duplication budget (computed relative to the methods code 
size). The greater the budget the more code duplication can be performed. This can improve performance at the cost of
additional code size.

See DuplicationCostReductionFactor. 

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

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

Enable early code emission order computation instead of late code emission order computation.

Tries to improve code generation by making checkcast operations better optimizable early in the compilation pipeline.

Performs early global value numbering on statements and expressions directly after parsing. This can clean up the 
intermediate representation and simplify later optimizations. .

Performs early loop-invariant code motion.

Emits substitutions for String methods. This can improve performance because the compiler can use optimized intrinsics 
for certain string operations.

Emit additional data as a result of the build. Use 'build-report' to emit a detailed Build Report, for example: '--emit 
build-report' or '--emit build-report=/tmp/report.html'.

Add all security service classes to the generated image.

Enable the feature that provides support for logging.

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), 'threaddump', 'nmt' (experimental), 'jcmd'
(experimental), or 'all' (deprecated behavior: defaults to 'all' if no argument is provided). For example:
'--enable-monitoring=heapdump,jfr'.

A comma-separated list of modules that are permitted to perform restricted native operations. The module name can also 
be ALL-UNNAMED.

Enables support for dynamic method address resolution. Should never be enabled directly.

Enable automatic registration of security services.

Enables signal handling. 

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.

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

Enterprise PEA Iterations. 

Performs an extended version of early global value numbering on a graph. (Considers only graphs without floating 
guards.).

Enterprise Loop Inversion for GVN.

Tries to improve counted loop detection by specially handling math exact operations with code duplication.

Enables the advanced version of partial loop unrolling that considers more loop shapes for unrolling.

Log all range check sub values to stdout.

Performs range check eliminations for Java long type range checks.

Runs more read eliminations early in the compilation pipeline.

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

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

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

Throw an error when there are discrepancies between layered open world type information. This is an experimental option 
which will be removed.

Run partial escape analysis on compiler graphs before static analysis.

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

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

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.

Exit on the first occurrence of an out-of-memory error that is thrown because the Java heap is out of memory.

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. 

Soft upper limit for used eden size. The hinted GC will be performed if the used eden size exceeds this value. 

A System.gc() request invokes a concurrent collection. G1 GC only.

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] 

Usage: -XX:FlightRecorderOptions=[option[=value][,...]]. [Extra help available] 

Enable Java Flight Recorder.

Try to float non-constant division operations to expose global value numbering of divisions.

Fold SecurityManager getter.

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.

Force-dump graphs before compilation.

Force an explicit compiler node for Reference.reachabilityFence, instead of relying on FrameState liveness.

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

Also invert loops that look like they can be inverted.

Force partial unrolling of loops if at all possible.

Support for calls via the Java Foreign Function and Memory API.

Files describing stubs allowing foreign calls. 

Resources describing stubs allowing foreign calls. 

Gather statistics on local variables and their lifetimes relative to FrameStates.

Perform a full GC of the libgraal heap after every compile to reduce idle heap and reclaim references to the HotSpot 
heap.  This flag has no effect in the context of jargraal.

Performs full unrolling as a Partial Escape Analysis Cleanup.

Maximum factor by which full unrolling can increase code size for large graphs. The FullUnrollSmallGraphThreshold option
determines which graphs are small.

Maximum factor by which full unrolling can increase code size for small graphs. The FullUnrollSmallGraphThreshold option
determines which graphs are small.

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.

Performs loop unrolling optimization. .

Target duration of individual concurrent marking steps in milliseconds. 

The number of parallel remembered set update threads. Will be set 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 1m, 2m, 4m, 8m, 16m, 32m, 64m, 128m, 256m, or 512m. 

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.

A target percentage of time that is allowed to be spend on processing remembered set 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.

Number of entries in an SATB log buffer. 

Size of an update buffer. 

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

Control whether concurrent refinement is performed. Disabling effectively ignores G1RSetUpdatingPauseTimePercent.

Verify the code root lists attached to each heap region.

Card table entry size (in bytes) for the G1 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 gc. G1 GC only. 

Time slice for MMU specification. G1 GC only. 

Adaptive size policy application time to GC time ratio. G1 GC only. 

Gather statistics about each safepoint.

Generate Java code before high tier lowering for methods that MethodFilter.match this string.

Enables inlining of generated expressions. If set to false, each node in the graph will correspond to a variable.

Naming convention for generated classes, fields and methods. 

Path for saving generated Java code. If the value is omitted the debug dump path will be used.

Print the name of each generated code file as it's created. This overrides the default behavior set by 
ShowDumpFiles=true.

Generate comments alongside variable declarations.

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.

Insert debug info into the generated native image or library. 

Create a embedded-resources.json file in the build directory. The output conforms to the JSON schema located at: 
docs/reference-manual/native-image/assets/embedded-resources-schema-v1.1.0.json.

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.

Compile the application for GraalOS.

Graal graph compression is performed when percent of live nodes falls below this value. 

Develop demographics of the object references visited. Serial GC only.

Ensure all created SubstrateTypes are linked.

Duplicate only loops where at least this fraction of guards can be hoisted.

See GuardHoistingLoopDuplicationMaxSize.

Duplicate only loops up to this estimated size. 

See GuardHoistingLoopDuplicationMinBodyIterations.

Duplicate only loops with at least this many expected iterations of the loop body.

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

Duplicate certain loops and eliminate their guards.

Maximum execution probability of a branch that contains the ControlSinkNode. 

Minimum estimated assembly size of a branch that triggers the exit guard. 

Minimum loop body execution probability. 

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.

A prefix that is used for heap dump filenames if no heap dump filename was specified explicitly.

Dump heap to file (see HeapDumpPath) the first time the image throws java.lang.OutOfMemoryError because it ran out of 
Java heap.

Path of the file or directory in which heap dumps are created. An empty value means a default file name will be used. An 
existing directory means the dump will be placed in the directory and have the default file name.

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

Control heap verifier verbosity level: 0 - quiet, 1 - info, 2 - warning, 3 - all. 

Enable EE partial unrolling in high tier.

Unswitch loops in high tier.

Minimal self time for a compilation unit to be considered hot globally. 

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. 

Testing only option that forces deopts for exception throws.

Testing only option that forces deopts for exception throws.

Print inlining optimizations.

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

Weight of a materialization triggered by an Invoke corresponding to a CutoffNode in the CallTree for IPEA. 

Indicates how often to run IPEA analysis. 

Boost for Parent Nodes based on reduction of materializations. 

Indicates how often to force IPEA analysis when otherwise inlining would not continue. 

Track IPEA statistics in substratePriorityInliner. 

Boost for CutoffNode for single escaping object. 

Ignores duplications with a bad benefit cost relation.

Ignore the maximum heap size while in VM-internal code. Serial GC only.

Ignore the maximum heap size while in VM-internal code. Serial GC only.

Image Build ID is a 128-bit UUID string generated randomly, once per bundle or digest of input args when bundles are not 
used.

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

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

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

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

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

Common prefix used by method symbols in image. 

Determines if implicit exceptions are fatal if they don't have a stack trace.

Include all classes, methods, fields, and resources from the class path.

Include all classes, methods, and fields from given modules. 

Include all classes, methods, fields, and resources from given paths. 

Make all hosted locales available at run time.

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

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.

Automatically include the necessary language internal resources in the produced image.

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

Include a list of methods included in the image for runtime inspection.

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. 

Assemble a Software Bill of Materials (SBOM) for the executable or shared library based on the results from the static 
analysis. Comma-separated list can contain 'embed' to store the SBOM in data sections of the binary, 'export' to save
the SBOM in the output directory, 'classpath' to include the SBOM as a Java resource on the classpath at
'META-INF/native-image/sbom.json', 'strict' to abort the build if any class cannot be matched to a library in the SBOM,
'cyclonedx' (the only format currently supported), and 'class-level' to include class-level metadata. Defaults to
--enable-sbom=embed,cyclonedx. For example: '--enable-sbom=embed,export,strict'.

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

Limit of the number of dominating if nodes to consider in infeasible path correlation to avoid compile time explosion. 

The garbage collection policy, either Adaptive (default) or BySpaceAndTime. Serial GC only. 

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

Percentage of real memory used for initial heap size. G1 GC only. 

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. G1 GC
only.

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.

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

Maximum call depth for method inlined before static analysis. 

Maximum number of methods inlined 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 number of invokes for constructors inlined into factory methods before static analysis.

Maximum number of computation nodes for constructors inlined into factory methods before static analysis.

Maximum call depth for method handle internals inlined before static analysis.

Maximum number of methods inlined for method handle internals before static analysis.

Maximum number of invokes for method handle internals inlined before static analysis.

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

Deprecated, option no longer has any effect.

Maximum depth when inlining during bytecode parsing. 

Inlines trivial methods during bytecode parsing.

Embeds all the emitted code for Graal-generated stubs.

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.

Inlines the vtable stub for method dispatch during inlining.

Performs inlining optimization. This can improve performance because callees are specialized to the types and values of 
callers.

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.

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.

Deprecated, has no effect. 

Intrinsify String.format with constant format strings.

Uses compiler intrinsifications.

Minimal loop frequency for a loop to be considered for inversion. 

Minimal relative frequency for a loop to be considered for inversion. 

Alignment in bytes for loop header blocks that have no fall through paths. 

Allow iterative peeling of loops up to this many times (each time the peeling phase runs). 

Allow iterative peeling of loops with an outer frequency bonus above this value.

Determines if stack traces are shown if exceptions occur in diagnostic commands that were triggered via jcmd.

Files describing program elements to be made accessible via JNI according to the schema at 
https://github.com/oracle/graal/blob/master/docs/reference-manual/native-image/assets/jni-config-schema-v1.1.0.json.

Resources describing program elements to be made accessible via JNI according to the schema at 
https://github.com/oracle/graal/blob/master/docs/reference-manual/native-image/assets/jni-config-schema-v1.1.0.json.

JNI functions will return more specific error codes.

Export Invocation API symbols.

Report information about known JNI elements when lookup fails.

Enable Java Native Interface (JNI) support.

Loads the specified native agent library. After the library name, a comma-separated list of options specific to the 
library can be used.

Loads the specified native agent library specified by the absolute path name. After the library path, a comma-separated 
list of options specific to the library can be used.

Enable JVM Tool Interface (JVMTI) support.

Print statistics collected during JFR-based execution sampler run.

Use JFR safepoint-based execution sampler.

Enable dynamic move profiling per method.

Path to jar file containing LIR instruction verifier.

Enable constant load optimization. 

Enable spill move elimination. 

Enable spill position optimization. 

Use linear scan stack slot allocation. 

Enable LIR level optimizations.

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

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. Serial and epsilon GC only. 

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

Experimental: Build a Native Image layer. 

Experimental: Build an image based on a Native Image layer. 

Specify the fully qualified class name of the LibGraalClassLoader implementation that gets used for building libgraal. 
[Extra help available]

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.

Require all types in given class or module-path entries to be fully defined at image build-time. [Extra help available] 

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]

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

Show CPU features specific to the target platform and exit.

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.

List observable modules and exit.

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

Load per compilation profile information.

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.

Number of cpu locals per counter. It has to be a power of 2. 

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.

Log discrepancies between layered open world type information. This is an experimental option which will be removed.

Log profiles predicted by the ML model, profiles tuned with the profile inference guards, and profiles collected via 
instrumentation profiling.

Log unique names which do not match across layers. This is an experimental option which will be removed.

Enable more verbose log output when available.

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

Enables logging of failed hash code injection.

Attempts to improve counted loop detection by finding more precise loop bounds.

Scaling factor of frequency difference computed based on loop ends or exits. 

Specifies the alignment in bytes for loop header blocks. 

Performs loop-inversion optimization.

Execute an endless loop before printing diagnostics for a fatal error.

Performs loop peeling optimization.

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 in NodeSize of the code to be duplicated during rotation. 

Enables loop rotation to let the compiler detect more loops as counted.

Specifies the number of nodes allowed for a loop unswitching per loop frequency. The number of nodes allowed for an 
unswitching is proportional to the relative frequency of the loop by this value.

Maximun value for the frequency factor of an invariant. 

Minimum value for the frequency factor of an invariant. 

Maximum loop unswitching code size increase in nodes. 

Lower bound for the minimun frequency of an invariant condition to be unswitched. 

Number of nodes allowed for a loop unswitching regardless of the loop frequency. 

Performs loop unswitching optimization.

Keep the original loop as the post-loop during loop vectorization.

The maximal number of fixed body nodes to consider in loop vectorization. 

Extract graph ML features to support the profile inference in the GraalVM Native Image.

Employ guards to tune the ML-inferred profiles.

Employ GNN ML model to infer profiles in the GraalVM Native Image.

Employ static profiler to infer profiles in the GraalVM Native Image.

Maximum size of marking stack in bytes. G1 GC only. 

Size of marking stack in bytes. G1 GC only. 

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.

Specifies 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. If the value is 0 there is no limit.

Maximum total size of NIO direct-buffer allocations. 

Maximum duplication anchor number. 

Specifies the maximum amount of extra effort to expend handling irreducible loops. A value <= 1 disables support for 
irreducible loops.

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

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 free bytes reserved for allocations, in bytes (0 for automatic according to GC policy). Serial GC only. 

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. 

The maximum number of nodes in a graph allowed after trivial inlining. 

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. G1 GC only. 

Physical memory size (in bytes). By default, the value is queried from the OS/container during VM startup. 

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

Maximum allowed address space size for the Java heap (0: no limit). 

Maximum number of expand/inline rounds during a single run of the phase. 

The maximum number words to randomly offset the entry of runtime installed methods. Use this option for less predictable 
entry points.

Maximum number of methods allowed for runtime compilation. 

See MaxSimulationIterations. 

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

Maximum number of survivor spaces. Serial GC only.

Maximum value for tenuring threshold. G1 GC only. 

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 split successors before aborting unswitching. 

Maximum number of unrolled alignment instructions. 

Maximum length of linear-code vector operations. 

Maximum desired size of the compiler graph in nodes. 

Specifies the maximum length of an array that will be escape analyzed. 

The maximum heap size as percent of physical memory. Serial and epsilon GC only. 

Specifies the maximum graph size (measured in nodes) for which inlining is explored for each call site. 

Max number of loop explosions per method. 

Specifies the 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. Serial and epsilon GC only. 

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.

Generate instructions for a specific machine type. Defaults to 'x86-64-v3' on AMD64 and 'armv8.1-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.

Enable EE partial unrolling in mid tier.

Unswitch loops in mid tier.

PullThroughPhiOptimization: Ignore low frequency branches during duplication. 

The minimum length of the methods context chains. 

Skip n duplication anchors. 

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). G1 GC only. 

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

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. G1 GC only. 

Minimum allowed TLAB size (in bytes). G1 GC only. 

Reduce number of inverted loop phis, necessary cleanup after loop inversion.

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

Minimal size in NodeSize to check the graph size increases of phases. 

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

Specifies the minimum size (in bytes) of constants to blind. . 

Minimum frequency a loop must have to be considered for loop peeling. 

Select the mode in which the missing reflection registrations will be reported. [Extra help available] 

Number of context lines printed for each missing registration error in Warn mode. 

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

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

Enable fallback to mremap for initializing the image heap.

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.

Deprecated, has no effect.

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

Name of the output file to be generated. 

Uses the native architecture, i.e., the architecture of a machine that builds an image.

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. G1 GC only. 

Initial new generation size (in bytes). G1 GC only. 

Force no direct relocations to be present in the text section of the generated image.

Benefit boost for strip mined non counted loops. 

See NonCountedStripMiningBudget. 

Code size budget of the non-counted strip mining transformation in terms of NodeCostSize. 

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

Ignores small loops from strip mining, the iv overhead can cause slowdowns.

The max number of iterations the counted inner loop takes. If -1, the frequency of the loop will 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.

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

Deprecated, option no longer has any effect. 

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.

Deprectated, has no effect. 

Deprectated, has no effect.

Deprectated, has no effect.

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

Initial tenured generation size (in bytes). G1 GC only. 

Omit generation of DebugLineInfo originating from inlined methods.

The fully qualified name of a no-arg, void, static method to be invoked in HotSpot when a HotSpotGraalRuntime is being 
shutdown.This option exists for the purpose of testing callbacks in this context.

Uses assumptions during compilation that may later be invalidated and cause code to be deoptimized.

Optimizes simple if branches with conditional moves. This can improve performance for patterns where branch prediction 
of a CPU does not work (if branches have nearly equal probability).

Replaces deoptimization points with movable guards where possible. This can help the optimizer to apply better code 
movement optimizations.

Deduplicates statements and expressions before control flow merges if they are equal. This can reduce code size.

Performs statement level code duplication at control flow merges to specialize code to branch values where possible.

Optimizes exact arithmetic where possible by rewriting it to non-exit counterparts iff provably no overflow is possible.

Performs floating-read optimization. This enables memory read operations to freely move in control-flow while respecting 
memory (anti)-dependencies. This helps to reduce memory accesses and can improve performance. .

Uses trapping null checks where possible to reduce explicit control flow for null checks. This can improve performance 
because explicit null checks do not have to be performed.

Optimize address operations that involve image heap constants.

Tries to perform lock elimination where possible. Reduces the number of monitorenter and monitorexit bytecodes if 
statically provable that they are not needed. .

Injects stamps on induction variables.

Duplicates methods to form hot part and cold part areas.

Propagate equality into dominated nodes.

Performs expression level code duplication at control flow merges to specialize code to branch values where possible.

Tries to remove redundant memory accesses (for example, successive reads of a non-volatile Java field).

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.

Eliminates redundant write barriers.

Performs aliasing analysis on arrays to determine which memory does not alias and enables more optimizations to be 
performed.

Use speculation and deoptimization in optimistic aliasing analysis.

Path to the directory where the optimization log is saved if OptimizationLog is set to Directory. Directories are 
created if they do no exist.

Enable the structured optimization log and specify where it is printed.

Optimize integer division operation by using various mathematical foundations to express it in faster, equivalent, 
arithmetic.

AMD64 only: Replace forward jumps (jmp, jcc) with equivalent but smaller instructions if the actual jump displacement 
fits in one byte.

Enables access node optimizations for loops. This can reduce the number of memory operations executed in the body of a 
loop.

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

Expand Vector API operations to optimized machine instructions.

Control code optimizations: b - optimize for fastest build time, s - optimize for size, 0 - no optimizations, 1 - basic 
optimizations, 2 - advanced optimizations, 3 - all optimizations for best performance.

Allocate memory for identity hash codes only for those objects that need it. 

Outline allocations into factory methods.

Outline string concatenation operations represented by invoke dynamic (indy) calls.

Allow outlined sequences of (StringBuilder|StringBuffer).append() to be materialized into a 
(StringBuilder|StringBuilder) instance.

Attempt to outline sequences of StringBuffer.append() operations.

Attempt to outline sequences of StringBuilder.append() operations.

Determines whether to always (if true) or never (if false) outline write barrier code to a separate function, trading 
reduced image size for (potentially) worse performance. Serial GC only.

Allow multiple compilations of the same method by overriding existing profiles.

The value that will be used to normalize adopted profiles.

Enables context sensitivity in PGO.

Once iprof files are loaded and merged, dump the resulting profile as an iprof file. 

Enable/disable normalization of profiles.

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). Each file must contain a single PGOProfiles object, serialized
in JSON format, optionally compressed by gzip.

Do not use dynamically collected profiles of CALL_COUNT, VIRTUAL_INVOKE, CONDITIONAL, MONITOR, or SAMPLER.

Prevent PGO run from failing if the profile version is not correct, and apply profiles on a best-effort basis.

Produce a file that contains the source mappings needed to use perf to produce profiles for PGO to this path.

Print a list of all calling-contexts that are dropped while loading profiles, as well as all contexts for which no 
profiles where found. NOTE: this is very verbose.

Print the quality metrics (relevance and applicability) for the provided profiles i.e. iprof file(s).

The value that will be used to normalize collected profiles.

Trace when legacy and replacement PGO profiles return different profiles.

Use 32-bit counter values for PGO (default is 64-bit counter values).

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

The largest page size of machines that can run the image. The default of 0 automatically selects a typically suitable 
value.

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

Wasted fraction of parallel allocation buffer. G1 GC only. 

Number of parallel threads G1 will use. 

Enable balancing of reference processing queues. G1 GC only.

Enable parallel reference processing whenever possible. G1 GC only.

Deprecated, option no longer has any effect.

Deprecated, option no longer has any effect.

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

Limit the parsing context depth. Default value is arbitrary set at 100. 

Performs partial escape analysis and scalar replacement optimization.

Enables partial redundancy scheduling. This is a special form of code scheduling that can revert the effects of partial 
redundancy elimination (for example, global value numbering) by duplicating expressions into branches. This can improve
performance if partially redundant expressions are only used in cold branches but the global value numbered version
not. .

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

See PartialUnrollCostReductionFactorMidTier.

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. 

See PartialUnrollMaxSizeMidTier. 

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. 

Performs partial loop unrolling optimizations. This is a special form of loop unrolling that splits a loop into a main 
and a post loop. The main loop can then be unrolled by a fixed amount of iterations. The post-loop performs any
necessary fixup iterations. This can improve performance because the loop control overhead is reduced in the unrolled
version.

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.

Stress test for the loop peeling optimization by applying it aggressively.

Peel only the loop with the specific loop begin node ID for debugging purposes. 

Minimal loop body iterations necessary to consider peeling. 

Minimal relative frequency of loop begin necessary to consider peeling. 

Cost/Benefit heuristic for EE simulation-based loop peeling in high tier: reduce cost by a constant factor when 
comparing with relative benefit.

Method Filter to ignore vectorization checks for peeling.

Cost/Benefit heuristic for EE simulation-based loop peeling in mid tier: reduce cost by a constant factor when comparing 
with relative benefit.

Increases 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. Serial GC with collection 
policy 'BySpaceAndTime' only.

Determines if the collected performance data should be written to a memory-mapped file so that it can be accessed by 
external tools.

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. 

Allows the addresses of pinned objects to be passed to other code.

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. G1 GC only. 

Files describing predefined classes that can be loaded at runtime according to the schema at
https://github.com/oracle/graal/blob/master/docs/reference-manual/native-image/assets/predefined-classes-config-schema-v1.0.0.json.

Resources describing predefined classes that can be loaded at runtime according to the schema at
https://github.com/oracle/graal/blob/master/docs/reference-manual/native-image/assets/predefined-classes-config-schema-v1.0.0.json.

Rewrite signed comparisons to unsigned ones if the result is equal.

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

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

Specify premain-class list. Multiple classes are separated by comma, and order matters. This is an experimental option. 

Saves stack base pointer on the stack on method entry.

Determines if aggressive method inlining should be used to prevent escaping of String.value.

Print logging information during compilation.

Change the output format of the analysis call tree, available options are TXT and CSV. See: Reports.md. 

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

Print analysis results statistics.

Enables dumping of basic blocks relative PC and frequencies in the dump directory.

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

Enable dumping CFG built during initial BciBlockMapping.

Print call edges with other analysis results statistics.

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 a list of active features.

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. Serial GC only.

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

Print summary GC information after each collection.

Prints the contents of the GOT.

Host part of the address to which graphs are dumped. 

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

Prints the difference in the graph state caused by each phase of the suite.

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 HIR along side LIR as the latter is generated.

Print the sizes of the elements of the built image.

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.

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

Print image object hierarchy.

Print the registered intrinsics in a format compatible with DisableIntrinsics.

Print JNI methods added to generated image.

Include the LIR as comments with the final assembly.

Print schedule result pre lowering to TTY.

Print statistics of methods in native image heap.

Print native memory tracking statistics on shutdown if native memory tracking is enabled.

Print histogram and metrics about the OutlinedSBMethods created.

Prints Infopoint call sites inside methods called through PLT/GOT.

Report analysis statistics.

Print to stdout when a profile is loaded.

Trace the state of the metadata forest after compilation.

Print profiling information when parsing a method's bytecode.

Make JVMCIPrintProperties show all Graal options, including debug and internal options.

Print path for @RestrictHeapAccess warnings.

Print warnings for @RestrictHeapAccess annotations.

Print call tree of methods reachable for runtime compilation.

Print methods available for runtime compilation.

Print counters collected while attempting to outline sequences of StringBuffer and StringBuilder operations.

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.

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.

Unconditionally inline all methods matching the pattern using the priority-based inliner. See the MethodFilter option 
for a description of the pattern syntax.

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.

Never inline methods matching the pattern using the priority-based inliner. See the MethodFilter option for a 
description of the pattern syntax.

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.

Track the creation of constant objects.

Print logging information during object file writing.

Profile types for instanceof checks.

Restrict saving or loading of profiles based on this filter. See the MethodFilter option for the pattern syntax.

Enable profiling of monitor operations.

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

Value should point to a profile dump file. 

If an exception happens during profile dumping, include it in the profile dump. Useful for debugging issues in shutdown 
hooks.

Custom path where the LCOV trace file is going be generated. The file is generated where the instrumented image is 
executed by default.

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

Emit a message to stderr after dumping a profile.

Replace profiling counters with path-profiling counters.

Dump the PGO profiles on shutdown.

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

Generate a LCOV trace file for an instrumented image.

A comma-separated list of package prefixes for which the PGO profiles are collected.

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

Use RDTSCP or RDPID if available to compute the index in the counter array. Setting this option to false ensures Knuth 
hashing is used instead.

Maximum depth of dependency when propagating equals property. 

Enable support for Memory Protection Keys.

See PullThroughPhiCodeSizeIncrease. 

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. 

Generate a query (i.e., C source code) if a CAP cache is used but the requested data is not found in the cache.

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

Resources describing reachability metadata needed for the program 
https://github.com/oracle/graal/blob/master/docs/reference-manual/native-image/assets/reachability-metadata-schema-v1.0.0.json.

Chose the scheduling strategy for inserting the read proxies.

Reassociates loop invariants and constants.

Disable optional dead code eliminations.

Reduce the amount of metadata in the image for implicit exceptions by removing inlining information from the stack
trace. This makes the image smaller, but also the stack trace of implicit exceptions less precise.

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; higher value means more aggressive inlining. 

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

Removes safepoints on counted loop ends.

Uses deoptimization to prune branches of code in the generated code that have never been executed by the interpreter.

Enable the type flow saturation analysis performance optimization.

Remove Deopt(Entries,Anchors,Proxies) determined to be unneeded after the runtime compiled graphs have been finalized.

Use linker option to prevent unreferenced symbols in image.

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

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

Report a fatal error on the first occurrence of an out-of-memory error that is thrown because the Java heap is out of 
memory.

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.

The number of bytes that should be reserved for the heap address space. 

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

Dynamically resize (survivor space) promotion LAB's. G1 GC only.

Dynamically resize TLAB size for threads. G1 GC only.

Files describing Java resources to be included in the image according to the schema at 
https://github.com/oracle/graal/blob/master/docs/reference-manual/native-image/assets/resource-config-schema-v1.0.0.json.

Resources describing Java resources to be included in the image according to the schema at 
https://github.com/oracle/graal/blob/master/docs/reference-manual/native-image/assets/resource-config-schema-v1.0.0.json.

Try avoid unrolling vectorizable loops.

Return after analysis.

Do not duplicate recursive methods but rather reuse a previous duplicate.

Rewrite the counter of a strip mined loop to have a 32bit type.

Reduces likelihood of spending a lot of time inlining when the IR is already large. 

At what size of the root IR graph do we start to consider applying a exploration penalty. 

Minimal loop frequency for a loop to be considered for rotation. 

Minimal relative frequency for a loop to be considered for rotation. 

Initializes and runs main entry point in a new native thread.

Run reachability handlers concurrently during analysis.

Enable or disable Java assert statements at run time. 

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: ''.

Deprecated, option no longer has any effect.

Enable or disable Java system assertions at run time.

Check for safepoints in method epilogue.

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. 

Perform profiling by sampling the AOT compiled code to collect data for profile-guided optimization. 

Path for saving compilation profiles. If the value is omitted the debug dump path will be used.

Save per compilation profile information.

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 the configuration of the selected compiler to the VM log. 

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.

Determines if JFR uses a signal handler for execution sampling. 

Configuration for SimulateClassInitializer: Collect all reasons why a class initializer cannot be simulated.

Configuration for SimulateClassInitializer: Maximum number of bytes allocated in the image heap for each class
initializer.

Configuration for SimulateClassInitializer: Maximum inlining depth during simulation.

Configuration for SimulateClassInitializer: Maximum number of loop iterations that are unrolled during simulation.

Simulate the effects of class initializer at image build time, to avoid class initialization at run time.

Uses the dominance-based duplication simulation (DBDS) algorithm to simulate the impact of peeling on a loop.

Ignores low frequency branches during simulation.

Size of the IR that forces a reduction in the number of IPEA runs made. 

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

See 'DuplicationBudgetFactor': for small graphs. 

Node cost graph size for a graph to be considered 'small'. 

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. G1 GC only. 

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.

Support multiple isolates.

Selects a strategy to mitigate speculative bounds check bypass (also known as Spectre-PHT or Spectre V1). . [Extra help 
available]

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

Stop speculative execution on all branch targets with execution barrier instructions.

Moves loop invariant guards (for example, array bounds checks) out of loops.

Speculates that arrays have exact type to optimize store checks. This can improve performance because less store checks 
have to be performed. (Dependent on loop invariant code motion.).

Check for stack overflow in method prologue.

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. 

Deprecated, has no effect.

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 a flight recording by passing a comma-separated list of key-value pairs. [Extra help available] 

Build statically linked executable with libc dynamically linked.

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

Builds image with libstdc++ statically linked into the image (if needed).

Perform constant folding in StrengthenGraphs.

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.

When configuration files do not match their schema, abort the image build instead of emitting a warning.

Perform checks that guards and deopts aren't introduced in graphs that should handle exceptions explicitly.

Deprecated, option no longer has any effect.

Throw an error if an attempt is made to overwrite/update a profile loaded from disk.

Use strict checks when performing query code compilation.

Invocations of String.indexOf are evaluated at compile time if the receiver is a constant and its length is less than 
this value.

Use a separate file for debug info.

Force strip mining of all loops that can be strip mined.

Performs strip-mining optimization on counted loops.

Strip mine inverted loops.

Performs strip-mining optimization on non-counted loops.

Instead of reporting substitution mismatches on the command line, write the result to the specified JSON file.

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.

Enable support for predefining additional classes.

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

Enable support for runtime class loading.

Please use '--gc=*' instead. Possible values are listed with '--help'. 

Suppress console error output for unittests.

Suppress console normal output for unittests.

Ratio of eden/survivor space size. G1 GC only. 

Specifies the compilation failure rate that indicates a systemic compilation problem (and a resulting warning). The 
value is made absolute and clamped to produce P, a value between 0 and 100. Systemic failure is detected if the
percentage 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.

Allocation averaging weight. G1 GC only. 

Maximum TLAB waste at a refill (internal fragmentation). G1 GC only. 

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

Increment allowed waste at slow allocation. G1 GC only. 

Percentage of Eden that can be wasted (half-full TLABs at GC). G1 GC only. 

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

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

Desired percentage of survivor space used after scavenge. G1 GC only. 

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.

Instead of warning, throw IOExceptions for link-at-build-time resources at build time.

Trigger exact handling of reflection, resources, JNI, and serialization from all types in the given class-path or
module-path entries. [Extra help available]

Enables exact and user-friendly handling of reflection, resources, JNI, and serialization. [Extra help available] 

Throw unsafe operation offset errors.

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.