-
Notifications
You must be signed in to change notification settings - Fork 29
/
All_Graal_CE_Flags
1101 lines (1052 loc) · 72 KB
/
All_Graal_CE_Flags
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
graalvm-ce-java17-22.2.0\bin>java -XX:+JVMCIPrintProperties --version
[JVMCI properties]
jvmci.Compiler = null [String]
Selects the system compiler. This must match the getCompilerName() value returned by a jdk.vm.ci.runtime.JVMCICompilerFactory provider. An empty string or the value "null" selects a compiler that will raise an exception upon receiving a compilation request.
jvmci.InitTimer = false [Boolean]
Specifies if initialization timing is enabled.
jvmci.ForceTranslateFailure = null [String]
Forces HotSpotJVMCIRuntime.translate to throw an exception in the context of the peer runtime. The value is a filter that can restrict the forced failure to matching translated objects. See HotSpotJVMCIRuntime.postTranslation for more details. This option exists soley to test correct handling of translation failure.
jvmci.PrintConfig = false [Boolean]
Prints VM configuration available via JVMCI.
jvmci.AuditHandles = false [Boolean]
Record stack trace along with scoped foreign object reference wrappers to debug issue with a wrapper being used after its scope has closed.
jvmci.TraceMethodDataFilter = null [String]
Enables tracing of profiling info when read by JVMCI.
Empty value: trace all methods
Non-empty value: trace methods whose fully qualified name contains the value.
jvmci.UseProfilingInformation = true [Boolean]
[Graal properties]
graal.ASMInstructionProfiling = null [String]
Enables instruction profiling on assembler level. Valid values are a
comma separated list of supported instructions. Compare with subclasses
of Assembler.InstructionCounter.
graal.AbortOnBenchmarkCounterOverflow = false [Boolean]
Abort VM with SIGILL if benchmark counters controlled by the
(Generic|Timed|Benchmark)DynamicCounters
option overflow. WARNING: No descriptive error message will be printed! In
case of an overflow, manual inspection of the emitted code is required.
graal.ActiveProcessorCount = -1 [Integer]
Overwrites the available number of processors provided by the OS. Any
value <= 0 means using the processor count from the OS.
graal.AggregatedMetricsFile = null [String]
File to which aggregated metrics are dumped at shutdown. A CSV format
is used if the file ends with .csv otherwise a more human readable
format is used. If not specified, metrics are dumped to the console.
graal.AliasArrayTypeFlows = true [Boolean]
Model all array type flows using a unique elements type flow
abstraction.
graal.AllocationProfilingThreshold = 1048576 [Integer]
The minimum size in bytes required for printing an allocation profiling
entry
graal.AllocationSiteSensitiveHeap = false [Boolean]
A context sensitive heap means that each heap allocated object is
modeled by using at least the allocation site.
graal.AlwaysInlineIntrinsics = false [Boolean]
Unconditionally inline intrinsics
graal.AlwaysInlineVTableStubs = false [Boolean]
graal.AnalysisContextSensitivity = "insens" [String]
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)
graal.AnalysisSizeCutoff = 8 [Integer]
The maximum size of type and method profiles returned by the static
analysis. -1 indicates no limitation.
graal.AnalysisStatisticsFile = null [String]
Analysis results statistics file.
graal.ArrayRegionEqualsConstantLimit = 4096 [Integer]
Array region equality checks will be evaluated at compile time if the
receiver is a constant and its length is smaller than this value.
graal.AutomaticReferenceHandling := false [Boolean]
Determines if the reference handling is executed automatically or
manually.
graal.BenchmarkCounterPrintingCutoff = true [Boolean]
Use a cutoff to print only most significant counters.
graal.BenchmarkCountersDumpDynamic = true [Boolean]
Dump dynamic counters
graal.BenchmarkCountersDumpStatic = false [Boolean]
Dump static counters
graal.BenchmarkCountersFile = null [String]
File to which benchmark counters are dumped. A CSV format is used if
the file ends with .csv otherwise a more human readable format is used.
The fields in the CSV format are: category, group, name, value
graal.BenchmarkDynamicCounters = null [String]
Turn on the benchmark counters. The format of this option is:
(err|out),start pattern,end pattern
Start counting when the start pattern matches on the given stream and stop when the end pattern occurs.
You can use "~" to match 1 or more digits.
Examples:
err, starting =====, PASSED in
out,Iteration ~ (~s) begins:,Iteration ~ (~s) ends:
The first pattern matches DaCapo output and the second matches SPECjvm2008 output.
As a more detailed example, here are the options to use for getting statistics
about allocations within the DaCapo pmd benchmark:
-XX:JVMCICounterSize=<value> -XX:-JVMCICountersExcludeCompiler \
-Dgraal.BenchmarkDynamicCounters="err, starting ====, PASSED in " \
-Dgraal.ProfileAllocations=true
The JVMCICounterSize value depends on the granularity of the profiling -
10000 should be sufficient. Omit JVMCICountersExcludeCompiler to exclude
counting allocations on the compiler threads.
The counters can be further configured by the ProfileAllocationsContext option.
We highly recommend the use of -Dgraal.AbortOnBenchmarkCounterOverflow=true to
detect counter overflows eagerly.
graal.BootstrapInitializeOnly = false [Boolean]
Do not compile anything on bootstrap but just initialize the compiler.
graal.BootstrapTimeout = 15.0 [Double]
Maximum time in minutes to spend bootstrapping (0 to disable this
limit).
graal.BootstrapWatchDogCriticalRateRatio = 0.25 [Double]
Ratio of the maximum compilation rate below which the bootstrap
compilation rate must not fall (0 or less disables monitoring).
graal.CanOmitFrame = true [Boolean]
graal.CanonicalGraphStringsCheckConstants = false [Boolean]
Exclude virtual nodes when dumping canonical text for graphs.
graal.CanonicalGraphStringsExcludeVirtuals = true [Boolean]
Exclude virtual nodes when dumping canonical text for graphs.
graal.CanonicalGraphStringsRemoveIdentities = true [Boolean]
Attempts to remove object identity hashes when dumping canonical text
for graphs.
graal.ClearMetricsAfterBootstrap = false [Boolean]
Clear the debug metrics after bootstrap.
graal.CollectImageBuildStatistics = false [Boolean]
Collect information during image build about devirtualized invokes and
bytecode exceptions.
graal.CollectYoungGenerationSeparately = null [Boolean]
Determines if a full GC collects the young generation separately or
together with the old generation.
graal.CompilationBailoutAsFailure = false [Boolean]
Treat compilation bailouts like compilation failures.
graal.CompilationCountLimit = 0 [Integer]
The number of compilations allowed for any method before the VM exits
(a value of 0 means there is no limit).
graal.CompilationExcludePhases = null [String]
Exclude certain phases from compilation, either unconditionally or with
a method filter. Multiple exclusions can be specified separated by ':'.
Phase names are matched as substrings, e.g.:
CompilationExcludePhases=PartialEscape:Loop=A.*,B.foo excludes
PartialEscapePhase from all compilations and any phase containing
'Loop' in its name from compilations of all methods in class A and of
method B.foo.
graal.CompilationExpirationPeriod = 300 [Integer]
Time limit in seconds before a compilation expires (0 to disable the
limit). A non-zero value for this option is doubled if assertions are
enabled and quadrupled if DetailedAsserts is true.
graal.CompilationFailureAction = Silent [String]
Specifies the action to take when compilation fails.
The accepted values are:
Silent - Print nothing to the console.
Print - Print a stack trace to the console.
Diagnose* - Retry the compilation with extra diagnostics.
ExitVM - Same as Diagnose except that the VM process exits after retrying.
* If "Diagnose" is set compilation will be retried with extra diagnostics enabled including dumping (see file:doc-files/DumpHelp.txt).
In such a scenario DiagnoseDumpLevel can be used to specify the dump level (DebugContext dump levels) accordingly.
graal.CompilationIsolateAddressSpaceSize = 0 [Long]
Size of the reserved address space of each compilation isolate (0:
default for new isolates).
graal.CompilationWatchDogStackTraceInterval = 60.0 [Double]
Interval in seconds between a watch dog reporting stack traces for long
running compilations.
graal.CompilationWatchDogStartDelay = 0.0 [Double]
Delay in seconds before watch dog monitoring a compilation (0 disables
monitoring).
graal.CompileGraalWithC1Only = true [Boolean]
In tiered mode compile Graal and JVMCI using optimized first tier code.
graal.CompileInIsolates = true [Boolean]
Activate runtime compilation in separate isolates (enable support
during image build with option SupportCompileInIsolates).
graal.CompilerConfiguration = null [String]
Names the compiler configuration to use. If omitted, the compiler
configuration with the highest auto-selection priority is used. To see
the set of available configurations, supply the value 'help' to this
option.
graal.ConditionalElimination = true [Boolean]
graal.ConditionalEliminationMaxIterations = 4 [Integer]
graal.Count = null [String]
Pattern for specifying scopes in which counters are enabled. See the
Dump option for the pattern syntax. An empty value enables all counters
unconditionally.
graal.Counters = null [String]
Comma separated names of counters that are enabled irrespective of the
value for Count option. An empty value enables all counters
unconditionally.
graal.CrashAt = null [String]
Pattern for method(s) that will trigger an exception when compiled.
This option exists to test handling compilation crashes gracefully. See
the MethodFilter option for the pattern syntax. A ':Bailout' suffix
will raise a bailout exception and a ':PermanentBailout' suffix will
raise a permanent bailout exception.
graal.CrashAtIsFatal = false [Boolean]
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. This option exists for the purpose of testing fatal
error handling in libgraal.
graal.DebugStubsAndSnippets = false [Boolean]
Enable debug output for stub code generation and snippet preparation.
graal.DeoptALot = false [Boolean]
graal.DeoptAfterOSR = true [Boolean]
Deoptimize OSR compiled code when the OSR entry loop is finished if
there is no mature profile available for the rest of the method.
graal.DeoptsToDisableOptimisticOptimization = 40 [Integer]
graal.DetailedAsserts = false [Boolean]
Enable expensive assertions if normal assertions (i.e. -ea or -esa) are
enabled.
graal.DiagnoseDumpLevel = 3 [Integer]
Specify the dump level if CompilationFailureAction#Diagnose is used.See
CompilationFailureAction for details.
file:doc-files/CompilationFailureActionHelp.txt
graal.DiagnosticDetails = "" [String]
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.
graal.DisableExplicitGC = false [Boolean]
Ignore calls to System.gc()
graal.DisableIntercept = false [Boolean]
Disable intercepting exceptions in debug scopes.
graal.DisableIntrinsics = null [String]
Disable intrinsics matching the given method filter (see MethodFilter
option for details). For example, 'DisableIntrinsics=String.equals'
disables intrinsics for any method named 'equals' in a class whose
simple name is 'String'. You can append ':verbose' at the end of the
filter value to print out disabled intrinsics as they are encountered
during compilation (e.g., 'String.equals:verbose').
graal.DivertParameterReturningMethod = true [Boolean]
Analysis: Detect methods that return one of their parameters and
hardwire the parameter straight to the return.
graal.Dump = null [String]
Filter pattern for specifying scopes in which dumping is enabled.
A filter is a list of comma-separated terms of the form:
<pattern>[:<level>]
If <pattern> contains a "*" or "?" character, it is interpreted as a glob pattern.
Otherwise, it is interpreted as a substring. If <pattern> is empty, it
matches every scope. If :<level> is omitted, it defaults to 1. The term
~<pattern> is a shorthand for <pattern>:0 to disable a debug facility for a pattern.
The default log level is 0 (disabled). Terms with an empty pattern set
the default log level to the specified value. The last
matching term with a non-empty pattern selects the level specified. If
no term matches, the log level is the default level. A filter with no
terms matches every scope with a log level of 1.
Examples of debug filters:
---------
(empty string)
Matches any scope with level 1.
---------
:1
Matches any scope with level 1.
---------
*
Matches any scope with level 1.
---------
CodeGen,CodeInstall
Matches scopes containing "CodeGen" or "CodeInstall", both with level 1.
---------
CodeGen:2,CodeInstall:1
Matches scopes containing "CodeGen" with level 2, or "CodeInstall" with level 1.
---------
Outer:2,Inner:0}
Matches scopes containing "Outer" with log level 2, or "Inner" with log level 0. If the scope
name contains both patterns then the log level will be 0. This is useful for silencing subscopes.
---------
:1,Dead:2
Matches scopes containing "Dead" with level 2, and all other scopes with level 1.
---------
Dead:0,:1
Matches all scopes with level 1, except those containing "Dead". Note that the location of
the :1 doesn't matter since it's specifying the default log level so it's the same as
specifying :1,Dead:0.
---------
Code*
Matches scopes starting with "Code" with level 1.
---------
Code,~Dead
Matches scopes containing "Code" but not "Dead", with level 1.
graal.DumpAfterEveryBCI = false [Boolean]
Dump the current graph after every bci to IGV.
graal.DumpEndVersusExitLoopFrequencies = false [Boolean]
Debug flag to dump loop frequency differences computed based on loop
end or exit nodes.If the frequencies diverge a lot, this may indicate
missing profiles on control flowinside the loop body.
graal.DumpHeapAndExit = false [Boolean]
Create a heap dump and exit.
graal.DumpOnError = false [Boolean]
Send compiler IR to dump handlers on error.
graal.DumpOnPhaseChange = null [String]
Dump a before and after graph if the named phase changes the
graph.%nThe argument is substring matched against the simple name of
the phase class
graal.DumpPath = "graal_dumps" [String]
The directory where various Graal dump files are written.
graal.DumpingErrorsAreFatal = false [Boolean]
Treat any exceptions during dumping as fatal.
graal.DynamicCountersPrintGroupSeparator = true [Boolean]
Use grouping separators for number printing
graal.EagerSnippets := true [Boolean]
Eagerly construct extra snippet info.
graal.EarlyCodeEmissionOrder = false [Boolean]
Enable early code emission order computation instead of late code
emission order computation
graal.EarlyGVN = false [Boolean]
Perform early global value numbering.
graal.EarlyLICM = false [Boolean]
Perform early loop invariant code motion.
graal.EmitStringSubstitutions = true [Boolean]
Emit substitutions for String methods
graal.EnableSignalHandling = false [Boolean]
Enables signal handling
graal.EscapeAnalysisIterations = 2 [Integer]
graal.EscapeAnalysisLoopCutoff = 20 [Integer]
graal.EscapeAnalyzeOnly = null [String]
graal.ExactFullUnrollMaxNodes = 800 [Integer]
graal.ExactPartialUnrollMaxNodes = 200 [Integer]
graal.ExhaustiveHeapScan = false [Boolean]
Scan all objects reachable from roots for analysis. By default false.
graal.ExitOnOutOfMemoryError = false [Boolean]
Exit on the first occurrence of an out-of-memory error that is thrown
because the Java heap is out of memory.
graal.ExitVMOnException = false [Boolean]
Alias for CompilationFailureAction=ExitVM.
graal.ExtendedAsserts = false [Boolean]
Enable extended asserts which slow down analysis.
graal.FailedLoopExplosionIsFatal = false [Boolean]
Do not bail out but throw an exception on failed loop explosion.
graal.FallbackExecutorRuntimeJavaArg = <string>* [Strings]
Internal option used to specify runtime java arguments for
FallbackExecutor.
graal.FlightRecorder = false [Boolean]
Enable Java Flight Recorder.
graal.FlightRecorderLogging = "all=warning" [String]
Usage: -XX:FlightRecorderLogging=[tag1[+tag2...][*][=level][,...]]
When this option is not set, logging is enabled at a level of WARNING.
When this option is set to the empty string, logging is enabled at a level of INFO.
When this option is set to "disable", logging is disabled entirely.
Otherwise, this option expects a comma separated list of tag combinations, each with an optional wildcard (*) and level.
A tag combination without a level is given a default level of INFO.
Messages with tags that match a given tag combination are set to log at that tag combination's level.
If a tag combination does not have a wildcard, then only messages with exactly the same tags are matched.
Otherwise, messages whose tags are a subset of the tag combination are matched.
Specifying "all" instead of a tag combination matches all tag combinations.
If more than one tag combination matches a message's tags, the rightmost one will apply.
Messages with tags that do not have any matching tag combinations are set to log at a default level of WARNING.
This option is case insensitive.
Available log levels:
[trace, debug, info, warning, error, off]
Available log tags:
[jfr, system, event, setting, bytecode, parser, metadata, dcmd]
graal.FloatingDivNodes = true [Boolean]
Try to float non-constant division operations to expose global value
numbering of divisions.
graal.ForceAdversarialLayout = false [Boolean]
Place N-byte constants in the data section such that they are
misaligned with respect to N*2. For example, place 4 byte constants at
offset 4, 12 or 20, etc. This layout is used to detect instructions
that load constants with alignment smaller than the fetch size. For
instance, an XORPS instruction that does a 16-byte fetch of a 4-byte
float not aligned to 16 bytes will cause a segfault.
graal.ForceDumpGraphsBeforeCompilation = false [Boolean]
Force-dump graphs before compilation
graal.FullUnroll = true [Boolean]
graal.FullUnrollConstantCompareBoost = 15 [Integer]
graal.FullUnrollMaxApplication = 60 [Integer]
graal.FullUnrollMaxIterations = 600 [Integer]
graal.FullUnrollMaxNodes = 400 [Integer]
graal.GCDebugStartCycle = -1 [Integer]
Start tracing compiled GC barriers after N garbage collections
(disabled if N <= 0).
graal.GenLoopSafepoints = true [Boolean]
graal.GenericDynamicCounters = false [Boolean]
Turn on the benchmark counters, and displays the results on VM shutdown
graal.GraalArithmeticStubs = true [Boolean]
Use Graal arithmetic stubs instead of HotSpot stubs where possible
graal.GraalCompileOnly = null [String]
A filter applied to a method the VM has selected for compilation by
Graal. A method not matching the filter is redirected to a lower tier
compiler. The filter format is the same as for the MethodFilter option.
graal.GraphCompressionThreshold = 70 [Integer]
Graal graph compression is performed when percent of live nodes falls
below this value
graal.GuardPriorities = true [Boolean]
graal.HeapVerifierVerbosity = 0 [Integer]
Control heap verifier verbosity level: 0 - quiet, 1 - info, 2 -
warning, 3 - all.
graal.HotSpotDeoptExplicitExceptions = false [Boolean]
Testing only option that forces deopts for exception throws
graal.HotSpotPostOnExceptions = false [Boolean]
Testing only option that forces deopts for exception throws
graal.HotSpotPrintInlining = false [Boolean]
Print inlining optimizations
graal.HybridStaticContext = false [Boolean]
Enable hybrid context for static methods, i.e. uses invocation site as
context for static methods.
graal.ImageBuildStatisticsFile = null [String]
File for printing image build statistics
graal.ImageObjectTreeExpandRoots = "" [String]
Override the default suppression of specified roots. See: Reports.md.
graal.ImageObjectTreeExpandTypes = "" [String]
Override the default suppression of specified types. See: Reports.md.
graal.ImageObjectTreeSuppressRoots = "" [String]
Suppress the expansion of specified roots. See: Reports.md.
graal.ImageObjectTreeSuppressTypes = "" [String]
Suppress the expansion of specified types. See: Reports.md.
graal.Inline = true [Boolean]
Enable inlining
graal.InlineBeforeAnalysis = true [Boolean]
Inline methods before static analysis
graal.InlineDuringParsing = true [Boolean]
Inlines trivial methods during bytecode parsing.
graal.InlineDuringParsingMaxDepth = 10 [Integer]
Maximum depth when inlining during bytecode parsing.
graal.InlineEverything = false [Boolean]
graal.InlineMegamorphicCalls = true [Boolean]
Inline calls with megamorphic type profile (i.e., not all types could
be recorded).
graal.InlineMonomorphicCalls = true [Boolean]
Inline calls with monomorphic type profile.
graal.InlinePartialIntrinsicExitDuringParsing = true [Boolean]
Inlines partial intrinsic exits during bytecode parsing when possible.
A partial intrinsic exit is a call within an intrinsic to the method
being intrinsified and denotes semantics of the original method that
the intrinsic does not support.
graal.InlinePolymorphicCalls = true [Boolean]
Inline calls with polymorphic type profile.
graal.InlineVTableStubs = true [Boolean]
graal.InliningDepthError = 1000 [Integer]
Maximum inlining depth during partial evaluation before reporting an
infinite recursion
graal.InspectServerContentPath = "inspect" [String]
Path to the contents of the Inspect web server.
graal.InstallSegfaultHandler = null [Boolean]
Install segfault handler that prints register contents and full Java
stacktrace. Default: enabled for an executable, disabled for a shared
library.
graal.InterceptBailout = false [Boolean]
Intercept also bailout exceptions
graal.Intrinsify = true [Boolean]
Use compiler intrinsifications.
graal.IsolatedLoopHeaderAlignment = 32 [Integer]
Alignment in bytes for loop header blocks that have no fall through
paths.
graal.IterativePeelingLimit = 2 [Integer]
Allow iterative peeling of loops up to this many times (each time the
peeling phase runs).
graal.LIRDynMoveProfileMethod = false [Boolean]
Enable dynamic move profiling per method.
graal.LIROptConstantLoadOptimization = true [Boolean]
Enable constant load optimization.
graal.LIROptControlFlowOptimizer = true [Boolean]
graal.LIROptEdgeMoveOptimizer = true [Boolean]
graal.LIROptLSRAEliminateSpillMoves = true [Boolean]
Enable spill move elimination.
graal.LIROptLSRAOptimizeSpillPosition = true [Boolean]
Enable spill position optimization
graal.LIROptLSStackSlotAllocator = true [Boolean]
Use linear scan stack slot allocation.
graal.LIROptNullCheckOptimizer = true [Boolean]
graal.LIROptRedundantMoveElimination = true [Boolean]
graal.LIROptStackMoveOptimizer = true [Boolean]
graal.LIROptimization = true [Boolean]
Enable LIR level optimizations.
graal.LIRProfileMethods = false [Boolean]
Enables profiling of methods.
graal.LIRProfileMoves = false [Boolean]
Enables profiling of move types on LIR level. Move types are for
example stores (register to stack), constant loads (constant to
register) or copies (register to register).
graal.LSRAOptSplitOnly = false [Boolean]
LSRA optimization: Only split but do not reassign
graal.LSRAOptimization = false [Boolean]
Enable LSRA optimization
graal.LibGraalManagementDelay = -1 [Integer]
Milliseconds to delay initialization of the libgraal JMX interface.
Specify a negative value to disable the interface altogether.
graal.LimitInlinedInvokes = 5.0 [Double]
graal.LimitObjectArrayLength = false [Boolean]
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.
graal.ListMetrics = false [Boolean]
Lists on the console at VM shutdown the metric names available to the
Timers, Counters and MemUseTrackers options. Note that this only lists
the metrics that were initialized during the VM execution and so will
not include metrics for compiler code that is not executed.
graal.LoadExceptionObjectInVM = false [Boolean]
Use a VM runtime call to load and clear the exception object from the
thread at the start of a compiled exception handler.
graal.Log = null [String]
Pattern for specifying scopes in which logging is enabled. See the Dump
option for the pattern syntax.
graal.LogFile = null [String]
File to which logging is sent. A %p in the name will be replaced with a
string identifying the process, usually the process id and %t will be
replaced by System.currentTimeMillis(). If the current runtime is in an
isolate, then %i will be replaced by '<isolate id>' otherwise %i is
removed. An %I is the same as %i except that the replacement is
'<isolate id>@<isolate address>'. Using %o as filename sends logging to
System.out whereas %e sends logging to System.err.
graal.LogVerbose = false [Boolean]
Enable more verbose log output when available
graal.LoopExitVsLoopEndFrequencyDiff = 1000.0 [Double]
Scaling factor of frequency difference computed based on loop ends or
exits
graal.LoopHeaderAlignment = 16 [Integer]
Alignment in bytes for loop header blocks.
graal.LoopMaxUnswitch = 3 [Integer]
graal.LoopOnFatalError = false [Boolean]
Execute an endless loop before printing diagnostics for a fatal error.
graal.LoopPeeling = true [Boolean]
graal.LoopPredication = true [Boolean]
Hoists array bounds checks out of simple loops. This is ignored if
SpeculativeGuardMovement is enabled.
graal.LoopPredicationMainPath = true [Boolean]
Restricts LoopPredication to only focus on array bounds checks that
dominate the back edge of a loop.
graal.LoopUnswitch = true [Boolean]
graal.LoopUnswitchFrequencyBoost = 10.0 [Double]
Number of nodes allowed for a loop unswitching per loop frequency. The
number of nodes allowed for the unswitching is proportional to the
relative frequency of the loop by this constant.
graal.LoopUnswitchFrequencyMaxFactor = 0.95 [Double]
Maximun value for the frequency factor of an invariant.
graal.LoopUnswitchFrequencyMinFactor = 0.05 [Double]
Minimum value for the frequency factor of an invariant.
graal.LoopUnswitchMaxIncrease = 2000 [Integer]
Maximum loop unswitching code size increase in nodes.
graal.LoopUnswitchMinSplitFrequency = 1.0 [Double]
Lower bound for the minimun frequency of an invariant condition to be
unswitched.
graal.LoopUnswitchTrivial = 10 [Integer]
Number of nodes allowed for a loop unswitching regardless of the loop
frequency.
graal.MatchExpressions = true [Boolean]
Allow backend to match complex expressions.
graal.MaxCallingContextDepth = 0 [Integer]
The maximum length of the methods context chains.
graal.MaxCallingContextWidth = 0 [Integer]
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.
graal.MaxCompilationProblemsPerAction = 2 [Integer]
The maximum number of compilation failures to handle with the action
specified by CompilationFailureAction before changing to a less verbose
action. This does not apply to the ExitVM action.
graal.MaxConstantObjectsPerType = 100 [Integer]
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.
graal.MaxDirectMemorySize = 0 [Long]
Maximum total size of NIO direct-buffer allocations
graal.MaxDuplicationFactor = 2.0 [Double]
Max amount of extra effort to expend handling irreducible loops. A
value <= 1 disables support for irreducible loops.
graal.MaxHeapContextDepth = 0 [Integer]
The maximum length of the context used to model a heap object in
addition to the allocation site; used only when ContextSensitiveHeap is
enabled.
graal.MaxHeapContextWidth = 0 [Integer]
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.
graal.MaxHeapFree = 0 [Long]
The maximum free bytes reserved for allocations, in bytes (0 for
automatic according to GC policy).
graal.MaxHeapSize = 0 [Long]
The maximum heap size at run-time, in bytes.
graal.MaxJavaStackTraceDepth = 1024 [Integer]
The maximum number of lines in the stack trace for Java exceptions (0
means all)
graal.MaxNewSize = 0 [Long]
The maximum size of the young generation at run-time, in bytes
graal.MaxObjectSetSize = 100 [Integer]
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.
graal.MaxTemplatesPerSnippet = 50 [Integer]
graal.MaximumDesiredSize = 20000 [Integer]
Maximum desired size of the compiler graph in nodes.
graal.MaximumEscapeAnalysisArrayLength = 128 [Integer]
The maximum length of an array that will be escape analyzed.
graal.MaximumHeapSizePercent = 80 [Integer]
The maximum heap size as percent of physical memory
graal.MaximumInliningSize = 300 [Integer]
Inlining is explored up to this number of nodes in the graph for each
call site.
graal.MaximumLoopExplosionCount = 10000 [Integer]
Max number of loop explosions per method.
graal.MaximumRecursiveInlining = 5 [Integer]
Maximum level of recursive inlining.
graal.MaximumYoungGenerationSizePercent = 10 [Integer]
The maximum size of the young generation as a percentage of the maximum
heap size
graal.MegamorphicInliningMinMethodProbability = 0.33 [Double]
Minimum probability for methods to be inlined for megamorphic type
profiles.
graal.MemUseTrackers = null [String]
Comma separated names of memory usage trackers that are enabled
irrespective of the value for TrackMemUse option. An empty value
enables all memory usage trackers unconditionally.
graal.MethodFilter = null [String]
Pattern for matching methods. The syntax for a pattern is:
SourcePatterns = SourcePattern ["," SourcePatterns] .
SourcePattern = [ "~" ] [ Class "." ] method [ "(" [ Parameter { ";" Parameter } ] ")" ] .
Parameter = Class | "int" | "long" | "float" | "double" | "short" | "char" | "boolean" .
Class = { package "." } class .
Glob pattern matching (*, ?) is allowed in all parts of the source pattern.
The "~" prefix negates the pattern.
Positive patterns are joined by an "or" operator: "A,B" matches anything
matched by "A" or "B". Negative patterns are joined by "and not": "~A,~B"
matches anything not matched by "A" and not matched by "B". "A,~B,~C,D"
matches anything matched by "A" or "D" and not matched by "B" and not
matched by "C".
A set of patterns containing negative patterns but no positive ones contains
an implicit positive "*" pattern: "~A,~B" is equivalent to "*,~A,~B".
Examples of method filters:
---------
*
Matches all methods in all classes.
---------
canonical(CanonicalizerTool;LogicNode;LogicNode)
Matches all methods named "canonical", with the first parameter of type
"CanonicalizerTool", and the second and third parameters of type
"LogicNode".
The packages of the parameter types are irrelevant.
---------
arraycopy(Object;;;;)
Matches all methods named "arraycopy", with the first parameter
of type "Object", and four more parameters of any type. The
packages of the parameter types are irrelevant.
---------
List.set
Matches all methods named "set" in a class whose simple name is "List".
---------
*List.set
Matches all methods named "set" in a class whose simple name ends with "List".
---------
org.graalvm.compiler.nodes.PhiNode.*
Matches all methods in the class "org.graalvm.compiler.nodes.PhiNode".
---------
org.graalvm.compiler.nodes.*.canonical
Matches all methods named "canonical" in classes in the package
"org.graalvm.compiler.nodes".
---------
arraycopy,toString
Matches all methods named "arraycopy" or "toString", meaning that ',' acts
as an "or" operator.
---------
java.util.*.*.,~java.util.*Array*.*
java.util.*.*.,~*Array*.*
These patterns are equivalent and match all methods in the package
"java.util" except for classes that have "Array" in their name.
---------
~java.util.*.*
Matches all methods in all classes in all packages except for anything in
the "java.util" package.
graal.MethodFilterRootOnly = false [Boolean]
Only check MethodFilter against the root method in the context if true,
otherwise check all methods
graal.MethodInlineBailoutLimit = 5000 [Integer]
Per-compilation method inlining exploration limit before giving up (use
0 to disable)
graal.MetricsFile = null [String]
File to which metrics are dumped per compilation.
A CSV format is used if the file ends with .csv otherwise a more
human readable format is used. The fields in the CSV format are:
compilable - method being compiled
compilable_identity - identity hash code of compilable
compilation_nr - where this compilation lies in the ordered
sequence of all compilations identified by
compilable_identity
compilation_id - runtime issued identifier for the compilation
metric_name - name of metric
metric_value - value of metric
graal.MinCallingContextDepth = 0 [Integer]
The minimum length of the methods context chains.
graal.MinHeapContextDepth = 0 [Integer]
The minimum length of the context used to model a heap object in
addition to the allocation site; used only when ContextSensitiveHeap is
enabled.
graal.MinHeapSize = 0 [Long]
The minimum heap size at run-time, in bytes.
graal.MinimalBulkZeroingSize = 2048 [Integer]
If applicable, use bulk zeroing instructions when the zeroing size in
bytes exceeds this threshold.
graal.MinimalGraphNodeSizeCheckSize = 1000 [Integer]
Minimal size in NodeSize to check the graph size increases of phases.
graal.MinimumPeelFrequency = 0.35 [Float]
graal.MoveGuardsUpwards = true [Boolean]
Move guard nodes to earlier places in the dominator tree if all
successors of basic block share a common guard condition.
graal.NDCV = 0 [Integer]
Run level for NoDeadCodeVerifyHandler (0 = off, 1 = info, 2 = verbose,
3 = fatal)
graal.NodeCounters = false [Boolean]
Counts the number of instances of each node class.
graal.NonFatalIdenticalCompilationSnapshots = 20 [Integer]
Number of contiguous identical compiler thread stack traces allowed
before the VM exits on the basis of a stuck compilation.
graal.ObjdumpExecutables = null [String]
Comma separated list of candidate GNU objdump executables. If not
specified, disassembling via GNU objdump is disabled. Otherwise, the
first existing executable in the list is used.
graal.OmitHotExceptionStacktrace = false [Boolean]
graal.OnShutdownCallback = null [String]
The fully qualified name of a no-arg, void, static method to be invoked
in HotSpot from libgraal when the libgraal isolate is being
shutdown.This option exists for the purpose of testing callbacks in
this context.
graal.OptAssumptions = true [Boolean]
graal.OptConvertDeoptsToGuards = true [Boolean]
graal.OptDeoptimizationGrouping = true [Boolean]
graal.OptDevirtualizeInvokesOptimistically = true [Boolean]
graal.OptEarlyReadElimination = true [Boolean]
graal.OptEliminateGuards = true [Boolean]
graal.OptFloatingReads = true [Boolean]
graal.OptImplicitNullChecks = true [Boolean]
graal.OptReadElimination = true [Boolean]
graal.OptScheduleOutOfLoops = true [Boolean]
graal.PartialEscapeAnalysis = true [Boolean]
graal.PartialUnroll = true [Boolean]
graal.PeelALot = false [Boolean]
graal.PercentTimeInIncrementalCollection = 50 [Integer]
Percentage of total collection time that should be spent on young
generation collections.
graal.PreferContainerQuotaForCPUCount = true [Boolean]
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.
graal.PrintAnalysisCallTree = false [Boolean]
Print analysis call tree, a breadth-first tree reduction of the call
graph.
graal.PrintAnalysisCallTreeType = TXT [String]
Change the output format of the analysis call tree, available options
are TXT and CSV. See: Reports.md.
graal.PrintAnalysisStatistics = false [Boolean]
Print analysis results statistics.
graal.PrintBackendCFG = false [Boolean]
Enable dumping scheduled HIR, LIR, register allocation and code
generation info to the C1Visualizer.
graal.PrintBlockMapping = false [Boolean]
Enable dumping CFG built during initial BciBlockMapping
graal.PrintCallEdges = false [Boolean]
Print call edges with other analysis results statistics.
graal.PrintCanonicalGraphStringFlavor = 0 [Integer]
Choose format used when dumping canonical text for graphs: 0 gives a
scheduled graph (better for spotting changes involving the schedule)
while 1 gives a CFG containing expressions rooted at fixed nodes
(better for spotting small structure differences)
graal.PrintCanonicalGraphStrings = false [Boolean]
Enable dumping canonical text from for graphs.
graal.PrintCompilation = false [Boolean]
Print an informational line to the console for each completed
compilation.
graal.PrintDetailedAllocationProfiling = true [Boolean]
Print detailed information for each allocation site
graal.PrintFlags = null [String]
Show available options based on comma-separated option-types (allowed
categories: User, Expert, Debug).
graal.PrintFlagsWithExtraHelp = null [String]
Print extra help, if available, based on comma-separated option names.
Pass * to show all options that contain extra help.
graal.PrintGC = false [Boolean]
Print summary GC information after each collection.
graal.PrintGCSummary = false [Boolean]
Print summary GC information after application main method returns.
graal.PrintGCTimeStamps = false [Boolean]
Print a time stamp at each collection, if +PrintGC or +VerboseGC.
graal.PrintGCTimes = false [Boolean]
Print the time for each of the phases of each collection, if
+VerboseGC.
graal.PrintGraph = File [String]
Where IdealGraphVisualizer graph dumps triggered by Dump or DumpOnError
should be written.
The accepted values are:
File - Dump IGV graphs to the local file system (see DumpPath).
Network - Dump IGV graphs to the network destination specified by PrintGraphHost and PrintGraphPort.
If a network connection cannot be opened, dumping falls back to file dumping.
Disable - Do not dump IGV graphs.
graal.PrintGraphFile = true [Boolean]
Setting to true sets PrintGraph=file, setting to false sets
PrintGraph=network
graal.PrintGraphHost = "127.0.0.1" [String]
Host part of the address to which graphs are dumped.
graal.PrintGraphPort = 4445 [Integer]
Port part of the address to which graphs are dumped in binary format.
graal.PrintGraphWithSchedule = false [Boolean]
Schedule graphs as they are dumped.
graal.PrintHeapShape = false [Boolean]
Print the shape of the heap before and after each collection, if
+VerboseGC.
graal.PrintIRWithLIR = false [Boolean]
Print HIR along side LIR as the latter is generated
graal.PrintImageObjectTree = false [Boolean]
Print image object hierarchy.
graal.PrintLIRWithAssembly = false [Boolean]
Include the LIR as comments with the final assembly.
graal.PrintPointsToStatistics = false [Boolean]
Report analysis statistics.
graal.PrintProfilingInformation = false [Boolean]
Print profiling information when parsing a method's bytecode
graal.PrintSynchronizedAnalysis = false [Boolean]
Print types used for Java synchronization.
graal.PrintUnmodifiedGraphs = true [Boolean]
Dump a graph even if it has not changed since it was last dumped.
Change detection is based on adding and deleting nodes or changing
inputs.
graal.ProfileAllocations = false [Boolean]
Enable profiling of allocation sites.
graal.ProfileAllocationsContext = AllocatingMethod [String]
Control the naming and granularity of the counters when using
ProfileAllocations.
The accepted values are:
AllocatingMethod - a counter per method
InstanceOrArray - one counter for all instance allocations and
one counter for all array allocations
AllocatedType - one counter per allocated type
AllocatedTypesInMethod - one counter per allocated type, per method
graal.ProfileAnalysisOperations = false [Boolean]
Track the progress of the static analysis.
graal.ProfileCompiledMethods = false [Boolean]
graal.ProfileConstantObjects = false [Boolean]
Track the creation of constant objects.
graal.ProfileMonitors = false [Boolean]
Enable profiling of monitor operations.
graal.RawConditionalElimination = true [Boolean]
graal.ReadEliminationMaxLoopVisits = 5 [Integer]
graal.ReassociateExpressions = true [Boolean]
Re-associate loop invariants and constants.
graal.ReduceDCE = true [Boolean]
Disable optional dead code eliminations
graal.RegisterPressure = null [String]
Comma separated list of registers that register allocation is limited
to.
graal.RelaxTypeFlowStateConstraints = true [Boolean]
Allow a type flow state to contain types not compatible with its
declared type.
graal.RemoveNeverExecutedCode = true [Boolean]
graal.RemoveSaturatedTypeFlows = true [Boolean]
Enable the type flow saturation analysis performance optimization.
graal.ReplaceInputsWithConstantsBasedOnStamps = true [Boolean]
graal.SafepointPromptnessFailureNanos = 0 [Long]
Exit the VM if I can not come to a safepoint in this many nanoseconds.
0 implies forever.
graal.SafepointPromptnessWarningNanos = 0 [Long]
Print a warning if I can not come to a safepoint in this many
nanoseconds. 0 implies forever.
graal.SamplingBasedProfiling = false [Boolean]
Allow sampling-based profiling. Default: disabled in execution.
graal.ScanObjectsParallel = true [Boolean]
Object scanning in parallel
graal.ShowConfiguration = none [String]
Writes to the VM log information about the compiler configuration
selected.
graal.ShowDumpFiles = false [Boolean]
Print the name of each dump file path as it's created.
graal.ShowSubstitutionSourceInfo = false [Boolean]
Controls whether the source position information of snippets and method
substitutions are exposed to HotSpot. Can be useful when profiling to
get more precise position information.
graal.SimpleFastInflatedLocking = true [Boolean]
Handle simple cases for inflated monitors in the fast-path.
graal.SmallCompiledLowLevelGraphSize = 330 [Integer]
If the previous low-level graph size of the method exceeds the
threshold, it is not inlined.
graal.SnippetCounters = false [Boolean]
Enable counters for various paths in snippets.
graal.SpectrePHTBarriers = None [String]
Select a strategy to mitigate speculative bounds check bypass (aka
Spectre-PHT or Spectre V1).
This is an experimental option - execution of untrusted code is not supported by GraalVM CE.
The accepted values are:
None - No mitigations are used in JIT compiled code.
AllTargets - Speculative execution on all conditional branch targets is
stopped using speculative execution barrier instructions.
GuardTargets - Branch targets relevant to Java memory safety are instrumented
with barrier instructions. This option has less performance impact
than AllTargets.
NonDeoptGuardTargets - Same as GuardTargets, except that branches which deoptimize are not
protected since they can not be executed repeatedly and are thus less
likely to be successfully exploited in an attack.
Note that all modes except "None" will also instrument branch target blocks containing UNSAFE memory accesses
with barrier instructions.
graal.SpectrePHTIndexMasking = false [Boolean]
Mask indices to scope access to allocation size after bounds check.
graal.SpeculativeGuardMovement = true [Boolean]
Move loop invariant guards (e.g., array bounds checks) out of loops.
graal.StackSize = 0 [Long]
The size of each thread stack at run-time, in bytes.
graal.StartFlightRecording = "" [String]
Start flight recording with options.
graal.StressExplicitExceptionCode = false [Boolean]
Stress the code emitting explicit exception throwing code.
graal.StressInvokeWithExceptionNode = false [Boolean]
Stress the code emitting invokes with explicit exception edges.
graal.StressTestEarlyReads = false [Boolean]
Stress the code by emitting reads at earliest instead of latest point.
graal.StrictDeoptInsertionChecks = false [Boolean]
Perform checks that guards and deopts aren't introduced in graphs that
should handle exceptions explicitly
graal.StringIndexOfConstantLimit = 4096 [Integer]
String.indexOf invocations will be evaluated at compile time if the
receiver is a constant and its length is smaller than this value.
graal.SupportJsrBytecodes = true [Boolean]
graal.SupportOSRWithLocks = true [Boolean]
Support OSR compilations with locks. If DeoptAfterOSR is true we can
per definition not have unbalanced enter/exits mappings. If
DeoptAfterOSR is false insert artificial monitor enters after the
OSRStart to have balanced enter/exits in the graph.
graal.TearDownFailureNanos = 0 [Long]
The number of nanoseconds before tearing down an isolate gives a
failure message. 0 implies no message.
graal.TearDownWarningNanos = 0 [Long]
The number of nanoseconds before and between which tearing down an
isolate gives a warning message. 0 implies no warning.
graal.Time = null [String]
Pattern for specifying scopes in which timing is enabled. See the Dump
option for the pattern syntax. An empty value enables all timers
unconditionally.
graal.TimedDynamicCounters = -1 [Integer]
Turn on the benchmark counters, and displays the results every n
milliseconds
graal.Timers = null [String]
Comma separated names of timers that are enabled irrespective of the
value for Time option. An empty value enables all timers
unconditionally.
graal.TraceBytecodeParserLevel = 0 [Integer]
The trace level for the bytecode parser. A value of 1 enables
instruction tracing and any greater value emits a frame state trace
just prior to each instruction trace.Instruction tracing output from
multiple compiler threads will be interleaved so use of this option
make most sense for single threaded compilation. The MethodFilter
option can be used to refine tracing to selected methods.
graal.TraceCodeCache = false [Boolean]
Print logging information for runtime code cache modifications
graal.TraceDeoptimization = false [Boolean]
Print logging information for every deoptimization
graal.TraceDeoptimizationDetails = false [Boolean]
Print verbose logging information for every deoptimization
graal.TraceEscapeAnalysis = false [Boolean]
graal.TraceExceptionHandlerStub = false [Boolean]
Trace execution of stub used to handle an exception thrown by a callee.
graal.TraceHeapChunks = false [Boolean]
Trace heap chunks during collections, if +VerboseGC and
+PrintHeapShape.
graal.TraceInlineDuringParsing = false [Boolean]
Traces inlining performed during bytecode parsing.
graal.TraceInlining = false [Boolean]
Enable tracing of inlining decisions.
Output format:
compilation of 'Signature of the compilation root method':
at 'Signature of the root method' ['Bytecode index']: <'Phase'> 'Child method signature': 'Decision made about this callsite'
at 'Signature of the child method' ['Bytecode index']:
|--<'Phase 1'> 'Grandchild method signature': 'First decision made about this callsite'
\--<'Phase 2'> 'Grandchild method signature': 'Second decision made about this callsite'
at 'Signature of the child method' ['Bytecode index']: <'Phase'> 'Another grandchild method signature': 'The only decision made about this callsite.'
graal.TraceInliningForStubsAndSnippets = false [Boolean]
Enable inlining decision tracing in stubs and snippets.
graal.TraceLIRGeneratorLevel = 0 [Integer]
The trace level for the LIR generator
graal.TraceMonitorsMethodFilter = null [String]
Trace monitor operations in methods whose fully qualified name contains
this substring.
graal.TraceMonitorsTypeFilter = null [String]