-
Notifications
You must be signed in to change notification settings - Fork 5.3k
/
globals.hpp
1987 lines (1971 loc) · 147 KB
/
globals.hpp
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
/*
* Copyright (c) 1997, 2023, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*
*/
#ifndef SHARE_RUNTIME_GLOBALS_HPP
#define SHARE_RUNTIME_GLOBALS_HPP
#include "compiler/compiler_globals_pd.hpp"
#include "runtime/globals_shared.hpp"
#include "utilities/align.hpp"
#include "utilities/globalDefinitions.hpp"
#include "utilities/macros.hpp"
#include CPU_HEADER(globals)
#include OS_HEADER(globals)
#include OS_CPU_HEADER(globals)
// develop flags are settable / visible only during development and are constant in the PRODUCT version
// product flags are always settable / visible
// notproduct flags are settable / visible only during development and are not declared in the PRODUCT version
// develop_pd/product_pd flags are the same as develop/product, except that their default values
// are specified in platform-dependent header files.
// Flags must be declared with the following number of parameters:
// non-pd flags:
// (type, name, default_value, doc), or
// (type, name, default_value, extra_attrs, doc)
// pd flags:
// (type, name, doc), or
// (type, name, extra_attrs, doc)
// A flag must be declared with one of the following types:
// bool, int, uint, intx, uintx, size_t, ccstr, ccstrlist, double, or uint64_t.
// The type "ccstr" and "ccstrlist" are an alias for "const char*" and is used
// only in this file, because the macrology requires single-token type names.
// The optional extra_attrs parameter may have one of the following values:
// DIAGNOSTIC, EXPERIMENTAL, or MANAGEABLE. Currently extra_attrs can be used
// only with product/product_pd flags.
//
// DIAGNOSTIC options are not meant for VM tuning or for product modes.
// They are to be used for VM quality assurance or field diagnosis
// of VM bugs. They are hidden so that users will not be encouraged to
// try them as if they were VM ordinary execution options. However, they
// are available in the product version of the VM. Under instruction
// from support engineers, VM customers can turn them on to collect
// diagnostic information about VM problems. To use a VM diagnostic
// option, you must first specify +UnlockDiagnosticVMOptions.
// (This master switch also affects the behavior of -Xprintflags.)
//
// EXPERIMENTAL flags are in support of features that may not be
// an officially supported part of a product, but may be available
// for experimenting with. They could, for example, be performance
// features that may not have undergone full or rigorous QA, but which may
// help performance in some cases and released for experimentation
// by the community of users and developers. This flag also allows one to
// be able to build a fully supported product that nonetheless also
// ships with some unsupported, lightly tested, experimental features.
// Refer to the documentation of any products using this code for details
// on support and fitness for production.
// Like the UnlockDiagnosticVMOptions flag above, there is a corresponding
// UnlockExperimentalVMOptions flag, which allows the control and
// modification of the experimental flags.
//
// Nota bene: neither diagnostic nor experimental options should be used casually,
// Refer to the documentation of any products using this code for details.
//
// MANAGEABLE flags are writeable external product flags.
// They are dynamically writeable through the JDK management interface
// (com.sun.management.HotSpotDiagnosticMXBean API) and also through JConsole.
// These flags are external exported interface (see CSR). The list of
// manageable flags can be queried programmatically through the management
// interface.
//
// A flag can be made as "manageable" only if
// - the flag is defined in a CSR request as an external exported interface.
// - the VM implementation supports dynamic setting of the flag.
// This implies that the VM must *always* query the flag variable
// and not reuse state related to the flag state at any given time.
// - you want the flag to be queried programmatically by the customers.
//
//
// range is a macro that will expand to min and max arguments for range
// checking code if provided - see jvmFlagLimit.hpp
//
// constraint is a macro that will expand to custom function call
// for constraint checking if provided - see jvmFlagLimit.hpp
// Default and minimum StringTable and SymbolTable size values
// Must be powers of 2
const size_t defaultStringTableSize = NOT_LP64(1024) LP64_ONLY(65536);
const size_t minimumStringTableSize = 128;
const size_t defaultSymbolTableSize = 32768; // 2^15
const size_t minimumSymbolTableSize = 1024;
#ifdef _LP64
#define LP64_RUNTIME_FLAGS(develop, \
develop_pd, \
product, \
product_pd, \
notproduct, \
range, \
constraint) \
\
product(bool, UseCompressedOops, false, \
"Use 32-bit object references in 64-bit VM. " \
"lp64_product means flag is always constant in 32 bit VM") \
\
product(bool, UseCompressedClassPointers, true, \
"Use 32-bit class pointers in 64-bit VM. " \
"lp64_product means flag is always constant in 32 bit VM") \
\
product(int, ObjectAlignmentInBytes, 8, \
"Default object alignment in bytes, 8 is minimum") \
range(8, 256) \
constraint(ObjectAlignmentInBytesConstraintFunc, AtParse)
#else
// !_LP64
#define LP64_RUNTIME_FLAGS(develop, \
develop_pd, \
product, \
product_pd, \
notproduct, \
range, \
constraint)
const bool UseCompressedOops = false;
const bool UseCompressedClassPointers = false;
const int ObjectAlignmentInBytes = 8;
#endif // _LP64
#define RUNTIME_FLAGS(develop, \
develop_pd, \
product, \
product_pd, \
notproduct, \
range, \
constraint) \
\
notproduct(bool, CheckCompressedOops, true, \
"Generate checks in encoding/decoding code in debug VM") \
\
product(uintx, HeapSearchSteps, 3 PPC64_ONLY(+17), \
"Heap allocation steps through preferred address regions to find" \
" where it can allocate the heap. Number of steps to take per " \
"region.") \
range(1, max_uintx) \
\
product(uint, HandshakeTimeout, 0, DIAGNOSTIC, \
"If nonzero set a timeout in milliseconds for handshakes") \
\
product(bool, AlwaysSafeConstructors, false, EXPERIMENTAL, \
"Force safe construction, as if all fields are final.") \
\
product(bool, UnlockDiagnosticVMOptions, trueInDebug, DIAGNOSTIC, \
"Enable normal processing of flags relating to field diagnostics")\
\
product(bool, UnlockExperimentalVMOptions, false, EXPERIMENTAL, \
"Enable normal processing of flags relating to experimental " \
"features") \
\
product(bool, JavaMonitorsInStackTrace, true, \
"Print information about Java monitor locks when the stacks are " \
"dumped") \
\
product_pd(bool, UseLargePages, \
"Use large page memory") \
\
product_pd(bool, UseLargePagesIndividualAllocation, \
"Allocate large pages individually for better affinity") \
\
develop(bool, LargePagesIndividualAllocationInjectError, false, \
"Fail large pages individual allocation") \
\
product(bool, UseNUMA, false, \
"Use NUMA if available") \
\
product(bool, UseNUMAInterleaving, false, \
"Interleave memory across NUMA nodes if available") \
\
product(size_t, NUMAInterleaveGranularity, 2*M, \
"Granularity to use for NUMA interleaving on Windows OS") \
constraint(NUMAInterleaveGranularityConstraintFunc, AtParse) \
\
product(uintx, NUMAChunkResizeWeight, 20, \
"Percentage (0-100) used to weight the current sample when " \
"computing exponentially decaying average for " \
"AdaptiveNUMAChunkSizing") \
range(0, 100) \
\
product(size_t, NUMASpaceResizeRate, 1*G, \
"Do not reallocate more than this amount per collection") \
range(0, max_uintx) \
\
product(bool, UseAdaptiveNUMAChunkSizing, true, \
"Enable adaptive chunk sizing for NUMA") \
\
product(bool, NUMAStats, false, \
"Print NUMA stats in detailed heap information") \
\
product(uintx, NUMAPageScanRate, 256, \
"Maximum number of pages to include in the page scan procedure") \
range(0, max_uintx) \
\
product(bool, UseAES, false, \
"Control whether AES instructions are used when available") \
\
product(bool, UseFMA, false, \
"Control whether FMA instructions are used when available") \
\
product(bool, UseSHA, false, \
"Control whether SHA instructions are used when available") \
\
product(bool, UseGHASHIntrinsics, false, DIAGNOSTIC, \
"Use intrinsics for GHASH versions of crypto") \
\
product(bool, UseBASE64Intrinsics, false, \
"Use intrinsics for java.util.Base64") \
\
product(bool, UsePoly1305Intrinsics, false, DIAGNOSTIC, \
"Use intrinsics for sun.security.util.math.intpoly") \
\
product(size_t, LargePageSizeInBytes, 0, \
"Maximum large page size used (0 will use the default large " \
"page size for the environment as the maximum)") \
range(0, max_uintx) \
\
product(size_t, LargePageHeapSizeThreshold, 128*M, \
"Use large pages if maximum heap is at least this big") \
range(0, max_uintx) \
\
product(bool, ForceTimeHighResolution, false, \
"Using high time resolution (for Win32 only)") \
\
develop(bool, TracePcPatching, false, \
"Trace usage of frame::patch_pc") \
\
develop(bool, TraceRelocator, false, \
"Trace the bytecode relocator") \
\
\
product(bool, SafepointALot, false, DIAGNOSTIC, \
"Generate a lot of safepoints. This works with " \
"GuaranteedSafepointInterval") \
\
product(bool, HandshakeALot, false, DIAGNOSTIC, \
"Generate a lot of handshakes. This works with " \
"GuaranteedSafepointInterval") \
\
product_pd(bool, BackgroundCompilation, \
"A thread requesting compilation is not blocked during " \
"compilation") \
\
product(bool, MethodFlushing, true, \
"Reclamation of compiled methods") \
\
develop(bool, VerifyStack, false, \
"Verify stack of each thread when it is entering a runtime call") \
\
product(bool, ForceUnreachable, false, DIAGNOSTIC, \
"Make all non code cache addresses to be unreachable by " \
"forcing use of 64bit literal fixups") \
\
develop(bool, TraceDerivedPointers, false, \
"Trace traversal of derived pointers on stack") \
\
notproduct(bool, TraceCodeBlobStacks, false, \
"Trace stack-walk of codeblobs") \
\
notproduct(bool, PrintRewrites, false, \
"Print methods that are being rewritten") \
\
product(bool, UseInlineCaches, true, \
"Use Inline Caches for virtual calls ") \
\
product(bool, InlineArrayCopy, true, DIAGNOSTIC, \
"Inline arraycopy native that is known to be part of " \
"base library DLL") \
\
product(bool, InlineObjectHash, true, DIAGNOSTIC, \
"Inline Object::hashCode() native that is known to be part " \
"of base library DLL") \
\
product(bool, InlineNatives, true, DIAGNOSTIC, \
"Inline natives that are known to be part of base library DLL") \
\
product(bool, InlineMathNatives, true, DIAGNOSTIC, \
"Inline SinD, CosD, etc.") \
\
product(bool, InlineClassNatives, true, DIAGNOSTIC, \
"Inline Class.isInstance, etc") \
\
product(bool, InlineThreadNatives, true, DIAGNOSTIC, \
"Inline Thread.currentThread, etc") \
\
product(bool, InlineUnsafeOps, true, DIAGNOSTIC, \
"Inline memory ops (native methods) from Unsafe") \
\
product(bool, UseAESIntrinsics, false, DIAGNOSTIC, \
"Use intrinsics for AES versions of crypto") \
\
product(bool, UseAESCTRIntrinsics, false, DIAGNOSTIC, \
"Use intrinsics for the paralleled version of AES/CTR crypto") \
\
product(bool, UseChaCha20Intrinsics, false, DIAGNOSTIC, \
"Use intrinsics for the vectorized version of ChaCha20") \
\
product(bool, UseMD5Intrinsics, false, DIAGNOSTIC, \
"Use intrinsics for MD5 crypto hash function") \
\
product(bool, UseSHA1Intrinsics, false, DIAGNOSTIC, \
"Use intrinsics for SHA-1 crypto hash function. " \
"Requires that UseSHA is enabled.") \
\
product(bool, UseSHA256Intrinsics, false, DIAGNOSTIC, \
"Use intrinsics for SHA-224 and SHA-256 crypto hash functions. " \
"Requires that UseSHA is enabled.") \
\
product(bool, UseSHA512Intrinsics, false, DIAGNOSTIC, \
"Use intrinsics for SHA-384 and SHA-512 crypto hash functions. " \
"Requires that UseSHA is enabled.") \
\
product(bool, UseSHA3Intrinsics, false, DIAGNOSTIC, \
"Use intrinsics for SHA3 crypto hash function. " \
"Requires that UseSHA is enabled.") \
\
product(bool, UseCRC32Intrinsics, false, DIAGNOSTIC, \
"use intrinsics for java.util.zip.CRC32") \
\
product(bool, UseCRC32CIntrinsics, false, DIAGNOSTIC, \
"use intrinsics for java.util.zip.CRC32C") \
\
product(bool, UseAdler32Intrinsics, false, DIAGNOSTIC, \
"use intrinsics for java.util.zip.Adler32") \
\
product(bool, UseVectorizedMismatchIntrinsic, false, DIAGNOSTIC, \
"Enables intrinsification of ArraysSupport.vectorizedMismatch()") \
\
product(bool, UseVectorizedHashCodeIntrinsic, false, DIAGNOSTIC, \
"Enables intrinsification of ArraysSupport.vectorizedHashCode()") \
\
product(bool, UseCopySignIntrinsic, false, DIAGNOSTIC, \
"Enables intrinsification of Math.copySign") \
\
product(bool, UseSignumIntrinsic, false, DIAGNOSTIC, \
"Enables intrinsification of Math.signum") \
\
product_pd(bool, DelayCompilerStubsGeneration, DIAGNOSTIC, \
"Use Compiler thread for compiler's stubs generation") \
\
product(ccstrlist, DisableIntrinsic, "", DIAGNOSTIC, \
"do not expand intrinsics whose (internal) names appear here") \
constraint(DisableIntrinsicConstraintFunc,AfterErgo) \
\
product(ccstrlist, ControlIntrinsic, "", DIAGNOSTIC, \
"Control intrinsics using a list of +/- (internal) names, " \
"separated by commas") \
constraint(ControlIntrinsicConstraintFunc,AfterErgo) \
\
develop(bool, TraceCallFixup, false, \
"Trace all call fixups") \
\
develop(bool, DeoptimizeALot, false, \
"Deoptimize at every exit from the runtime system") \
\
notproduct(ccstrlist, DeoptimizeOnlyAt, "", \
"A comma separated list of bcis to deoptimize at") \
\
develop(bool, DeoptimizeRandom, false, \
"Deoptimize random frames on random exit from the runtime system")\
\
notproduct(bool, ZombieALot, false, \
"Create non-entrant nmethods at exit from the runtime system") \
\
notproduct(bool, WalkStackALot, false, \
"Trace stack (no print) at every exit from the runtime system") \
\
develop(bool, DeoptimizeObjectsALot, false, \
"For testing purposes concurrent threads revert optimizations " \
"based on escape analysis at intervals given with " \
"DeoptimizeObjectsALotInterval=n. The thread count is given " \
"with DeoptimizeObjectsALotThreadCountSingle and " \
"DeoptimizeObjectsALotThreadCountAll.") \
\
develop(uint64_t, DeoptimizeObjectsALotInterval, 5, \
"Interval for DeoptimizeObjectsALot.") \
range(0, max_jlong) \
\
develop(int, DeoptimizeObjectsALotThreadCountSingle, 1, \
"The number of threads that revert optimizations based on " \
"escape analysis for a single thread if DeoptimizeObjectsALot " \
"is enabled. The target thread is selected round robin." ) \
range(0, max_jint) \
\
develop(int, DeoptimizeObjectsALotThreadCountAll, 1, \
"The number of threads that revert optimizations based on " \
"escape analysis for all threads if DeoptimizeObjectsALot " \
"is enabled." ) \
range(0, max_jint) \
\
notproduct(bool, VerifyLastFrame, false, \
"Verify oops on last frame on entry to VM") \
\
product(bool, SafepointTimeout, false, \
"Time out and warn or fail after SafepointTimeoutDelay " \
"milliseconds if failed to reach safepoint") \
\
product(bool, AbortVMOnSafepointTimeout, false, DIAGNOSTIC, \
"Abort upon failure to reach safepoint (see SafepointTimeout)") \
\
product(bool, AbortVMOnVMOperationTimeout, false, DIAGNOSTIC, \
"Abort upon failure to complete VM operation promptly") \
\
product(intx, AbortVMOnVMOperationTimeoutDelay, 1000, DIAGNOSTIC, \
"Delay in milliseconds for option AbortVMOnVMOperationTimeout") \
range(0, max_intx) \
\
product(bool, MaxFDLimit, true, \
"Bump the number of file descriptors to maximum (Unix only)") \
\
product(bool, LogEvents, true, DIAGNOSTIC, \
"Enable the various ring buffer event logs") \
\
product(uintx, LogEventsBufferEntries, 20, DIAGNOSTIC, \
"Number of ring buffer event logs") \
range(1, NOT_LP64(1*K) LP64_ONLY(1*M)) \
\
product(bool, BytecodeVerificationRemote, true, DIAGNOSTIC, \
"Enable the Java bytecode verifier for remote classes") \
\
product(bool, BytecodeVerificationLocal, false, DIAGNOSTIC, \
"Enable the Java bytecode verifier for local classes") \
\
develop(bool, VerifyStackAtCalls, false, \
"Verify that the stack pointer is unchanged after calls") \
\
develop(bool, TraceJavaAssertions, false, \
"Trace java language assertions") \
\
notproduct(bool, VerifyCodeCache, false, \
"Verify code cache on memory allocation/deallocation") \
\
develop(bool, ZapResourceArea, trueInDebug, \
"Zap freed resource/arena space") \
\
notproduct(bool, ZapVMHandleArea, trueInDebug, \
"Zap freed VM handle space") \
\
notproduct(bool, ZapStackSegments, trueInDebug, \
"Zap allocated/freed stack segments") \
\
develop(bool, ZapUnusedHeapArea, trueInDebug, \
"Zap unused heap space") \
\
develop(bool, CheckZapUnusedHeapArea, false, \
"Check zapping of unused heap space") \
\
develop(bool, ZapFillerObjects, trueInDebug, \
"Zap filler objects") \
\
product(bool, ExecutingUnitTests, false, \
"Whether the JVM is running unit tests or not") \
\
develop(uint, ErrorHandlerTest, 0, \
"If > 0, provokes an error after VM initialization; the value " \
"determines which error to provoke. See controlled_crash() " \
"in vmError.cpp.") \
range(0, 17) \
\
develop(uint, TestCrashInErrorHandler, 0, \
"If > 0, provokes an error inside VM error handler (a secondary " \
"crash). see controlled_crash() in vmError.cpp") \
range(0, 17) \
\
develop(bool, TestSafeFetchInErrorHandler, false , \
"If true, tests SafeFetch inside error handler.") \
\
develop(bool, TestUnresponsiveErrorHandler, false, \
"If true, simulates an unresponsive error handler.") \
\
develop(bool, Verbose, false, \
"Print additional debugging information from other modes") \
\
develop(bool, PrintMiscellaneous, false, \
"Print uncategorized debugging information (requires +Verbose)") \
\
develop(bool, WizardMode, false, \
"Print much more debugging information") \
\
product(bool, ShowMessageBoxOnError, false, \
"Keep process alive on VM fatal error") \
\
product(bool, CreateCoredumpOnCrash, true, \
"Create core/mini dump on VM fatal error") \
\
product(uint64_t, ErrorLogTimeout, 2 * 60, \
"Timeout, in seconds, to limit the time spent on writing an " \
"error log in case of a crash.") \
range(0, (uint64_t)max_jlong/1000) \
\
product(bool, ErrorLogSecondaryErrorDetails, false, DIAGNOSTIC, \
"If enabled, show details on secondary crashes in the error log") \
\
develop(intx, TraceDwarfLevel, 0, \
"Debug levels for the dwarf parser") \
range(0, 4) \
\
product(bool, SuppressFatalErrorMessage, false, \
"Report NO fatal error message (avoid deadlock)") \
\
product(ccstrlist, OnError, "", \
"Run user-defined commands on fatal error; see VMError.cpp " \
"for examples") \
\
product(ccstrlist, OnOutOfMemoryError, "", \
"Run user-defined commands on first java.lang.OutOfMemoryError " \
"thrown from JVM") \
\
product(bool, HeapDumpBeforeFullGC, false, MANAGEABLE, \
"Dump heap to file before any major stop-the-world GC") \
\
product(bool, HeapDumpAfterFullGC, false, MANAGEABLE, \
"Dump heap to file after any major stop-the-world GC") \
\
product(bool, HeapDumpOnOutOfMemoryError, false, MANAGEABLE, \
"Dump heap to file when java.lang.OutOfMemoryError is thrown " \
"from JVM") \
\
product(ccstr, HeapDumpPath, nullptr, MANAGEABLE, \
"When HeapDumpOnOutOfMemoryError is on, the path (filename or " \
"directory) of the dump file (defaults to java_pid<pid>.hprof " \
"in the working directory)") \
\
product(intx, HeapDumpGzipLevel, 0, MANAGEABLE, \
"When HeapDumpOnOutOfMemoryError is on, the gzip compression " \
"level of the dump file. 0 (the default) disables gzip " \
"compression. Otherwise the level must be between 1 and 9.") \
range(0, 9) \
\
product(ccstr, NativeMemoryTracking, DEBUG_ONLY("summary") NOT_DEBUG("off"), \
"Native memory tracking options") \
\
product(bool, PrintNMTStatistics, false, DIAGNOSTIC, \
"Print native memory tracking summary data if it is on") \
\
product(bool, LogCompilation, false, DIAGNOSTIC, \
"Log compilation activity in detail to LogFile") \
\
product(bool, PrintCompilation, false, \
"Print compilations") \
\
product(intx, RepeatCompilation, 0, DIAGNOSTIC, \
"Repeat compilation without installing code (number of times)") \
range(0, max_jint) \
\
product(bool, PrintExtendedThreadInfo, false, \
"Print more information in thread dump") \
\
product(intx, ScavengeRootsInCode, 2, DIAGNOSTIC, \
"0: do not allow scavengable oops in the code cache; " \
"1: allow scavenging from the code cache; " \
"2: emit as many constants as the compiler can see") \
range(0, 2) \
\
product(bool, AlwaysRestoreFPU, false, \
"Restore the FPU control word after every JNI call (expensive)") \
\
product(bool, PrintCompilation2, false, DIAGNOSTIC, \
"Print additional statistics per compilation") \
\
product(bool, PrintAdapterHandlers, false, DIAGNOSTIC, \
"Print code generated for i2c/c2i adapters") \
\
product(bool, VerifyAdapterCalls, trueInDebug, DIAGNOSTIC, \
"Verify that i2c/c2i adapters are called properly") \
\
develop(bool, VerifyAdapterSharing, false, \
"Verify that the code for shared adapters is the equivalent") \
\
product(bool, PrintAssembly, false, DIAGNOSTIC, \
"Print assembly code (using external disassembler.so)") \
\
product(ccstr, PrintAssemblyOptions, nullptr, DIAGNOSTIC, \
"Print options string passed to disassembler.so") \
\
notproduct(bool, PrintNMethodStatistics, false, \
"Print a summary statistic for the generated nmethods") \
\
product(bool, PrintNMethods, false, DIAGNOSTIC, \
"Print assembly code for nmethods when generated") \
\
product(bool, PrintNativeNMethods, false, DIAGNOSTIC, \
"Print assembly code for native nmethods when generated") \
\
develop(bool, PrintDebugInfo, false, \
"Print debug information for all nmethods when generated") \
\
develop(bool, PrintRelocations, false, \
"Print relocation information for all nmethods when generated") \
\
develop(bool, PrintDependencies, false, \
"Print dependency information for all nmethods when generated") \
\
develop(bool, PrintExceptionHandlers, false, \
"Print exception handler tables for all nmethods when generated") \
\
develop(bool, StressCompiledExceptionHandlers, false, \
"Exercise compiled exception handlers") \
\
develop(bool, InterceptOSException, false, \
"Start debugger when an implicit OS (e.g. null pointer) " \
"exception happens") \
\
product(bool, PrintCodeCache, false, \
"Print the code cache memory usage when exiting") \
\
develop(bool, PrintCodeCache2, false, \
"Print detailed usage information on the code cache when exiting")\
\
product(bool, PrintCodeCacheOnCompilation, false, \
"Print the code cache memory usage each time a method is " \
"compiled") \
\
product(bool, PrintCodeHeapAnalytics, false, DIAGNOSTIC, \
"Print code heap usage statistics on exit and on full condition") \
\
product(bool, PrintStubCode, false, DIAGNOSTIC, \
"Print generated stub code") \
\
product(bool, StackTraceInThrowable, true, \
"Collect backtrace in throwable when exception happens") \
\
product(bool, OmitStackTraceInFastThrow, true, \
"Omit backtraces for some 'hot' exceptions in optimized code") \
\
product(bool, ShowCodeDetailsInExceptionMessages, true, MANAGEABLE, \
"Show exception messages from RuntimeExceptions that contain " \
"snippets of the failing code. Disable this to improve privacy.") \
\
product(bool, PrintWarnings, true, \
"Print JVM warnings to output stream") \
\
product(bool, RegisterFinalizersAtInit, true, \
"Register finalizable objects at end of Object.<init> or " \
"after allocation") \
\
develop(bool, RegisterReferences, true, \
"Tell whether the VM should register soft/weak/final/phantom " \
"references") \
\
develop(bool, PrintCodeCacheExtension, false, \
"Print extension of code cache") \
\
develop(bool, UsePrivilegedStack, true, \
"Enable the security JVM functions") \
\
product(bool, ClassUnloading, true, \
"Do unloading of classes") \
\
product(bool, ClassUnloadingWithConcurrentMark, true, \
"Do unloading of classes with a concurrent marking cycle") \
\
notproduct(bool, PrintSystemDictionaryAtExit, false, \
"Print the system dictionary at exit") \
\
notproduct(bool, PrintClassLoaderDataGraphAtExit, false, \
"Print the class loader data graph at exit") \
\
product(bool, AllowParallelDefineClass, false, \
"Allow parallel defineClass requests for class loaders " \
"registering as parallel capable") \
\
product_pd(bool, DontYieldALot, \
"Throw away obvious excess yield calls") \
\
product(bool, DisablePrimordialThreadGuardPages, false, EXPERIMENTAL, \
"Disable the use of stack guard pages if the JVM is loaded " \
"on the primordial process thread") \
\
product(bool, DoJVMTIVirtualThreadTransitions, true, EXPERIMENTAL, \
"Do JVMTI virtual thread mount/unmount transitions " \
"(disabling this flag implies no JVMTI events are posted)") \
\
/* notice: the max range value here is max_jint, not max_intx */ \
/* because of overflow issue */ \
product(intx, AsyncDeflationInterval, 250, DIAGNOSTIC, \
"Async deflate idle monitors every so many milliseconds when " \
"MonitorUsedDeflationThreshold is exceeded (0 is off).") \
range(0, max_jint) \
\
/* notice: the max range value here is max_jint, not max_intx */ \
/* because of overflow issue */ \
product(intx, GuaranteedAsyncDeflationInterval, 60000, DIAGNOSTIC, \
"Async deflate idle monitors every so many milliseconds even " \
"when MonitorUsedDeflationThreshold is NOT exceeded (0 is off).") \
range(0, max_jint) \
\
product(size_t, AvgMonitorsPerThreadEstimate, 1024, DIAGNOSTIC, \
"Used to estimate a variable ceiling based on number of threads " \
"for use with MonitorUsedDeflationThreshold (0 is off).") \
range(0, max_uintx) \
\
/* notice: the max range value here is max_jint, not max_intx */ \
/* because of overflow issue */ \
product(intx, MonitorDeflationMax, 1000000, DIAGNOSTIC, \
"The maximum number of monitors to deflate, unlink and delete " \
"at one time (minimum is 1024).") \
range(1024, max_jint) \
\
product(intx, MonitorUsedDeflationThreshold, 90, DIAGNOSTIC, \
"Percentage of used monitors before triggering deflation (0 is " \
"off). The check is performed on GuaranteedSafepointInterval, " \
"AsyncDeflationInterval or GuaranteedAsyncDeflationInterval, " \
"whichever is lower.") \
range(0, 100) \
\
product(uintx, NoAsyncDeflationProgressMax, 3, DIAGNOSTIC, \
"Max number of no progress async deflation attempts to tolerate " \
"before adjusting the in_use_list_ceiling up (0 is off).") \
range(0, max_uintx) \
\
product(intx, hashCode, 5, EXPERIMENTAL, \
"(Unstable) select hashCode generation algorithm") \
\
product(bool, ReduceSignalUsage, false, \
"Reduce the use of OS signals in Java and/or the VM") \
\
develop(bool, LoadLineNumberTables, true, \
"Tell whether the class file parser loads line number tables") \
\
develop(bool, LoadLocalVariableTables, true, \
"Tell whether the class file parser loads local variable tables") \
\
develop(bool, LoadLocalVariableTypeTables, true, \
"Tell whether the class file parser loads local variable type" \
"tables") \
\
product(bool, AllowUserSignalHandlers, false, \
"Application will install primary signal handlers for the JVM " \
"(Unix only)") \
\
product(bool, UseSignalChaining, true, \
"Use signal-chaining to invoke signal handlers installed " \
"by the application (Unix only)") \
\
product(bool, RestoreMXCSROnJNICalls, false, \
"Restore MXCSR when returning from JNI calls") \
\
product(bool, CheckJNICalls, false, \
"Verify all arguments to JNI calls") \
\
product(bool, UseFastJNIAccessors, true, \
"Use optimized versions of Get<Primitive>Field") \
\
product(intx, MaxJNILocalCapacity, 65536, \
"Maximum allowable local JNI handle capacity to " \
"EnsureLocalCapacity() and PushLocalFrame(), " \
"where <= 0 is unlimited, default: 65536") \
range(min_intx, max_intx) \
\
product(bool, EagerXrunInit, false, \
"Eagerly initialize -Xrun libraries; allows startup profiling, " \
"but not all -Xrun libraries may support the state of the VM " \
"at this time") \
\
product(bool, PreserveAllAnnotations, false, \
"Preserve RuntimeInvisibleAnnotations as well " \
"as RuntimeVisibleAnnotations") \
\
develop(uintx, PreallocatedOutOfMemoryErrorCount, 4, \
"Number of OutOfMemoryErrors preallocated with backtrace") \
\
product(bool, UseXMMForArrayCopy, false, \
"Use SSE2 MOVQ instruction for Arraycopy") \
\
notproduct(bool, PrintFieldLayout, false, \
"Print field layout for each class") \
\
/* Need to limit the extent of the padding to reasonable size. */\
/* 8K is well beyond the reasonable HW cache line size, even with */\
/* aggressive prefetching, while still leaving the room for segregating */\
/* among the distinct pages. */\
product(intx, ContendedPaddingWidth, 128, \
"How many bytes to pad the fields/classes marked @Contended with")\
range(0, 8192) \
constraint(ContendedPaddingWidthConstraintFunc,AfterErgo) \
\
product(bool, EnableContended, true, \
"Enable @Contended annotation support") \
\
product(bool, RestrictContended, true, \
"Restrict @Contended to trusted classes") \
\
product(int, DiagnoseSyncOnValueBasedClasses, 0, DIAGNOSTIC, \
"Detect and take action upon identifying synchronization on " \
"value based classes. Modes: " \
"0: off; " \
"1: exit with fatal error; " \
"2: log message to stdout. Output file can be specified with " \
" -Xlog:valuebasedclasses. If JFR is running it will " \
" also generate JFR events.") \
range(0, 2) \
\
product(bool, ExitOnOutOfMemoryError, false, \
"JVM exits on the first occurrence of an out-of-memory error " \
"thrown from JVM") \
\
product(bool, CrashOnOutOfMemoryError, false, \
"JVM aborts, producing an error log and core/mini dump, on the " \
"first occurrence of an out-of-memory error thrown from JVM") \
\
/* tracing */ \
\
develop(bool, StressRewriter, false, \
"Stress linktime bytecode rewriting") \
\
product(ccstr, TraceJVMTI, nullptr, \
"Trace flags for JVMTI functions and events") \
\
product(bool, StressLdcRewrite, false, DIAGNOSTIC, \
"Force ldc -> ldc_w rewrite during RedefineClasses. " \
"This option can change an EMCP method into an obsolete method " \
"and can affect tests that expect specific methods to be EMCP. " \
"This option should be used with caution.") \
\
product(bool, AllowRedefinitionToAddDeleteMethods, false, \
"(Deprecated) Allow redefinition to add and delete private " \
"static or final methods for compatibility with old releases") \
\
develop(bool, TraceBytecodes, false, \
"Trace bytecode execution") \
\
develop(bool, TraceICs, false, \
"Trace inline cache changes") \
\
notproduct(bool, TraceInvocationCounterOverflow, false, \
"Trace method invocation counter overflow") \
\
develop(bool, TraceInlineCacheClearing, false, \
"Trace clearing of inline caches in nmethods") \
\
develop(bool, VerifyDependencies, trueInDebug, \
"Exercise and verify the compilation dependency mechanism") \
\
develop(bool, TraceNewOopMapGeneration, false, \
"Trace OopMapGeneration") \
\
develop(bool, TraceNewOopMapGenerationDetailed, false, \
"Trace OopMapGeneration: print detailed cell states") \
\
develop(bool, TimeOopMap, false, \
"Time calls to GenerateOopMap::compute_map() in sum") \
\
develop(bool, TimeOopMap2, false, \
"Time calls to GenerateOopMap::compute_map() individually") \
\
develop(bool, TraceOopMapRewrites, false, \
"Trace rewriting of methods during oop map generation") \
\
develop(bool, TraceICBuffer, false, \
"Trace usage of IC buffer") \
\
develop(bool, TraceCompiledIC, false, \
"Trace changes of compiled IC") \
\
develop(bool, FLSVerifyDictionary, false, \
"Do lots of (expensive) FLS dictionary verification") \
\
product(uintx, ProcessDistributionStride, 4, \
"Stride through processors when distributing processes") \
range(0, max_juint) \
\
develop(bool, TraceFinalizerRegistration, false, \
"Trace registration of final references") \
\
product(bool, IgnoreEmptyClassPaths, false, \
"Ignore empty path elements in -classpath") \
\
product(bool, PrintHeapAtSIGBREAK, true, \
"Print heap layout in response to SIGBREAK") \
\
product(bool, PrintClassHistogram, false, MANAGEABLE, \
"Print a histogram of class instances") \
\
product(double, ObjectCountCutOffPercent, 0.5, EXPERIMENTAL, \
"The percentage of the used heap that the instances of a class " \
"must occupy for the class to generate a trace event") \
range(0.0, 100.0) \
\
/* JVMTI heap profiling */ \
\
product(bool, VerifyBeforeIteration, false, DIAGNOSTIC, \
"Verify memory system before JVMTI iteration") \
\
/* compiler */ \
\
/* notice: the max range value here is max_jint, not max_intx */ \
/* because of overflow issue */ \
product(intx, CICompilerCount, CI_COMPILER_COUNT, \
"Number of compiler threads to run") \
range(0, max_jint) \
constraint(CICompilerCountConstraintFunc, AfterErgo) \
\
product(bool, UseDynamicNumberOfCompilerThreads, true, \
"Dynamically choose the number of parallel compiler threads") \
\
product(bool, ReduceNumberOfCompilerThreads, true, DIAGNOSTIC, \
"Reduce the number of parallel compiler threads when they " \
"are not used") \
\
product(bool, TraceCompilerThreads, false, DIAGNOSTIC, \
"Trace creation and removal of compiler threads") \
\
develop(bool, InjectCompilerCreationFailure, false, \
"Inject thread creation failures for " \
"UseDynamicNumberOfCompilerThreads") \
\
develop(bool, GenerateSynchronizationCode, true, \
"generate locking/unlocking code for synchronized methods and " \
"monitors") \
\
product_pd(bool, ImplicitNullChecks, DIAGNOSTIC, \
"Generate code for implicit null checks") \
\
product_pd(bool, TrapBasedNullChecks, \
"Generate code for null checks that uses a cmp and trap " \
"instruction raising SIGTRAP. This is only used if an access to" \
"null (+offset) will not raise a SIGSEGV, i.e.," \
"ImplicitNullChecks don't work (PPC64).") \
\
product(bool, EnableThreadSMRStatistics, trueInDebug, DIAGNOSTIC, \
"Enable Thread SMR Statistics") \
\
product(bool, UseNotificationThread, true, \
"Use Notification Thread") \
\
product(bool, Inline, true, \
"Enable inlining") \
\
product(bool, ClipInlining, true, \
"Clip inlining if aggregate method exceeds DesiredMethodLimit") \
\
develop(bool, UseCHA, true, \
"Enable CHA") \
\
product(bool, UseVtableBasedCHA, true, DIAGNOSTIC, \
"Use vtable information during CHA") \
\
product(bool, UseTypeProfile, true, \
"Check interpreter profile for historically monomorphic calls") \
\
product(bool, PrintInlining, false, DIAGNOSTIC, \
"Print inlining optimizations") \
\
product(bool, UsePopCountInstruction, false, \
"Use population count instruction") \
\
develop(bool, TraceMethodReplacement, false, \
"Print when methods are replaced do to recompilation") \
\
product(bool, PrintMethodFlushingStatistics, false, DIAGNOSTIC, \
"print statistics about method flushing") \
\
product(intx, MinPassesBeforeFlush, 10, DIAGNOSTIC, \
"Minimum number of sweeper passes before an nmethod " \
"can be flushed") \
range(0, max_intx) \
\
develop(bool, StressCodeBuffers, false, \
"Exercise code buffer expansion and other rare state changes") \
\
product(bool, DebugNonSafepoints, trueInDebug, DIAGNOSTIC, \
"Generate extra debugging information for non-safepoints in " \
"nmethods") \
\
product(bool, PrintVMOptions, false, \
"Print flags that appeared on the command line") \
\