archive/jdk
1
0
Fork 0
mirror of https://github.com/openjdk/jdk.git synced 2025-08-28 07:14:30 +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.set_name(flag->name()); \
event.set_value(flag->get_ ## flagType()); \
event.set_origin(flag->get_origin()); \
event.set_origin(static_cast<u8>(flag->get_origin())); \
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);
}
static const char* flag_value_origin_to_string(JVMFlag::Flags origin) {
static const char* flag_value_origin_to_string(JVMFlagOrigin origin) {
switch (origin) {
case JVMFlag::DEFAULT: return "Default";
case JVMFlag::COMMAND_LINE: return "Command line";
case JVMFlag::ENVIRON_VAR: return "Environment variable";
case JVMFlag::CONFIG_FILE: return "Config file";
case JVMFlag::MANAGEMENT: return "Management";
case JVMFlag::ERGONOMIC: return "Ergonomic";
case JVMFlag::ATTACH_ON_DEMAND: return "Attach on demand";
case JVMFlag::INTERNAL: return "Internal";
case JVMFlag::JIMAGE_RESOURCE: return "JImage resource";
case JVMFlagOrigin::DEFAULT: return "Default";
case JVMFlagOrigin::COMMAND_LINE: return "Command line";
case JVMFlagOrigin::ENVIRON_VAR: return "Environment variable";
case JVMFlagOrigin::CONFIG_FILE: return "Config file";
case JVMFlagOrigin::MANAGEMENT: return "Management";
case JVMFlagOrigin::ERGONOMIC: return "Ergonomic";
case JVMFlagOrigin::ATTACH_ON_DEMAND: return "Attach on demand";
case JVMFlagOrigin::INTERNAL: return "Internal";
case JVMFlagOrigin::JIMAGE_RESOURCE: return "JImage resource";
default: ShouldNotReachHere(); return "";
}
}
void FlagValueOriginConstant::serialize(JfrCheckpointWriter& writer) {
static const u4 nof_entries = JVMFlag::LAST_VALUE_ORIGIN + 1;
writer.write_count(nof_entries);
for (u4 i = 0; i < nof_entries; ++i) {
writer.write_key(i);
writer.write(flag_value_origin_to_string((JVMFlag::Flags)i));
constexpr EnumRange<JVMFlagOrigin> range;
writer.write_count(static_cast<u4>(range.size()));
for (EnumIterator<JVMFlagOrigin> it = range.begin(); it != range.end(); ++it) {
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 "oops/compressedOops.hpp"
#include "oops/klass.inline.hpp"
#include "runtime/flags/jvmFlag.hpp"
#include "runtime/sharedRuntime.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
bool JVMCIGlobals::enable_jvmci_product_mode(JVMFlag::Flags origin) {
bool JVMCIGlobals::enable_jvmci_product_mode(JVMFlagOrigin origin) {
const char *JVMCIFlags[] = {
"EnableJVMCI",
"EnableJVMCIProduct",

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

@ -25,7 +25,7 @@
#ifndef SHARE_JVMCI_JVMCI_GLOBALS_HPP
#define SHARE_JVMCI_JVMCI_GLOBALS_HPP
#include "runtime/flags/jvmFlag.hpp"
#include "utilities/vmEnums.hpp"
class fileStream;
@ -153,7 +153,7 @@ class JVMCIGlobals {
static bool check_jvmci_flags_are_consistent();
// 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.
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 "oops/objArrayKlass.hpp"
#include "runtime/deoptimization.hpp"
#include "runtime/flags/jvmFlag.hpp"
#include "runtime/sharedRuntime.hpp"
#if INCLUDE_G1GC
#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);
CHECK_JNI_EXCEPTION_(env, false);
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);
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) {
return true;
} 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;
errno = 0;
double v = strtod(value, &end);
@ -899,7 +899,7 @@ static bool set_fp_numeric_flag(JVMFlag* flag, char* value, JVMFlag::Flags origi
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;
int int_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;
// Contract: JVMFlag always returns a pointer that needs freeing.
FREE_C_HEAP_ARRAY(char, value);
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 = "";
if (JVMFlagAccess::ccstrAt(flag, &old_value) != JVMFlag::SUCCESS) return false;
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;
}
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
#define NAME_RANGE "[abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_]"
@ -1275,7 +1275,7 @@ void Arguments::print_jvm_args_on(outputStream* st) {
bool Arguments::process_argument(const char* arg,
jboolean ignore_unrecognized,
JVMFlag::Flags origin) {
JVMFlagOrigin origin) {
JDK_Version since = JDK_Version();
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
token[pos] = '\0';
logOption(token);
result &= process_argument(token, ignore_unrecognized, JVMFlag::CONFIG_FILE);
result &= process_argument(token, ignore_unrecognized, JVMFlagOrigin::CONFIG_FILE);
build_jvm_flags(token);
pos = 0;
in_white_space = true;
@ -1422,7 +1422,7 @@ bool Arguments::process_settings_file(const char* file_name, bool should_exist,
}
if (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);
}
fclose(stream);
@ -2288,27 +2288,27 @@ jint Arguments::parse_vm_init_args(const JavaVMInitArgs *vm_options_args,
set_mode_flags(_mixed);
// 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) {
return result;
}
// Parse args structure generated from JAVA_TOOL_OPTIONS environment
// 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) {
return result;
}
// 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) {
return result;
}
// Parse args structure generated from the _JAVA_OPTIONS environment
// 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) {
return result;
}
@ -2452,7 +2452,7 @@ jint Arguments::parse_xss(const JavaVMOption* option, const char* tail, intx* ou
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
const char* tail;

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

@ -28,11 +28,11 @@
#include "logging/logLevel.hpp"
#include "logging/logTag.hpp"
#include "memory/allocation.hpp"
#include "runtime/flags/jvmFlag.hpp"
#include "runtime/java.hpp"
#include "runtime/os.hpp"
#include "runtime/perfData.hpp"
#include "utilities/debug.hpp"
#include "utilities/vmEnums.hpp"
// Arguments parses the command line and recognizes options
@ -408,8 +408,8 @@ class Arguments : AllStatic {
static jint set_aggressive_heap_flags();
// Argument parsing
static bool parse_argument(const char* arg, JVMFlag::Flags origin);
static bool process_argument(const char* arg, jboolean ignore_unrecognized, JVMFlag::Flags origin);
static bool parse_argument(const char* arg, JVMFlagOrigin 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_compiler_argument(const char* arg);
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_options_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 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
}
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");
Flags new_origin = Flags((origin == COMMAND_LINE) ? Flags(origin | ORIG_COMMAND_LINE) : origin);
_flags = Flags((_flags & ~VALUE_ORIGIN_MASK) | new_origin);
int was_in_cmdline = (new_origin == JVMFlagOrigin::COMMAND_LINE) ? WAS_SET_ON_COMMAND_LINE : 0;
_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 {
int origin = _flags & VALUE_ORIGIN_MASK;
st->print("{");
switch(origin) {
case DEFAULT:
switch(get_origin()) {
case JVMFlagOrigin::DEFAULT:
st->print("default"); break;
case COMMAND_LINE:
case JVMFlagOrigin::COMMAND_LINE:
st->print("command line"); break;
case ENVIRON_VAR:
case JVMFlagOrigin::ENVIRON_VAR:
st->print("environment"); break;
case CONFIG_FILE:
case JVMFlagOrigin::CONFIG_FILE:
st->print("config file"); break;
case MANAGEMENT:
case JVMFlagOrigin::MANAGEMENT:
st->print("management"); break;
case ERGONOMIC:
if (_flags & ORIG_COMMAND_LINE) {
case JVMFlagOrigin::ERGONOMIC:
if (_flags & WAS_SET_ON_COMMAND_LINE) {
st->print("command line, ");
}
st->print("ergonomic"); break;
case ATTACH_ON_DEMAND:
case JVMFlagOrigin::ATTACH_ON_DEMAND:
st->print("attach"); break;
case INTERNAL:
case JVMFlagOrigin::INTERNAL:
st->print("internal"); break;
case JIMAGE_RESOURCE:
case JVMFlagOrigin::JIMAGE_RESOURCE:
st->print("jimage"); break;
}
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,
void* addr, int flags, int extra_flags, const char* 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_DIAGNOSTIC | JVMFlag::KIND_MANAGEABLE | JVMFlag::KIND_EXPERIMENTAL)) {
// Backwards compatibility. This will be relaxed in JDK-7123237.
@ -653,7 +657,7 @@ void JVMFlag::printSetFlags(outputStream* out) {
// Print
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);
out->print(" ");
}

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

@ -26,16 +26,16 @@
#define SHARE_RUNTIME_FLAGS_JVMFLAG_HPP
#include "utilities/globalDefinitions.hpp"
#include "utilities/enumIterator.hpp"
#include "utilities/macros.hpp"
#include "utilities/vmEnums.hpp"
class outputStream;
class JVMFlag {
friend class VMStructs;
public:
enum Flags : int {
// latest value origin
enum class JVMFlagOrigin : int {
// This is the value returned by JVMFlag::get_origin(). It records who
// has most recently changed the value of a JVMFlag. DEFAULT means that the
// flag was never changed, or was most recently changed by FLAG_SET_DEFAULT.
DEFAULT = 0,
COMMAND_LINE = 1,
ENVIRON_VAR = 2,
@ -45,8 +45,15 @@ public:
ATTACH_ON_DEMAND = 6,
INTERNAL = 7,
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_MASK = right_n_bits(VALUE_ORIGIN_BITS),
@ -64,10 +71,15 @@ public:
KIND_LP64_PRODUCT = 1 << 14,
KIND_JVMCI = 1 << 15,
// set this bit if the flag was set on the command line
ORIG_COMMAND_LINE = 1 << 17,
// Note the difference:
// 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 {
@ -232,14 +244,14 @@ public:
*static_cast<T*>(_addr) = value;
}
Flags get_origin() const { return Flags(_flags & VALUE_ORIGIN_MASK); }
void set_origin(Flags origin);
JVMFlagOrigin get_origin() const { return JVMFlagOrigin(_flags & VALUE_ORIGIN_MASK); }
void set_origin(JVMFlagOrigin origin);
bool is_default() const { return (get_origin() == DEFAULT); }
bool is_ergonomic() const { return (get_origin() == ERGONOMIC); }
bool is_command_line() const { return (_flags & ORIG_COMMAND_LINE) != 0; }
void set_command_line() { _flags = Flags(_flags | ORIG_COMMAND_LINE); }
bool is_jimage_resource() const { return (get_origin() == JIMAGE_RESOURCE); }
bool is_default() const { return (get_origin() == JVMFlagOrigin::DEFAULT); }
bool is_ergonomic() const { return (get_origin() == JVMFlagOrigin::ERGONOMIC); }
bool is_command_line() const { return (_flags & WAS_SET_ON_COMMAND_LINE) != 0; }
void set_command_line() { _flags = Flags(_flags | WAS_SET_ON_COMMAND_LINE); }
bool is_jimage_resource() const { return (get_origin() == JVMFlagOrigin::JIMAGE_RESOURCE); }
bool is_product() const { return (_flags & KIND_PRODUCT) != 0; }
bool is_manageable() const { return (_flags & KIND_MANAGEABLE) != 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"
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;
e.set_name(flag->name());
e.set_oldValue(old_value);
e.set_newValue(new_value);
e.set_origin(origin);
e.set_origin(static_cast<u8>(origin));
e.commit();
}
class FlagAccessImpl {
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);
}
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 void print_range(outputStream* st, const JVMFlagLimit* range) 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 {
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);
const JVMTypedFlagLimit<T>* constraint = (const JVMTypedFlagLimit<T>*)JVMFlagLimit::get_constraint(flag);
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> {
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();
return TypedFlagAccessImpl<JVM_FLAG_TYPE(bool), EventBooleanFlagChanged>
::check_constraint_and_set(flag, value_addr, origin, verbose);
@ -101,7 +101,7 @@ public:
template <typename T, int type_enum, typename EVENT>
class RangedFlagAccessImpl : public TypedFlagAccessImpl<T, type_enum, EVENT> {
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);
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, ...)
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) {
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);
}
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->is_ccstr()) return JVMFlag::WRONG_FORMAT;
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.
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) {
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.
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);
assert(faddr->is_ccstr(), "wrong flag type");
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.
class JVMFlagAccess : AllStatic {
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(JVMFlag* flag, int type_enum, void* value, JVMFlag::Flags origin);
static JVMFlag::Error ccstrAtPut(JVMFlagsEnum flag, ccstr 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, JVMFlagOrigin origin);
static JVMFlag::Error ccstrAtPut(JVMFlagsEnum flag, ccstr value, JVMFlagOrigin origin);
public:
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
// type_enum will result in an assert.
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);
}
@ -95,23 +95,23 @@ public:
// Examples callers are arguments.cpp, writeableFlags.cpp, and WB_SetXxxVMFlag functions.
// A mismatched type_enum would result in a JVMFlag::WRONG_FORMAT code.
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);
}
static JVMFlag::Error boolAtPut (JVMFlag* f, bool* v, JVMFlag::Flags 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 uintAtPut (JVMFlag* f, uint* v, JVMFlag::Flags 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 uintxAtPut (JVMFlag* f, uintx* v, JVMFlag::Flags 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 size_tAtPut (JVMFlag* f, size_t* v, JVMFlag::Flags 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 boolAtPut (JVMFlag* f, bool* v, JVMFlagOrigin origin) { return set<JVM_FLAG_TYPE(bool)> (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, JVMFlagOrigin origin) { return set<JVM_FLAG_TYPE(uint)> (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, JVMFlagOrigin origin) { return set<JVM_FLAG_TYPE(uintx)> (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, JVMFlagOrigin origin) { return set<JVM_FLAG_TYPE(size_t)> (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
// Contract: JVMFlag will make private copy of the incoming value.
// 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
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_(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); \
}
@ -75,9 +75,9 @@ ALL_FLAGS(DEFINE_FLAG_MEMBER_SETTER,
#define FLAG_SET_DEFAULT(name, value) ((name) = (value))
#define FLAG_SET_CMDLINE(name, value) (JVMFlag::setOnCmdLine(FLAG_MEMBER_ENUM(name)), \
FLAG_MEMBER_SETTER(name)((value), JVMFlag::COMMAND_LINE))
#define FLAG_SET_ERGO(name, value) (FLAG_MEMBER_SETTER(name)((value), JVMFlag::ERGONOMIC))
#define FLAG_SET_MGMT(name, value) (FLAG_MEMBER_SETTER(name)((value), JVMFlag::MANAGEMENT))
FLAG_MEMBER_SETTER(name)((value), JVMFlagOrigin::COMMAND_LINE))
#define FLAG_SET_ERGO(name, value) (FLAG_MEMBER_SETTER(name)((value), JVMFlagOrigin::ERGONOMIC))
#define FLAG_SET_MGMT(name, value) (FLAG_MEMBER_SETTER(name)((value), JVMFlagOrigin::MANAGEMENT))
#define FLAG_SET_ERGO_IF_DEFAULT(name, value) \
do { \

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

@ -2600,17 +2600,17 @@ typedef HashtableEntry<InstanceKlass*, mtClass> KlassHashtableEntry;
/******************************/ \
/* -XX flags (value origin) */ \
/******************************/ \
declare_constant(JVMFlag::DEFAULT) \
declare_constant(JVMFlag::COMMAND_LINE) \
declare_constant(JVMFlag::ENVIRON_VAR) \
declare_constant(JVMFlag::CONFIG_FILE) \
declare_constant(JVMFlag::MANAGEMENT) \
declare_constant(JVMFlag::ERGONOMIC) \
declare_constant(JVMFlag::ATTACH_ON_DEMAND) \
declare_constant(JVMFlag::INTERNAL) \
declare_constant(JVMFlag::JIMAGE_RESOURCE) \
declare_constant(JVMFlagOrigin::DEFAULT) \
declare_constant(JVMFlagOrigin::COMMAND_LINE) \
declare_constant(JVMFlagOrigin::ENVIRON_VAR) \
declare_constant(JVMFlagOrigin::CONFIG_FILE) \
declare_constant(JVMFlagOrigin::MANAGEMENT) \
declare_constant(JVMFlagOrigin::ERGONOMIC) \
declare_constant(JVMFlagOrigin::ATTACH_ON_DEMAND) \
declare_constant(JVMFlagOrigin::INTERNAL) \
declare_constant(JVMFlagOrigin::JIMAGE_RESOURCE) \
declare_constant(JVMFlag::VALUE_ORIGIN_MASK) \
declare_constant(JVMFlag::ORIG_COMMAND_LINE)
declare_constant(JVMFlag::WAS_SET_ON_COMMAND_LINE)
//--------------------------------------------------------------------------------
// 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", "");
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::NON_WRITABLE) {
// 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", "");
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) {
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->external = flag->is_external();
switch (flag->get_origin()) {
case JVMFlag::DEFAULT:
case JVMFlagOrigin::DEFAULT:
global->origin = JMM_VMGLOBAL_ORIGIN_DEFAULT;
break;
case JVMFlag::COMMAND_LINE:
case JVMFlagOrigin::COMMAND_LINE:
global->origin = JMM_VMGLOBAL_ORIGIN_COMMAND_LINE;
break;
case JVMFlag::ENVIRON_VAR:
case JVMFlagOrigin::ENVIRON_VAR:
global->origin = JMM_VMGLOBAL_ORIGIN_ENVIRON_VAR;
break;
case JVMFlag::CONFIG_FILE:
case JVMFlagOrigin::CONFIG_FILE:
global->origin = JMM_VMGLOBAL_ORIGIN_CONFIG_FILE;
break;
case JVMFlag::MANAGEMENT:
case JVMFlagOrigin::MANAGEMENT:
global->origin = JMM_VMGLOBAL_ORIGIN_MANAGEMENT;
break;
case JVMFlag::ERGONOMIC:
case JVMFlagOrigin::ERGONOMIC:
global->origin = JMM_VMGLOBAL_ORIGIN_ERGONOMIC;
break;
case JVMFlag::ATTACH_ON_DEMAND:
case JVMFlagOrigin::ATTACH_ON_DEMAND:
global->origin = JMM_VMGLOBAL_ORIGIN_ATTACH_ON_DEMAND;
break;
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);
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::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
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)) {
return set_bool_flag(name, true, origin, err_msg);
} 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;
}
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::Error err = JVMFlagAccess::boolAtPut(flag, &value, origin);
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
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;
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;
}
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::Error err = JVMFlagAccess::intAtPut(flag, &value, origin);
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
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;
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;
}
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::Error err = JVMFlagAccess::uintAtPut(flag, &value, origin);
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
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;
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;
}
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::Error err = JVMFlagAccess::intxAtPut(flag, &value, origin);
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
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;
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;
}
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::Error err = JVMFlagAccess::uintxAtPut(flag, &value, origin);
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
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;
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;
}
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::Error err = JVMFlagAccess::uint64_tAtPut(flag, &value, origin);
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
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;
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;
}
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::Error err = JVMFlagAccess::size_tAtPut(flag, &value, origin);
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
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;
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;
}
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::Error err = JVMFlagAccess::doubleAtPut(flag, &value, origin);
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
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::Error err = JVMFlagAccess::ccstrAtPut(flag, &value, origin);
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
* - 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);
}
@ -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
* - 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);
}
// 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) {
err_msg.print("flag name is missing");
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
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;
if (flag_value == NULL) {
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
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) {
jvalue new_value = *(jvalue*)value;
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.
*
* This code is free software; you can redistribute it and/or modify it
@ -32,46 +32,46 @@
class WriteableFlags : AllStatic {
private:
// 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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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:
/* sets a writeable flag to the provided value
@ -79,14 +79,14 @@ public:
* - return status is one of the WriteableFlags::err enum values
* - 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
*
* - return status is one of the WriteableFlags::err enum values
* - 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

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

@ -210,6 +210,10 @@ public:
constexpr Iterator end() const {
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

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
// complex header files that have the full definitions of these enums.
enum class JVMFlagOrigin : int;
enum JVMFlagsEnum : 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_JIMAGE_RESOURCE;
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 */
private CodeCache codeCache;
/** This is only present in a C1 build */
@ -195,7 +195,7 @@ public class VM {
return "management";
} else if (origin == Flags_ERGONOMIC) {
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, ";
}
return result + "ergonomic";
@ -490,17 +490,17 @@ public class VM {
bytesPerLong = db.lookupIntConstant("BytesPerLong").intValue();
bytesPerWord = db.lookupIntConstant("BytesPerWord").intValue();
heapWordSize = db.lookupIntConstant("HeapWordSize").intValue();
Flags_DEFAULT = db.lookupIntConstant("JVMFlag::DEFAULT").intValue();
Flags_COMMAND_LINE = db.lookupIntConstant("JVMFlag::COMMAND_LINE").intValue();
Flags_ENVIRON_VAR = db.lookupIntConstant("JVMFlag::ENVIRON_VAR").intValue();
Flags_CONFIG_FILE = db.lookupIntConstant("JVMFlag::CONFIG_FILE").intValue();
Flags_MANAGEMENT = db.lookupIntConstant("JVMFlag::MANAGEMENT").intValue();
Flags_ERGONOMIC = db.lookupIntConstant("JVMFlag::ERGONOMIC").intValue();
Flags_ATTACH_ON_DEMAND = db.lookupIntConstant("JVMFlag::ATTACH_ON_DEMAND").intValue();
Flags_INTERNAL = db.lookupIntConstant("JVMFlag::INTERNAL").intValue();
Flags_JIMAGE_RESOURCE = db.lookupIntConstant("JVMFlag::JIMAGE_RESOURCE").intValue();
Flags_DEFAULT = db.lookupIntConstant("JVMFlagOrigin::DEFAULT").intValue();
Flags_COMMAND_LINE = db.lookupIntConstant("JVMFlagOrigin::COMMAND_LINE").intValue();
Flags_ENVIRON_VAR = db.lookupIntConstant("JVMFlagOrigin::ENVIRON_VAR").intValue();
Flags_CONFIG_FILE = db.lookupIntConstant("JVMFlagOrigin::CONFIG_FILE").intValue();
Flags_MANAGEMENT = db.lookupIntConstant("JVMFlagOrigin::MANAGEMENT").intValue();
Flags_ERGONOMIC = db.lookupIntConstant("JVMFlagOrigin::ERGONOMIC").intValue();
Flags_ATTACH_ON_DEMAND = db.lookupIntConstant("JVMFlagOrigin::ATTACH_ON_DEMAND").intValue();
Flags_INTERNAL = db.lookupIntConstant("JVMFlagOrigin::INTERNAL").intValue();
Flags_JIMAGE_RESOURCE = db.lookupIntConstant("JVMFlagOrigin::JIMAGE_RESOURCE").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();
intType = db.lookupType("int");