8255285: Move JVMFlag origins into a new enum JVMFlagOrigin

Reviewed-by: dholmes, redestad

Author: iklam

src/hotspot/share/jfr/periodic/jfrPeriodic.cpp

@@ -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();                                         \
         }                                                         \
       }                                                           \

src/hotspot/share/jfr/recorder/checkpoint/types/jfrType.cpp

@@ -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));
   }
 }
 

src/hotspot/share/jvmci/jvmciCompilerToVMInit.cpp

@@ -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"
 

src/hotspot/share/jvmci/jvmci_globals.cpp

@@ -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",

src/hotspot/share/jvmci/jvmci_globals.hpp

@@ -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();

src/hotspot/share/jvmci/vmStructs_jvmci.cpp

@@ -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"

src/hotspot/share/prims/whitebox.cpp

@@ -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);
 }

src/hotspot/share/runtime/arguments.cpp

@@ -877,15 +877,15 @@ 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 {
     return false;
   }
 }
 
-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;
 

src/hotspot/share/runtime/arguments.hpp

@@ -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);
 

src/hotspot/share/runtime/flags/jvmFlag.cpp

@@ -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(" ");
     }