stan/jdk-24
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge

Browse Source
This commit is contained in:
Dmitry Dmitriev 2015-11-05 13:39:03 +00:00
commit 56d0d62359
3 changed files with 162 additions and 143 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

64
hotspot/src/share/vm/runtime/arguments.cpp
View File

@ -818,9 +818,15 @@ static bool set_numeric_flag(const char* name, char* value, Flag::Flags origin)
int int_v;
intx intx_v;
bool is_neg = false;
Flag* result = Flag::find_flag(name, strlen(name));
if (result == NULL) {
return false;
}
// Check the sign first since atomull() parses only unsigned values.
if (*value == '-') {
if ((CommandLineFlags::intxAt(name, &intx_v) != Flag::SUCCESS) && (CommandLineFlags::intAt(name, &int_v) != Flag::SUCCESS)) {
if (!result->is_intx() && !result->is_int()) {
return false;
}
value++;
@ -829,37 +835,33 @@ static bool set_numeric_flag(const char* name, char* value, Flag::Flags origin)
if (!atomull(value, &v)) {
return false;
}
int_v = (int) v;
if (is_neg) {
int_v = -int_v;
if (result->is_int()) {
int_v = (int) v;
if (is_neg) {
int_v = -int_v;
}
return CommandLineFlags::intAtPut(result, &int_v, origin) == Flag::SUCCESS;
} else if (result->is_uint()) {
uint uint_v = (uint) v;
return CommandLineFlags::uintAtPut(result, &uint_v, origin) == Flag::SUCCESS;
} else if (result->is_intx()) {
intx_v = (intx) v;
if (is_neg) {
intx_v = -intx_v;
}
return CommandLineFlags::intxAtPut(result, &intx_v, origin) == Flag::SUCCESS;
} else if (result->is_uintx()) {
uintx uintx_v = (uintx) v;
return CommandLineFlags::uintxAtPut(result, &uintx_v, origin) == Flag::SUCCESS;
} else if (result->is_uint64_t()) {
uint64_t uint64_t_v = (uint64_t) v;
return CommandLineFlags::uint64_tAtPut(result, &uint64_t_v, origin) == Flag::SUCCESS;
} else if (result->is_size_t()) {
size_t size_t_v = (size_t) v;
return CommandLineFlags::size_tAtPut(result, &size_t_v, origin) == Flag::SUCCESS;
} else {
return false;
}
if (CommandLineFlags::intAtPut(name, &int_v, origin) == Flag::SUCCESS) {
return true;
}
uint uint_v = (uint) v;
if (!is_neg && CommandLineFlags::uintAtPut(name, &uint_v, origin) == Flag::SUCCESS) {
return true;
}
intx_v = (intx) v;
if (is_neg) {
intx_v = -intx_v;
}
if (CommandLineFlags::intxAtPut(name, &intx_v, origin) == Flag::SUCCESS) {
return true;
}
uintx uintx_v = (uintx) v;
if (!is_neg && (CommandLineFlags::uintxAtPut(name, &uintx_v, origin) == Flag::SUCCESS)) {
return true;
}
uint64_t uint64_t_v = (uint64_t) v;
if (!is_neg && (CommandLineFlags::uint64_tAtPut(name, &uint64_t_v, origin) == Flag::SUCCESS)) {
return true;
}
size_t size_t_v = (size_t) v;
if (!is_neg && (CommandLineFlags::size_tAtPut(name, &size_t_v, origin) == Flag::SUCCESS)) {
return true;
}
return false;
}
static bool set_string_flag(const char* name, const char* value, Flag::Flags origin) {

233
hotspot/src/share/vm/runtime/globals.cpp
View File

@ -787,7 +787,7 @@ static void trace_flag_changed(const char* name, const T old_value, const T new_
e.commit();
}
static Flag::Error apply_constraint_and_check_range_bool(const char* name, bool new_value, bool verbose = true) {
static Flag::Error apply_constraint_and_check_range_bool(const char* name, bool new_value, bool verbose) {
Flag::Error status = Flag::SUCCESS;
CommandLineFlagConstraint* constraint = CommandLineFlagConstraintList::find_if_needs_check(name);
if (constraint != NULL) {
@ -804,32 +804,33 @@ Flag::Error CommandLineFlags::boolAt(const char* name, size_t len, bool* value,
return Flag::SUCCESS;
}
Flag::Error CommandLineFlags::boolAtPut(const char* name, size_t len, bool* value, Flag::Flags origin) {
Flag* result = Flag::find_flag(name, len);
if (result == NULL) return Flag::INVALID_FLAG;
if (!result->is_bool()) return Flag::WRONG_FORMAT;
Flag::Error CommandLineFlags::boolAtPut(Flag* flag, bool* value, Flag::Flags origin) {
const char* name;
if (flag == NULL) return Flag::INVALID_FLAG;
if (!flag->is_bool()) return Flag::WRONG_FORMAT;
name = flag->_name;
Flag::Error check = apply_constraint_and_check_range_bool(name, *value, !CommandLineFlagConstraintList::validated_after_ergo());
if (check != Flag::SUCCESS) return check;
bool old_value = result->get_bool();
bool old_value = flag->get_bool();
trace_flag_changed<EventBooleanFlagChanged, bool>(name, old_value, *value, origin);
result->set_bool(*value);
flag->set_bool(*value);
*value = old_value;
result->set_origin(origin);
flag->set_origin(origin);
return Flag::SUCCESS;
}
Flag::Error CommandLineFlags::boolAtPut(const char* name, size_t len, bool* value, Flag::Flags origin) {
Flag* result = Flag::find_flag(name, len);
return boolAtPut(result, value, origin);
}
Flag::Error CommandLineFlagsEx::boolAtPut(CommandLineFlagWithType flag, bool value, Flag::Flags origin) {
Flag* faddr = address_of_flag(flag);
guarantee(faddr != NULL && faddr->is_bool(), "wrong flag type");
Flag::Error check = apply_constraint_and_check_range_bool(faddr->_name, value);
if (check != Flag::SUCCESS) return check;
trace_flag_changed<EventBooleanFlagChanged, bool>(faddr->_name, faddr->get_bool(), value, origin);
faddr->set_bool(value);
faddr->set_origin(origin);
return Flag::SUCCESS;
return CommandLineFlags::boolAtPut(faddr, &value, origin);
}
static Flag::Error apply_constraint_and_check_range_int(const char* name, int new_value, bool verbose = true) {
static Flag::Error apply_constraint_and_check_range_int(const char* name, int new_value, bool verbose) {
Flag::Error status = Flag::SUCCESS;
CommandLineFlagRange* range = CommandLineFlagRangeList::find(name);
if (range != NULL) {
@ -852,32 +853,33 @@ Flag::Error CommandLineFlags::intAt(const char* name, size_t len, int* value, bo
return Flag::SUCCESS;
}
Flag::Error CommandLineFlags::intAtPut(const char* name, size_t len, int* value, Flag::Flags origin) {
Flag* result = Flag::find_flag(name, len);
if (result == NULL) return Flag::INVALID_FLAG;
if (!result->is_int()) return Flag::WRONG_FORMAT;
Flag::Error CommandLineFlags::intAtPut(Flag* flag, int* value, Flag::Flags origin) {
const char* name;
if (flag == NULL) return Flag::INVALID_FLAG;
if (!flag->is_int()) return Flag::WRONG_FORMAT;
name = flag->_name;
Flag::Error check = apply_constraint_and_check_range_int(name, *value, !CommandLineFlagConstraintList::validated_after_ergo());
if (check != Flag::SUCCESS) return check;
int old_value = result->get_int();
int old_value = flag->get_int();
trace_flag_changed<EventIntFlagChanged, s4>(name, old_value, *value, origin);
result->set_int(*value);
flag->set_int(*value);
*value = old_value;
result->set_origin(origin);
flag->set_origin(origin);
return Flag::SUCCESS;
}
Flag::Error CommandLineFlags::intAtPut(const char* name, size_t len, int* value, Flag::Flags origin) {
Flag* result = Flag::find_flag(name, len);
return intAtPut(result, value, origin);
}
Flag::Error CommandLineFlagsEx::intAtPut(CommandLineFlagWithType flag, int value, Flag::Flags origin) {
Flag* faddr = address_of_flag(flag);
guarantee(faddr != NULL && faddr->is_int(), "wrong flag type");
Flag::Error check = apply_constraint_and_check_range_int(faddr->_name, value, !CommandLineFlagConstraintList::validated_after_ergo());
if (check != Flag::SUCCESS) return check;
trace_flag_changed<EventIntFlagChanged, s4>(faddr->_name, faddr->get_int(), value, origin);
faddr->set_int(value);
faddr->set_origin(origin);
return Flag::SUCCESS;
return CommandLineFlags::intAtPut(faddr, &value, origin);
}
static Flag::Error apply_constraint_and_check_range_uint(const char* name, uint new_value, bool verbose = true) {
static Flag::Error apply_constraint_and_check_range_uint(const char* name, uint new_value, bool verbose) {
Flag::Error status = Flag::SUCCESS;
CommandLineFlagRange* range = CommandLineFlagRangeList::find(name);
if (range != NULL) {
@ -900,29 +902,30 @@ Flag::Error CommandLineFlags::uintAt(const char* name, size_t len, uint* value,
return Flag::SUCCESS;
}
Flag::Error CommandLineFlags::uintAtPut(const char* name, size_t len, uint* value, Flag::Flags origin) {
Flag* result = Flag::find_flag(name, len);
if (result == NULL) return Flag::INVALID_FLAG;
if (!result->is_uint()) return Flag::WRONG_FORMAT;
Flag::Error CommandLineFlags::uintAtPut(Flag* flag, uint* value, Flag::Flags origin) {
const char* name;
if (flag == NULL) return Flag::INVALID_FLAG;
if (!flag->is_uint()) return Flag::WRONG_FORMAT;
name = flag->_name;
Flag::Error check = apply_constraint_and_check_range_uint(name, *value, !CommandLineFlagConstraintList::validated_after_ergo());
if (check != Flag::SUCCESS) return check;
uint old_value = result->get_uint();
uint old_value = flag->get_uint();
trace_flag_changed<EventUnsignedIntFlagChanged, u4>(name, old_value, *value, origin);
result->set_uint(*value);
flag->set_uint(*value);
*value = old_value;
result->set_origin(origin);
flag->set_origin(origin);
return Flag::SUCCESS;
}
Flag::Error CommandLineFlags::uintAtPut(const char* name, size_t len, uint* value, Flag::Flags origin) {
Flag* result = Flag::find_flag(name, len);
return uintAtPut(result, value, origin);
}
Flag::Error CommandLineFlagsEx::uintAtPut(CommandLineFlagWithType flag, uint value, Flag::Flags origin) {
Flag* faddr = address_of_flag(flag);
guarantee(faddr != NULL && faddr->is_uint(), "wrong flag type");
Flag::Error check = apply_constraint_and_check_range_uint(faddr->_name, value, !CommandLineFlagConstraintList::validated_after_ergo());
if (check != Flag::SUCCESS) return check;
trace_flag_changed<EventUnsignedIntFlagChanged, u4>(faddr->_name, faddr->get_uint(), value, origin);
faddr->set_uint(value);
faddr->set_origin(origin);
return Flag::SUCCESS;
return CommandLineFlags::uintAtPut(faddr, &value, origin);
}
Flag::Error CommandLineFlags::intxAt(const char* name, size_t len, intx* value, bool allow_locked, bool return_flag) {
@ -933,7 +936,7 @@ Flag::Error CommandLineFlags::intxAt(const char* name, size_t len, intx* value,
return Flag::SUCCESS;
}
static Flag::Error apply_constraint_and_check_range_intx(const char* name, intx new_value, bool verbose = true) {
static Flag::Error apply_constraint_and_check_range_intx(const char* name, intx new_value, bool verbose) {
Flag::Error status = Flag::SUCCESS;
CommandLineFlagRange* range = CommandLineFlagRangeList::find(name);
if (range != NULL) {
@ -948,29 +951,30 @@ static Flag::Error apply_constraint_and_check_range_intx(const char* name, intx
return status;
}
Flag::Error CommandLineFlags::intxAtPut(const char* name, size_t len, intx* value, Flag::Flags origin) {
Flag* result = Flag::find_flag(name, len);
if (result == NULL) return Flag::INVALID_FLAG;
if (!result->is_intx()) return Flag::WRONG_FORMAT;
Flag::Error CommandLineFlags::intxAtPut(Flag* flag, intx* value, Flag::Flags origin) {
const char* name;
if (flag == NULL) return Flag::INVALID_FLAG;
if (!flag->is_intx()) return Flag::WRONG_FORMAT;
name = flag->_name;
Flag::Error check = apply_constraint_and_check_range_intx(name, *value, !CommandLineFlagConstraintList::validated_after_ergo());
if (check != Flag::SUCCESS) return check;
intx old_value = result->get_intx();
intx old_value = flag->get_intx();
trace_flag_changed<EventLongFlagChanged, intx>(name, old_value, *value, origin);
result->set_intx(*value);
flag->set_intx(*value);
*value = old_value;
result->set_origin(origin);
flag->set_origin(origin);
return Flag::SUCCESS;
}
Flag::Error CommandLineFlags::intxAtPut(const char* name, size_t len, intx* value, Flag::Flags origin) {
Flag* result = Flag::find_flag(name, len);
return intxAtPut(result, value, origin);
}
Flag::Error CommandLineFlagsEx::intxAtPut(CommandLineFlagWithType flag, intx value, Flag::Flags origin) {
Flag* faddr = address_of_flag(flag);
guarantee(faddr != NULL && faddr->is_intx(), "wrong flag type");
Flag::Error check = apply_constraint_and_check_range_intx(faddr->_name, value);
if (check != Flag::SUCCESS) return check;
trace_flag_changed<EventLongFlagChanged, intx>(faddr->_name, faddr->get_intx(), value, origin);
faddr->set_intx(value);
faddr->set_origin(origin);
return Flag::SUCCESS;
return CommandLineFlags::intxAtPut(faddr, &value, origin);
}
Flag::Error CommandLineFlags::uintxAt(const char* name, size_t len, uintx* value, bool allow_locked, bool return_flag) {
@ -981,7 +985,7 @@ Flag::Error CommandLineFlags::uintxAt(const char* name, size_t len, uintx* value
return Flag::SUCCESS;
}
static Flag::Error apply_constraint_and_check_range_uintx(const char* name, uintx new_value, bool verbose = true) {
static Flag::Error apply_constraint_and_check_range_uintx(const char* name, uintx new_value, bool verbose) {
Flag::Error status = Flag::SUCCESS;
CommandLineFlagRange* range = CommandLineFlagRangeList::find(name);
if (range != NULL) {
@ -996,29 +1000,30 @@ static Flag::Error apply_constraint_and_check_range_uintx(const char* name, uint
return status;
}
Flag::Error CommandLineFlags::uintxAtPut(const char* name, size_t len, uintx* value, Flag::Flags origin) {
Flag* result = Flag::find_flag(name, len);
if (result == NULL) return Flag::INVALID_FLAG;
if (!result->is_uintx()) return Flag::WRONG_FORMAT;
Flag::Error CommandLineFlags::uintxAtPut(Flag* flag, uintx* value, Flag::Flags origin) {
const char* name;
if (flag == NULL) return Flag::INVALID_FLAG;
if (!flag->is_uintx()) return Flag::WRONG_FORMAT;
name = flag->_name;
Flag::Error check = apply_constraint_and_check_range_uintx(name, *value, !CommandLineFlagConstraintList::validated_after_ergo());
if (check != Flag::SUCCESS) return check;
uintx old_value = result->get_uintx();
uintx old_value = flag->get_uintx();
trace_flag_changed<EventUnsignedLongFlagChanged, u8>(name, old_value, *value, origin);
result->set_uintx(*value);
flag->set_uintx(*value);
*value = old_value;
result->set_origin(origin);
flag->set_origin(origin);
return Flag::SUCCESS;
}
Flag::Error CommandLineFlags::uintxAtPut(const char* name, size_t len, uintx* value, Flag::Flags origin) {
Flag* result = Flag::find_flag(name, len);
return uintxAtPut(result, value, origin);
}
Flag::Error CommandLineFlagsEx::uintxAtPut(CommandLineFlagWithType flag, uintx value, Flag::Flags origin) {
Flag* faddr = address_of_flag(flag);
guarantee(faddr != NULL && faddr->is_uintx(), "wrong flag type");
Flag::Error check = apply_constraint_and_check_range_uintx(faddr->_name, value);
if (check != Flag::SUCCESS) return check;
trace_flag_changed<EventUnsignedLongFlagChanged, u8>(faddr->_name, faddr->get_uintx(), value, origin);
faddr->set_uintx(value);
faddr->set_origin(origin);
return Flag::SUCCESS;
return CommandLineFlags::uintxAtPut(faddr, &value, origin);
}
Flag::Error CommandLineFlags::uint64_tAt(const char* name, size_t len, uint64_t* value, bool allow_locked, bool return_flag) {
@ -1029,7 +1034,7 @@ Flag::Error CommandLineFlags::uint64_tAt(const char* name, size_t len, uint64_t*
return Flag::SUCCESS;
}
static Flag::Error apply_constraint_and_check_range_uint64_t(const char* name, uint64_t new_value, bool verbose = true) {
static Flag::Error apply_constraint_and_check_range_uint64_t(const char* name, uint64_t new_value, bool verbose) {
Flag::Error status = Flag::SUCCESS;
CommandLineFlagRange* range = CommandLineFlagRangeList::find(name);
if (range != NULL) {
@ -1044,29 +1049,30 @@ static Flag::Error apply_constraint_and_check_range_uint64_t(const char* name, u
return status;
}
Flag::Error CommandLineFlags::uint64_tAtPut(const char* name, size_t len, uint64_t* value, Flag::Flags origin) {
Flag* result = Flag::find_flag(name, len);
if (result == NULL) return Flag::INVALID_FLAG;
if (!result->is_uint64_t()) return Flag::WRONG_FORMAT;
Flag::Error CommandLineFlags::uint64_tAtPut(Flag* flag, uint64_t* value, Flag::Flags origin) {
const char* name;
if (flag == NULL) return Flag::INVALID_FLAG;
if (!flag->is_uint64_t()) return Flag::WRONG_FORMAT;
name = flag->_name;
Flag::Error check = apply_constraint_and_check_range_uint64_t(name, *value, !CommandLineFlagConstraintList::validated_after_ergo());
if (check != Flag::SUCCESS) return check;
uint64_t old_value = result->get_uint64_t();
uint64_t old_value = flag->get_uint64_t();
trace_flag_changed<EventUnsignedLongFlagChanged, u8>(name, old_value, *value, origin);
result->set_uint64_t(*value);
flag->set_uint64_t(*value);
*value = old_value;
result->set_origin(origin);
flag->set_origin(origin);
return Flag::SUCCESS;
}
Flag::Error CommandLineFlags::uint64_tAtPut(const char* name, size_t len, uint64_t* value, Flag::Flags origin) {
Flag* result = Flag::find_flag(name, len);
return uint64_tAtPut(result, value, origin);
}
Flag::Error CommandLineFlagsEx::uint64_tAtPut(CommandLineFlagWithType flag, uint64_t value, Flag::Flags origin) {
Flag* faddr = address_of_flag(flag);
guarantee(faddr != NULL && faddr->is_uint64_t(), "wrong flag type");
Flag::Error check = apply_constraint_and_check_range_uint64_t(faddr->_name, value);
if (check != Flag::SUCCESS) return check;
trace_flag_changed<EventUnsignedLongFlagChanged, u8>(faddr->_name, faddr->get_uint64_t(), value, origin);
faddr->set_uint64_t(value);
faddr->set_origin(origin);
return Flag::SUCCESS;
return CommandLineFlags::uint64_tAtPut(faddr, &value, origin);
}
Flag::Error CommandLineFlags::size_tAt(const char* name, size_t len, size_t* value, bool allow_locked, bool return_flag) {
@ -1077,7 +1083,7 @@ Flag::Error CommandLineFlags::size_tAt(const char* name, size_t len, size_t* val
return Flag::SUCCESS;
}
static Flag::Error apply_constraint_and_check_range_size_t(const char* name, size_t new_value, bool verbose = true) {
static Flag::Error apply_constraint_and_check_range_size_t(const char* name, size_t new_value, bool verbose) {
Flag::Error status = Flag::SUCCESS;
CommandLineFlagRange* range = CommandLineFlagRangeList::find(name);
if (range != NULL) {
@ -1092,29 +1098,31 @@ static Flag::Error apply_constraint_and_check_range_size_t(const char* name, siz
return status;
}
Flag::Error CommandLineFlags::size_tAtPut(const char* name, size_t len, size_t* value, Flag::Flags origin) {
Flag* result = Flag::find_flag(name, len);
if (result == NULL) return Flag::INVALID_FLAG;
if (!result->is_size_t()) return Flag::WRONG_FORMAT;
Flag::Error CommandLineFlags::size_tAtPut(Flag* flag, size_t* value, Flag::Flags origin) {
const char* name;
if (flag == NULL) return Flag::INVALID_FLAG;
if (!flag->is_size_t()) return Flag::WRONG_FORMAT;
name = flag->_name;
Flag::Error check = apply_constraint_and_check_range_size_t(name, *value, !CommandLineFlagConstraintList::validated_after_ergo());
if (check != Flag::SUCCESS) return check;
size_t old_value = result->get_size_t();
size_t old_value = flag->get_size_t();
trace_flag_changed<EventUnsignedLongFlagChanged, u8>(name, old_value, *value, origin);
result->set_size_t(*value);
flag->set_size_t(*value);
*value = old_value;
result->set_origin(origin);
flag->set_origin(origin);
return Flag::SUCCESS;
}
Flag::Error CommandLineFlags::size_tAtPut(const char* name, size_t len, size_t* value, Flag::Flags origin) {
Flag* result = Flag::find_flag(name, len);
return size_tAtPut(result, value, origin);
}
Flag::Error CommandLineFlagsEx::size_tAtPut(CommandLineFlagWithType flag, size_t value, Flag::Flags origin) {
Flag* faddr = address_of_flag(flag);
guarantee(faddr != NULL && faddr->is_size_t(), "wrong flag type");
Flag::Error check = apply_constraint_and_check_range_size_t(faddr->_name, value);
if (check != Flag::SUCCESS) return check;
trace_flag_changed<EventUnsignedLongFlagChanged, u8>(faddr->_name, faddr->get_size_t(), value, origin);
faddr->set_size_t(value);
faddr->set_origin(origin);
return Flag::SUCCESS;
return CommandLineFlags::size_tAtPut(faddr, &value, origin);
}
Flag::Error CommandLineFlags::doubleAt(const char* name, size_t len, double* value, bool allow_locked, bool return_flag) {
@ -1125,7 +1133,7 @@ Flag::Error CommandLineFlags::doubleAt(const char* name, size_t len, double* val
return Flag::SUCCESS;
}
static Flag::Error apply_constraint_and_check_range_double(const char* name, double new_value, bool verbose = true) {
static Flag::Error apply_constraint_and_check_range_double(const char* name, double new_value, bool verbose) {
Flag::Error status = Flag::SUCCESS;
CommandLineFlagRange* range = CommandLineFlagRangeList::find(name);
if (range != NULL) {
@ -1140,29 +1148,30 @@ static Flag::Error apply_constraint_and_check_range_double(const char* name, dou
return status;
}
Flag::Error CommandLineFlags::doubleAtPut(const char* name, size_t len, double* value, Flag::Flags origin) {
Flag* result = Flag::find_flag(name, len);
if (result == NULL) return Flag::INVALID_FLAG;
if (!result->is_double()) return Flag::WRONG_FORMAT;
Flag::Error CommandLineFlags::doubleAtPut(Flag* flag, double* value, Flag::Flags origin) {
const char* name;
if (flag == NULL) return Flag::INVALID_FLAG;
if (!flag->is_double()) return Flag::WRONG_FORMAT;
name = flag->_name;
Flag::Error check = apply_constraint_and_check_range_double(name, *value, !CommandLineFlagConstraintList::validated_after_ergo());
if (check != Flag::SUCCESS) return check;
double old_value = result->get_double();
double old_value = flag->get_double();
trace_flag_changed<EventDoubleFlagChanged, double>(name, old_value, *value, origin);
result->set_double(*value);
flag->set_double(*value);
*value = old_value;
result->set_origin(origin);
flag->set_origin(origin);
return Flag::SUCCESS;
}
Flag::Error CommandLineFlags::doubleAtPut(const char* name, size_t len, double* value, Flag::Flags origin) {
Flag* result = Flag::find_flag(name, len);
return doubleAtPut(result, value, origin);
}
Flag::Error CommandLineFlagsEx::doubleAtPut(CommandLineFlagWithType flag, double value, Flag::Flags origin) {
Flag* faddr = address_of_flag(flag);
guarantee(faddr != NULL && faddr->is_double(), "wrong flag type");
Flag::Error check = apply_constraint_and_check_range_double(faddr->_name, value);
if (check != Flag::SUCCESS) return check;
trace_flag_changed<EventDoubleFlagChanged, double>(faddr->_name, faddr->get_double(), value, origin);
faddr->set_double(value);
faddr->set_origin(origin);
return Flag::SUCCESS;
return CommandLineFlags::doubleAtPut(faddr, &value, origin);
}
Flag::Error CommandLineFlags::ccstrAt(const char* name, size_t len, ccstr* value, bool allow_locked, bool return_flag) {

8
hotspot/src/share/vm/runtime/globals.hpp
View File

@ -452,41 +452,49 @@ class CommandLineFlags {
public:
static Flag::Error boolAt(const char* name, size_t len, bool* value, bool allow_locked = false, bool return_flag = false);
static Flag::Error boolAt(const char* name, bool* value, bool allow_locked = false, bool return_flag = false) { return boolAt(name, strlen(name), value, allow_locked, return_flag); }
static Flag::Error boolAtPut(Flag* flag, bool* value, Flag::Flags origin);
static Flag::Error boolAtPut(const char* name, size_t len, bool* value, Flag::Flags origin);
static Flag::Error boolAtPut(const char* name, bool* value, Flag::Flags origin) { return boolAtPut(name, strlen(name), value, origin); }
static Flag::Error intAt(const char* name, size_t len, int* value, bool allow_locked = false, bool return_flag = false);
static Flag::Error intAt(const char* name, int* value, bool allow_locked = false, bool return_flag = false) { return intAt(name, strlen(name), value, allow_locked, return_flag); }
static Flag::Error intAtPut(Flag* flag, int* value, Flag::Flags origin);
static Flag::Error intAtPut(const char* name, size_t len, int* value, Flag::Flags origin);
static Flag::Error intAtPut(const char* name, int* value, Flag::Flags origin) { return intAtPut(name, strlen(name), value, origin); }
static Flag::Error uintAt(const char* name, size_t len, uint* value, bool allow_locked = false, bool return_flag = false);
static Flag::Error uintAt(const char* name, uint* value, bool allow_locked = false, bool return_flag = false) { return uintAt(name, strlen(name), value, allow_locked, return_flag); }
static Flag::Error uintAtPut(Flag* flag, uint* value, Flag::Flags origin);
static Flag::Error uintAtPut(const char* name, size_t len, uint* value, Flag::Flags origin);
static Flag::Error uintAtPut(const char* name, uint* value, Flag::Flags origin) { return uintAtPut(name, strlen(name), value, origin); }
static Flag::Error intxAt(const char* name, size_t len, intx* value, bool allow_locked = false, bool return_flag = false);
static Flag::Error intxAt(const char* name, intx* value, bool allow_locked = false, bool return_flag = false) { return intxAt(name, strlen(name), value, allow_locked, return_flag); }
static Flag::Error intxAtPut(Flag* flag, intx* value, Flag::Flags origin);
static Flag::Error intxAtPut(const char* name, size_t len, intx* value, Flag::Flags origin);
static Flag::Error intxAtPut(const char* name, intx* value, Flag::Flags origin) { return intxAtPut(name, strlen(name), value, origin); }
static Flag::Error uintxAt(const char* name, size_t len, uintx* value, bool allow_locked = false, bool return_flag = false);
static Flag::Error uintxAt(const char* name, uintx* value, bool allow_locked = false, bool return_flag = false) { return uintxAt(name, strlen(name), value, allow_locked, return_flag); }
static Flag::Error uintxAtPut(Flag* flag, uintx* value, Flag::Flags origin);
static Flag::Error uintxAtPut(const char* name, size_t len, uintx* value, Flag::Flags origin);
static Flag::Error uintxAtPut(const char* name, uintx* value, Flag::Flags origin) { return uintxAtPut(name, strlen(name), value, origin); }
static Flag::Error size_tAt(const char* name, size_t len, size_t* value, bool allow_locked = false, bool return_flag = false);
static Flag::Error size_tAt(const char* name, size_t* value, bool allow_locked = false, bool return_flag = false) { return size_tAt(name, strlen(name), value, allow_locked, return_flag); }
static Flag::Error size_tAtPut(Flag* flag, size_t* value, Flag::Flags origin);
static Flag::Error size_tAtPut(const char* name, size_t len, size_t* value, Flag::Flags origin);
static Flag::Error size_tAtPut(const char* name, size_t* value, Flag::Flags origin) { return size_tAtPut(name, strlen(name), value, origin); }
static Flag::Error uint64_tAt(const char* name, size_t len, uint64_t* value, bool allow_locked = false, bool return_flag = false);
static Flag::Error uint64_tAt(const char* name, uint64_t* value, bool allow_locked = false, bool return_flag = false) { return uint64_tAt(name, strlen(name), value, allow_locked, return_flag); }
static Flag::Error uint64_tAtPut(Flag* flag, uint64_t* value, Flag::Flags origin);
static Flag::Error uint64_tAtPut(const char* name, size_t len, uint64_t* value, Flag::Flags origin);
static Flag::Error uint64_tAtPut(const char* name, uint64_t* value, Flag::Flags origin) { return uint64_tAtPut(name, strlen(name), value, origin); }
static Flag::Error doubleAt(const char* name, size_t len, double* value, bool allow_locked = false, bool return_flag = false);
static Flag::Error doubleAt(const char* name, double* value, bool allow_locked = false, bool return_flag = false) { return doubleAt(name, strlen(name), value, allow_locked, return_flag); }
static Flag::Error doubleAtPut(Flag* flag, double* value, Flag::Flags origin);
static Flag::Error doubleAtPut(const char* name, size_t len, double* value, Flag::Flags origin);
static Flag::Error doubleAtPut(const char* name, double* value, Flag::Flags origin) { return doubleAtPut(name, strlen(name), value, origin); }