8202150: [REDO] Split globals.hpp to factor out the Flag class

Summary: Factored out Flag out go globals, renamed to JVMFlag
Reviewed-by: coleenp, dholmes, kvn

Author: gziemski

src/hotspot/cpu/aarch64/methodHandles_aarch64.cpp

@@ -30,6 +30,7 @@
 #include "interpreter/interpreterRuntime.hpp"
 #include "memory/allocation.inline.hpp"
 #include "prims/methodHandles.hpp"
+#include "runtime/flags/flagSetting.hpp"
 #include "runtime/frame.inline.hpp"
 
 #define __ _masm->

src/hotspot/cpu/sparc/macroAssembler_sparc.cpp

@@ -35,6 +35,7 @@
 #include "oops/klass.inline.hpp"
 #include "prims/methodHandles.hpp"
 #include "runtime/biasedLocking.hpp"
+#include "runtime/flags/flagSetting.hpp"
 #include "runtime/interfaceSupport.inline.hpp"
 #include "runtime/jniHandles.inline.hpp"
 #include "runtime/objectMonitor.hpp"

src/hotspot/cpu/sparc/methodHandles_sparc.cpp

@@ -31,6 +31,7 @@
 #include "memory/allocation.inline.hpp"
 #include "memory/resourceArea.hpp"
 #include "prims/methodHandles.hpp"
+#include "runtime/flags/flagSetting.hpp"
 #include "runtime/frame.inline.hpp"
 #include "utilities/preserveException.hpp"
 

src/hotspot/cpu/x86/macroAssembler_x86.cpp

@@ -37,6 +37,7 @@
 #include "oops/klass.inline.hpp"
 #include "prims/methodHandles.hpp"
 #include "runtime/biasedLocking.hpp"
+#include "runtime/flags/flagSetting.hpp"
 #include "runtime/interfaceSupport.inline.hpp"
 #include "runtime/objectMonitor.hpp"
 #include "runtime/os.hpp"

src/hotspot/cpu/x86/methodHandles_x86.cpp

@@ -31,6 +31,7 @@
 #include "memory/allocation.inline.hpp"
 #include "memory/resourceArea.hpp"
 #include "prims/methodHandles.hpp"
+#include "runtime/flags/flagSetting.hpp"
 #include "runtime/frame.inline.hpp"
 #include "utilities/preserveException.hpp"
 

src/hotspot/share/code/dependencies.cpp

@@ -35,6 +35,7 @@
 #include "memory/resourceArea.hpp"
 #include "oops/oop.inline.hpp"
 #include "oops/objArrayKlass.hpp"
+#include "runtime/flags/flagSetting.hpp"
 #include "runtime/handles.hpp"
 #include "runtime/handles.inline.hpp"
 #include "runtime/jniHandles.inline.hpp"

src/hotspot/share/code/nmethod.cpp

@@ -47,6 +47,7 @@
 #include "oops/oop.inline.hpp"
 #include "prims/jvmtiImpl.hpp"
 #include "runtime/atomic.hpp"
+#include "runtime/flags/flagSetting.hpp"
 #include "runtime/frame.inline.hpp"
 #include "runtime/handles.inline.hpp"
 #include "runtime/jniHandles.inline.hpp"

src/hotspot/share/code/relocInfo.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 2017, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 2018, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -29,6 +29,7 @@
 #include "code/relocInfo.hpp"
 #include "memory/resourceArea.hpp"
 #include "oops/compressedOops.inline.hpp"
+#include "runtime/flags/flagSetting.hpp"
 #include "runtime/stubCodeGenerator.hpp"
 #include "utilities/copy.hpp"
 #include "oops/oop.inline.hpp"

src/hotspot/share/gc/cms/concurrentMarkSweepGeneration.cpp

@@ -68,6 +68,7 @@
 #include "oops/oop.inline.hpp"
 #include "prims/jvmtiExport.hpp"
 #include "runtime/atomic.hpp"
+#include "runtime/flags/flagSetting.hpp"
 #include "runtime/globals_extension.hpp"
 #include "runtime/handles.inline.hpp"
 #include "runtime/java.hpp"

…gc/cms/commandLineFlagConstraintsCMS.cpp …t/share/gc/cms/jvmFlagConstraintsCMS.cppsrc/hotspot/share/gc/cms/commandLineFlagConstraintsCMS.cpp renamed to src/hotspot/share/gc/cms/jvmFlagConstraintsCMS.cpp src/hotspot/share/gc/cms/commandLineFlagConstraintsCMS.cpp renamed to src/hotspot/share/gc/cms/jvmFlagConstraintsCMS.cpp

