37 #include "gc/shared/gcConfig.hpp"
38 #include "gc/shared/stringdedup/stringDedup.hpp"
39 #include "gc/shared/tlab_globals.hpp"
40 #include "jvm.h"
41 #include "logging/log.hpp"
42 #include "logging/logConfiguration.hpp"
43 #include "logging/logStream.hpp"
44 #include "logging/logTag.hpp"
45 #include "memory/allocation.inline.hpp"
46 #include "nmt/nmtCommon.hpp"
47 #include "oops/compressedKlass.hpp"
48 #include "oops/instanceKlass.hpp"
49 #include "oops/objLayout.hpp"
50 #include "oops/oop.inline.hpp"
51 #include "prims/jvmtiAgentList.hpp"
52 #include "prims/jvmtiExport.hpp"
53 #include "runtime/arguments.hpp"
54 #include "runtime/flags/jvmFlag.hpp"
55 #include "runtime/flags/jvmFlagAccess.hpp"
56 #include "runtime/flags/jvmFlagLimit.hpp"
57 #include "runtime/globals_extension.hpp"
58 #include "runtime/java.hpp"
59 #include "runtime/os.hpp"
60 #include "runtime/safepoint.hpp"
61 #include "runtime/safepointMechanism.hpp"
62 #include "runtime/synchronizer.hpp"
63 #include "runtime/vm_version.hpp"
64 #include "services/management.hpp"
65 #include "utilities/align.hpp"
66 #include "utilities/debug.hpp"
67 #include "utilities/defaultStream.hpp"
68 #include "utilities/macros.hpp"
69 #include "utilities/parseInteger.hpp"
70 #include "utilities/powerOfTwo.hpp"
71 #include "utilities/stringUtils.hpp"
72 #include "utilities/systemMemoryBarrier.hpp"
73 #if INCLUDE_JFR
74 #include "jfr/jfr.hpp"
75 #endif
76
77 static const char _default_java_launcher[] = "generic";
78
79 #define DEFAULT_JAVA_LAUNCHER _default_java_launcher
80
81 char* Arguments::_jvm_flags_file = nullptr;
82 char** Arguments::_jvm_flags_array = nullptr;
83 int Arguments::_num_jvm_flags = 0;
84 char** Arguments::_jvm_args_array = nullptr;
85 int Arguments::_num_jvm_args = 0;
86 unsigned int Arguments::_addmods_count = 0;
87 char* Arguments::_java_command = nullptr;
88 SystemProperty* Arguments::_system_properties = nullptr;
89 size_t Arguments::_conservative_max_heap_alignment = 0;
90 Arguments::Mode Arguments::_mode = _mixed;
91 const char* Arguments::_java_vendor_url_bug = nullptr;
92 const char* Arguments::_sun_java_launcher = DEFAULT_JAVA_LAUNCHER;
93 bool Arguments::_executing_unit_tests = false;
94
95 // These parameters are reset in method parse_vm_init_args()
96 bool Arguments::_AlwaysCompileLoopMethods = AlwaysCompileLoopMethods;
2642
2643 #ifndef COMPILER2
2644 // Don't degrade server performance for footprint
2645 if (FLAG_IS_DEFAULT(UseLargePages) &&
2646 MaxHeapSize < LargePageHeapSizeThreshold) {
2647 // No need for large granularity pages w/small heaps.
2648 // Note that large pages are enabled/disabled for both the
2649 // Java heap and the code cache.
2650 FLAG_SET_DEFAULT(UseLargePages, false);
2651 }
2652
2653 UNSUPPORTED_OPTION(ProfileInterpreter);
2654 #endif // !COMPILER2
2655
2656 // Parse the CompilationMode flag
2657 if (!CompilationModeFlag::initialize()) {
2658 return JNI_ERR;
2659 }
2660
2661 // Called after ClassLoader::lookup_vm_options() but before class loading begins.
2662 // TODO: Obtain and pass correct preview mode flag value here.
2663 ClassLoader::set_preview_mode(false);
2664
2665 if (!check_vm_args_consistency()) {
2666 return JNI_ERR;
2667 }
2668
2669
2670 #ifndef CAN_SHOW_REGISTERS_ON_ASSERT
2671 UNSUPPORTED_OPTION(ShowRegistersOnAssert);
2672 #endif // CAN_SHOW_REGISTERS_ON_ASSERT
2673
2674 return JNI_OK;
2675 }
2676
2677 // Helper class for controlling the lifetime of JavaVMInitArgs
2678 // objects. The contents of the JavaVMInitArgs are guaranteed to be
2679 // deleted on the destruction of the ScopedVMInitArgs object.
2680 class ScopedVMInitArgs : public StackObj {
2681 private:
2682 JavaVMInitArgs _args;
2683 char* _container_name;
3514 FLAG_SET_DEFAULT(StressSecondarySupers, false);
3515 FLAG_SET_DEFAULT(VerifySecondarySupers, false);
3516 }
3517
3518 #ifdef ZERO
3519 // Clear flags not supported on zero.
3520 FLAG_SET_DEFAULT(ProfileInterpreter, false);
3521 #endif // ZERO
3522
3523 if (PrintAssembly && FLAG_IS_DEFAULT(DebugNonSafepoints)) {
3524 warning("PrintAssembly is enabled; turning on DebugNonSafepoints to gain additional output");
3525 DebugNonSafepoints = true;
3526 }
3527
3528 // Treat the odd case where local verification is enabled but remote
3529 // verification is not as if both were enabled.
3530 if (BytecodeVerificationLocal && !BytecodeVerificationRemote) {
3531 log_info(verification)("Turning on remote verification because local verification is on");
3532 FLAG_SET_DEFAULT(BytecodeVerificationRemote, true);
3533 }
3534
3535 #ifndef PRODUCT
3536 if (!LogVMOutput && FLAG_IS_DEFAULT(LogVMOutput)) {
3537 if (use_vm_log()) {
3538 LogVMOutput = true;
3539 }
3540 }
3541 #endif // PRODUCT
3542
3543 if (PrintCommandLineFlags) {
3544 JVMFlag::printSetFlags(tty);
3545 }
3546
3547 #ifdef COMPILER2
3548 if (!FLAG_IS_DEFAULT(EnableVectorSupport) && !EnableVectorSupport) {
3549 if (!FLAG_IS_DEFAULT(EnableVectorReboxing) && EnableVectorReboxing) {
3550 warning("Disabling EnableVectorReboxing since EnableVectorSupport is turned off.");
3551 }
3552 FLAG_SET_DEFAULT(EnableVectorReboxing, false);
3553
|
37 #include "gc/shared/gcConfig.hpp"
38 #include "gc/shared/stringdedup/stringDedup.hpp"
39 #include "gc/shared/tlab_globals.hpp"
40 #include "jvm.h"
41 #include "logging/log.hpp"
42 #include "logging/logConfiguration.hpp"
43 #include "logging/logStream.hpp"
44 #include "logging/logTag.hpp"
45 #include "memory/allocation.inline.hpp"
46 #include "nmt/nmtCommon.hpp"
47 #include "oops/compressedKlass.hpp"
48 #include "oops/instanceKlass.hpp"
49 #include "oops/objLayout.hpp"
50 #include "oops/oop.inline.hpp"
51 #include "prims/jvmtiAgentList.hpp"
52 #include "prims/jvmtiExport.hpp"
53 #include "runtime/arguments.hpp"
54 #include "runtime/flags/jvmFlag.hpp"
55 #include "runtime/flags/jvmFlagAccess.hpp"
56 #include "runtime/flags/jvmFlagLimit.hpp"
57 #include "runtime/globals.hpp"
58 #include "runtime/globals_extension.hpp"
59 #include "runtime/java.hpp"
60 #include "runtime/os.hpp"
61 #include "runtime/safepoint.hpp"
62 #include "runtime/safepointMechanism.hpp"
63 #include "runtime/synchronizer.hpp"
64 #include "runtime/vm_version.hpp"
65 #include "services/management.hpp"
66 #include "utilities/align.hpp"
67 #include "utilities/debug.hpp"
68 #include "utilities/defaultStream.hpp"
69 #include "utilities/macros.hpp"
70 #include "utilities/parseInteger.hpp"
71 #include "utilities/powerOfTwo.hpp"
72 #include "utilities/stringUtils.hpp"
73 #include "utilities/systemMemoryBarrier.hpp"
74 #if INCLUDE_JFR
75 #include "jfr/jfr.hpp"
76 #endif
77
78 #include <string.h>
79
80 static const char _default_java_launcher[] = "generic";
81
82 #define DEFAULT_JAVA_LAUNCHER _default_java_launcher
83
84 char* Arguments::_jvm_flags_file = nullptr;
85 char** Arguments::_jvm_flags_array = nullptr;
86 int Arguments::_num_jvm_flags = 0;
87 char** Arguments::_jvm_args_array = nullptr;
88 int Arguments::_num_jvm_args = 0;
89 unsigned int Arguments::_addmods_count = 0;
90 char* Arguments::_java_command = nullptr;
91 SystemProperty* Arguments::_system_properties = nullptr;
92 size_t Arguments::_conservative_max_heap_alignment = 0;
93 Arguments::Mode Arguments::_mode = _mixed;
94 const char* Arguments::_java_vendor_url_bug = nullptr;
95 const char* Arguments::_sun_java_launcher = DEFAULT_JAVA_LAUNCHER;
96 bool Arguments::_executing_unit_tests = false;
97
98 // These parameters are reset in method parse_vm_init_args()
99 bool Arguments::_AlwaysCompileLoopMethods = AlwaysCompileLoopMethods;
2645
2646 #ifndef COMPILER2
2647 // Don't degrade server performance for footprint
2648 if (FLAG_IS_DEFAULT(UseLargePages) &&
2649 MaxHeapSize < LargePageHeapSizeThreshold) {
2650 // No need for large granularity pages w/small heaps.
2651 // Note that large pages are enabled/disabled for both the
2652 // Java heap and the code cache.
2653 FLAG_SET_DEFAULT(UseLargePages, false);
2654 }
2655
2656 UNSUPPORTED_OPTION(ProfileInterpreter);
2657 #endif // !COMPILER2
2658
2659 // Parse the CompilationMode flag
2660 if (!CompilationModeFlag::initialize()) {
2661 return JNI_ERR;
2662 }
2663
2664 // Called after ClassLoader::lookup_vm_options() but before class loading begins.
2665 ClassLoader::set_preview_mode(is_valhalla_enabled());
2666
2667 if (!check_vm_args_consistency()) {
2668 return JNI_ERR;
2669 }
2670
2671
2672 #ifndef CAN_SHOW_REGISTERS_ON_ASSERT
2673 UNSUPPORTED_OPTION(ShowRegistersOnAssert);
2674 #endif // CAN_SHOW_REGISTERS_ON_ASSERT
2675
2676 return JNI_OK;
2677 }
2678
2679 // Helper class for controlling the lifetime of JavaVMInitArgs
2680 // objects. The contents of the JavaVMInitArgs are guaranteed to be
2681 // deleted on the destruction of the ScopedVMInitArgs object.
2682 class ScopedVMInitArgs : public StackObj {
2683 private:
2684 JavaVMInitArgs _args;
2685 char* _container_name;
3516 FLAG_SET_DEFAULT(StressSecondarySupers, false);
3517 FLAG_SET_DEFAULT(VerifySecondarySupers, false);
3518 }
3519
3520 #ifdef ZERO
3521 // Clear flags not supported on zero.
3522 FLAG_SET_DEFAULT(ProfileInterpreter, false);
3523 #endif // ZERO
3524
3525 if (PrintAssembly && FLAG_IS_DEFAULT(DebugNonSafepoints)) {
3526 warning("PrintAssembly is enabled; turning on DebugNonSafepoints to gain additional output");
3527 DebugNonSafepoints = true;
3528 }
3529
3530 // Treat the odd case where local verification is enabled but remote
3531 // verification is not as if both were enabled.
3532 if (BytecodeVerificationLocal && !BytecodeVerificationRemote) {
3533 log_info(verification)("Turning on remote verification because local verification is on");
3534 FLAG_SET_DEFAULT(BytecodeVerificationRemote, true);
3535 }
3536 if (!is_valhalla_enabled()) {
3537 #define WARN_IF_NOT_DEFAULT_FLAG(flag) \
3538 if (!FLAG_IS_DEFAULT(flag)) { \
3539 warning("Preview-specific flag \"%s\" has no effect when --enable-preview is not specified.", #flag); \
3540 }
3541
3542 #define DISABLE_FLAG_AND_WARN_IF_NOT_DEFAULT(flag) \
3543 WARN_IF_NOT_DEFAULT_FLAG(flag) \
3544 FLAG_SET_DEFAULT(flag, false);
3545
3546 DISABLE_FLAG_AND_WARN_IF_NOT_DEFAULT(InlineTypePassFieldsAsArgs);
3547 DISABLE_FLAG_AND_WARN_IF_NOT_DEFAULT(InlineTypeReturnedAsFields);
3548 DISABLE_FLAG_AND_WARN_IF_NOT_DEFAULT(UseArrayFlattening);
3549 DISABLE_FLAG_AND_WARN_IF_NOT_DEFAULT(UseFieldFlattening);
3550 DISABLE_FLAG_AND_WARN_IF_NOT_DEFAULT(UseNullFreeNonAtomicValueFlattening);
3551 DISABLE_FLAG_AND_WARN_IF_NOT_DEFAULT(UseNullableAtomicValueFlattening);
3552 DISABLE_FLAG_AND_WARN_IF_NOT_DEFAULT(UseNullFreeAtomicValueFlattening);
3553 DISABLE_FLAG_AND_WARN_IF_NOT_DEFAULT(UseNullableNonAtomicValueFlattening);
3554 DISABLE_FLAG_AND_WARN_IF_NOT_DEFAULT(UseAcmpFastPath);
3555 DISABLE_FLAG_AND_WARN_IF_NOT_DEFAULT(PrintInlineLayout);
3556 DISABLE_FLAG_AND_WARN_IF_NOT_DEFAULT(PrintFlatArrayLayout);
3557 DISABLE_FLAG_AND_WARN_IF_NOT_DEFAULT(IgnoreAssertUnsetFields);
3558 WARN_IF_NOT_DEFAULT_FLAG(FlatArrayElementMaxOops);
3559 WARN_IF_NOT_DEFAULT_FLAG(ForceNonTearable);
3560 #ifdef ASSERT
3561 DISABLE_FLAG_AND_WARN_IF_NOT_DEFAULT(StressCallingConvention);
3562 DISABLE_FLAG_AND_WARN_IF_NOT_DEFAULT(PreloadClasses);
3563 WARN_IF_NOT_DEFAULT_FLAG(PrintInlineKlassFields);
3564 #endif
3565 #ifdef COMPILER1
3566 DEBUG_ONLY(DISABLE_FLAG_AND_WARN_IF_NOT_DEFAULT(C1UseDelayedFlattenedFieldReads);)
3567 #endif
3568 #ifdef COMPILER2
3569 DISABLE_FLAG_AND_WARN_IF_NOT_DEFAULT(UseArrayLoadStoreProfile);
3570 DISABLE_FLAG_AND_WARN_IF_NOT_DEFAULT(UseACmpProfile);
3571 #endif
3572 #undef DISABLE_FLAG_AND_WARN_IF_NOT_DEFAULT
3573 #undef WARN_IF_NOT_DEFAULT_FLAG
3574 } else {
3575 #define DISABLE_FLAG_AND_WARN_IF_NO_FLATTENING(flag, fallback) \
3576 if (!FLAG_IS_DEFAULT(flag) && !UseArrayFlattening && !UseFieldFlattening) { \
3577 warning("Flattening flag \"%s\" has no effect when all flattening modes are disabled.", #flag); \
3578 FLAG_SET_DEFAULT(flag, fallback); \
3579 }
3580
3581 DISABLE_FLAG_AND_WARN_IF_NO_FLATTENING(UseNullFreeNonAtomicValueFlattening, false);
3582 DISABLE_FLAG_AND_WARN_IF_NO_FLATTENING(UseNullableAtomicValueFlattening, false);
3583 DISABLE_FLAG_AND_WARN_IF_NO_FLATTENING(UseNullFreeAtomicValueFlattening, false);
3584 DISABLE_FLAG_AND_WARN_IF_NO_FLATTENING(UseNullableNonAtomicValueFlattening, false);
3585 DISABLE_FLAG_AND_WARN_IF_NO_FLATTENING(FlatArrayElementMaxOops, 0);
3586 DISABLE_FLAG_AND_WARN_IF_NO_FLATTENING(FlatteningBudget, 0);
3587 #undef DISABLE_FLAG_AND_WARN_IF_NO_FLATTENING
3588 if (is_interpreter_only() && !CDSConfig::is_dumping_archive() && !UseSharedSpaces) {
3589 // Disable calling convention optimizations if inline types are not supported.
3590 // Also these aren't useful in -Xint. However, don't disable them when dumping or using
3591 // the CDS archive, as the values must match between dumptime and runtime.
3592 FLAG_SET_DEFAULT(InlineTypePassFieldsAsArgs, false);
3593 FLAG_SET_DEFAULT(InlineTypeReturnedAsFields, false);
3594 }
3595 if (!UseNullFreeNonAtomicValueFlattening &&
3596 !UseNullableAtomicValueFlattening &&
3597 !UseNullFreeAtomicValueFlattening &&
3598 !UseNullableNonAtomicValueFlattening) {
3599 // Flattening is disabled
3600 FLAG_SET_DEFAULT(UseArrayFlattening, false);
3601 FLAG_SET_DEFAULT(UseFieldFlattening, false);
3602 }
3603 }
3604
3605 #ifndef PRODUCT
3606 if (!LogVMOutput && FLAG_IS_DEFAULT(LogVMOutput)) {
3607 if (use_vm_log()) {
3608 LogVMOutput = true;
3609 }
3610 }
3611 #endif // PRODUCT
3612
3613 if (PrintCommandLineFlags) {
3614 JVMFlag::printSetFlags(tty);
3615 }
3616
3617 #ifdef COMPILER2
3618 if (!FLAG_IS_DEFAULT(EnableVectorSupport) && !EnableVectorSupport) {
3619 if (!FLAG_IS_DEFAULT(EnableVectorReboxing) && EnableVectorReboxing) {
3620 warning("Disabling EnableVectorReboxing since EnableVectorSupport is turned off.");
3621 }
3622 FLAG_SET_DEFAULT(EnableVectorReboxing, false);
3623
|