src/hotspot/share/services/writeableFlags.cpp

@@ -25,11 +25,10 @@
 #include "precompiled.hpp"
 #include "classfile/javaClasses.hpp"
 #include "memory/allocation.inline.hpp"
 #include "runtime/arguments.hpp"
 #include "runtime/flags/jvmFlag.hpp"
-#include "runtime/flags/jvmFlagRangeList.hpp"
 #include "runtime/java.hpp"
 #include "runtime/jniHandles.hpp"
 #include "services/writeableFlags.hpp"
 
 #define TEMP_BUF_SIZE 80

@@ -37,16 +36,15 @@
 static void buffer_concat(char* buffer, const char* src) {
   strncat(buffer, src, TEMP_BUF_SIZE - 1 - strlen(buffer));
 }
 
 static void print_flag_error_message_bounds(const JVMFlag* flag, char* buffer) {
-  JVMFlagRange* range = JVMFlagRangeList::find(flag);
-  if (range != NULL) {
+  if (flag->has_range()) {
     buffer_concat(buffer, "must have value in range ");
 
     stringStream stream;
-    range->print(&stream);
+    flag->print_range(&stream);
     const char* range_string = stream.as_string();
     size_t j = strlen(buffer);
     for (size_t i=0; j<TEMP_BUF_SIZE-1; i++) {
       if (range_string[i] == '\0') {
         break;

@@ -62,11 +60,11 @@
 static void print_flag_error_message_if_needed(JVMFlag::Error error, const JVMFlag* flag, FormatBuffer<80>& err_msg) {
   if (error == JVMFlag::SUCCESS) {
     return;
   }
 
-  const char* name = flag->_name;
+  const char* name = flag->name();
   char buffer[TEMP_BUF_SIZE] = {'\0'};
   if ((error != JVMFlag::MISSING_NAME) && (name != NULL)) {
     buffer_concat(buffer, name);
     buffer_concat(buffer, " error: ");
   } else {

@@ -94,10 +92,12 @@
   }
 
   err_msg.print("%s", buffer);
 }
 
+// TODO: templatize all of the following set_xxx_flag functions!
+
 // set a boolean global flag
 JVMFlag::Error WriteableFlags::set_bool_flag(const char* name, const char* arg, JVMFlag::Flags 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,11 +107,11 @@
   return JVMFlag::WRONG_FORMAT;
 }
 
 JVMFlag::Error WriteableFlags::set_bool_flag(const char* name, bool value, JVMFlag::Flags origin, FormatBuffer<80>& err_msg) {
   JVMFlag* flag = JVMFlag::find_flag(name);
-  JVMFlag::Error err = JVMFlag::boolAtPut(flag, &value, origin);
+  JVMFlag::Error err = JVMFlag::boolAtPut(flag, value, origin);
   print_flag_error_message_if_needed(err, flag, err_msg);
   return err;
 }
 
 // set a int global flag

@@ -125,11 +125,11 @@
   return JVMFlag::WRONG_FORMAT;
 }
 
 JVMFlag::Error WriteableFlags::set_int_flag(const char* name, int value, JVMFlag::Flags origin, FormatBuffer<80>& err_msg) {
   JVMFlag* flag = JVMFlag::find_flag(name);
-  JVMFlag::Error err = JVMFlag::intAtPut(flag, &value, origin);
+  JVMFlag::Error err = JVMFlag::intAtPut(flag, value, origin);
   print_flag_error_message_if_needed(err, flag, err_msg);
   return err;
 }
 
 // set a uint global flag

@@ -143,11 +143,11 @@
   return JVMFlag::WRONG_FORMAT;
 }
 
 JVMFlag::Error WriteableFlags::set_uint_flag(const char* name, uint value, JVMFlag::Flags origin, FormatBuffer<80>& err_msg) {
   JVMFlag* flag = JVMFlag::find_flag(name);
-  JVMFlag::Error err = JVMFlag::uintAtPut(flag, &value, origin);
+  JVMFlag::Error err = JVMFlag::uintAtPut(flag, value, origin);
   print_flag_error_message_if_needed(err, flag, err_msg);
   return err;
 }
 
 // set a intx global flag

@@ -161,11 +161,11 @@
   return JVMFlag::WRONG_FORMAT;
 }
 
 JVMFlag::Error WriteableFlags::set_intx_flag(const char* name, intx value, JVMFlag::Flags origin, FormatBuffer<80>& err_msg) {
   JVMFlag* flag = JVMFlag::find_flag(name);
-  JVMFlag::Error err = JVMFlag::intxAtPut(flag, &value, origin);
+  JVMFlag::Error err = JVMFlag::intxAtPut(flag, value, origin);
   print_flag_error_message_if_needed(err, flag, err_msg);
   return err;
 }
 
 // set a uintx global flag

@@ -179,11 +179,11 @@
   return JVMFlag::WRONG_FORMAT;
 }
 
 JVMFlag::Error WriteableFlags::set_uintx_flag(const char* name, uintx value, JVMFlag::Flags origin, FormatBuffer<80>& err_msg) {
   JVMFlag* flag = JVMFlag::find_flag(name);
-  JVMFlag::Error err = JVMFlag::uintxAtPut(flag, &value, origin);
+  JVMFlag::Error err = JVMFlag::uintxAtPut(flag, value, origin);
   print_flag_error_message_if_needed(err, flag, err_msg);
   return err;
 }
 
 // set a uint64_t global flag

@@ -197,11 +197,11 @@
   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* flag = JVMFlag::find_flag(name);
-  JVMFlag::Error err = JVMFlag::uint64_tAtPut(flag, &value, origin);
+  JVMFlag::Error err = JVMFlag::uint64_tAtPut(flag, value, origin);
   print_flag_error_message_if_needed(err, flag, err_msg);
   return err;
 }
 
 // set a size_t global flag

