archive/jdk
1
0
Fork 0
mirror of https://github.com/openjdk/jdk.git synced 2025-08-28 23:34:52 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

8255285: Move JVMFlag origins into a new enum JVMFlagOrigin

Browse source 
Reviewed-by: dholmes, redestad
This commit is contained in:
Ioi Lam 2020-10-30 03:44:54 +00:00
parent 56eb5f54f4
commit 1a89d68e87
23 changed files with 214 additions and 189 deletions
Download patch file Download diff file Expand all files Collapse all files

2
src/hotspot/share/jfr/periodic/jfrPeriodic.cpp
View file

@ -285,7 +285,7 @@ TRACE_REQUEST_FUNC(ThreadContextSwitchRate) {
Event ## eventType event; \ Event ## eventType event; \
event.set_name(flag->name()); \ event.set_name(flag->name()); \
event.set_value(flag->get_ ## flagType()); \ event.set_value(flag->get_ ## flagType()); \
event.set_origin(flag->get_origin()); \ event.set_origin(static_cast<u8>(flag->get_origin())); \
event.commit(); \ event.commit(); \
} \ } \
} \ } \

32
src/hotspot/share/jfr/recorder/checkpoint/types/jfrType.cpp
View file

@ -122,27 +122,29 @@ void JfrThreadGroupConstant::serialize(JfrCheckpointWriter& writer) {
JfrThreadGroup::serialize(writer); JfrThreadGroup::serialize(writer);
} }
static const char* flag_value_origin_to_string(JVMFlag::Flags origin) { static const char* flag_value_origin_to_string(JVMFlagOrigin origin) {
switch (origin) { switch (origin) {
case JVMFlag::DEFAULT: return "Default"; case JVMFlagOrigin::DEFAULT: return "Default";
case JVMFlag::COMMAND_LINE: return "Command line"; case JVMFlagOrigin::COMMAND_LINE: return "Command line";
case JVMFlag::ENVIRON_VAR: return "Environment variable"; case JVMFlagOrigin::ENVIRON_VAR: return "Environment variable";
case JVMFlag::CONFIG_FILE: return "Config file"; case JVMFlagOrigin::CONFIG_FILE: return "Config file";
case JVMFlag::MANAGEMENT: return "Management"; case JVMFlagOrigin::MANAGEMENT: return "Management";
case JVMFlag::ERGONOMIC: return "Ergonomic"; case JVMFlagOrigin::ERGONOMIC: return "Ergonomic";
case JVMFlag::ATTACH_ON_DEMAND: return "Attach on demand"; case JVMFlagOrigin::ATTACH_ON_DEMAND: return "Attach on demand";
case JVMFlag::INTERNAL: return "Internal"; case JVMFlagOrigin::INTERNAL: return "Internal";
case JVMFlag::JIMAGE_RESOURCE: return "JImage resource"; case JVMFlagOrigin::JIMAGE_RESOURCE: return "JImage resource";
default: ShouldNotReachHere(); return ""; default: ShouldNotReachHere(); return "";
} }
} }
void FlagValueOriginConstant::serialize(JfrCheckpointWriter& writer) { void FlagValueOriginConstant::serialize(JfrCheckpointWriter& writer) {
static const u4 nof_entries = JVMFlag::LAST_VALUE_ORIGIN + 1; constexpr EnumRange<JVMFlagOrigin> range;
writer.write_count(nof_entries); writer.write_count(static_cast<u4>(range.size()));
for (u4 i = 0; i < nof_entries; ++i) {
writer.write_key(i); for (EnumIterator<JVMFlagOrigin> it = range.begin(); it != range.end(); ++it) {
writer.write(flag_value_origin_to_string((JVMFlag::Flags)i)); JVMFlagOrigin origin = *it;
writer.write_key(static_cast<u4>(origin));
writer.write(flag_value_origin_to_string(origin));
} }
} }

1
src/hotspot/share/jvmci/jvmciCompilerToVMInit.cpp
View file

@ -32,6 +32,7 @@
#include "memory/universe.hpp" #include "memory/universe.hpp"
#include "oops/compressedOops.hpp" #include "oops/compressedOops.hpp"
#include "oops/klass.inline.hpp" #include "oops/klass.inline.hpp"
#include "runtime/flags/jvmFlag.hpp"
#include "runtime/sharedRuntime.hpp" #include "runtime/sharedRuntime.hpp"
#include "utilities/resourceHash.hpp" #include "utilities/resourceHash.hpp"

2
src/hotspot/share/jvmci/jvmci_globals.cpp
View file

