955 |
955 |
956 return match; |
956 return match; |
957 } |
957 } |
958 |
958 |
959 // Returns the address of the index'th element |
959 // Returns the address of the index'th element |
960 static JVMFlag* address_of_flag(JVMFlagsEnum flag) { |
960 JVMFlag* JVMFlagEx::flag_from_enum(JVMFlagsEnum flag) { |
961 assert((size_t)flag < JVMFlag::numFlags, "bad command line flag index"); |
961 assert((size_t)flag < JVMFlag::numFlags, "bad command line flag index"); |
962 return &JVMFlag::flags[flag]; |
962 return &JVMFlag::flags[flag]; |
963 } |
963 } |
964 |
964 |
965 bool JVMFlagEx::is_default(JVMFlagsEnum flag) { |
965 bool JVMFlagEx::is_default(JVMFlagsEnum flag) { |
966 assert((size_t)flag < JVMFlag::numFlags, "bad command line flag index"); |
966 return flag_from_enum(flag)->is_default(); |
967 JVMFlag* f = &JVMFlag::flags[flag]; |
|
968 return f->is_default(); |
|
969 } |
967 } |
970 |
968 |
971 bool JVMFlagEx::is_ergo(JVMFlagsEnum flag) { |
969 bool JVMFlagEx::is_ergo(JVMFlagsEnum flag) { |
972 assert((size_t)flag < JVMFlag::numFlags, "bad command line flag index"); |
970 return flag_from_enum(flag)->is_ergonomic(); |
973 JVMFlag* f = &JVMFlag::flags[flag]; |
|
974 return f->is_ergonomic(); |
|
975 } |
971 } |
976 |
972 |
977 bool JVMFlagEx::is_cmdline(JVMFlagsEnum flag) { |
973 bool JVMFlagEx::is_cmdline(JVMFlagsEnum flag) { |
978 assert((size_t)flag < JVMFlag::numFlags, "bad command line flag index"); |
974 return flag_from_enum(flag)->is_command_line(); |
979 JVMFlag* f = &JVMFlag::flags[flag]; |
|
980 return f->is_command_line(); |
|
981 } |
|
982 |
|
983 bool JVMFlag::wasSetOnCmdline(const char* name, bool* value) { |
|
984 JVMFlag* result = JVMFlag::find_flag((char*)name, strlen(name)); |
|
985 if (result == NULL) return false; |
|
986 *value = result->is_command_line(); |
|
987 return true; |
|
988 } |
975 } |
989 |
976 |
990 void JVMFlagEx::setOnCmdLine(JVMFlagsEnum flag) { |
977 void JVMFlagEx::setOnCmdLine(JVMFlagsEnum flag) { |
991 JVMFlag* faddr = address_of_flag(flag); |
978 JVMFlag* faddr = flag_from_enum(flag); |
992 assert(faddr != NULL, "Unknown flag"); |
979 assert(faddr != NULL, "Unknown flag"); |
993 faddr->set_command_line(); |
980 faddr->set_command_line(); |
994 } |
981 } |
995 |
982 |
996 template<class E, class T> |
983 template<class E, class T> |
997 static void trace_flag_changed(const char* name, const T old_value, const T new_value, const JVMFlag::Flags origin) { |
984 static void trace_flag_changed(const JVMFlag* flag, const T old_value, const T new_value, const JVMFlag::Flags origin) { |
998 E e; |
985 E e; |
999 e.set_name(name); |
986 e.set_name(flag->_name); |
1000 e.set_oldValue(old_value); |
987 e.set_oldValue(old_value); |
1001 e.set_newValue(new_value); |
988 e.set_newValue(new_value); |
1002 e.set_origin(origin); |
989 e.set_origin(origin); |
1003 e.commit(); |
990 e.commit(); |
1004 } |
991 } |
1005 |
992 |
1006 static JVMFlag::Error apply_constraint_and_check_range_bool(const char* name, bool new_value, bool verbose) { |
993 static JVMFlag::Error apply_constraint_and_check_range_bool(const JVMFlag* flag, bool new_value, bool verbose) { |
1007 JVMFlag::Error status = JVMFlag::SUCCESS; |
994 JVMFlag::Error status = JVMFlag::SUCCESS; |
1008 JVMFlagConstraint* constraint = JVMFlagConstraintList::find_if_needs_check(name); |
995 JVMFlagConstraint* constraint = JVMFlagConstraintList::find_if_needs_check(flag); |
1009 if (constraint != NULL) { |
996 if (constraint != NULL) { |
1010 status = constraint->apply_bool(new_value, verbose); |
997 status = constraint->apply_bool(new_value, verbose); |
1011 } |
998 } |
1012 return status; |
999 return status; |
1013 } |
1000 } |
1014 |
1001 |
1015 JVMFlag::Error JVMFlag::boolAt(const char* name, size_t len, bool* value, bool allow_locked, bool return_flag) { |
1002 JVMFlag::Error JVMFlag::boolAt(const JVMFlag* flag, bool* value) { |
1016 JVMFlag* result = JVMFlag::find_flag(name, len, allow_locked, return_flag); |
1003 if (flag == NULL) return JVMFlag::INVALID_FLAG; |
1017 if (result == NULL) return JVMFlag::INVALID_FLAG; |
1004 if (!flag->is_bool()) return JVMFlag::WRONG_FORMAT; |
1018 if (!result->is_bool()) return JVMFlag::WRONG_FORMAT; |
1005 *value = flag->get_bool(); |
1019 *value = result->get_bool(); |
|
1020 return JVMFlag::SUCCESS; |
1006 return JVMFlag::SUCCESS; |
1021 } |
1007 } |
1022 |
1008 |
1023 JVMFlag::Error JVMFlag::boolAtPut(JVMFlag* flag, bool* value, JVMFlag::Flags origin) { |
1009 JVMFlag::Error JVMFlag::boolAtPut(JVMFlag* flag, bool* value, JVMFlag::Flags origin) { |
1024 const char* name; |
|
1025 if (flag == NULL) return JVMFlag::INVALID_FLAG; |
1010 if (flag == NULL) return JVMFlag::INVALID_FLAG; |
1026 if (!flag->is_bool()) return JVMFlag::WRONG_FORMAT; |
1011 if (!flag->is_bool()) return JVMFlag::WRONG_FORMAT; |
1027 name = flag->_name; |
1012 JVMFlag::Error check = apply_constraint_and_check_range_bool(flag, *value, !JVMFlagConstraintList::validated_after_ergo()); |
1028 JVMFlag::Error check = apply_constraint_and_check_range_bool(name, *value, !JVMFlagConstraintList::validated_after_ergo()); |
|
1029 if (check != JVMFlag::SUCCESS) return check; |
1013 if (check != JVMFlag::SUCCESS) return check; |
1030 bool old_value = flag->get_bool(); |
1014 bool old_value = flag->get_bool(); |
1031 trace_flag_changed<EventBooleanFlagChanged, bool>(name, old_value, *value, origin); |
1015 trace_flag_changed<EventBooleanFlagChanged, bool>(flag, old_value, *value, origin); |
1032 check = flag->set_bool(*value); |
1016 check = flag->set_bool(*value); |
1033 *value = old_value; |
1017 *value = old_value; |
1034 flag->set_origin(origin); |
1018 flag->set_origin(origin); |
1035 return check; |
1019 return check; |
1036 } |
1020 } |
1037 |
1021 |
1038 JVMFlag::Error JVMFlag::boolAtPut(const char* name, size_t len, bool* value, JVMFlag::Flags origin) { |
|
1039 JVMFlag* result = JVMFlag::find_flag(name, len); |
|
1040 return boolAtPut(result, value, origin); |
|
1041 } |
|
1042 |
|
1043 JVMFlag::Error JVMFlagEx::boolAtPut(JVMFlagsEnum flag, bool value, JVMFlag::Flags origin) { |
1022 JVMFlag::Error JVMFlagEx::boolAtPut(JVMFlagsEnum flag, bool value, JVMFlag::Flags origin) { |
1044 JVMFlag* faddr = address_of_flag(flag); |
1023 JVMFlag* faddr = flag_from_enum(flag); |
1045 guarantee(faddr != NULL && faddr->is_bool(), "wrong flag type"); |
1024 guarantee(faddr != NULL && faddr->is_bool(), "wrong flag type"); |
1046 return JVMFlag::boolAtPut(faddr, &value, origin); |
1025 return JVMFlag::boolAtPut(faddr, &value, origin); |
1047 } |
1026 } |
1048 |
1027 |
1049 static JVMFlag::Error apply_constraint_and_check_range_int(const char* name, int new_value, bool verbose) { |
1028 static JVMFlag::Error apply_constraint_and_check_range_int(const JVMFlag* flag, int new_value, bool verbose) { |
1050 JVMFlag::Error status = JVMFlag::SUCCESS; |
1029 JVMFlag::Error status = JVMFlag::SUCCESS; |
1051 JVMFlagRange* range = JVMFlagRangeList::find(name); |
1030 JVMFlagRange* range = JVMFlagRangeList::find(flag); |
1052 if (range != NULL) { |
1031 if (range != NULL) { |
1053 status = range->check_int(new_value, verbose); |
1032 status = range->check_int(new_value, verbose); |
1054 } |
1033 } |
1055 if (status == JVMFlag::SUCCESS) { |
1034 if (status == JVMFlag::SUCCESS) { |
1056 JVMFlagConstraint* constraint = JVMFlagConstraintList::find_if_needs_check(name); |
1035 JVMFlagConstraint* constraint = JVMFlagConstraintList::find_if_needs_check(flag); |
1057 if (constraint != NULL) { |
1036 if (constraint != NULL) { |
1058 status = constraint->apply_int(new_value, verbose); |
1037 status = constraint->apply_int(new_value, verbose); |
1059 } |
1038 } |
1060 } |
1039 } |
1061 return status; |
1040 return status; |
1062 } |
1041 } |
1063 |
1042 |
1064 JVMFlag::Error JVMFlag::intAt(const char* name, size_t len, int* value, bool allow_locked, bool return_flag) { |
1043 JVMFlag::Error JVMFlag::intAt(const JVMFlag* flag, int* value) { |
1065 JVMFlag* result = JVMFlag::find_flag(name, len, allow_locked, return_flag); |
1044 if (flag == NULL) return JVMFlag::INVALID_FLAG; |
1066 if (result == NULL) return JVMFlag::INVALID_FLAG; |
1045 if (!flag->is_int()) return JVMFlag::WRONG_FORMAT; |
1067 if (!result->is_int()) return JVMFlag::WRONG_FORMAT; |
1046 *value = flag->get_int(); |
1068 *value = result->get_int(); |
|
1069 return JVMFlag::SUCCESS; |
1047 return JVMFlag::SUCCESS; |
1070 } |
1048 } |
1071 |
1049 |
1072 JVMFlag::Error JVMFlag::intAtPut(JVMFlag* flag, int* value, JVMFlag::Flags origin) { |
1050 JVMFlag::Error JVMFlag::intAtPut(JVMFlag* flag, int* value, JVMFlag::Flags origin) { |
1073 const char* name; |
|
1074 if (flag == NULL) return JVMFlag::INVALID_FLAG; |
1051 if (flag == NULL) return JVMFlag::INVALID_FLAG; |
1075 if (!flag->is_int()) return JVMFlag::WRONG_FORMAT; |
1052 if (!flag->is_int()) return JVMFlag::WRONG_FORMAT; |
1076 name = flag->_name; |
1053 JVMFlag::Error check = apply_constraint_and_check_range_int(flag, *value, !JVMFlagConstraintList::validated_after_ergo()); |
1077 JVMFlag::Error check = apply_constraint_and_check_range_int(name, *value, !JVMFlagConstraintList::validated_after_ergo()); |
|
1078 if (check != JVMFlag::SUCCESS) return check; |
1054 if (check != JVMFlag::SUCCESS) return check; |
1079 int old_value = flag->get_int(); |
1055 int old_value = flag->get_int(); |
1080 trace_flag_changed<EventIntFlagChanged, s4>(name, old_value, *value, origin); |
1056 trace_flag_changed<EventIntFlagChanged, s4>(flag, old_value, *value, origin); |
1081 check = flag->set_int(*value); |
1057 check = flag->set_int(*value); |
1082 *value = old_value; |
1058 *value = old_value; |
1083 flag->set_origin(origin); |
1059 flag->set_origin(origin); |
1084 return check; |
1060 return check; |
1085 } |
1061 } |
1086 |
1062 |
1087 JVMFlag::Error JVMFlag::intAtPut(const char* name, size_t len, int* value, JVMFlag::Flags origin) { |
|
1088 JVMFlag* result = JVMFlag::find_flag(name, len); |
|
1089 return intAtPut(result, value, origin); |
|
1090 } |
|
1091 |
|
1092 JVMFlag::Error JVMFlagEx::intAtPut(JVMFlagsEnum flag, int value, JVMFlag::Flags origin) { |
1063 JVMFlag::Error JVMFlagEx::intAtPut(JVMFlagsEnum flag, int value, JVMFlag::Flags origin) { |
1093 JVMFlag* faddr = address_of_flag(flag); |
1064 JVMFlag* faddr = flag_from_enum(flag); |
1094 guarantee(faddr != NULL && faddr->is_int(), "wrong flag type"); |
1065 guarantee(faddr != NULL && faddr->is_int(), "wrong flag type"); |
1095 return JVMFlag::intAtPut(faddr, &value, origin); |
1066 return JVMFlag::intAtPut(faddr, &value, origin); |
1096 } |
1067 } |
1097 |
1068 |
1098 static JVMFlag::Error apply_constraint_and_check_range_uint(const char* name, uint new_value, bool verbose) { |
1069 static JVMFlag::Error apply_constraint_and_check_range_uint(const JVMFlag* flag, uint new_value, bool verbose) { |
1099 JVMFlag::Error status = JVMFlag::SUCCESS; |
1070 JVMFlag::Error status = JVMFlag::SUCCESS; |
1100 JVMFlagRange* range = JVMFlagRangeList::find(name); |
1071 JVMFlagRange* range = JVMFlagRangeList::find(flag); |
1101 if (range != NULL) { |
1072 if (range != NULL) { |
1102 status = range->check_uint(new_value, verbose); |
1073 status = range->check_uint(new_value, verbose); |
1103 } |
1074 } |
1104 if (status == JVMFlag::SUCCESS) { |
1075 if (status == JVMFlag::SUCCESS) { |
1105 JVMFlagConstraint* constraint = JVMFlagConstraintList::find_if_needs_check(name); |
1076 JVMFlagConstraint* constraint = JVMFlagConstraintList::find_if_needs_check(flag); |
1106 if (constraint != NULL) { |
1077 if (constraint != NULL) { |
1107 status = constraint->apply_uint(new_value, verbose); |
1078 status = constraint->apply_uint(new_value, verbose); |
1108 } |
1079 } |
1109 } |
1080 } |
1110 return status; |
1081 return status; |
1111 } |
1082 } |
1112 |
1083 |
1113 JVMFlag::Error JVMFlag::uintAt(const char* name, size_t len, uint* value, bool allow_locked, bool return_flag) { |
1084 JVMFlag::Error JVMFlag::uintAt(const JVMFlag* flag, uint* value) { |
1114 JVMFlag* result = JVMFlag::find_flag(name, len, allow_locked, return_flag); |
1085 if (flag == NULL) return JVMFlag::INVALID_FLAG; |
1115 if (result == NULL) return JVMFlag::INVALID_FLAG; |
1086 if (!flag->is_uint()) return JVMFlag::WRONG_FORMAT; |
1116 if (!result->is_uint()) return JVMFlag::WRONG_FORMAT; |
1087 *value = flag->get_uint(); |
1117 *value = result->get_uint(); |
|
1118 return JVMFlag::SUCCESS; |
1088 return JVMFlag::SUCCESS; |
1119 } |
1089 } |
1120 |
1090 |
1121 JVMFlag::Error JVMFlag::uintAtPut(JVMFlag* flag, uint* value, JVMFlag::Flags origin) { |
1091 JVMFlag::Error JVMFlag::uintAtPut(JVMFlag* flag, uint* value, JVMFlag::Flags origin) { |
1122 const char* name; |
|
1123 if (flag == NULL) return JVMFlag::INVALID_FLAG; |
1092 if (flag == NULL) return JVMFlag::INVALID_FLAG; |
1124 if (!flag->is_uint()) return JVMFlag::WRONG_FORMAT; |
1093 if (!flag->is_uint()) return JVMFlag::WRONG_FORMAT; |
1125 name = flag->_name; |
1094 JVMFlag::Error check = apply_constraint_and_check_range_uint(flag, *value, !JVMFlagConstraintList::validated_after_ergo()); |
1126 JVMFlag::Error check = apply_constraint_and_check_range_uint(name, *value, !JVMFlagConstraintList::validated_after_ergo()); |
|
1127 if (check != JVMFlag::SUCCESS) return check; |
1095 if (check != JVMFlag::SUCCESS) return check; |
1128 uint old_value = flag->get_uint(); |
1096 uint old_value = flag->get_uint(); |
1129 trace_flag_changed<EventUnsignedIntFlagChanged, u4>(name, old_value, *value, origin); |
1097 trace_flag_changed<EventUnsignedIntFlagChanged, u4>(flag, old_value, *value, origin); |
1130 check = flag->set_uint(*value); |
1098 check = flag->set_uint(*value); |
1131 *value = old_value; |
1099 *value = old_value; |
1132 flag->set_origin(origin); |
1100 flag->set_origin(origin); |
1133 return check; |
1101 return check; |
1134 } |
1102 } |
1135 |
1103 |
1136 JVMFlag::Error JVMFlag::uintAtPut(const char* name, size_t len, uint* value, JVMFlag::Flags origin) { |
|
1137 JVMFlag* result = JVMFlag::find_flag(name, len); |
|
1138 return uintAtPut(result, value, origin); |
|
1139 } |
|
1140 |
|
1141 JVMFlag::Error JVMFlagEx::uintAtPut(JVMFlagsEnum flag, uint value, JVMFlag::Flags origin) { |
1104 JVMFlag::Error JVMFlagEx::uintAtPut(JVMFlagsEnum flag, uint value, JVMFlag::Flags origin) { |
1142 JVMFlag* faddr = address_of_flag(flag); |
1105 JVMFlag* faddr = flag_from_enum(flag); |
1143 guarantee(faddr != NULL && faddr->is_uint(), "wrong flag type"); |
1106 guarantee(faddr != NULL && faddr->is_uint(), "wrong flag type"); |
1144 return JVMFlag::uintAtPut(faddr, &value, origin); |
1107 return JVMFlag::uintAtPut(faddr, &value, origin); |
1145 } |
1108 } |
1146 |
1109 |
1147 JVMFlag::Error JVMFlag::intxAt(const char* name, size_t len, intx* value, bool allow_locked, bool return_flag) { |
1110 JVMFlag::Error JVMFlag::intxAt(const JVMFlag* flag, intx* value) { |
1148 JVMFlag* result = JVMFlag::find_flag(name, len, allow_locked, return_flag); |
1111 if (flag == NULL) return JVMFlag::INVALID_FLAG; |
1149 if (result == NULL) return JVMFlag::INVALID_FLAG; |
1112 if (!flag->is_intx()) return JVMFlag::WRONG_FORMAT; |
1150 if (!result->is_intx()) return JVMFlag::WRONG_FORMAT; |
1113 *value = flag->get_intx(); |
1151 *value = result->get_intx(); |
|
1152 return JVMFlag::SUCCESS; |
1114 return JVMFlag::SUCCESS; |
1153 } |
1115 } |
1154 |
1116 |
1155 static JVMFlag::Error apply_constraint_and_check_range_intx(const char* name, intx new_value, bool verbose) { |
1117 static JVMFlag::Error apply_constraint_and_check_range_intx(const JVMFlag* flag, intx new_value, bool verbose) { |
1156 JVMFlag::Error status = JVMFlag::SUCCESS; |
1118 JVMFlag::Error status = JVMFlag::SUCCESS; |
1157 JVMFlagRange* range = JVMFlagRangeList::find(name); |
1119 JVMFlagRange* range = JVMFlagRangeList::find(flag); |
1158 if (range != NULL) { |
1120 if (range != NULL) { |
1159 status = range->check_intx(new_value, verbose); |
1121 status = range->check_intx(new_value, verbose); |
1160 } |
1122 } |
1161 if (status == JVMFlag::SUCCESS) { |
1123 if (status == JVMFlag::SUCCESS) { |
1162 JVMFlagConstraint* constraint = JVMFlagConstraintList::find_if_needs_check(name); |
1124 JVMFlagConstraint* constraint = JVMFlagConstraintList::find_if_needs_check(flag); |
1163 if (constraint != NULL) { |
1125 if (constraint != NULL) { |
1164 status = constraint->apply_intx(new_value, verbose); |
1126 status = constraint->apply_intx(new_value, verbose); |
1165 } |
1127 } |
1166 } |
1128 } |
1167 return status; |
1129 return status; |
1168 } |
1130 } |
1169 |
1131 |
1170 JVMFlag::Error JVMFlag::intxAtPut(JVMFlag* flag, intx* value, JVMFlag::Flags origin) { |
1132 JVMFlag::Error JVMFlag::intxAtPut(JVMFlag* flag, intx* value, JVMFlag::Flags origin) { |
1171 const char* name; |
|
1172 if (flag == NULL) return JVMFlag::INVALID_FLAG; |
1133 if (flag == NULL) return JVMFlag::INVALID_FLAG; |
1173 if (!flag->is_intx()) return JVMFlag::WRONG_FORMAT; |
1134 if (!flag->is_intx()) return JVMFlag::WRONG_FORMAT; |
1174 name = flag->_name; |
1135 JVMFlag::Error check = apply_constraint_and_check_range_intx(flag, *value, !JVMFlagConstraintList::validated_after_ergo()); |
1175 JVMFlag::Error check = apply_constraint_and_check_range_intx(name, *value, !JVMFlagConstraintList::validated_after_ergo()); |
|
1176 if (check != JVMFlag::SUCCESS) return check; |
1136 if (check != JVMFlag::SUCCESS) return check; |
1177 intx old_value = flag->get_intx(); |
1137 intx old_value = flag->get_intx(); |
1178 trace_flag_changed<EventLongFlagChanged, intx>(name, old_value, *value, origin); |
1138 trace_flag_changed<EventLongFlagChanged, intx>(flag, old_value, *value, origin); |
1179 check = flag->set_intx(*value); |
1139 check = flag->set_intx(*value); |
1180 *value = old_value; |
1140 *value = old_value; |
1181 flag->set_origin(origin); |
1141 flag->set_origin(origin); |
1182 return check; |
1142 return check; |
1183 } |
1143 } |
1184 |
1144 |
1185 JVMFlag::Error JVMFlag::intxAtPut(const char* name, size_t len, intx* value, JVMFlag::Flags origin) { |
|
1186 JVMFlag* result = JVMFlag::find_flag(name, len); |
|
1187 return intxAtPut(result, value, origin); |
|
1188 } |
|
1189 |
|
1190 JVMFlag::Error JVMFlagEx::intxAtPut(JVMFlagsEnum flag, intx value, JVMFlag::Flags origin) { |
1145 JVMFlag::Error JVMFlagEx::intxAtPut(JVMFlagsEnum flag, intx value, JVMFlag::Flags origin) { |
1191 JVMFlag* faddr = address_of_flag(flag); |
1146 JVMFlag* faddr = flag_from_enum(flag); |
1192 guarantee(faddr != NULL && faddr->is_intx(), "wrong flag type"); |
1147 guarantee(faddr != NULL && faddr->is_intx(), "wrong flag type"); |
1193 return JVMFlag::intxAtPut(faddr, &value, origin); |
1148 return JVMFlag::intxAtPut(faddr, &value, origin); |
1194 } |
1149 } |
1195 |
1150 |
1196 JVMFlag::Error JVMFlag::uintxAt(const char* name, size_t len, uintx* value, bool allow_locked, bool return_flag) { |
1151 JVMFlag::Error JVMFlag::uintxAt(const JVMFlag* flag, uintx* value) { |
1197 JVMFlag* result = JVMFlag::find_flag(name, len, allow_locked, return_flag); |
1152 if (flag == NULL) return JVMFlag::INVALID_FLAG; |
1198 if (result == NULL) return JVMFlag::INVALID_FLAG; |
1153 if (!flag->is_uintx()) return JVMFlag::WRONG_FORMAT; |
1199 if (!result->is_uintx()) return JVMFlag::WRONG_FORMAT; |
1154 *value = flag->get_uintx(); |
1200 *value = result->get_uintx(); |
|
1201 return JVMFlag::SUCCESS; |
1155 return JVMFlag::SUCCESS; |
1202 } |
1156 } |
1203 |
1157 |
1204 static JVMFlag::Error apply_constraint_and_check_range_uintx(const char* name, uintx new_value, bool verbose) { |
1158 static JVMFlag::Error apply_constraint_and_check_range_uintx(const JVMFlag* flag, uintx new_value, bool verbose) { |
1205 JVMFlag::Error status = JVMFlag::SUCCESS; |
1159 JVMFlag::Error status = JVMFlag::SUCCESS; |
1206 JVMFlagRange* range = JVMFlagRangeList::find(name); |
1160 JVMFlagRange* range = JVMFlagRangeList::find(flag); |
1207 if (range != NULL) { |
1161 if (range != NULL) { |
1208 status = range->check_uintx(new_value, verbose); |
1162 status = range->check_uintx(new_value, verbose); |
1209 } |
1163 } |
1210 if (status == JVMFlag::SUCCESS) { |
1164 if (status == JVMFlag::SUCCESS) { |
1211 JVMFlagConstraint* constraint = JVMFlagConstraintList::find_if_needs_check(name); |
1165 JVMFlagConstraint* constraint = JVMFlagConstraintList::find_if_needs_check(flag); |
1212 if (constraint != NULL) { |
1166 if (constraint != NULL) { |
1213 status = constraint->apply_uintx(new_value, verbose); |
1167 status = constraint->apply_uintx(new_value, verbose); |
1214 } |
1168 } |
1215 } |
1169 } |
1216 return status; |
1170 return status; |
1217 } |
1171 } |
1218 |
1172 |
1219 JVMFlag::Error JVMFlag::uintxAtPut(JVMFlag* flag, uintx* value, JVMFlag::Flags origin) { |
1173 JVMFlag::Error JVMFlag::uintxAtPut(JVMFlag* flag, uintx* value, JVMFlag::Flags origin) { |
1220 const char* name; |
|
1221 if (flag == NULL) return JVMFlag::INVALID_FLAG; |
1174 if (flag == NULL) return JVMFlag::INVALID_FLAG; |
1222 if (!flag->is_uintx()) return JVMFlag::WRONG_FORMAT; |
1175 if (!flag->is_uintx()) return JVMFlag::WRONG_FORMAT; |
1223 name = flag->_name; |
1176 JVMFlag::Error check = apply_constraint_and_check_range_uintx(flag, *value, !JVMFlagConstraintList::validated_after_ergo()); |
1224 JVMFlag::Error check = apply_constraint_and_check_range_uintx(name, *value, !JVMFlagConstraintList::validated_after_ergo()); |
|
1225 if (check != JVMFlag::SUCCESS) return check; |
1177 if (check != JVMFlag::SUCCESS) return check; |
1226 uintx old_value = flag->get_uintx(); |
1178 uintx old_value = flag->get_uintx(); |
1227 trace_flag_changed<EventUnsignedLongFlagChanged, u8>(name, old_value, *value, origin); |
1179 trace_flag_changed<EventUnsignedLongFlagChanged, u8>(flag, old_value, *value, origin); |
1228 check = flag->set_uintx(*value); |
1180 check = flag->set_uintx(*value); |
1229 *value = old_value; |
1181 *value = old_value; |
1230 flag->set_origin(origin); |
1182 flag->set_origin(origin); |
1231 return check; |
1183 return check; |
1232 } |
1184 } |
1233 |
1185 |
1234 JVMFlag::Error JVMFlag::uintxAtPut(const char* name, size_t len, uintx* value, JVMFlag::Flags origin) { |
|
1235 JVMFlag* result = JVMFlag::find_flag(name, len); |
|
1236 return uintxAtPut(result, value, origin); |
|
1237 } |
|
1238 |
|
1239 JVMFlag::Error JVMFlagEx::uintxAtPut(JVMFlagsEnum flag, uintx value, JVMFlag::Flags origin) { |
1186 JVMFlag::Error JVMFlagEx::uintxAtPut(JVMFlagsEnum flag, uintx value, JVMFlag::Flags origin) { |
1240 JVMFlag* faddr = address_of_flag(flag); |
1187 JVMFlag* faddr = flag_from_enum(flag); |
1241 guarantee(faddr != NULL && faddr->is_uintx(), "wrong flag type"); |
1188 guarantee(faddr != NULL && faddr->is_uintx(), "wrong flag type"); |
1242 return JVMFlag::uintxAtPut(faddr, &value, origin); |
1189 return JVMFlag::uintxAtPut(faddr, &value, origin); |
1243 } |
1190 } |
1244 |
1191 |
1245 JVMFlag::Error JVMFlag::uint64_tAt(const char* name, size_t len, uint64_t* value, bool allow_locked, bool return_flag) { |
1192 JVMFlag::Error JVMFlag::uint64_tAt(const JVMFlag* flag, uint64_t* value) { |
1246 JVMFlag* result = JVMFlag::find_flag(name, len, allow_locked, return_flag); |
1193 if (flag == NULL) return JVMFlag::INVALID_FLAG; |
1247 if (result == NULL) return JVMFlag::INVALID_FLAG; |
1194 if (!flag->is_uint64_t()) return JVMFlag::WRONG_FORMAT; |
1248 if (!result->is_uint64_t()) return JVMFlag::WRONG_FORMAT; |
1195 *value = flag->get_uint64_t(); |
1249 *value = result->get_uint64_t(); |
|
1250 return JVMFlag::SUCCESS; |
1196 return JVMFlag::SUCCESS; |
1251 } |
1197 } |
1252 |
1198 |
1253 static JVMFlag::Error apply_constraint_and_check_range_uint64_t(const char* name, uint64_t new_value, bool verbose) { |
1199 static JVMFlag::Error apply_constraint_and_check_range_uint64_t(const JVMFlag* flag, uint64_t new_value, bool verbose) { |
1254 JVMFlag::Error status = JVMFlag::SUCCESS; |
1200 JVMFlag::Error status = JVMFlag::SUCCESS; |
1255 JVMFlagRange* range = JVMFlagRangeList::find(name); |
1201 JVMFlagRange* range = JVMFlagRangeList::find(flag); |
1256 if (range != NULL) { |
1202 if (range != NULL) { |
1257 status = range->check_uint64_t(new_value, verbose); |
1203 status = range->check_uint64_t(new_value, verbose); |
1258 } |
1204 } |
1259 if (status == JVMFlag::SUCCESS) { |
1205 if (status == JVMFlag::SUCCESS) { |
1260 JVMFlagConstraint* constraint = JVMFlagConstraintList::find_if_needs_check(name); |
1206 JVMFlagConstraint* constraint = JVMFlagConstraintList::find_if_needs_check(flag); |
1261 if (constraint != NULL) { |
1207 if (constraint != NULL) { |
1262 status = constraint->apply_uint64_t(new_value, verbose); |
1208 status = constraint->apply_uint64_t(new_value, verbose); |
1263 } |
1209 } |
1264 } |
1210 } |
1265 return status; |
1211 return status; |
1266 } |
1212 } |
1267 |
1213 |
1268 JVMFlag::Error JVMFlag::uint64_tAtPut(JVMFlag* flag, uint64_t* value, JVMFlag::Flags origin) { |
1214 JVMFlag::Error JVMFlag::uint64_tAtPut(JVMFlag* flag, uint64_t* value, JVMFlag::Flags origin) { |
1269 const char* name; |
|
1270 if (flag == NULL) return JVMFlag::INVALID_FLAG; |
1215 if (flag == NULL) return JVMFlag::INVALID_FLAG; |
1271 if (!flag->is_uint64_t()) return JVMFlag::WRONG_FORMAT; |
1216 if (!flag->is_uint64_t()) return JVMFlag::WRONG_FORMAT; |
1272 name = flag->_name; |
1217 JVMFlag::Error check = apply_constraint_and_check_range_uint64_t(flag, *value, !JVMFlagConstraintList::validated_after_ergo()); |
1273 JVMFlag::Error check = apply_constraint_and_check_range_uint64_t(name, *value, !JVMFlagConstraintList::validated_after_ergo()); |
|
1274 if (check != JVMFlag::SUCCESS) return check; |
1218 if (check != JVMFlag::SUCCESS) return check; |
1275 uint64_t old_value = flag->get_uint64_t(); |
1219 uint64_t old_value = flag->get_uint64_t(); |
1276 trace_flag_changed<EventUnsignedLongFlagChanged, u8>(name, old_value, *value, origin); |
1220 trace_flag_changed<EventUnsignedLongFlagChanged, u8>(flag, old_value, *value, origin); |
1277 check = flag->set_uint64_t(*value); |
1221 check = flag->set_uint64_t(*value); |
1278 *value = old_value; |
1222 *value = old_value; |
1279 flag->set_origin(origin); |
1223 flag->set_origin(origin); |
1280 return check; |
1224 return check; |
1281 } |
1225 } |
1282 |
1226 |
1283 JVMFlag::Error JVMFlag::uint64_tAtPut(const char* name, size_t len, uint64_t* value, JVMFlag::Flags origin) { |
|
1284 JVMFlag* result = JVMFlag::find_flag(name, len); |
|
1285 return uint64_tAtPut(result, value, origin); |
|
1286 } |
|
1287 |
|
1288 JVMFlag::Error JVMFlagEx::uint64_tAtPut(JVMFlagsEnum flag, uint64_t value, JVMFlag::Flags origin) { |
1227 JVMFlag::Error JVMFlagEx::uint64_tAtPut(JVMFlagsEnum flag, uint64_t value, JVMFlag::Flags origin) { |
1289 JVMFlag* faddr = address_of_flag(flag); |
1228 JVMFlag* faddr = flag_from_enum(flag); |
1290 guarantee(faddr != NULL && faddr->is_uint64_t(), "wrong flag type"); |
1229 guarantee(faddr != NULL && faddr->is_uint64_t(), "wrong flag type"); |
1291 return JVMFlag::uint64_tAtPut(faddr, &value, origin); |
1230 return JVMFlag::uint64_tAtPut(faddr, &value, origin); |
1292 } |
1231 } |
1293 |
1232 |
1294 JVMFlag::Error JVMFlag::size_tAt(const char* name, size_t len, size_t* value, bool allow_locked, bool return_flag) { |
1233 JVMFlag::Error JVMFlag::size_tAt(const JVMFlag* flag, size_t* value) { |
1295 JVMFlag* result = JVMFlag::find_flag(name, len, allow_locked, return_flag); |
1234 if (flag == NULL) return JVMFlag::INVALID_FLAG; |
1296 if (result == NULL) return JVMFlag::INVALID_FLAG; |
1235 if (!flag->is_size_t()) return JVMFlag::WRONG_FORMAT; |
1297 if (!result->is_size_t()) return JVMFlag::WRONG_FORMAT; |
1236 *value = flag->get_size_t(); |
1298 *value = result->get_size_t(); |
|
1299 return JVMFlag::SUCCESS; |
1237 return JVMFlag::SUCCESS; |
1300 } |
1238 } |
1301 |
1239 |
1302 static JVMFlag::Error apply_constraint_and_check_range_size_t(const char* name, size_t new_value, bool verbose) { |
1240 static JVMFlag::Error apply_constraint_and_check_range_size_t(const JVMFlag* flag, size_t new_value, bool verbose) { |
1303 JVMFlag::Error status = JVMFlag::SUCCESS; |
1241 JVMFlag::Error status = JVMFlag::SUCCESS; |
1304 JVMFlagRange* range = JVMFlagRangeList::find(name); |
1242 JVMFlagRange* range = JVMFlagRangeList::find(flag); |
1305 if (range != NULL) { |
1243 if (range != NULL) { |
1306 status = range->check_size_t(new_value, verbose); |
1244 status = range->check_size_t(new_value, verbose); |
1307 } |
1245 } |
1308 if (status == JVMFlag::SUCCESS) { |
1246 if (status == JVMFlag::SUCCESS) { |
1309 JVMFlagConstraint* constraint = JVMFlagConstraintList::find_if_needs_check(name); |
1247 JVMFlagConstraint* constraint = JVMFlagConstraintList::find_if_needs_check(flag); |
1310 if (constraint != NULL) { |
1248 if (constraint != NULL) { |
1311 status = constraint->apply_size_t(new_value, verbose); |
1249 status = constraint->apply_size_t(new_value, verbose); |
1312 } |
1250 } |
1313 } |
1251 } |
1314 return status; |
1252 return status; |
1315 } |
1253 } |
1316 |
1254 |
1317 |
1255 |
1318 JVMFlag::Error JVMFlag::size_tAtPut(JVMFlag* flag, size_t* value, JVMFlag::Flags origin) { |
1256 JVMFlag::Error JVMFlag::size_tAtPut(JVMFlag* flag, size_t* value, JVMFlag::Flags origin) { |
1319 const char* name; |
|
1320 if (flag == NULL) return JVMFlag::INVALID_FLAG; |
1257 if (flag == NULL) return JVMFlag::INVALID_FLAG; |
1321 if (!flag->is_size_t()) return JVMFlag::WRONG_FORMAT; |
1258 if (!flag->is_size_t()) return JVMFlag::WRONG_FORMAT; |
1322 name = flag->_name; |
1259 JVMFlag::Error check = apply_constraint_and_check_range_size_t(flag, *value, !JVMFlagConstraintList::validated_after_ergo()); |
1323 JVMFlag::Error check = apply_constraint_and_check_range_size_t(name, *value, !JVMFlagConstraintList::validated_after_ergo()); |
|
1324 if (check != JVMFlag::SUCCESS) return check; |
1260 if (check != JVMFlag::SUCCESS) return check; |
1325 size_t old_value = flag->get_size_t(); |
1261 size_t old_value = flag->get_size_t(); |
1326 trace_flag_changed<EventUnsignedLongFlagChanged, u8>(name, old_value, *value, origin); |
1262 trace_flag_changed<EventUnsignedLongFlagChanged, u8>(flag, old_value, *value, origin); |
1327 check = flag->set_size_t(*value); |
1263 check = flag->set_size_t(*value); |
1328 *value = old_value; |
1264 *value = old_value; |
1329 flag->set_origin(origin); |
1265 flag->set_origin(origin); |
1330 return check; |
1266 return check; |
1331 } |
1267 } |
1332 |
1268 |
1333 JVMFlag::Error JVMFlag::size_tAtPut(const char* name, size_t len, size_t* value, JVMFlag::Flags origin) { |
|
1334 JVMFlag* result = JVMFlag::find_flag(name, len); |
|
1335 return size_tAtPut(result, value, origin); |
|
1336 } |
|
1337 |
|
1338 JVMFlag::Error JVMFlagEx::size_tAtPut(JVMFlagsEnum flag, size_t value, JVMFlag::Flags origin) { |
1269 JVMFlag::Error JVMFlagEx::size_tAtPut(JVMFlagsEnum flag, size_t value, JVMFlag::Flags origin) { |
1339 JVMFlag* faddr = address_of_flag(flag); |
1270 JVMFlag* faddr = flag_from_enum(flag); |
1340 guarantee(faddr != NULL && faddr->is_size_t(), "wrong flag type"); |
1271 guarantee(faddr != NULL && faddr->is_size_t(), "wrong flag type"); |
1341 return JVMFlag::size_tAtPut(faddr, &value, origin); |
1272 return JVMFlag::size_tAtPut(faddr, &value, origin); |
1342 } |
1273 } |
1343 |
1274 |
1344 JVMFlag::Error JVMFlag::doubleAt(const char* name, size_t len, double* value, bool allow_locked, bool return_flag) { |
1275 JVMFlag::Error JVMFlag::doubleAt(const JVMFlag* flag, double* value) { |
1345 JVMFlag* result = JVMFlag::find_flag(name, len, allow_locked, return_flag); |
1276 if (flag == NULL) return JVMFlag::INVALID_FLAG; |
1346 if (result == NULL) return JVMFlag::INVALID_FLAG; |
1277 if (!flag->is_double()) return JVMFlag::WRONG_FORMAT; |
1347 if (!result->is_double()) return JVMFlag::WRONG_FORMAT; |
1278 *value = flag->get_double(); |
1348 *value = result->get_double(); |
|
1349 return JVMFlag::SUCCESS; |
1279 return JVMFlag::SUCCESS; |
1350 } |
1280 } |
1351 |
1281 |
1352 static JVMFlag::Error apply_constraint_and_check_range_double(const char* name, double new_value, bool verbose) { |
1282 static JVMFlag::Error apply_constraint_and_check_range_double(const JVMFlag* flag, double new_value, bool verbose) { |
1353 JVMFlag::Error status = JVMFlag::SUCCESS; |
1283 JVMFlag::Error status = JVMFlag::SUCCESS; |
1354 JVMFlagRange* range = JVMFlagRangeList::find(name); |
1284 JVMFlagRange* range = JVMFlagRangeList::find(flag); |
1355 if (range != NULL) { |
1285 if (range != NULL) { |
1356 status = range->check_double(new_value, verbose); |
1286 status = range->check_double(new_value, verbose); |
1357 } |
1287 } |
1358 if (status == JVMFlag::SUCCESS) { |
1288 if (status == JVMFlag::SUCCESS) { |
1359 JVMFlagConstraint* constraint = JVMFlagConstraintList::find_if_needs_check(name); |
1289 JVMFlagConstraint* constraint = JVMFlagConstraintList::find_if_needs_check(flag); |
1360 if (constraint != NULL) { |
1290 if (constraint != NULL) { |
1361 status = constraint->apply_double(new_value, verbose); |
1291 status = constraint->apply_double(new_value, verbose); |
1362 } |
1292 } |
1363 } |
1293 } |
1364 return status; |
1294 return status; |
1365 } |
1295 } |
1366 |
1296 |
1367 JVMFlag::Error JVMFlag::doubleAtPut(JVMFlag* flag, double* value, JVMFlag::Flags origin) { |
1297 JVMFlag::Error JVMFlag::doubleAtPut(JVMFlag* flag, double* value, JVMFlag::Flags origin) { |
1368 const char* name; |
|
1369 if (flag == NULL) return JVMFlag::INVALID_FLAG; |
1298 if (flag == NULL) return JVMFlag::INVALID_FLAG; |
1370 if (!flag->is_double()) return JVMFlag::WRONG_FORMAT; |
1299 if (!flag->is_double()) return JVMFlag::WRONG_FORMAT; |
1371 name = flag->_name; |
1300 JVMFlag::Error check = apply_constraint_and_check_range_double(flag, *value, !JVMFlagConstraintList::validated_after_ergo()); |
1372 JVMFlag::Error check = apply_constraint_and_check_range_double(name, *value, !JVMFlagConstraintList::validated_after_ergo()); |
|
1373 if (check != JVMFlag::SUCCESS) return check; |
1301 if (check != JVMFlag::SUCCESS) return check; |
1374 double old_value = flag->get_double(); |
1302 double old_value = flag->get_double(); |
1375 trace_flag_changed<EventDoubleFlagChanged, double>(name, old_value, *value, origin); |
1303 trace_flag_changed<EventDoubleFlagChanged, double>(flag, old_value, *value, origin); |
1376 check = flag->set_double(*value); |
1304 check = flag->set_double(*value); |
1377 *value = old_value; |
1305 *value = old_value; |
1378 flag->set_origin(origin); |
1306 flag->set_origin(origin); |
1379 return check; |
1307 return check; |
1380 } |
1308 } |
1381 |
1309 |
1382 JVMFlag::Error JVMFlag::doubleAtPut(const char* name, size_t len, double* value, JVMFlag::Flags origin) { |
|
1383 JVMFlag* result = JVMFlag::find_flag(name, len); |
|
1384 return doubleAtPut(result, value, origin); |
|
1385 } |
|
1386 |
|
1387 JVMFlag::Error JVMFlagEx::doubleAtPut(JVMFlagsEnum flag, double value, JVMFlag::Flags origin) { |
1310 JVMFlag::Error JVMFlagEx::doubleAtPut(JVMFlagsEnum flag, double value, JVMFlag::Flags origin) { |
1388 JVMFlag* faddr = address_of_flag(flag); |
1311 JVMFlag* faddr = flag_from_enum(flag); |
1389 guarantee(faddr != NULL && faddr->is_double(), "wrong flag type"); |
1312 guarantee(faddr != NULL && faddr->is_double(), "wrong flag type"); |
1390 return JVMFlag::doubleAtPut(faddr, &value, origin); |
1313 return JVMFlag::doubleAtPut(faddr, &value, origin); |
1391 } |
1314 } |
1392 |
1315 |
1393 JVMFlag::Error JVMFlag::ccstrAt(const char* name, size_t len, ccstr* value, bool allow_locked, bool return_flag) { |
1316 JVMFlag::Error JVMFlag::ccstrAt(const JVMFlag* flag, ccstr* value) { |
1394 JVMFlag* result = JVMFlag::find_flag(name, len, allow_locked, return_flag); |
1317 if (flag == NULL) return JVMFlag::INVALID_FLAG; |
1395 if (result == NULL) return JVMFlag::INVALID_FLAG; |
1318 if (!flag->is_ccstr()) return JVMFlag::WRONG_FORMAT; |
1396 if (!result->is_ccstr()) return JVMFlag::WRONG_FORMAT; |
1319 *value = flag->get_ccstr(); |
1397 *value = result->get_ccstr(); |
|
1398 return JVMFlag::SUCCESS; |
1320 return JVMFlag::SUCCESS; |
1399 } |
1321 } |
1400 |
1322 |
1401 JVMFlag::Error JVMFlag::ccstrAtPut(const char* name, size_t len, ccstr* value, JVMFlag::Flags origin) { |
1323 JVMFlag::Error JVMFlag::ccstrAtPut(JVMFlag* flag, ccstr* value, JVMFlag::Flags origin) { |
1402 JVMFlag* result = JVMFlag::find_flag(name, len); |
1324 if (flag == NULL) return JVMFlag::INVALID_FLAG; |
1403 if (result == NULL) return JVMFlag::INVALID_FLAG; |
1325 if (!flag->is_ccstr()) return JVMFlag::WRONG_FORMAT; |
1404 if (!result->is_ccstr()) return JVMFlag::WRONG_FORMAT; |
1326 ccstr old_value = flag->get_ccstr(); |
1405 ccstr old_value = result->get_ccstr(); |
1327 trace_flag_changed<EventStringFlagChanged, const char*>(flag, old_value, *value, origin); |
1406 trace_flag_changed<EventStringFlagChanged, const char*>(name, old_value, *value, origin); |
|
1407 char* new_value = NULL; |
1328 char* new_value = NULL; |
1408 if (*value != NULL) { |
1329 if (*value != NULL) { |
1409 new_value = os::strdup_check_oom(*value); |
1330 new_value = os::strdup_check_oom(*value); |
1410 } |
1331 } |
1411 JVMFlag::Error check = result->set_ccstr(new_value); |
1332 JVMFlag::Error check = flag->set_ccstr(new_value); |
1412 if (result->is_default() && old_value != NULL) { |
1333 if (flag->is_default() && old_value != NULL) { |
1413 // Prior value is NOT heap allocated, but was a literal constant. |
1334 // Prior value is NOT heap allocated, but was a literal constant. |
1414 old_value = os::strdup_check_oom(old_value); |
1335 old_value = os::strdup_check_oom(old_value); |
1415 } |
1336 } |
1416 *value = old_value; |
1337 *value = old_value; |
1417 result->set_origin(origin); |
1338 flag->set_origin(origin); |
1418 return check; |
1339 return check; |
1419 } |
1340 } |
1420 |
1341 |
1421 JVMFlag::Error JVMFlagEx::ccstrAtPut(JVMFlagsEnum flag, ccstr value, JVMFlag::Flags origin) { |
1342 JVMFlag::Error JVMFlagEx::ccstrAtPut(JVMFlagsEnum flag, ccstr value, JVMFlag::Flags origin) { |
1422 JVMFlag* faddr = address_of_flag(flag); |
1343 JVMFlag* faddr = flag_from_enum(flag); |
1423 guarantee(faddr != NULL && faddr->is_ccstr(), "wrong flag type"); |
1344 guarantee(faddr != NULL && faddr->is_ccstr(), "wrong flag type"); |
1424 ccstr old_value = faddr->get_ccstr(); |
1345 ccstr old_value = faddr->get_ccstr(); |
1425 trace_flag_changed<EventStringFlagChanged, const char*>(faddr->_name, old_value, value, origin); |
1346 trace_flag_changed<EventStringFlagChanged, const char*>(faddr, old_value, value, origin); |
1426 char* new_value = os::strdup_check_oom(value); |
1347 char* new_value = os::strdup_check_oom(value); |
1427 JVMFlag::Error check = faddr->set_ccstr(new_value); |
1348 JVMFlag::Error check = faddr->set_ccstr(new_value); |
1428 if (!faddr->is_default() && old_value != NULL) { |
1349 if (!faddr->is_default() && old_value != NULL) { |
1429 // Prior value is heap allocated so free it. |
1350 // Prior value is heap allocated so free it. |
1430 FREE_C_HEAP_ARRAY(char, old_value); |
1351 FREE_C_HEAP_ARRAY(char, old_value); |