@@ -215,11 +215,11 @@
   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* flag = JVMFlag::find_flag(name);
-  JVMFlag::Error err = JVMFlag::size_tAtPut(flag, &value, origin);
+  JVMFlag::Error err = JVMFlag::size_tAtPut(flag, value, origin);
   print_flag_error_message_if_needed(err, flag, err_msg);
   return err;
 }
 
 // set a double global flag

@@ -233,19 +233,19 @@
   return JVMFlag::WRONG_FORMAT;
 }
 
 JVMFlag::Error WriteableFlags::set_double_flag(const char* name, double value, JVMFlag::Flags origin, FormatBuffer<80>& err_msg) {
   JVMFlag* flag = JVMFlag::find_flag(name);
-  JVMFlag::Error err = JVMFlag::doubleAtPut(flag, &value, origin);
+  JVMFlag::Error err = JVMFlag::doubleAtPut(flag, value, origin);
   print_flag_error_message_if_needed(err, flag, err_msg);
   return err;
 }
 
 // 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* flag = JVMFlag::find_flag(name);
-  JVMFlag::Error err = JVMFlag::ccstrAtPut(flag, &value, origin);
+  JVMFlag::Error err = JVMFlag::ccstrAtPut(flag, &value, origin); // TODO -- free the old value??
   print_flag_error_message_if_needed(err, flag, err_msg);
   return err;
 }
 
 /* sets a writeable flag to the provided value

@@ -298,27 +298,27 @@
   if (flag_value == NULL) {
     err_msg.print("flag value is missing");
     return JVMFlag::MISSING_VALUE;
   }
   if (f->is_bool()) {
-    return set_bool_flag(f->_name, flag_value, origin, err_msg);
+    return set_bool_flag(f->name(), flag_value, origin, err_msg);
   } else if (f->is_int()) {
-    return set_int_flag(f->_name, flag_value, origin, err_msg);
+    return set_int_flag(f->name(), flag_value, origin, err_msg);
   } else if (f->is_uint()) {
-    return set_uint_flag(f->_name, flag_value, origin, err_msg);
+    return set_uint_flag(f->name(), flag_value, origin, err_msg);
   } else if (f->is_intx()) {
-    return set_intx_flag(f->_name, flag_value, origin, err_msg);
+    return set_intx_flag(f->name(), flag_value, origin, err_msg);
   } else if (f->is_uintx()) {
-    return set_uintx_flag(f->_name, flag_value, origin, err_msg);
+    return set_uintx_flag(f->name(), flag_value, origin, err_msg);
   } else if (f->is_uint64_t()) {
-    return set_uint64_t_flag(f->_name, flag_value, origin, err_msg);
+    return set_uint64_t_flag(f->name(), flag_value, origin, err_msg);
   } else if (f->is_size_t()) {
-    return set_size_t_flag(f->_name, flag_value, origin, err_msg);
+    return set_size_t_flag(f->name(), flag_value, origin, err_msg);
   } else if (f->is_double()) {
-    return set_double_flag(f->_name, flag_value, origin, err_msg);
+    return set_double_flag(f->name(), flag_value, origin, err_msg);
   } else if (f->is_ccstr()) {
-    return set_ccstr_flag(f->_name, flag_value, origin, err_msg);
+    return set_ccstr_flag(f->name(), flag_value, origin, err_msg);
   } else {
     ShouldNotReachHere();
   }
   return JVMFlag::ERR_OTHER;
 }

@@ -327,40 +327,40 @@
 JVMFlag::Error WriteableFlags::set_flag_from_jvalue(JVMFlag* f, const void* value, JVMFlag::Flags origin,
                                                  FormatBuffer<80>& err_msg) {
   jvalue new_value = *(jvalue*)value;
   if (f->is_bool()) {
     bool bvalue = (new_value.z == JNI_TRUE ? true : false);
-    return set_bool_flag(f->_name, bvalue, origin, err_msg);
+    return set_bool_flag(f->name(), bvalue, origin, err_msg);
   } else if (f->is_int()) {
     int ivalue = (int)new_value.j;
-    return set_int_flag(f->_name, ivalue, origin, err_msg);
+    return set_int_flag(f->name(), ivalue, origin, err_msg);
   } else if (f->is_uint()) {
     uint uvalue = (uint)new_value.j;
-    return set_uint_flag(f->_name, uvalue, origin, err_msg);
+    return set_uint_flag(f->name(), uvalue, origin, err_msg);
   } else if (f->is_intx()) {
     intx ivalue = (intx)new_value.j;
-    return set_intx_flag(f->_name, ivalue, origin, err_msg);
+    return set_intx_flag(f->name(), ivalue, origin, err_msg);
   } else if (f->is_uintx()) {
     uintx uvalue = (uintx)new_value.j;
-    return set_uintx_flag(f->_name, uvalue, origin, err_msg);
+    return set_uintx_flag(f->name(), uvalue, origin, err_msg);
   } else if (f->is_uint64_t()) {
     uint64_t uvalue = (uint64_t)new_value.j;
-    return set_uint64_t_flag(f->_name, uvalue, origin, err_msg);
+    return set_uint64_t_flag(f->name(), uvalue, origin, err_msg);
   } else if (f->is_size_t()) {
     size_t svalue = (size_t)new_value.j;
-    return set_size_t_flag(f->_name, svalue, origin, err_msg);
+    return set_size_t_flag(f->name(), svalue, origin, err_msg);
   } else if (f->is_double()) {
     double dvalue = (double)new_value.d;
-    return set_double_flag(f->_name, dvalue, origin, err_msg);
+    return set_double_flag(f->name(), dvalue, origin, err_msg);
   } else if (f->is_ccstr()) {
     oop str = JNIHandles::resolve_external_guard(new_value.l);
     if (str == NULL) {
       err_msg.print("flag value is missing");
       return JVMFlag::MISSING_VALUE;
     }
     ccstr svalue = java_lang_String::as_utf8_string(str);
-    JVMFlag::Error ret = WriteableFlags::set_ccstr_flag(f->_name, svalue, origin, err_msg);
+    JVMFlag::Error ret = WriteableFlags::set_ccstr_flag(f->name(), svalue, origin, err_msg);
     if (ret != JVMFlag::SUCCESS) {
       FREE_C_HEAP_ARRAY(char, svalue);
     }
     return ret;
   } else {