@@ -23,52 +23,52 @@
  */
 
 #include "precompiled.hpp"
-#include "gc/cms/commandLineFlagConstraintsCMS.hpp"
+#include "gc/cms/jvmFlagConstraintsCMS.hpp"
 #include "gc/cms/concurrentMarkSweepGeneration.inline.hpp"
 #include "gc/shared/cardTableRS.hpp"
 #include "gc/shared/collectedHeap.hpp"
 #include "gc/shared/genCollectedHeap.hpp"
-#include "gc/shared/commandLineFlagConstraintsGC.hpp"
+#include "gc/shared/jvmFlagConstraintsGC.hpp"
 #include "memory/universe.hpp"
-#include "runtime/commandLineFlagRangeList.hpp"
+#include "runtime/flags/jvmFlagRangeList.hpp"
 #include "runtime/globals_extension.hpp"
 #include "utilities/globalDefinitions.hpp"
 
-static Flag::Error ParallelGCThreadsAndCMSWorkQueueDrainThreshold(uint threads, uintx threshold, bool verbose) {
+static JVMFlag::Error ParallelGCThreadsAndCMSWorkQueueDrainThreshold(uint threads, uintx threshold, bool verbose) {
   // CMSWorkQueueDrainThreshold is verified to be less than max_juint
   if (UseConcMarkSweepGC && (threads > (uint)(max_jint / (uint)threshold))) {
     CommandLineError::print(verbose,
                             "ParallelGCThreads (" UINT32_FORMAT ") or CMSWorkQueueDrainThreshold ("
                             UINTX_FORMAT ") is too large\n",
                             threads, threshold);
-    return Flag::VIOLATES_CONSTRAINT;
+    return JVMFlag::VIOLATES_CONSTRAINT;
   }
-  return Flag::SUCCESS;
+  return JVMFlag::SUCCESS;
 }
 
-Flag::Error ParallelGCThreadsConstraintFuncCMS(uint value, bool verbose) {
+JVMFlag::Error ParallelGCThreadsConstraintFuncCMS(uint value, bool verbose) {
   // To avoid overflow at ParScanClosure::do_oop_work.
   if (UseConcMarkSweepGC && (value > (max_jint / 10))) {
     CommandLineError::print(verbose,
                             "ParallelGCThreads (" UINT32_FORMAT ") must be "
                             "less than or equal to " UINT32_FORMAT " for CMS GC\n",
                             value, (max_jint / 10));
-    return Flag::VIOLATES_CONSTRAINT;
+    return JVMFlag::VIOLATES_CONSTRAINT;
   }
   return ParallelGCThreadsAndCMSWorkQueueDrainThreshold(value, CMSWorkQueueDrainThreshold, verbose);
 }
-Flag::Error ParGCStridesPerThreadConstraintFunc(uintx value, bool verbose) {
+JVMFlag::Error ParGCStridesPerThreadConstraintFunc(uintx value, bool verbose) {
   if (UseConcMarkSweepGC && (value > ((uintx)max_jint / (uintx)ParallelGCThreads))) {
     CommandLineError::print(verbose,
                             "ParGCStridesPerThread (" UINTX_FORMAT ") must be "
                             "less than or equal to ergonomic maximum (" UINTX_FORMAT ")\n",
                             value, ((uintx)max_jint / (uintx)ParallelGCThreads));
-    return Flag::VIOLATES_CONSTRAINT;
+    return JVMFlag::VIOLATES_CONSTRAINT;
   }
-  return Flag::SUCCESS;
+  return JVMFlag::SUCCESS;
 }
 
-Flag::Error ParGCCardsPerStrideChunkConstraintFunc(intx value, bool verbose) {
+JVMFlag::Error ParGCCardsPerStrideChunkConstraintFunc(intx value, bool verbose) {
   if (UseConcMarkSweepGC) {
     // ParGCCardsPerStrideChunk should be compared with card table size.
     size_t heap_size = Universe::heap()->reserved_region().word_size();
@@ -80,7 +80,7 @@ Flag::Error ParGCCardsPerStrideChunkConstraintFunc(intx value, bool verbose) {
                               "ParGCCardsPerStrideChunk (" INTX_FORMAT ") is too large for the heap size and "
                               "must be less than or equal to card table size (" SIZE_FORMAT ")\n",
                               value, card_table_size);
-      return Flag::VIOLATES_CONSTRAINT;
+      return JVMFlag::VIOLATES_CONSTRAINT;
     }
 
     // ParGCCardsPerStrideChunk is used with n_strides(ParallelGCThreads*ParGCStridesPerThread)
@@ -93,38 +93,38 @@ Flag::Error ParGCCardsPerStrideChunkConstraintFunc(intx value, bool verbose) {
                               "ParGCCardsPerStrideChunk (" INTX_FORMAT ") must be "
                               "less than or equal to ergonomic maximum (" UINTX_FORMAT ")\n",
                               value, ergo_max);
-      return Flag::VIOLATES_CONSTRAINT;
+      return JVMFlag::VIOLATES_CONSTRAINT;
     }
   }
-  return Flag::SUCCESS;
+  return JVMFlag::SUCCESS;
 }
 
-Flag::Error CMSOldPLABMinConstraintFunc(size_t value, bool verbose) {
-  Flag::Error status = Flag::SUCCESS;
+JVMFlag::Error CMSOldPLABMinConstraintFunc(size_t value, bool verbose) {
+  JVMFlag::Error status = JVMFlag::SUCCESS;
 
   if (UseConcMarkSweepGC) {
     if (value > CMSOldPLABMax) {
       CommandLineError::print(verbose,
                               "CMSOldPLABMin (" SIZE_FORMAT ") must be "
                               "less than or equal to CMSOldPLABMax (" SIZE_FORMAT ")\n",
                               value, CMSOldPLABMax);
-      return Flag::VIOLATES_CONSTRAINT;
+      return JVMFlag::VIOLATES_CONSTRAINT;
     }
     status = MaxPLABSizeBounds("CMSOldPLABMin", value, verbose);
   }
   return status;
 }
 
-Flag::Error CMSOldPLABMaxConstraintFunc(size_t value, bool verbose) {
-  Flag::Error status = Flag::SUCCESS;
+JVMFlag::Error CMSOldPLABMaxConstraintFunc(size_t value, bool verbose) {
+  JVMFlag::Error status = JVMFlag::SUCCESS;
 
   if (UseConcMarkSweepGC) {
     status = MaxPLABSizeBounds("CMSOldPLABMax", value, verbose);
   }
   return status;
 }
 
-static Flag::Error CMSReservedAreaConstraintFunc(const char* name, size_t value, bool verbose) {
+static JVMFlag::Error CMSReservedAreaConstraintFunc(const char* name, size_t value, bool verbose) {
   if (UseConcMarkSweepGC) {
     ConcurrentMarkSweepGeneration* cms = (ConcurrentMarkSweepGeneration*)GenCollectedHeap::heap()->old_gen();
     const size_t ergo_max = cms->cmsSpace()->max_flag_size_for_task_size();
@@ -134,17 +134,17 @@ static Flag::Error CMSReservedAreaConstraintFunc(const char* name, size_t value,
                               "less than or equal to ergonomic maximum (" SIZE_FORMAT ") "
                               "which is based on the maximum size of the old generation of the Java heap\n",
                               name, value, ergo_max);
-      return Flag::VIOLATES_CONSTRAINT;
+      return JVMFlag::VIOLATES_CONSTRAINT;
     }
   }
 
-  return Flag::SUCCESS;
+  return JVMFlag::SUCCESS;
 }
 
-Flag::Error CMSRescanMultipleConstraintFunc(size_t value, bool verbose) {
-  Flag::Error status = CMSReservedAreaConstraintFunc("CMSRescanMultiple", value, verbose);
+JVMFlag::Error CMSRescanMultipleConstraintFunc(size_t value, bool verbose) {
+  JVMFlag::Error status = CMSReservedAreaConstraintFunc("CMSRescanMultiple", value, verbose);
 
-  if (status == Flag::SUCCESS && UseConcMarkSweepGC) {
+  if (status == JVMFlag::SUCCESS && UseConcMarkSweepGC) {
     // CMSParRemarkTask::do_dirty_card_rescan_tasks requires CompactibleFreeListSpace::rescan_task_size()
     // to be aligned to CardTable::card_size * BitsPerWord.
     // Note that rescan_task_size() will be aligned if CMSRescanMultiple is a multiple of 'HeapWordSize'
@@ -154,61 +154,61 @@ Flag::Error CMSRescanMultipleConstraintFunc(size_t value, bool verbose) {
                               "CMSRescanMultiple (" SIZE_FORMAT ") must be "
                               "a multiple of " SIZE_FORMAT "\n",
                               value, HeapWordSize);
-      status = Flag::VIOLATES_CONSTRAINT;
+      status = JVMFlag::VIOLATES_CONSTRAINT;
     }
   }
 
   return status;
 }
 
-Flag::Error CMSConcMarkMultipleConstraintFunc(size_t value, bool verbose) {
+JVMFlag::Error CMSConcMarkMultipleConstraintFunc(size_t value, bool verbose) {
   return CMSReservedAreaConstraintFunc("CMSConcMarkMultiple", value, verbose);
 }
 
-Flag::Error CMSPrecleanDenominatorConstraintFunc(uintx value, bool verbose) {
+JVMFlag::Error CMSPrecleanDenominatorConstraintFunc(uintx value, bool verbose) {
   if (UseConcMarkSweepGC && (value <= CMSPrecleanNumerator)) {
     CommandLineError::print(verbose,
                             "CMSPrecleanDenominator (" UINTX_FORMAT ") must be "
                             "strickly greater than CMSPrecleanNumerator (" UINTX_FORMAT ")\n",
                             value, CMSPrecleanNumerator);
-    return Flag::VIOLATES_CONSTRAINT;
+    return JVMFlag::VIOLATES_CONSTRAINT;
   }
-  return Flag::SUCCESS;
+  return JVMFlag::SUCCESS;
 }
 
-Flag::Error CMSPrecleanNumeratorConstraintFunc(uintx value, bool verbose) {
+JVMFlag::Error CMSPrecleanNumeratorConstraintFunc(uintx value, bool verbose) {
   if (UseConcMarkSweepGC && (value >= CMSPrecleanDenominator)) {
     CommandLineError::print(verbose,
                             "CMSPrecleanNumerator (" UINTX_FORMAT ") must be "
                             "less than CMSPrecleanDenominator (" UINTX_FORMAT ")\n",
                             value, CMSPrecleanDenominator);
-    return Flag::VIOLATES_CONSTRAINT;
+    return JVMFlag::VIOLATES_CONSTRAINT;
   }
-  return Flag::SUCCESS;
+  return JVMFlag::SUCCESS;
 }
 
-Flag::Error CMSSamplingGrainConstraintFunc(uintx value, bool verbose) {
+JVMFlag::Error CMSSamplingGrainConstraintFunc(uintx value, bool verbose) {
   if (UseConcMarkSweepGC) {
     size_t max_capacity = GenCollectedHeap::heap()->young_gen()->max_capacity();
     if (value > max_uintx - max_capacity) {
     CommandLineError::print(verbose,
                             "CMSSamplingGrain (" UINTX_FORMAT ") must be "
                             "less than or equal to ergonomic maximum (" SIZE_FORMAT ")\n",
                             value, max_uintx - max_capacity);
-    return Flag::VIOLATES_CONSTRAINT;
+    return JVMFlag::VIOLATES_CONSTRAINT;
     }
   }
-  return Flag::SUCCESS;
+  return JVMFlag::SUCCESS;
 }
 
-Flag::Error CMSWorkQueueDrainThresholdConstraintFunc(uintx value, bool verbose) {
+JVMFlag::Error CMSWorkQueueDrainThresholdConstraintFunc(uintx value, bool verbose) {
   if (UseConcMarkSweepGC) {
     return ParallelGCThreadsAndCMSWorkQueueDrainThreshold(ParallelGCThreads, value, verbose);
   }
-  return Flag::SUCCESS;
+  return JVMFlag::SUCCESS;
 }
 
-Flag::Error CMSBitMapYieldQuantumConstraintFunc(size_t value, bool verbose) {
+JVMFlag::Error CMSBitMapYieldQuantumConstraintFunc(size_t value, bool verbose) {
   // Skip for current default value.
   if (UseConcMarkSweepGC && FLAG_IS_CMDLINE(CMSBitMapYieldQuantum)) {
     // CMSBitMapYieldQuantum should be compared with mark bitmap size.
@@ -221,18 +221,18 @@ Flag::Error CMSBitMapYieldQuantumConstraintFunc(size_t value, bool verbose) {
                               "be less than or equal to bitmap size (" SIZE_FORMAT ") "
                               "whose size corresponds to the size of old generation of the Java heap\n",
                               value, bitmap_size);
-      return Flag::VIOLATES_CONSTRAINT;
+      return JVMFlag::VIOLATES_CONSTRAINT;
     }
   }
-  return Flag::SUCCESS;
+  return JVMFlag::SUCCESS;
 }
 
-Flag::Error OldPLABSizeConstraintFuncCMS(size_t value, bool verbose) {
+JVMFlag::Error OldPLABSizeConstraintFuncCMS(size_t value, bool verbose) {
   if (value == 0) {
     CommandLineError::print(verbose,
                             "OldPLABSize (" SIZE_FORMAT ") must be greater than 0",
                             value);
-    return Flag::VIOLATES_CONSTRAINT;
+    return JVMFlag::VIOLATES_CONSTRAINT;
   }
   // For CMS, OldPLABSize is the number of free blocks of a given size that are used when
   // replenishing the local per-worker free list caches.