@ -158,7 +158,7 @@ bool JVMCIGlobals::check_jvmci_flags_are_consistent() {
} }
// Convert JVMCI flags from experimental to product // Convert JVMCI flags from experimental to product
bool JVMCIGlobals::enable_jvmci_product_mode(JVMFlag::Flags origin) { bool JVMCIGlobals::enable_jvmci_product_mode(JVMFlagOrigin origin) {
const char *JVMCIFlags[] = { const char *JVMCIFlags[] = {
"EnableJVMCI", "EnableJVMCI",
"EnableJVMCIProduct", "EnableJVMCIProduct",

4
src/hotspot/share/jvmci/jvmci_globals.hpp
View file

@ -25,7 +25,7 @@
#ifndef SHARE_JVMCI_JVMCI_GLOBALS_HPP #ifndef SHARE_JVMCI_JVMCI_GLOBALS_HPP
#define SHARE_JVMCI_JVMCI_GLOBALS_HPP #define SHARE_JVMCI_JVMCI_GLOBALS_HPP
#include "runtime/flags/jvmFlag.hpp" #include "utilities/vmEnums.hpp"
class fileStream; class fileStream;
@ -153,7 +153,7 @@ class JVMCIGlobals {
static bool check_jvmci_flags_are_consistent(); static bool check_jvmci_flags_are_consistent();
// Convert JVMCI experimental flags to product // Convert JVMCI experimental flags to product
static bool enable_jvmci_product_mode(JVMFlag::Flags); static bool enable_jvmci_product_mode(JVMFlagOrigin);
// Check and exit VM with error if selected GC is not supported by JVMCI. // Check and exit VM with error if selected GC is not supported by JVMCI.
static void check_jvmci_supported_gc(); static void check_jvmci_supported_gc();

1
src/hotspot/share/jvmci/vmStructs_jvmci.cpp
View file

@ -33,6 +33,7 @@
#include "jvmci/vmStructs_jvmci.hpp" #include "jvmci/vmStructs_jvmci.hpp"
#include "oops/objArrayKlass.hpp" #include "oops/objArrayKlass.hpp"
#include "runtime/deoptimization.hpp" #include "runtime/deoptimization.hpp"
#include "runtime/flags/jvmFlag.hpp"
#include "runtime/sharedRuntime.hpp" #include "runtime/sharedRuntime.hpp"
#if INCLUDE_G1GC #if INCLUDE_G1GC
#include "gc/g1/g1CardTable.hpp" #include "gc/g1/g1CardTable.hpp"

2
src/hotspot/share/prims/whitebox.cpp
View file

@ -1245,7 +1245,7 @@ static bool SetVMFlag(JavaThread* thread, JNIEnv* env, jstring name, T* value) {
const char* flag_name = env->GetStringUTFChars(name, NULL); const char* flag_name = env->GetStringUTFChars(name, NULL);
CHECK_JNI_EXCEPTION_(env, false); CHECK_JNI_EXCEPTION_(env, false);
JVMFlag* flag = JVMFlag::find_flag(flag_name); JVMFlag* flag = JVMFlag::find_flag(flag_name);
JVMFlag::Error result = JVMFlagAccess::set<T, type_enum>(flag, value, JVMFlag::INTERNAL); JVMFlag::Error result = JVMFlagAccess::set<T, type_enum>(flag, value, JVMFlagOrigin::INTERNAL);
env->ReleaseStringUTFChars(name, flag_name); env->ReleaseStringUTFChars(name, flag_name);
return (result == JVMFlag::SUCCESS); return (result == JVMFlag::SUCCESS);
} }

28
src/hotspot/share/runtime/arguments.cpp
View file

@ -877,7 +877,7 @@ void Arguments::describe_range_error(ArgsRange errcode) {
} }
} }
static bool set_bool_flag(JVMFlag* flag, bool value, JVMFlag::Flags origin) { static bool set_bool_flag(JVMFlag* flag, bool value, JVMFlagOrigin origin) {
if (JVMFlagAccess::boolAtPut(flag, &value, origin) == JVMFlag::SUCCESS) { if (JVMFlagAccess::boolAtPut(flag, &value, origin) == JVMFlag::SUCCESS) {
return true; return true;
} else { } else {
@ -885,7 +885,7 @@ static bool set_bool_flag(JVMFlag* flag, bool value, JVMFlag::Flags origin) {
} }
} }
static bool set_fp_numeric_flag(JVMFlag* flag, char* value, JVMFlag::Flags origin) { static bool set_fp_numeric_flag(JVMFlag* flag, char* value, JVMFlagOrigin origin) {
char* end; char* end;
errno = 0; errno = 0;
double v = strtod(value, &end); double v = strtod(value, &end);
@ -899,7 +899,7 @@ static bool set_fp_numeric_flag(JVMFlag* flag, char* value, JVMFlag::Flags origi
return false; return false;
} }
static bool set_numeric_flag(JVMFlag* flag, char* value, JVMFlag::Flags origin) { static bool set_numeric_flag(JVMFlag* flag, char* value, JVMFlagOrigin origin) {
julong v; julong v;
int int_v; int int_v;
intx intx_v; intx intx_v;
@ -952,14 +952,14 @@ static bool set_numeric_flag(JVMFlag* flag, char* value, JVMFlag::Flags origin)
} }
} }
static bool set_string_flag(JVMFlag* flag, const char* value, JVMFlag::Flags origin) { static bool set_string_flag(JVMFlag* flag, const char* value, JVMFlagOrigin origin) {
if (JVMFlagAccess::ccstrAtPut(flag, &value, origin) != JVMFlag::SUCCESS) return false; if (JVMFlagAccess::ccstrAtPut(flag, &value, origin) != JVMFlag::SUCCESS) return false;
// Contract: JVMFlag always returns a pointer that needs freeing. // Contract: JVMFlag always returns a pointer that needs freeing.
FREE_C_HEAP_ARRAY(char, value); FREE_C_HEAP_ARRAY(char, value);
return true; return true;
} }
static bool append_to_string_flag(JVMFlag* flag, const char* new_value, JVMFlag::Flags origin) { static bool append_to_string_flag(JVMFlag* flag, const char* new_value, JVMFlagOrigin origin) {
const char* old_value = ""; const char* old_value = "";
if (JVMFlagAccess::ccstrAt(flag, &old_value) != JVMFlag::SUCCESS) return false; if (JVMFlagAccess::ccstrAt(flag, &old_value) != JVMFlag::SUCCESS) return false;
size_t old_len = old_value != NULL ? strlen(old_value) : 0; size_t old_len = old_value != NULL ? strlen(old_value) : 0;
@ -1060,7 +1060,7 @@ AliasedLoggingFlag Arguments::catch_logging_aliases(const char* name, bool on){
return a; return a;
} }
bool Arguments::parse_argument(const char* arg, JVMFlag::Flags origin) { bool Arguments::parse_argument(const char* arg, JVMFlagOrigin origin) {
// range of acceptable characters spelled out for portability reasons // range of acceptable characters spelled out for portability reasons
#define NAME_RANGE "[abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_]" #define NAME_RANGE "[abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_]"
@ -1275,7 +1275,7 @@ void Arguments::print_jvm_args_on(outputStream* st) {
bool Arguments::process_argument(const char* arg, bool Arguments::process_argument(const char* arg,
jboolean ignore_unrecognized, jboolean ignore_unrecognized,
JVMFlag::Flags origin) { JVMFlagOrigin origin) {
JDK_Version since = JDK_Version(); JDK_Version since = JDK_Version();
if (parse_argument(arg, origin)) { if (parse_argument(arg, origin)) {
@ -1404,7 +1404,7 @@ bool Arguments::process_settings_file(const char* file_name, bool should_exist,
// this allows a way to include spaces in string-valued options // this allows a way to include spaces in string-valued options
token[pos] = '\0'; token[pos] = '\0';
logOption(token); logOption(token);
result &= process_argument(token, ignore_unrecognized, JVMFlag::CONFIG_FILE); result &= process_argument(token, ignore_unrecognized, JVMFlagOrigin::CONFIG_FILE);
build_jvm_flags(token); build_jvm_flags(token);
pos = 0; pos = 0;
in_white_space = true; in_white_space = true;
@ -1422,7 +1422,7 @@ bool Arguments::process_settings_file(const char* file_name, bool should_exist,
} }
if (pos > 0) { if (pos > 0) {
token[pos] = '\0'; token[pos] = '\0';
result &= process_argument(token, ignore_unrecognized, JVMFlag::CONFIG_FILE); result &= process_argument(token, ignore_unrecognized, JVMFlagOrigin::CONFIG_FILE);
build_jvm_flags(token); build_jvm_flags(token);
} }
fclose(stream); fclose(stream);
@ -2288,27 +2288,27 @@ jint Arguments::parse_vm_init_args(const JavaVMInitArgs *vm_options_args,
set_mode_flags(_mixed); set_mode_flags(_mixed);
// Parse args structure generated from java.base vm options resource // Parse args structure generated from java.base vm options resource
jint result = parse_each_vm_init_arg(vm_options_args, &patch_mod_javabase, JVMFlag::JIMAGE_RESOURCE); jint result = parse_each_vm_init_arg(vm_options_args, &patch_mod_javabase, JVMFlagOrigin::JIMAGE_RESOURCE);
if (result != JNI_OK) { if (result != JNI_OK) {
return result; return result;
} }
// Parse args structure generated from JAVA_TOOL_OPTIONS environment // Parse args structure generated from JAVA_TOOL_OPTIONS environment
// variable (if present). // variable (if present).
result = parse_each_vm_init_arg(java_tool_options_args, &patch_mod_javabase, JVMFlag::ENVIRON_VAR); result = parse_each_vm_init_arg(java_tool_options_args, &patch_mod_javabase, JVMFlagOrigin::ENVIRON_VAR);
if (result != JNI_OK) { if (result != JNI_OK) {
return result; return result;
} }
// Parse args structure generated from the command line flags. // Parse args structure generated from the command line flags.
result = parse_each_vm_init_arg(cmd_line_args, &patch_mod_javabase, JVMFlag::COMMAND_LINE); result = parse_each_vm_init_arg(cmd_line_args, &patch_mod_javabase, JVMFlagOrigin::COMMAND_LINE);
if (result != JNI_OK) { if (result != JNI_OK) {
return result; return result;
} }
// Parse args structure generated from the _JAVA_OPTIONS environment // Parse args structure generated from the _JAVA_OPTIONS environment
// variable (if present) (mimics classic VM) // variable (if present) (mimics classic VM)
result = parse_each_vm_init_arg(java_options_args, &patch_mod_javabase, JVMFlag::ENVIRON_VAR); result = parse_each_vm_init_arg(java_options_args, &patch_mod_javabase, JVMFlagOrigin::ENVIRON_VAR);
if (result != JNI_OK) { if (result != JNI_OK) {
return result; return result;
} }
@ -2452,7 +2452,7 @@ jint Arguments::parse_xss(const JavaVMOption* option, const char* tail, intx* ou
return JNI_OK; return JNI_OK;
} }
jint Arguments::parse_each_vm_init_arg(const JavaVMInitArgs* args, bool* patch_mod_javabase, JVMFlag::Flags origin) { jint Arguments::parse_each_vm_init_arg(const JavaVMInitArgs* args, bool* patch_mod_javabase, JVMFlagOrigin origin) {
// For match_option to return remaining or value part of option string // For match_option to return remaining or value part of option string
const char* tail; const char* tail;

8
src/hotspot/share/runtime/arguments.hpp
View file

@ -28,11 +28,11 @@
#include "logging/logLevel.hpp" #include "logging/logLevel.hpp"
#include "logging/logTag.hpp" #include "logging/logTag.hpp"
#include "memory/allocation.hpp" #include "memory/allocation.hpp"
#include "runtime/flags/jvmFlag.hpp"
#include "runtime/java.hpp" #include "runtime/java.hpp"
#include "runtime/os.hpp" #include "runtime/os.hpp"
#include "runtime/perfData.hpp" #include "runtime/perfData.hpp"
#include "utilities/debug.hpp" #include "utilities/debug.hpp"
#include "utilities/vmEnums.hpp"
// Arguments parses the command line and recognizes options // Arguments parses the command line and recognizes options
@ -408,8 +408,8 @@ class Arguments : AllStatic {
static jint set_aggressive_heap_flags(); static jint set_aggressive_heap_flags();
// Argument parsing // Argument parsing
static bool parse_argument(const char* arg, JVMFlag::Flags origin); static bool parse_argument(const char* arg, JVMFlagOrigin origin);
static bool process_argument(const char* arg, jboolean ignore_unrecognized, JVMFlag::Flags origin); static bool process_argument(const char* arg, jboolean ignore_unrecognized, JVMFlagOrigin origin);
static void process_java_launcher_argument(const char*, void*); static void process_java_launcher_argument(const char*, void*);
static void process_java_compiler_argument(const char* arg); static void process_java_compiler_argument(const char* arg);
static jint parse_options_environment_variable(const char* name, ScopedVMInitArgs* vm_args); static jint parse_options_environment_variable(const char* name, ScopedVMInitArgs* vm_args);
@ -436,7 +436,7 @@ class Arguments : AllStatic {
const JavaVMInitArgs *java_tool_options_args, const JavaVMInitArgs *java_tool_options_args,
const JavaVMInitArgs *java_options_args, const JavaVMInitArgs *java_options_args,
const JavaVMInitArgs *cmd_line_args); const JavaVMInitArgs *cmd_line_args);
static jint parse_each_vm_init_arg(const JavaVMInitArgs* args, bool* patch_mod_javabase, JVMFlag::Flags origin); static jint parse_each_vm_init_arg(const JavaVMInitArgs* args, bool* patch_mod_javabase, JVMFlagOrigin origin);
static jint finalize_vm_init_args(bool patch_mod_javabase); static jint finalize_vm_init_args(bool patch_mod_javabase);
static bool is_bad_option(const JavaVMOption* option, jboolean ignore, const char* option_type); static bool is_bad_option(const JavaVMOption* option, jboolean ignore, const char* option_type);

38
src/hotspot/share/runtime/flags/jvmFlag.cpp
View file

@ -41,10 +41,15 @@ static bool is_product_build() {
#endif #endif
} }
void JVMFlag::set_origin(Flags origin) { void JVMFlag::set_origin(JVMFlagOrigin new_origin) {
int old_flags = _flags;
int origin = static_cast<int>(new_origin);
assert((origin & VALUE_ORIGIN_MASK) == origin, "sanity"); assert((origin & VALUE_ORIGIN_MASK) == origin, "sanity");
Flags new_origin = Flags((origin == COMMAND_LINE) ? Flags(origin | ORIG_COMMAND_LINE) : origin); int was_in_cmdline = (new_origin == JVMFlagOrigin::COMMAND_LINE) ? WAS_SET_ON_COMMAND_LINE : 0;
_flags = Flags((_flags & ~VALUE_ORIGIN_MASK) | new_origin); _flags = Flags((_flags & ~VALUE_ORIGIN_MASK) | origin | was_in_cmdline);
if ((old_flags & WAS_SET_ON_COMMAND_LINE) != 0) {
assert((_flags & WAS_SET_ON_COMMAND_LINE) != 0, "once initialized, should never change");
}
} }
/** /**
@ -376,29 +381,28 @@ void JVMFlag::print_kind(outputStream* st, unsigned int width) const {
} }
void JVMFlag::print_origin(outputStream* st, unsigned int width) const { void JVMFlag::print_origin(outputStream* st, unsigned int width) const {
int origin = _flags & VALUE_ORIGIN_MASK;
st->print("{"); st->print("{");
switch(origin) { switch(get_origin()) {
case DEFAULT: case JVMFlagOrigin::DEFAULT:
st->print("default"); break; st->print("default"); break;
case COMMAND_LINE: case JVMFlagOrigin::COMMAND_LINE:
st->print("command line"); break; st->print("command line"); break;
case ENVIRON_VAR: case JVMFlagOrigin::ENVIRON_VAR:
st->print("environment"); break; st->print("environment"); break;
case CONFIG_FILE: case JVMFlagOrigin::CONFIG_FILE:
st->print("config file"); break; st->print("config file"); break;
case MANAGEMENT: case JVMFlagOrigin::MANAGEMENT:
st->print("management"); break; st->print("management"); break;
case ERGONOMIC: case JVMFlagOrigin::ERGONOMIC:
if (_flags & ORIG_COMMAND_LINE) { if (_flags & WAS_SET_ON_COMMAND_LINE) {
st->print("command line, "); st->print("command line, ");
} }
st->print("ergonomic"); break; st->print("ergonomic"); break;
case ATTACH_ON_DEMAND: case JVMFlagOrigin::ATTACH_ON_DEMAND:
st->print("attach"); break; st->print("attach"); break;
case INTERNAL: case JVMFlagOrigin::INTERNAL:
st->print("internal"); break; st->print("internal"); break;
case JIMAGE_RESOURCE: case JVMFlagOrigin::JIMAGE_RESOURCE:
st->print("jimage"); break; st->print("jimage"); break;
} }
st->print("}"); st->print("}");
@ -495,7 +499,7 @@ static constexpr int flag_group(int flag_enum) {
constexpr JVMFlag::JVMFlag(int flag_enum, FlagType type, const char* name, constexpr JVMFlag::JVMFlag(int flag_enum, FlagType type, const char* name,
void* addr, int flags, int extra_flags, const char* doc) : void* addr, int flags, int extra_flags, const char* doc) :
_addr(addr), _name(name), _flags(), _type(type) NOT_PRODUCT(COMMA _doc(doc)) { _addr(addr), _name(name), _flags(), _type(type) NOT_PRODUCT(COMMA _doc(doc)) {
flags = flags | extra_flags | JVMFlag::DEFAULT | flag_group(flag_enum); flags = flags | extra_flags | static_cast<int>(JVMFlagOrigin::DEFAULT) | flag_group(flag_enum);
if ((flags & JVMFlag::KIND_PRODUCT) != 0) { if ((flags & JVMFlag::KIND_PRODUCT) != 0) {
if (flags & (JVMFlag::KIND_DIAGNOSTIC | JVMFlag::KIND_MANAGEABLE | JVMFlag::KIND_EXPERIMENTAL)) { if (flags & (JVMFlag::KIND_DIAGNOSTIC | JVMFlag::KIND_MANAGEABLE | JVMFlag::KIND_EXPERIMENTAL)) {
// Backwards compatibility. This will be relaxed in JDK-7123237. // Backwards compatibility. This will be relaxed in JDK-7123237.
@ -653,7 +657,7 @@ void JVMFlag::printSetFlags(outputStream* out) {
// Print // Print
for (size_t i = 0; i < length; i++) { for (size_t i = 0; i < length; i++) {
if (array[i]->get_origin() /* naked field! */) { if (array[i]->get_origin() != JVMFlagOrigin::DEFAULT) {
array[i]->print_as_flag(out); array[i]->print_as_flag(out);
out->print(" "); out->print(" ");
} }

44
src/hotspot/share/runtime/flags/jvmFlag.hpp
View file

@ -26,16 +26,16 @@
#define SHARE_RUNTIME_FLAGS_JVMFLAG_HPP #define SHARE_RUNTIME_FLAGS_JVMFLAG_HPP
#include "utilities/globalDefinitions.hpp" #include "utilities/globalDefinitions.hpp"
#include "utilities/enumIterator.hpp"
#include "utilities/macros.hpp" #include "utilities/macros.hpp"
#include "utilities/vmEnums.hpp" #include "utilities/vmEnums.hpp"
class outputStream; class outputStream;
class JVMFlag { enum class JVMFlagOrigin : int {
friend class VMStructs; // This is the value returned by JVMFlag::get_origin(). It records who
public: // has most recently changed the value of a JVMFlag. DEFAULT means that the
enum Flags : int { // flag was never changed, or was most recently changed by FLAG_SET_DEFAULT.
// latest value origin
DEFAULT = 0, DEFAULT = 0,
COMMAND_LINE = 1, COMMAND_LINE = 1,
ENVIRON_VAR = 2, ENVIRON_VAR = 2,
@ -45,8 +45,15 @@ public:
ATTACH_ON_DEMAND = 6, ATTACH_ON_DEMAND = 6,
INTERNAL = 7, INTERNAL = 7,
JIMAGE_RESOURCE = 8, JIMAGE_RESOURCE = 8,
};
LAST_VALUE_ORIGIN = JIMAGE_RESOURCE, ENUMERATOR_RANGE(JVMFlagOrigin, JVMFlagOrigin::DEFAULT, JVMFlagOrigin::JIMAGE_RESOURCE)
class JVMFlag {
friend class VMStructs;
public:
enum Flags : int {
VALUE_ORIGIN_BITS = 4, VALUE_ORIGIN_BITS = 4,
VALUE_ORIGIN_MASK = right_n_bits(VALUE_ORIGIN_BITS), VALUE_ORIGIN_MASK = right_n_bits(VALUE_ORIGIN_BITS),
@ -64,10 +71,15 @@ public:
KIND_LP64_PRODUCT = 1 << 14, KIND_LP64_PRODUCT = 1 << 14,
KIND_JVMCI = 1 << 15, KIND_JVMCI = 1 << 15,
// set this bit if the flag was set on the command line // Note the difference:
ORIG_COMMAND_LINE = 1 << 17, // f->get_origin() == COMMAND_LINE
// f was mostly recently set by the command-line
// f->_flags & WAS_SET_ON_COMMAND_LINE
// f was specified on the command-line (but may have since been updated by
// someone else like FLAG_SET_ERGO)
WAS_SET_ON_COMMAND_LINE = 1 << 17,
KIND_MASK = ~(VALUE_ORIGIN_MASK | ORIG_COMMAND_LINE) KIND_MASK = ~(VALUE_ORIGIN_MASK | WAS_SET_ON_COMMAND_LINE)
}; };
enum Error { enum Error {
@ -232,14 +244,14 @@ public:
*static_cast<T*>(_addr) = value; *static_cast<T*>(_addr) = value;
} }
Flags get_origin() const { return Flags(_flags & VALUE_ORIGIN_MASK); } JVMFlagOrigin get_origin() const { return JVMFlagOrigin(_flags & VALUE_ORIGIN_MASK); }
void set_origin(Flags origin); void set_origin(JVMFlagOrigin origin);
bool is_default() const { return (get_origin() == DEFAULT); } bool is_default() const { return (get_origin() == JVMFlagOrigin::DEFAULT); }
bool is_ergonomic() const { return (get_origin() == ERGONOMIC); } bool is_ergonomic() const { return (get_origin() == JVMFlagOrigin::ERGONOMIC); }
bool is_command_line() const { return (_flags & ORIG_COMMAND_LINE) != 0; } bool is_command_line() const { return (_flags & WAS_SET_ON_COMMAND_LINE) != 0; }
void set_command_line() { _flags = Flags(_flags | ORIG_COMMAND_LINE); } void set_command_line() { _flags = Flags(_flags | WAS_SET_ON_COMMAND_LINE); }
bool is_jimage_resource() const { return (get_origin() == JIMAGE_RESOURCE); } bool is_jimage_resource() const { return (get_origin() == JVMFlagOrigin::JIMAGE_RESOURCE); }
bool is_product() const { return (_flags & KIND_PRODUCT) != 0; } bool is_product() const { return (_flags & KIND_PRODUCT) != 0; }
bool is_manageable() const { return (_flags & KIND_MANAGEABLE) != 0; } bool is_manageable() const { return (_flags & KIND_MANAGEABLE) != 0; }
bool is_diagnostic() const { return (_flags & KIND_DIAGNOSTIC) != 0; } bool is_diagnostic() const { return (_flags & KIND_DIAGNOSTIC) != 0; }

22
src/hotspot/share/runtime/flags/jvmFlagAccess.cpp
View file

@ -33,22 +33,22 @@
#include "utilities/ostream.hpp" #include "utilities/ostream.hpp"
template<typename T, typename EVENT> template<typename T, typename EVENT>
static void trace_flag_changed(JVMFlag* flag, const T old_value, const T new_value, const JVMFlag::Flags origin) { static void trace_flag_changed(JVMFlag* flag, const T old_value, const T new_value, const JVMFlagOrigin origin) {
EVENT e; EVENT e;
e.set_name(flag->name()); e.set_name(flag->name());
e.set_oldValue(old_value); e.set_oldValue(old_value);
e.set_newValue(new_value); e.set_newValue(new_value);
e.set_origin(origin); e.set_origin(static_cast<u8>(origin));
e.commit(); e.commit();
} }
class FlagAccessImpl { class FlagAccessImpl {
public: public:
JVMFlag::Error set(JVMFlag* flag, void* value, JVMFlag::Flags origin) const { JVMFlag::Error set(JVMFlag* flag, void* value, JVMFlagOrigin origin) const {
return set_impl(flag, value, origin); return set_impl(flag, value, origin);
} }
virtual JVMFlag::Error set_impl(JVMFlag* flag, void* value, JVMFlag::Flags origin) const = 0; virtual JVMFlag::Error set_impl(JVMFlag* flag, void* value, JVMFlagOrigin origin) const = 0;
virtual JVMFlag::Error check_range(const JVMFlag* flag, bool verbose) const { return JVMFlag::SUCCESS; } virtual JVMFlag::Error check_range(const JVMFlag* flag, bool verbose) const { return JVMFlag::SUCCESS; }
virtual void print_range(outputStream* st, const JVMFlagLimit* range) const { ShouldNotReachHere(); } virtual void print_range(outputStream* st, const JVMFlagLimit* range) const { ShouldNotReachHere(); }
virtual void print_default_range(outputStream* st) const { ShouldNotReachHere(); } virtual void print_default_range(outputStream* st) const { ShouldNotReachHere(); }
@ -59,7 +59,7 @@ template <typename T, int type_enum, typename EVENT>
class TypedFlagAccessImpl : public FlagAccessImpl { class TypedFlagAccessImpl : public FlagAccessImpl {
public: public:
JVMFlag::Error check_constraint_and_set(JVMFlag* flag, void* value_addr, JVMFlag::Flags origin, bool verbose) const { JVMFlag::Error check_constraint_and_set(JVMFlag* flag, void* value_addr, JVMFlagOrigin origin, bool verbose) const {
T value = *((T*)value_addr); T value = *((T*)value_addr);
const JVMTypedFlagLimit<T>* constraint = (const JVMTypedFlagLimit<T>*)JVMFlagLimit::get_constraint(flag); const JVMTypedFlagLimit<T>* constraint = (const JVMTypedFlagLimit<T>*)JVMFlagLimit::get_constraint(flag);
if (constraint != NULL && constraint->phase() <= static_cast<int>(JVMFlagLimit::validating_phase())) { if (constraint != NULL && constraint->phase() <= static_cast<int>(JVMFlagLimit::validating_phase())) {
@ -87,7 +87,7 @@ public:
class FlagAccessImpl_bool : public TypedFlagAccessImpl<JVM_FLAG_TYPE(bool), EventBooleanFlagChanged> { class FlagAccessImpl_bool : public TypedFlagAccessImpl<JVM_FLAG_TYPE(bool), EventBooleanFlagChanged> {
public: public:
JVMFlag::Error set_impl(JVMFlag* flag, void* value_addr, JVMFlag::Flags origin) const { JVMFlag::Error set_impl(JVMFlag* flag, void* value_addr, JVMFlagOrigin origin) const {
bool verbose = JVMFlagLimit::verbose_checks_needed(); bool verbose = JVMFlagLimit::verbose_checks_needed();
return TypedFlagAccessImpl<JVM_FLAG_TYPE(bool), EventBooleanFlagChanged> return TypedFlagAccessImpl<JVM_FLAG_TYPE(bool), EventBooleanFlagChanged>
::check_constraint_and_set(flag, value_addr, origin, verbose); ::check_constraint_and_set(flag, value_addr, origin, verbose);
@ -101,7 +101,7 @@ public:
template <typename T, int type_enum, typename EVENT> template <typename T, int type_enum, typename EVENT>
class RangedFlagAccessImpl : public TypedFlagAccessImpl<T, type_enum, EVENT> { class RangedFlagAccessImpl : public TypedFlagAccessImpl<T, type_enum, EVENT> {
public: public:
virtual JVMFlag::Error set_impl(JVMFlag* flag, void* value_addr, JVMFlag::Flags origin) const { virtual JVMFlag::Error set_impl(JVMFlag* flag, void* value_addr, JVMFlagOrigin origin) const {
T value = *((T*)value_addr); T value = *((T*)value_addr);
bool verbose = JVMFlagLimit::verbose_checks_needed(); bool verbose = JVMFlagLimit::verbose_checks_needed();
@ -292,7 +292,7 @@ inline const FlagAccessImpl* JVMFlagAccess::access_impl(const JVMFlag* flag) {
} }
// This is called by JVMFlagAccess::*AtPut() and JVMFlagAccess::set<...>(JVMFlag* flag, ...) // This is called by JVMFlagAccess::*AtPut() and JVMFlagAccess::set<...>(JVMFlag* flag, ...)
JVMFlag::Error JVMFlagAccess::set_impl(JVMFlag* flag, int type_enum, void* value, JVMFlag::Flags origin) { JVMFlag::Error JVMFlagAccess::set_impl(JVMFlag* flag, int type_enum, void* value, JVMFlagOrigin origin) {
if (type_enum == JVMFlag::TYPE_ccstr || type_enum == JVMFlag::TYPE_ccstrlist) { if (type_enum == JVMFlag::TYPE_ccstr || type_enum == JVMFlag::TYPE_ccstrlist) {
return ccstrAtPut(flag, (ccstr*)value, origin); return ccstrAtPut(flag, (ccstr*)value, origin);
} }
@ -306,7 +306,7 @@ JVMFlag::Error JVMFlagAccess::set_impl(JVMFlag* flag, int type_enum, void* value
return access_impl(flag)->set(flag, value, origin); return access_impl(flag)->set(flag, value, origin);
} }
JVMFlag::Error JVMFlagAccess::ccstrAtPut(JVMFlag* flag, ccstr* value, JVMFlag::Flags origin) { JVMFlag::Error JVMFlagAccess::ccstrAtPut(JVMFlag* flag, ccstr* value, JVMFlagOrigin origin) {
if (flag == NULL) return JVMFlag::INVALID_FLAG; if (flag == NULL) return JVMFlag::INVALID_FLAG;
if (!flag->is_ccstr()) return JVMFlag::WRONG_FORMAT; if (!flag->is_ccstr()) return JVMFlag::WRONG_FORMAT;
ccstr old_value = flag->get_ccstr(); ccstr old_value = flag->get_ccstr();
@ -326,7 +326,7 @@ JVMFlag::Error JVMFlagAccess::ccstrAtPut(JVMFlag* flag, ccstr* value, JVMFlag::F
} }
// This is called by the FLAG_SET_XXX macros. // This is called by the FLAG_SET_XXX macros.
JVMFlag::Error JVMFlagAccess::set_impl(JVMFlagsEnum flag_enum, int type_enum, void* value, JVMFlag::Flags origin) { JVMFlag::Error JVMFlagAccess::set_impl(JVMFlagsEnum flag_enum, int type_enum, void* value, JVMFlagOrigin origin) {
if (type_enum == JVMFlag::TYPE_ccstr || type_enum == JVMFlag::TYPE_ccstrlist) { if (type_enum == JVMFlag::TYPE_ccstr || type_enum == JVMFlag::TYPE_ccstrlist) {
return ccstrAtPut((JVMFlagsEnum)flag_enum, *((ccstr*)value), origin); return ccstrAtPut((JVMFlagsEnum)flag_enum, *((ccstr*)value), origin);
} }
@ -337,7 +337,7 @@ JVMFlag::Error JVMFlagAccess::set_impl(JVMFlagsEnum flag_enum, int type_enum, vo
} }
// This is called by the FLAG_SET_XXX macros. // This is called by the FLAG_SET_XXX macros.
JVMFlag::Error JVMFlagAccess::ccstrAtPut(JVMFlagsEnum flag, ccstr value, JVMFlag::Flags origin) { JVMFlag::Error JVMFlagAccess::ccstrAtPut(JVMFlagsEnum flag, ccstr value, JVMFlagOrigin origin) {
JVMFlag* faddr = JVMFlag::flag_from_enum(flag); JVMFlag* faddr = JVMFlag::flag_from_enum(flag);
assert(faddr->is_ccstr(), "wrong flag type"); assert(faddr->is_ccstr(), "wrong flag type");
ccstr old_value = faddr->get_ccstr(); ccstr old_value = faddr->get_ccstr();

28
src/hotspot/share/runtime/flags/jvmFlagAccess.hpp
View file

@ -52,9 +52,9 @@ class outputStream;
// of setters are provided. See notes below on which one to use. // of setters are provided. See notes below on which one to use.
class JVMFlagAccess : AllStatic { class JVMFlagAccess : AllStatic {
inline static const FlagAccessImpl* access_impl(const JVMFlag* flag); inline static const FlagAccessImpl* access_impl(const JVMFlag* flag);
static JVMFlag::Error set_impl(JVMFlagsEnum flag_enum, int type_enum, void* value, JVMFlag::Flags origin); static JVMFlag::Error set_impl(JVMFlagsEnum flag_enum, int type_enum, void* value, JVMFlagOrigin origin);
static JVMFlag::Error set_impl(JVMFlag* flag, int type_enum, void* value, JVMFlag::Flags origin); static JVMFlag::Error set_impl(JVMFlag* flag, int type_enum, void* value, JVMFlagOrigin origin);
static JVMFlag::Error ccstrAtPut(JVMFlagsEnum flag, ccstr value, JVMFlag::Flags origin); static JVMFlag::Error ccstrAtPut(JVMFlagsEnum flag, ccstr value, JVMFlagOrigin origin);
public: public:
static JVMFlag::Error check_range(const JVMFlag* flag, bool verbose); static JVMFlag::Error check_range(const JVMFlag* flag, bool verbose);
@ -85,7 +85,7 @@ public:
// It's used to set a specific flag whose type is statically known. A mismatched // It's used to set a specific flag whose type is statically known. A mismatched
// type_enum will result in an assert. // type_enum will result in an assert.
template <typename T, int type_enum> template <typename T, int type_enum>
static JVMFlag::Error set(JVMFlagsEnum flag_enum, T value, JVMFlag::Flags origin) { static JVMFlag::Error set(JVMFlagsEnum flag_enum, T value, JVMFlagOrigin origin) {
return set_impl(flag_enum, type_enum, &value, origin); return set_impl(flag_enum, type_enum, &value, origin);
} }
@ -95,23 +95,23 @@ public:
// Examples callers are arguments.cpp, writeableFlags.cpp, and WB_SetXxxVMFlag functions. // Examples callers are arguments.cpp, writeableFlags.cpp, and WB_SetXxxVMFlag functions.
// A mismatched type_enum would result in a JVMFlag::WRONG_FORMAT code. // A mismatched type_enum would result in a JVMFlag::WRONG_FORMAT code.
template <typename T, int type_enum> template <typename T, int type_enum>
static JVMFlag::Error set(JVMFlag* flag, T* value, JVMFlag::Flags origin) { static JVMFlag::Error set(JVMFlag* flag, T* value, JVMFlagOrigin origin) {
return set_impl(flag, type_enum, (void*)value, origin); return set_impl(flag, type_enum, (void*)value, origin);
} }
static JVMFlag::Error boolAtPut (JVMFlag* f, bool* v, JVMFlag::Flags origin) { return set<JVM_FLAG_TYPE(bool)> (f, v, origin); } static JVMFlag::Error boolAtPut (JVMFlag* f, bool* v, JVMFlagOrigin origin) { return set<JVM_FLAG_TYPE(bool)> (f, v, origin); }
static JVMFlag::Error intAtPut (JVMFlag* f, int* v, JVMFlag::Flags origin) { return set<JVM_FLAG_TYPE(int)> (f, v, origin); } static JVMFlag::Error intAtPut (JVMFlag* f, int* v, JVMFlagOrigin origin) { return set<JVM_FLAG_TYPE(int)> (f, v, origin); }
static JVMFlag::Error uintAtPut (JVMFlag* f, uint* v, JVMFlag::Flags origin) { return set<JVM_FLAG_TYPE(uint)> (f, v, origin); } static JVMFlag::Error uintAtPut (JVMFlag* f, uint* v, JVMFlagOrigin origin) { return set<JVM_FLAG_TYPE(uint)> (f, v, origin); }
static JVMFlag::Error intxAtPut (JVMFlag* f, intx* v, JVMFlag::Flags origin) { return set<JVM_FLAG_TYPE(intx)> (f, v, origin); } static JVMFlag::Error intxAtPut (JVMFlag* f, intx* v, JVMFlagOrigin origin) { return set<JVM_FLAG_TYPE(intx)> (f, v, origin); }
static JVMFlag::Error uintxAtPut (JVMFlag* f, uintx* v, JVMFlag::Flags origin) { return set<JVM_FLAG_TYPE(uintx)> (f, v, origin); } static JVMFlag::Error uintxAtPut (JVMFlag* f, uintx* v, JVMFlagOrigin origin) { return set<JVM_FLAG_TYPE(uintx)> (f, v, origin); }
static JVMFlag::Error uint64_tAtPut(JVMFlag* f, uint64_t* v, JVMFlag::Flags origin) { return set<JVM_FLAG_TYPE(uint64_t)>(f, v, origin); } static JVMFlag::Error uint64_tAtPut(JVMFlag* f, uint64_t* v, JVMFlagOrigin origin) { return set<JVM_FLAG_TYPE(uint64_t)>(f, v, origin); }
static JVMFlag::Error size_tAtPut (JVMFlag* f, size_t* v, JVMFlag::Flags origin) { return set<JVM_FLAG_TYPE(size_t)> (f, v, origin); } static JVMFlag::Error size_tAtPut (JVMFlag* f, size_t* v, JVMFlagOrigin origin) { return set<JVM_FLAG_TYPE(size_t)> (f, v, origin); }
static JVMFlag::Error doubleAtPut (JVMFlag* f, double* v, JVMFlag::Flags origin) { return set<JVM_FLAG_TYPE(double)> (f, v, origin); } static JVMFlag::Error doubleAtPut (JVMFlag* f, double* v, JVMFlagOrigin origin) { return set<JVM_FLAG_TYPE(double)> (f, v, origin); }
// Special handling needed for ccstr // Special handling needed for ccstr
// Contract: JVMFlag will make private copy of the incoming value. // Contract: JVMFlag will make private copy of the incoming value.
// Outgoing value is always malloc-ed, and caller MUST call free. // Outgoing value is always malloc-ed, and caller MUST call free.
static JVMFlag::Error ccstrAtPut(JVMFlag* flag, ccstr* value, JVMFlag::Flags origin); static JVMFlag::Error ccstrAtPut(JVMFlag* flag, ccstr* value, JVMFlagOrigin origin);
// Handy aliases // Handy aliases
static JVMFlag::Error ccstrAt(const JVMFlag* flag, ccstr* value) { static JVMFlag::Error ccstrAt(const JVMFlag* flag, ccstr* value) {

8
src/hotspot/share/runtime/globals_extension.hpp
View file

@ -53,7 +53,7 @@ enum JVMFlagsEnum : int {
#define FLAG_MEMBER_SETTER(name) Flag_##name##_set #define FLAG_MEMBER_SETTER(name) Flag_##name##_set
#define FLAG_MEMBER_SETTER_(type, name) \ #define FLAG_MEMBER_SETTER_(type, name) \
inline JVMFlag::Error FLAG_MEMBER_SETTER(name)(type value, JVMFlag::Flags origin) { \ inline JVMFlag::Error FLAG_MEMBER_SETTER(name)(type value, JVMFlagOrigin origin) { \
return JVMFlagAccess::set<JVM_FLAG_TYPE(type)>(FLAG_MEMBER_ENUM(name), value, origin); \ return JVMFlagAccess::set<JVM_FLAG_TYPE(type)>(FLAG_MEMBER_ENUM(name), value, origin); \
} }
@ -75,9 +75,9 @@ ALL_FLAGS(DEFINE_FLAG_MEMBER_SETTER,
#define FLAG_SET_DEFAULT(name, value) ((name) = (value)) #define FLAG_SET_DEFAULT(name, value) ((name) = (value))
#define FLAG_SET_CMDLINE(name, value) (JVMFlag::setOnCmdLine(FLAG_MEMBER_ENUM(name)), \ #define FLAG_SET_CMDLINE(name, value) (JVMFlag::setOnCmdLine(FLAG_MEMBER_ENUM(name)), \
FLAG_MEMBER_SETTER(name)((value), JVMFlag::COMMAND_LINE)) FLAG_MEMBER_SETTER(name)((value), JVMFlagOrigin::COMMAND_LINE))
#define FLAG_SET_ERGO(name, value) (FLAG_MEMBER_SETTER(name)((value), JVMFlag::ERGONOMIC)) #define FLAG_SET_ERGO(name, value) (FLAG_MEMBER_SETTER(name)((value), JVMFlagOrigin::ERGONOMIC))
#define FLAG_SET_MGMT(name, value) (FLAG_MEMBER_SETTER(name)((value), JVMFlag::MANAGEMENT)) #define FLAG_SET_MGMT(name, value) (FLAG_MEMBER_SETTER(name)((value), JVMFlagOrigin::MANAGEMENT))
#define FLAG_SET_ERGO_IF_DEFAULT(name, value) \ #define FLAG_SET_ERGO_IF_DEFAULT(name, value) \
do { \ do { \

20
src/hotspot/share/runtime/vmStructs.cpp
View file

@ -2600,17 +2600,17 @@ typedef HashtableEntry<InstanceKlass*, mtClass> KlassHashtableEntry;
/******************************/ \ /******************************/ \
/* -XX flags (value origin) */ \ /* -XX flags (value origin) */ \
/******************************/ \ /******************************/ \
declare_constant(JVMFlag::DEFAULT) \ declare_constant(JVMFlagOrigin::DEFAULT) \
declare_constant(JVMFlag::COMMAND_LINE) \ declare_constant(JVMFlagOrigin::COMMAND_LINE) \
declare_constant(JVMFlag::ENVIRON_VAR) \ declare_constant(JVMFlagOrigin::ENVIRON_VAR) \
declare_constant(JVMFlag::CONFIG_FILE) \ declare_constant(JVMFlagOrigin::CONFIG_FILE) \
declare_constant(JVMFlag::MANAGEMENT) \ declare_constant(JVMFlagOrigin::MANAGEMENT) \
declare_constant(JVMFlag::ERGONOMIC) \ declare_constant(JVMFlagOrigin::ERGONOMIC) \
declare_constant(JVMFlag::ATTACH_ON_DEMAND) \ declare_constant(JVMFlagOrigin::ATTACH_ON_DEMAND) \
declare_constant(JVMFlag::INTERNAL) \ declare_constant(JVMFlagOrigin::INTERNAL) \
declare_constant(JVMFlag::JIMAGE_RESOURCE) \ declare_constant(JVMFlagOrigin::JIMAGE_RESOURCE) \
declare_constant(JVMFlag::VALUE_ORIGIN_MASK) \ declare_constant(JVMFlag::VALUE_ORIGIN_MASK) \
declare_constant(JVMFlag::ORIG_COMMAND_LINE) declare_constant(JVMFlag::WAS_SET_ON_COMMAND_LINE)
//-------------------------------------------------------------------------------- //--------------------------------------------------------------------------------
// VM_LONG_CONSTANTS // VM_LONG_CONSTANTS

2
src/hotspot/share/services/attachListener.cpp
View file

@ -303,7 +303,7 @@ static jint set_flag(AttachOperation* op, outputStream* out) {
FormatBuffer<80> err_msg("%s", ""); FormatBuffer<80> err_msg("%s", "");
int ret = WriteableFlags::set_flag(op->arg(0), op->arg(1), JVMFlag::ATTACH_ON_DEMAND, err_msg); int ret = WriteableFlags::set_flag(op->arg(0), op->arg(1), JVMFlagOrigin::ATTACH_ON_DEMAND, err_msg);
if (ret != JVMFlag::SUCCESS) { if (ret != JVMFlag::SUCCESS) {
if (ret == JVMFlag::NON_WRITABLE) { if (ret == JVMFlag::NON_WRITABLE) {
// if the flag is not manageable try to change it through // if the flag is not manageable try to change it through

2
src/hotspot/share/services/diagnosticCommand.cpp
View file

@ -276,7 +276,7 @@ void SetVMFlagDCmd::execute(DCmdSource source, TRAPS) {
} }
FormatBuffer<80> err_msg("%s", ""); FormatBuffer<80> err_msg("%s", "");
int ret = WriteableFlags::set_flag(_flag.value(), val, JVMFlag::MANAGEMENT, err_msg); int ret = WriteableFlags::set_flag(_flag.value(), val, JVMFlagOrigin::MANAGEMENT, err_msg);
if (ret != JVMFlag::SUCCESS) { if (ret != JVMFlag::SUCCESS) {
output()->print_cr("%s", err_msg.buffer()); output()->print_cr("%s", err_msg.buffer());

16
src/hotspot/share/services/management.cpp
View file

@ -1474,25 +1474,25 @@ bool add_global_entry(Handle name, jmmVMGlobal *global, JVMFlag *flag, TRAPS) {
global->writeable = flag->is_writeable(); global->writeable = flag->is_writeable();
global->external = flag->is_external(); global->external = flag->is_external();
switch (flag->get_origin()) { switch (flag->get_origin()) {
case JVMFlag::DEFAULT: case JVMFlagOrigin::DEFAULT:
global->origin = JMM_VMGLOBAL_ORIGIN_DEFAULT; global->origin = JMM_VMGLOBAL_ORIGIN_DEFAULT;
break; break;
case JVMFlag::COMMAND_LINE: case JVMFlagOrigin::COMMAND_LINE:
global->origin = JMM_VMGLOBAL_ORIGIN_COMMAND_LINE; global->origin = JMM_VMGLOBAL_ORIGIN_COMMAND_LINE;
break; break;
case JVMFlag::ENVIRON_VAR: case JVMFlagOrigin::ENVIRON_VAR:
global->origin = JMM_VMGLOBAL_ORIGIN_ENVIRON_VAR; global->origin = JMM_VMGLOBAL_ORIGIN_ENVIRON_VAR;
break; break;
case JVMFlag::CONFIG_FILE: case JVMFlagOrigin::CONFIG_FILE:
global->origin = JMM_VMGLOBAL_ORIGIN_CONFIG_FILE; global->origin = JMM_VMGLOBAL_ORIGIN_CONFIG_FILE;
break; break;
case JVMFlag::MANAGEMENT: case JVMFlagOrigin::MANAGEMENT:
global->origin = JMM_VMGLOBAL_ORIGIN_MANAGEMENT; global->origin = JMM_VMGLOBAL_ORIGIN_MANAGEMENT;
break; break;
case JVMFlag::ERGONOMIC: case JVMFlagOrigin::ERGONOMIC:
global->origin = JMM_VMGLOBAL_ORIGIN_ERGONOMIC; global->origin = JMM_VMGLOBAL_ORIGIN_ERGONOMIC;
break; break;
case JVMFlag::ATTACH_ON_DEMAND: case JVMFlagOrigin::ATTACH_ON_DEMAND:
global->origin = JMM_VMGLOBAL_ORIGIN_ATTACH_ON_DEMAND; global->origin = JMM_VMGLOBAL_ORIGIN_ATTACH_ON_DEMAND;
break; break;
default: default:
@ -1584,7 +1584,7 @@ JVM_ENTRY(void, jmm_SetVMGlobal(JNIEnv *env, jstring flag_name, jvalue new_value
char* name = java_lang_String::as_utf8_string(fn); char* name = java_lang_String::as_utf8_string(fn);
FormatBuffer<80> error_msg("%s", ""); FormatBuffer<80> error_msg("%s", "");
int succeed = WriteableFlags::set_flag(name, new_value, JVMFlag::MANAGEMENT, error_msg); int succeed = WriteableFlags::set_flag(name, new_value, JVMFlagOrigin::MANAGEMENT, error_msg);
if (succeed != JVMFlag::SUCCESS) { if (succeed != JVMFlag::SUCCESS) {
if (succeed == JVMFlag::MISSING_VALUE) { if (succeed == JVMFlag::MISSING_VALUE) {

44
src/hotspot/share/services/writeableFlags.cpp
View file

@ -97,7 +97,7 @@ static void print_flag_error_message_if_needed(JVMFlag::Error error, const JVMFl
} }
// set a boolean global flag // set a boolean global flag
JVMFlag::Error WriteableFlags::set_bool_flag(const char* name, const char* arg, JVMFlag::Flags origin, FormatBuffer<80>& err_msg) { JVMFlag::Error WriteableFlags::set_bool_flag(const char* name, const char* arg, JVMFlagOrigin origin, FormatBuffer<80>& err_msg) {
if ((strcasecmp(arg, "true") == 0) || (*arg == '1' && *(arg + 1) == 0)) { if ((strcasecmp(arg, "true") == 0) || (*arg == '1' && *(arg + 1) == 0)) {
return set_bool_flag(name, true, origin, err_msg); return set_bool_flag(name, true, origin, err_msg);
} else if ((strcasecmp(arg, "false") == 0) || (*arg == '0' && *(arg + 1) == 0)) { } else if ((strcasecmp(arg, "false") == 0) || (*arg == '0' && *(arg + 1) == 0)) {
@ -107,7 +107,7 @@ JVMFlag::Error WriteableFlags::set_bool_flag(const char* name, const char* arg,
return JVMFlag::WRONG_FORMAT; return JVMFlag::WRONG_FORMAT;
} }
JVMFlag::Error WriteableFlags::set_bool_flag(const char* name, bool value, JVMFlag::Flags origin, FormatBuffer<80>& err_msg) { JVMFlag::Error WriteableFlags::set_bool_flag(const char* name, bool value, JVMFlagOrigin origin, FormatBuffer<80>& err_msg) {
JVMFlag* flag = JVMFlag::find_flag(name); JVMFlag* flag = JVMFlag::find_flag(name);
JVMFlag::Error err = JVMFlagAccess::boolAtPut(flag, &value, origin); JVMFlag::Error err = JVMFlagAccess::boolAtPut(flag, &value, origin);
print_flag_error_message_if_needed(err, flag, err_msg); print_flag_error_message_if_needed(err, flag, err_msg);
@ -115,7 +115,7 @@ JVMFlag::Error WriteableFlags::set_bool_flag(const char* name, bool value, JVMFl
} }
// set a int global flag // set a int global flag
JVMFlag::Error WriteableFlags::set_int_flag(const char* name, const char* arg, JVMFlag::Flags origin, FormatBuffer<80>& err_msg) { JVMFlag::Error WriteableFlags::set_int_flag(const char* name, const char* arg, JVMFlagOrigin origin, FormatBuffer<80>& err_msg) {
int value; int value;
if (sscanf(arg, "%d", &value) == 1) { if (sscanf(arg, "%d", &value) == 1) {
@ -125,7 +125,7 @@ JVMFlag::Error WriteableFlags::set_int_flag(const char* name, const char* arg, J
return JVMFlag::WRONG_FORMAT; return JVMFlag::WRONG_FORMAT;
} }
JVMFlag::Error WriteableFlags::set_int_flag(const char* name, int value, JVMFlag::Flags origin, FormatBuffer<80>& err_msg) { JVMFlag::Error WriteableFlags::set_int_flag(const char* name, int value, JVMFlagOrigin origin, FormatBuffer<80>& err_msg) {
JVMFlag* flag = JVMFlag::find_flag(name); JVMFlag* flag = JVMFlag::find_flag(name);
JVMFlag::Error err = JVMFlagAccess::intAtPut(flag, &value, origin); JVMFlag::Error err = JVMFlagAccess::intAtPut(flag, &value, origin);
print_flag_error_message_if_needed(err, flag, err_msg); print_flag_error_message_if_needed(err, flag, err_msg);
@ -133,7 +133,7 @@ JVMFlag::Error WriteableFlags::set_int_flag(const char* name, int value, JVMFlag
} }
// set a uint global flag // set a uint global flag
JVMFlag::Error WriteableFlags::set_uint_flag(const char* name, const char* arg, JVMFlag::Flags origin, FormatBuffer<80>& err_msg) { JVMFlag::Error WriteableFlags::set_uint_flag(const char* name, const char* arg, JVMFlagOrigin origin, FormatBuffer<80>& err_msg) {
uint value; uint value;
if (sscanf(arg, "%u", &value) == 1) { if (sscanf(arg, "%u", &value) == 1) {
@ -143,7 +143,7 @@ JVMFlag::Error WriteableFlags::set_uint_flag(const char* name, const char* arg,
return JVMFlag::WRONG_FORMAT; return JVMFlag::WRONG_FORMAT;
} }
JVMFlag::Error WriteableFlags::set_uint_flag(const char* name, uint value, JVMFlag::Flags origin, FormatBuffer<80>& err_msg) { JVMFlag::Error WriteableFlags::set_uint_flag(const char* name, uint value, JVMFlagOrigin origin, FormatBuffer<80>& err_msg) {
JVMFlag* flag = JVMFlag::find_flag(name); JVMFlag* flag = JVMFlag::find_flag(name);
JVMFlag::Error err = JVMFlagAccess::uintAtPut(flag, &value, origin); JVMFlag::Error err = JVMFlagAccess::uintAtPut(flag, &value, origin);
print_flag_error_message_if_needed(err, flag, err_msg); print_flag_error_message_if_needed(err, flag, err_msg);
@ -151,7 +151,7 @@ JVMFlag::Error WriteableFlags::set_uint_flag(const char* name, uint value, JVMFl
} }
// set a intx global flag // set a intx global flag
JVMFlag::Error WriteableFlags::set_intx_flag(const char* name, const char* arg, JVMFlag::Flags origin, FormatBuffer<80>& err_msg) { JVMFlag::Error WriteableFlags::set_intx_flag(const char* name, const char* arg, JVMFlagOrigin origin, FormatBuffer<80>& err_msg) {
intx value; intx value;
if (sscanf(arg, INTX_FORMAT, &value) == 1) { if (sscanf(arg, INTX_FORMAT, &value) == 1) {
@ -161,7 +161,7 @@ JVMFlag::Error WriteableFlags::set_intx_flag(const char* name, const char* arg,
return JVMFlag::WRONG_FORMAT; return JVMFlag::WRONG_FORMAT;
} }
JVMFlag::Error WriteableFlags::set_intx_flag(const char* name, intx value, JVMFlag::Flags origin, FormatBuffer<80>& err_msg) { JVMFlag::Error WriteableFlags::set_intx_flag(const char* name, intx value, JVMFlagOrigin origin, FormatBuffer<80>& err_msg) {
JVMFlag* flag = JVMFlag::find_flag(name); JVMFlag* flag = JVMFlag::find_flag(name);
JVMFlag::Error err = JVMFlagAccess::intxAtPut(flag, &value, origin); JVMFlag::Error err = JVMFlagAccess::intxAtPut(flag, &value, origin);
print_flag_error_message_if_needed(err, flag, err_msg); print_flag_error_message_if_needed(err, flag, err_msg);
@ -169,7 +169,7 @@ JVMFlag::Error WriteableFlags::set_intx_flag(const char* name, intx value, JVMFl
} }
// set a uintx global flag // set a uintx global flag
JVMFlag::Error WriteableFlags::set_uintx_flag(const char* name, const char* arg, JVMFlag::Flags origin, FormatBuffer<80>& err_msg) { JVMFlag::Error WriteableFlags::set_uintx_flag(const char* name, const char* arg, JVMFlagOrigin origin, FormatBuffer<80>& err_msg) {
uintx value; uintx value;
if (sscanf(arg, UINTX_FORMAT, &value) == 1) { if (sscanf(arg, UINTX_FORMAT, &value) == 1) {
@ -179,7 +179,7 @@ JVMFlag::Error WriteableFlags::set_uintx_flag(const char* name, const char* arg,
return JVMFlag::WRONG_FORMAT; return JVMFlag::WRONG_FORMAT;
} }
JVMFlag::Error WriteableFlags::set_uintx_flag(const char* name, uintx value, JVMFlag::Flags origin, FormatBuffer<80>& err_msg) { JVMFlag::Error WriteableFlags::set_uintx_flag(const char* name, uintx value, JVMFlagOrigin origin, FormatBuffer<80>& err_msg) {
JVMFlag* flag = JVMFlag::find_flag(name); JVMFlag* flag = JVMFlag::find_flag(name);
JVMFlag::Error err = JVMFlagAccess::uintxAtPut(flag, &value, origin); JVMFlag::Error err = JVMFlagAccess::uintxAtPut(flag, &value, origin);
print_flag_error_message_if_needed(err, flag, err_msg); print_flag_error_message_if_needed(err, flag, err_msg);
@ -187,7 +187,7 @@ JVMFlag::Error WriteableFlags::set_uintx_flag(const char* name, uintx value, JVM
} }
// set a uint64_t global flag // set a uint64_t global flag
JVMFlag::Error WriteableFlags::set_uint64_t_flag(const char* name, const char* arg, JVMFlag::Flags origin, FormatBuffer<80>& err_msg) { JVMFlag::Error WriteableFlags::set_uint64_t_flag(const char* name, const char* arg, JVMFlagOrigin origin, FormatBuffer<80>& err_msg) {
uint64_t value; uint64_t value;
if (sscanf(arg, UINT64_FORMAT, &value) == 1) { if (sscanf(arg, UINT64_FORMAT, &value) == 1) {
@ -197,7 +197,7 @@ JVMFlag::Error WriteableFlags::set_uint64_t_flag(const char* name, const char* a
return JVMFlag::WRONG_FORMAT; return JVMFlag::WRONG_FORMAT;
} }
JVMFlag::Error WriteableFlags::set_uint64_t_flag(const char* name, uint64_t value, JVMFlag::Flags origin, FormatBuffer<80>& err_msg) { JVMFlag::Error WriteableFlags::set_uint64_t_flag(const char* name, uint64_t value, JVMFlagOrigin origin, FormatBuffer<80>& err_msg) {
JVMFlag* flag = JVMFlag::find_flag(name); JVMFlag* flag = JVMFlag::find_flag(name);
JVMFlag::Error err = JVMFlagAccess::uint64_tAtPut(flag, &value, origin); JVMFlag::Error err = JVMFlagAccess::uint64_tAtPut(flag, &value, origin);
print_flag_error_message_if_needed(err, flag, err_msg); print_flag_error_message_if_needed(err, flag, err_msg);
@ -205,7 +205,7 @@ JVMFlag::Error WriteableFlags::set_uint64_t_flag(const char* name, uint64_t valu
} }
// set a size_t global flag // set a size_t global flag
JVMFlag::Error WriteableFlags::set_size_t_flag(const char* name, const char* arg, JVMFlag::Flags origin, FormatBuffer<80>& err_msg) { JVMFlag::Error WriteableFlags::set_size_t_flag(const char* name, const char* arg, JVMFlagOrigin origin, FormatBuffer<80>& err_msg) {
size_t value; size_t value;
if (sscanf(arg, SIZE_FORMAT, &value) == 1) { if (sscanf(arg, SIZE_FORMAT, &value) == 1) {
@ -215,7 +215,7 @@ JVMFlag::Error WriteableFlags::set_size_t_flag(const char* name, const char* arg
return JVMFlag::WRONG_FORMAT; return JVMFlag::WRONG_FORMAT;
} }
JVMFlag::Error WriteableFlags::set_size_t_flag(const char* name, size_t value, JVMFlag::Flags origin, FormatBuffer<80>& err_msg) { JVMFlag::Error WriteableFlags::set_size_t_flag(const char* name, size_t value, JVMFlagOrigin origin, FormatBuffer<80>& err_msg) {
JVMFlag* flag = JVMFlag::find_flag(name); JVMFlag* flag = JVMFlag::find_flag(name);
JVMFlag::Error err = JVMFlagAccess::size_tAtPut(flag, &value, origin); JVMFlag::Error err = JVMFlagAccess::size_tAtPut(flag, &value, origin);
print_flag_error_message_if_needed(err, flag, err_msg); print_flag_error_message_if_needed(err, flag, err_msg);
@ -223,7 +223,7 @@ JVMFlag::Error WriteableFlags::set_size_t_flag(const char* name, size_t value, J
} }
// set a double global flag // set a double global flag
JVMFlag::Error WriteableFlags::set_double_flag(const char* name, const char* arg, JVMFlag::Flags origin, FormatBuffer<80>& err_msg) { JVMFlag::Error WriteableFlags::set_double_flag(const char* name, const char* arg, JVMFlagOrigin origin, FormatBuffer<80>& err_msg) {
double value; double value;
if (sscanf(arg, "%lf", &value) == 1) { if (sscanf(arg, "%lf", &value) == 1) {
@ -233,7 +233,7 @@ JVMFlag::Error WriteableFlags::set_double_flag(const char* name, const char* arg
return JVMFlag::WRONG_FORMAT; return JVMFlag::WRONG_FORMAT;
} }
JVMFlag::Error WriteableFlags::set_double_flag(const char* name, double value, JVMFlag::Flags origin, FormatBuffer<80>& err_msg) { JVMFlag::Error WriteableFlags::set_double_flag(const char* name, double value, JVMFlagOrigin origin, FormatBuffer<80>& err_msg) {
JVMFlag* flag = JVMFlag::find_flag(name); JVMFlag* flag = JVMFlag::find_flag(name);
JVMFlag::Error err = JVMFlagAccess::doubleAtPut(flag, &value, origin); JVMFlag::Error err = JVMFlagAccess::doubleAtPut(flag, &value, origin);
print_flag_error_message_if_needed(err, flag, err_msg); print_flag_error_message_if_needed(err, flag, err_msg);
@ -241,7 +241,7 @@ JVMFlag::Error WriteableFlags::set_double_flag(const char* name, double value, J
} }
// set a string global flag using value from AttachOperation // set a string global flag using value from AttachOperation
JVMFlag::Error WriteableFlags::set_ccstr_flag(const char* name, const char* value, JVMFlag::Flags origin, FormatBuffer<80>& err_msg) { JVMFlag::Error WriteableFlags::set_ccstr_flag(const char* name, const char* value, JVMFlagOrigin origin, FormatBuffer<80>& err_msg) {
JVMFlag* flag = JVMFlag::find_flag(name); JVMFlag* flag = JVMFlag::find_flag(name);
JVMFlag::Error err = JVMFlagAccess::ccstrAtPut(flag, &value, origin); JVMFlag::Error err = JVMFlagAccess::ccstrAtPut(flag, &value, origin);
print_flag_error_message_if_needed(err, flag, err_msg); print_flag_error_message_if_needed(err, flag, err_msg);
@ -253,7 +253,7 @@ JVMFlag::Error WriteableFlags::set_ccstr_flag(const char* name, const char* valu
* - return status is one of the WriteableFlags::err enum values * - return status is one of the WriteableFlags::err enum values
* - an eventual error message will be generated to the provided err_msg buffer * - an eventual error message will be generated to the provided err_msg buffer
*/ */
JVMFlag::Error WriteableFlags::set_flag(const char* flag_name, const char* flag_value, JVMFlag::Flags origin, FormatBuffer<80>& err_msg) { JVMFlag::Error WriteableFlags::set_flag(const char* flag_name, const char* flag_value, JVMFlagOrigin origin, FormatBuffer<80>& err_msg) {
return set_flag(flag_name, &flag_value, set_flag_from_char, origin, err_msg); return set_flag(flag_name, &flag_value, set_flag_from_char, origin, err_msg);
} }
@ -262,12 +262,12 @@ JVMFlag::Error WriteableFlags::set_flag(const char* flag_name, const char* flag_
* - return status is one of the WriteableFlags::err enum values * - return status is one of the WriteableFlags::err enum values
* - an eventual error message will be generated to the provided err_msg buffer * - an eventual error message will be generated to the provided err_msg buffer
*/ */
JVMFlag::Error WriteableFlags::set_flag(const char* flag_name, jvalue flag_value, JVMFlag::Flags origin, FormatBuffer<80>& err_msg) { JVMFlag::Error WriteableFlags::set_flag(const char* flag_name, jvalue flag_value, JVMFlagOrigin origin, FormatBuffer<80>& err_msg) {
return set_flag(flag_name, &flag_value, set_flag_from_jvalue, origin, err_msg); return set_flag(flag_name, &flag_value, set_flag_from_jvalue, origin, err_msg);
} }
// a writeable flag setter accepting either 'jvalue' or 'char *' values // a writeable flag setter accepting either 'jvalue' or 'char *' values
JVMFlag::Error WriteableFlags::set_flag(const char* name, const void* value, JVMFlag::Error(*setter)(JVMFlag*,const void*,JVMFlag::Flags,FormatBuffer<80>&), JVMFlag::Flags origin, FormatBuffer<80>& err_msg) { JVMFlag::Error WriteableFlags::set_flag(const char* name, const void* value, JVMFlag::Error(*setter)(JVMFlag*,const void*,JVMFlagOrigin,FormatBuffer<80>&), JVMFlagOrigin origin, FormatBuffer<80>& err_msg) {
if (name == NULL) { if (name == NULL) {
err_msg.print("flag name is missing"); err_msg.print("flag name is missing");
return JVMFlag::MISSING_NAME; return JVMFlag::MISSING_NAME;
@ -293,7 +293,7 @@ JVMFlag::Error WriteableFlags::set_flag(const char* name, const void* value, JVM
} }
// a writeable flag setter accepting 'char *' values // a writeable flag setter accepting 'char *' values
JVMFlag::Error WriteableFlags::set_flag_from_char(JVMFlag* f, const void* value, JVMFlag::Flags origin, FormatBuffer<80>& err_msg) { JVMFlag::Error WriteableFlags::set_flag_from_char(JVMFlag* f, const void* value, JVMFlagOrigin origin, FormatBuffer<80>& err_msg) {
char* flag_value = *(char**)value; char* flag_value = *(char**)value;
if (flag_value == NULL) { if (flag_value == NULL) {
err_msg.print("flag value is missing"); err_msg.print("flag value is missing");
@ -324,7 +324,7 @@ JVMFlag::Error WriteableFlags::set_flag_from_char(JVMFlag* f, const void* value,
} }
// a writeable flag setter accepting 'jvalue' values // a writeable flag setter accepting 'jvalue' values
JVMFlag::Error WriteableFlags::set_flag_from_jvalue(JVMFlag* f, const void* value, JVMFlag::Flags origin, JVMFlag::Error WriteableFlags::set_flag_from_jvalue(JVMFlag* f, const void* value, JVMFlagOrigin origin,
FormatBuffer<80>& err_msg) { FormatBuffer<80>& err_msg) {
jvalue new_value = *(jvalue*)value; jvalue new_value = *(jvalue*)value;
if (f->is_bool()) { if (f->is_bool()) {

46
src/hotspot/share/services/writeableFlags.hpp
View file

@ -1,5 +1,5 @@
/* /*
* Copyright (c) 2015, 2019, Oracle and/or its affiliates. All rights reserved. * Copyright (c) 2015, 2020, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
* *
* This code is free software; you can redistribute it and/or modify it * This code is free software; you can redistribute it and/or modify it
@ -32,46 +32,46 @@
class WriteableFlags : AllStatic { class WriteableFlags : AllStatic {
private: private:
// a writeable flag setter accepting either 'jvalue' or 'char *' values // a writeable flag setter accepting either 'jvalue' or 'char *' values
static JVMFlag::Error set_flag(const char* name, const void* value, JVMFlag::Error(*setter)(JVMFlag*, const void*, JVMFlag::Flags, FormatBuffer<80>&), JVMFlag::Flags origin, FormatBuffer<80>& err_msg); static JVMFlag::Error set_flag(const char* name, const void* value, JVMFlag::Error(*setter)(JVMFlag*, const void*, JVMFlagOrigin, FormatBuffer<80>&), JVMFlagOrigin origin, FormatBuffer<80>& err_msg);
// a writeable flag setter accepting 'char *' values // a writeable flag setter accepting 'char *' values
static JVMFlag::Error set_flag_from_char(JVMFlag* f, const void* value, JVMFlag::Flags origin, FormatBuffer<80>& err_msg); static JVMFlag::Error set_flag_from_char(JVMFlag* f, const void* value, JVMFlagOrigin origin, FormatBuffer<80>& err_msg);
// a writeable flag setter accepting 'jvalue' values // a writeable flag setter accepting 'jvalue' values
static JVMFlag::Error set_flag_from_jvalue(JVMFlag* f, const void* value, JVMFlag::Flags origin, FormatBuffer<80>& err_msg); static JVMFlag::Error set_flag_from_jvalue(JVMFlag* f, const void* value, JVMFlagOrigin origin, FormatBuffer<80>& err_msg);
// set a boolean global flag // set a boolean global flag
static JVMFlag::Error set_bool_flag(const char* name, const char* value, JVMFlag::Flags origin, FormatBuffer<80>& err_msg); static JVMFlag::Error set_bool_flag(const char* name, const char* value, JVMFlagOrigin origin, FormatBuffer<80>& err_msg);
// set a int global flag // set a int global flag
static JVMFlag::Error set_int_flag(const char* name, const char* value, JVMFlag::Flags origin, FormatBuffer<80>& err_msg); static JVMFlag::Error set_int_flag(const char* name, const char* value, JVMFlagOrigin origin, FormatBuffer<80>& err_msg);
// set a uint global flag // set a uint global flag
static JVMFlag::Error set_uint_flag(const char* name, const char* value, JVMFlag::Flags origin, FormatBuffer<80>& err_msg); static JVMFlag::Error set_uint_flag(const char* name, const char* value, JVMFlagOrigin origin, FormatBuffer<80>& err_msg);
// set a intx global flag // set a intx global flag
static JVMFlag::Error set_intx_flag(const char* name, const char* value, JVMFlag::Flags origin, FormatBuffer<80>& err_msg); static JVMFlag::Error set_intx_flag(const char* name, const char* value, JVMFlagOrigin origin, FormatBuffer<80>& err_msg);
// set a uintx global flag // set a uintx global flag
static JVMFlag::Error set_uintx_flag(const char* name, const char* value, JVMFlag::Flags origin, FormatBuffer<80>& err_msg); static JVMFlag::Error set_uintx_flag(const char* name, const char* value, JVMFlagOrigin origin, FormatBuffer<80>& err_msg);
// set a uint64_t global flag // set a uint64_t global flag
static JVMFlag::Error set_uint64_t_flag(const char* name, const char* value, JVMFlag::Flags origin, FormatBuffer<80>& err_msg); static JVMFlag::Error set_uint64_t_flag(const char* name, const char* value, JVMFlagOrigin origin, FormatBuffer<80>& err_msg);
// set a size_t global flag using value from AttachOperation // set a size_t global flag using value from AttachOperation
static JVMFlag::Error set_size_t_flag(const char* name, const char* value, JVMFlag::Flags origin, FormatBuffer<80>& err_msg); static JVMFlag::Error set_size_t_flag(const char* name, const char* value, JVMFlagOrigin origin, FormatBuffer<80>& err_msg);
// set a double global flag using value from AttachOperation // set a double global flag using value from AttachOperation
static JVMFlag::Error set_double_flag(const char* name, const char* value, JVMFlag::Flags origin, FormatBuffer<80>& err_msg); static JVMFlag::Error set_double_flag(const char* name, const char* value, JVMFlagOrigin origin, FormatBuffer<80>& err_msg);
// set a boolean global flag // set a boolean global flag
static JVMFlag::Error set_bool_flag(const char* name, bool value, JVMFlag::Flags origin, FormatBuffer<80>& err_msg); static JVMFlag::Error set_bool_flag(const char* name, bool value, JVMFlagOrigin origin, FormatBuffer<80>& err_msg);
// set a int global flag // set a int global flag
static JVMFlag::Error set_int_flag(const char* name, int value, JVMFlag::Flags origin, FormatBuffer<80>& err_msg); static JVMFlag::Error set_int_flag(const char* name, int value, JVMFlagOrigin origin, FormatBuffer<80>& err_msg);
// set a uint global flag // set a uint global flag
static JVMFlag::Error set_uint_flag(const char* name, uint value, JVMFlag::Flags origin, FormatBuffer<80>& err_msg); static JVMFlag::Error set_uint_flag(const char* name, uint value, JVMFlagOrigin origin, FormatBuffer<80>& err_msg);
// set a intx global flag // set a intx global flag
static JVMFlag::Error set_intx_flag(const char* name, intx value, JVMFlag::Flags origin, FormatBuffer<80>& err_msg); static JVMFlag::Error set_intx_flag(const char* name, intx value, JVMFlagOrigin origin, FormatBuffer<80>& err_msg);
// set a uintx global flag // set a uintx global flag
static JVMFlag::Error set_uintx_flag(const char* name, uintx value, JVMFlag::Flags origin, FormatBuffer<80>& err_msg); static JVMFlag::Error set_uintx_flag(const char* name, uintx value, JVMFlagOrigin origin, FormatBuffer<80>& err_msg);
// set a uint64_t global flag // set a uint64_t global flag
static JVMFlag::Error set_uint64_t_flag(const char* name, uint64_t value, JVMFlag::Flags origin, FormatBuffer<80>& err_msg); static JVMFlag::Error set_uint64_t_flag(const char* name, uint64_t value, JVMFlagOrigin origin, FormatBuffer<80>& err_msg);
// set a size_t global flag using value from AttachOperation // set a size_t global flag using value from AttachOperation
static JVMFlag::Error set_size_t_flag(const char* name, size_t value, JVMFlag::Flags origin, FormatBuffer<80>& err_msg); static JVMFlag::Error set_size_t_flag(const char* name, size_t value, JVMFlagOrigin origin, FormatBuffer<80>& err_msg);
// set a double global flag using value from AttachOperation // set a double global flag using value from AttachOperation
static JVMFlag::Error set_double_flag(const char* name, double value, JVMFlag::Flags origin, FormatBuffer<80>& err_msg); static JVMFlag::Error set_double_flag(const char* name, double value, JVMFlagOrigin origin, FormatBuffer<80>& err_msg);
// set a string global flag // set a string global flag
static JVMFlag::Error set_ccstr_flag(const char* name, const char* value, JVMFlag::Flags origin, FormatBuffer<80>& err_msg); static JVMFlag::Error set_ccstr_flag(const char* name, const char* value, JVMFlagOrigin origin, FormatBuffer<80>& err_msg);
public: public:
/* sets a writeable flag to the provided value /* sets a writeable flag to the provided value
@ -79,14 +79,14 @@ public:
* - return status is one of the WriteableFlags::err enum values * - return status is one of the WriteableFlags::err enum values
* - an eventual error message will be generated to the provided err_msg buffer * - an eventual error message will be generated to the provided err_msg buffer
*/ */
static JVMFlag::Error set_flag(const char* flag_name, const char* flag_value, JVMFlag::Flags origin, FormatBuffer<80>& err_msg); static JVMFlag::Error set_flag(const char* flag_name, const char* flag_value, JVMFlagOrigin origin, FormatBuffer<80>& err_msg);
/* sets a writeable flag to the provided value /* sets a writeable flag to the provided value
* *
* - return status is one of the WriteableFlags::err enum values * - return status is one of the WriteableFlags::err enum values
* - an eventual error message will be generated to the provided err_msg buffer * - an eventual error message will be generated to the provided err_msg buffer
*/ */
static JVMFlag::Error set_flag(const char* flag_name, jvalue flag_value, JVMFlag::Flags origin, FormatBuffer<80>& err_msg); static JVMFlag::Error set_flag(const char* flag_name, jvalue flag_value, JVMFlagOrigin origin, FormatBuffer<80>& err_msg);
}; };
#endif // SHARE_SERVICES_WRITEABLEFLAGS_HPP #endif // SHARE_SERVICES_WRITEABLEFLAGS_HPP

4
src/hotspot/share/utilities/enumIterator.hpp
View file

@ -210,6 +210,10 @@ public:
constexpr Iterator end() const { constexpr Iterator end() const {
return Iterator(static_cast<T>(_end)); return Iterator(static_cast<T>(_end));
} }
constexpr size_t size() const {
return static_cast<size_t>(_end - _start); // _end is exclusive
}
}; };
#endif // SHARE_UTILITIES_ENUMITERATOR_HPP #endif // SHARE_UTILITIES_ENUMITERATOR_HPP

1
src/hotspot/share/utilities/vmEnums.hpp
View file

@ -29,6 +29,7 @@
// you don't use their members directly. This way you don't need to include the // you don't use their members directly. This way you don't need to include the
// complex header files that have the full definitions of these enums. // complex header files that have the full definitions of these enums.
enum class JVMFlagOrigin : int;
enum JVMFlagsEnum : int; enum JVMFlagsEnum : int;
enum class vmSymbolID : int; enum class vmSymbolID : int;

24
src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/runtime/VM.java
View file

@ -118,7 +118,7 @@ public class VM {
public static int Flags_INTERNAL; public static int Flags_INTERNAL;
public static int Flags_JIMAGE_RESOURCE; public static int Flags_JIMAGE_RESOURCE;
private static int Flags_VALUE_ORIGIN_MASK; private static int Flags_VALUE_ORIGIN_MASK;
private static int Flags_ORIG_COMMAND_LINE; private static int Flags_WAS_SET_ON_COMMAND_LINE;
/** This is only present in a non-core build */ /** This is only present in a non-core build */
private CodeCache codeCache; private CodeCache codeCache;
/** This is only present in a C1 build */ /** This is only present in a C1 build */
@ -195,7 +195,7 @@ public class VM {
return "management"; return "management";
} else if (origin == Flags_ERGONOMIC) { } else if (origin == Flags_ERGONOMIC) {
String result = ""; String result = "";
if ((flags & Flags_ORIG_COMMAND_LINE) == Flags_ORIG_COMMAND_LINE) { if ((flags & Flags_WAS_SET_ON_COMMAND_LINE) == Flags_WAS_SET_ON_COMMAND_LINE) {
result = "command line, "; result = "command line, ";
} }
return result + "ergonomic"; return result + "ergonomic";
@ -490,17 +490,17 @@ public class VM {
bytesPerLong = db.lookupIntConstant("BytesPerLong").intValue(); bytesPerLong = db.lookupIntConstant("BytesPerLong").intValue();
bytesPerWord = db.lookupIntConstant("BytesPerWord").intValue(); bytesPerWord = db.lookupIntConstant("BytesPerWord").intValue();
heapWordSize = db.lookupIntConstant("HeapWordSize").intValue(); heapWordSize = db.lookupIntConstant("HeapWordSize").intValue();
Flags_DEFAULT = db.lookupIntConstant("JVMFlag::DEFAULT").intValue(); Flags_DEFAULT = db.lookupIntConstant("JVMFlagOrigin::DEFAULT").intValue();
Flags_COMMAND_LINE = db.lookupIntConstant("JVMFlag::COMMAND_LINE").intValue(); Flags_COMMAND_LINE = db.lookupIntConstant("JVMFlagOrigin::COMMAND_LINE").intValue();
Flags_ENVIRON_VAR = db.lookupIntConstant("JVMFlag::ENVIRON_VAR").intValue(); Flags_ENVIRON_VAR = db.lookupIntConstant("JVMFlagOrigin::ENVIRON_VAR").intValue();
Flags_CONFIG_FILE = db.lookupIntConstant("JVMFlag::CONFIG_FILE").intValue(); Flags_CONFIG_FILE = db.lookupIntConstant("JVMFlagOrigin::CONFIG_FILE").intValue();
Flags_MANAGEMENT = db.lookupIntConstant("JVMFlag::MANAGEMENT").intValue(); Flags_MANAGEMENT = db.lookupIntConstant("JVMFlagOrigin::MANAGEMENT").intValue();
Flags_ERGONOMIC = db.lookupIntConstant("JVMFlag::ERGONOMIC").intValue(); Flags_ERGONOMIC = db.lookupIntConstant("JVMFlagOrigin::ERGONOMIC").intValue();
Flags_ATTACH_ON_DEMAND = db.lookupIntConstant("JVMFlag::ATTACH_ON_DEMAND").intValue(); Flags_ATTACH_ON_DEMAND = db.lookupIntConstant("JVMFlagOrigin::ATTACH_ON_DEMAND").intValue();
Flags_INTERNAL = db.lookupIntConstant("JVMFlag::INTERNAL").intValue(); Flags_INTERNAL = db.lookupIntConstant("JVMFlagOrigin::INTERNAL").intValue();
Flags_JIMAGE_RESOURCE = db.lookupIntConstant("JVMFlag::JIMAGE_RESOURCE").intValue(); Flags_JIMAGE_RESOURCE = db.lookupIntConstant("JVMFlagOrigin::JIMAGE_RESOURCE").intValue();
Flags_VALUE_ORIGIN_MASK = db.lookupIntConstant("JVMFlag::VALUE_ORIGIN_MASK").intValue(); Flags_VALUE_ORIGIN_MASK = db.lookupIntConstant("JVMFlag::VALUE_ORIGIN_MASK").intValue();
Flags_ORIG_COMMAND_LINE = db.lookupIntConstant("JVMFlag::ORIG_COMMAND_LINE").intValue(); Flags_WAS_SET_ON_COMMAND_LINE = db.lookupIntConstant("JVMFlag::WAS_SET_ON_COMMAND_LINE").intValue();
oopSize = db.lookupIntConstant("oopSize").intValue(); oopSize = db.lookupIntConstant("oopSize").intValue();
intType = db.lookupType("int"); intType = db.lookupType("int");