changeset 49618:947560700a09

8201136: Move GC flags from globals.hpp to GC specific files Reviewed-by: sjohanss, shade, rehn
author stefank
date Fri, 06 Apr 2018 13:55:25 +0200
parents 86a349234225
children 450d709262c1
files src/hotspot/share/gc/cms/cms_globals.hpp src/hotspot/share/gc/g1/g1_globals.cpp src/hotspot/share/gc/g1/g1_globals.hpp src/hotspot/share/gc/parallel/parallel_globals.hpp src/hotspot/share/gc/serial/serial_globals.hpp src/hotspot/share/gc/shared/gc_globals.hpp src/hotspot/share/runtime/commandLineFlagConstraintList.cpp src/hotspot/share/runtime/commandLineFlagRangeList.cpp src/hotspot/share/runtime/commandLineFlagWriteableList.cpp src/hotspot/share/runtime/globals.cpp src/hotspot/share/runtime/globals.hpp src/hotspot/share/runtime/globals_extension.hpp
diffstat 12 files changed, 1504 insertions(+), 1373 deletions(-) [+]
line wrap: on
line diff
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/hotspot/share/gc/cms/cms_globals.hpp	Fri Apr 06 13:55:25 2018 +0200
@@ -0,0 +1,429 @@
+/*
+ * 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ *
+ */
+
+#ifndef SHARE_GC_CMS_CMS_GLOBALS_HPP
+#define SHARE_GC_CMS_CMS_GLOBALS_HPP
+
+#define GC_CMS_FLAGS(develop,                                               \
+                     develop_pd,                                            \
+                     product,                                               \
+                     product_pd,                                            \
+                     diagnostic,                                            \
+                     diagnostic_pd,                                         \
+                     experimental,                                          \
+                     notproduct,                                            \
+                     manageable,                                            \
+                     product_rw,                                            \
+                     lp64_product,                                          \
+                     range,                                                 \
+                     constraint,                                            \
+                     writeable)                                             \
+  product(bool, UseCMSBestFit, true,                                        \
+          "Use CMS best fit allocation strategy")                           \
+                                                                            \
+  product(size_t, CMSOldPLABMax, 1024,                                      \
+          "Maximum size of CMS gen promotion LAB caches per worker "        \
+          "per block size")                                                 \
+          range(1, max_uintx)                                               \
+          constraint(CMSOldPLABMaxConstraintFunc,AfterMemoryInit)           \
+                                                                            \
+  product(size_t, CMSOldPLABMin, 16,                                        \
+          "Minimum size of CMS gen promotion LAB caches per worker "        \
+          "per block size")                                                 \
+          range(1, max_uintx)                                               \
+          constraint(CMSOldPLABMinConstraintFunc,AfterMemoryInit)           \
+                                                                            \
+  product(uintx, CMSOldPLABNumRefills, 4,                                   \
+          "Nominal number of refills of CMS gen promotion LAB cache "       \
+          "per worker per block size")                                      \
+          range(1, max_uintx)                                               \
+                                                                            \
+  product(bool, CMSOldPLABResizeQuicker, false,                             \
+          "React on-the-fly during a scavenge to a sudden "                 \
+          "change in block demand rate")                                    \
+                                                                            \
+  product(uintx, CMSOldPLABToleranceFactor, 4,                              \
+          "The tolerance of the phase-change detector for on-the-fly "      \
+          "PLAB resizing during a scavenge")                                \
+          range(1, max_uintx)                                               \
+                                                                            \
+  product(uintx, CMSOldPLABReactivityFactor, 2,                             \
+          "The gain in the feedback loop for on-the-fly PLAB resizing "     \
+          "during a scavenge")                                              \
+          range(1, max_uintx)                                               \
+                                                                            \
+  product_pd(size_t, CMSYoungGenPerWorker,                                  \
+          "The maximum size of young gen chosen by default per GC worker "  \
+          "thread available")                                               \
+          range(1, max_uintx)                                               \
+                                                                            \
+  product(uintx, CMSIncrementalSafetyFactor, 10,                            \
+          "Percentage (0-100) used to add conservatism when computing the " \
+          "duty cycle")                                                     \
+          range(0, 100)                                                     \
+                                                                            \
+  product(uintx, CMSExpAvgFactor, 50,                                       \
+          "Percentage (0-100) used to weight the current sample when "      \
+          "computing exponential averages for CMS statistics")              \
+          range(0, 100)                                                     \
+                                                                            \
+  product(uintx, CMS_FLSWeight, 75,                                         \
+          "Percentage (0-100) used to weight the current sample when "      \
+          "computing exponentially decaying averages for CMS FLS "          \
+          "statistics")                                                     \
+          range(0, 100)                                                     \
+                                                                            \
+  product(uintx, CMS_FLSPadding, 1,                                         \
+          "The multiple of deviation from mean to use for buffering "       \
+          "against volatility in free list demand")                         \
+          range(0, max_juint)                                               \
+                                                                            \
+  product(uintx, FLSCoalescePolicy, 2,                                      \
+          "CMS: aggressiveness level for coalescing, increasing "           \
+          "from 0 to 4")                                                    \
+          range(0, 4)                                                       \
+                                                                            \
+  product(bool, FLSAlwaysCoalesceLarge, false,                              \
+          "CMS: larger free blocks are always available for coalescing")    \
+                                                                            \
+  product(double, FLSLargestBlockCoalesceProximity, 0.99,                   \
+          "CMS: the smaller the percentage the greater the coalescing "     \
+          "force")                                                          \
+          range(0.0, 1.0)                                                   \
+                                                                            \
+  product(double, CMSSmallCoalSurplusPercent, 1.05,                         \
+          "CMS: the factor by which to inflate estimated demand of small "  \
+          "block sizes to prevent coalescing with an adjoining block")      \
+          range(0.0, DBL_MAX)                                               \
+                                                                            \
+  product(double, CMSLargeCoalSurplusPercent, 0.95,                         \
+          "CMS: the factor by which to inflate estimated demand of large "  \
+          "block sizes to prevent coalescing with an adjoining block")      \
+          range(0.0, DBL_MAX)                                               \
+                                                                            \
+  product(double, CMSSmallSplitSurplusPercent, 1.10,                        \
+          "CMS: the factor by which to inflate estimated demand of small "  \
+          "block sizes to prevent splitting to supply demand for smaller "  \
+          "blocks")                                                         \
+          range(0.0, DBL_MAX)                                               \
+                                                                            \
+  product(double, CMSLargeSplitSurplusPercent, 1.00,                        \
+          "CMS: the factor by which to inflate estimated demand of large "  \
+          "block sizes to prevent splitting to supply demand for smaller "  \
+          "blocks")                                                         \
+          range(0.0, DBL_MAX)                                               \
+                                                                            \
+  product(bool, CMSExtrapolateSweep, false,                                 \
+          "CMS: cushion for block demand during sweep")                     \
+                                                                            \
+  product(uintx, CMS_SweepWeight, 75,                                       \
+          "Percentage (0-100) used to weight the current sample when "      \
+          "computing exponentially decaying average for inter-sweep "       \
+          "duration")                                                       \
+          range(0, 100)                                                     \
+                                                                            \
+  product(uintx, CMS_SweepPadding, 1,                                       \
+          "The multiple of deviation from mean to use for buffering "       \
+          "against volatility in inter-sweep duration")                     \
+          range(0, max_juint)                                               \
+                                                                            \
+  product(uintx, CMS_SweepTimerThresholdMillis, 10,                         \
+          "Skip block flux-rate sampling for an epoch unless inter-sweep "  \
+          "duration exceeds this threshold in milliseconds")                \
+          range(0, max_uintx)                                               \
+                                                                            \
+  product(bool, CMSClassUnloadingEnabled, true,                             \
+          "Whether class unloading enabled when using CMS GC")              \
+                                                                            \
+  product(uintx, CMSClassUnloadingMaxInterval, 0,                           \
+          "When CMS class unloading is enabled, the maximum CMS cycle "     \
+          "count for which classes may not be unloaded")                    \
+          range(0, max_uintx)                                               \
+                                                                            \
+  product(uintx, CMSIndexedFreeListReplenish, 4,                            \
+          "Replenish an indexed free list with this number of chunks")      \
+          range(1, max_uintx)                                               \
+                                                                            \
+  product(bool, CMSReplenishIntermediate, true,                             \
+          "Replenish all intermediate free-list caches")                    \
+                                                                            \
+  product(bool, CMSSplitIndexedFreeListBlocks, true,                        \
+          "When satisfying batched demand, split blocks from the "          \
+          "IndexedFreeList whose size is a multiple of requested size")     \
+                                                                            \
+  product(bool, CMSLoopWarn, false,                                         \
+          "Warn in case of excessive CMS looping")                          \
+                                                                            \
+  notproduct(bool, CMSMarkStackOverflowALot, false,                         \
+          "Simulate frequent marking stack / work queue overflow")          \
+                                                                            \
+  notproduct(uintx, CMSMarkStackOverflowInterval, 1000,                     \
+          "An \"interval\" counter that determines how frequently "         \
+          "to simulate overflow; a smaller number increases frequency")     \
+                                                                            \
+  product(uintx, CMSMaxAbortablePrecleanLoops, 0,                           \
+          "Maximum number of abortable preclean iterations, if > 0")        \
+          range(0, max_uintx)                                               \
+                                                                            \
+  product(intx, CMSMaxAbortablePrecleanTime, 5000,                          \
+          "Maximum time in abortable preclean (in milliseconds)")           \
+          range(0, max_intx)                                                \
+                                                                            \
+  product(uintx, CMSAbortablePrecleanMinWorkPerIteration, 100,              \
+          "Nominal minimum work per abortable preclean iteration")          \
+          range(0, max_uintx)                                               \
+                                                                            \
+  manageable(intx, CMSAbortablePrecleanWaitMillis, 100,                     \
+          "Time that we sleep between iterations when not given "           \
+          "enough work per iteration")                                      \
+          range(0, max_intx)                                                \
+                                                                            \
+  /* 4096 = CardTable::card_size_in_words * BitsPerWord */                  \
+  product(size_t, CMSRescanMultiple, 32,                                    \
+          "Size (in cards) of CMS parallel rescan task")                    \
+          range(1, SIZE_MAX / 4096)                                         \
+          constraint(CMSRescanMultipleConstraintFunc,AfterMemoryInit)       \
+                                                                            \
+  /* 4096 = CardTable::card_size_in_words * BitsPerWord */                  \
+  product(size_t, CMSConcMarkMultiple, 32,                                  \
+          "Size (in cards) of CMS concurrent MT marking task")              \
+          range(1, SIZE_MAX / 4096)                                         \
+          constraint(CMSConcMarkMultipleConstraintFunc,AfterMemoryInit)     \
+                                                                            \
+  product(bool, CMSAbortSemantics, false,                                   \
+          "Whether abort-on-overflow semantics is implemented")             \
+                                                                            \
+  product(bool, CMSParallelInitialMarkEnabled, true,                        \
+          "Use the parallel initial mark.")                                 \
+                                                                            \
+  product(bool, CMSParallelRemarkEnabled, true,                             \
+          "Whether parallel remark enabled (only if ParNewGC)")             \
+                                                                            \
+  product(bool, CMSParallelSurvivorRemarkEnabled, true,                     \
+          "Whether parallel remark of survivor space "                      \
+          "enabled (effective only if CMSParallelRemarkEnabled)")           \
+                                                                            \
+  product(bool, CMSPLABRecordAlways, true,                                  \
+          "Always record survivor space PLAB boundaries (effective only "   \
+          "if CMSParallelSurvivorRemarkEnabled)")                           \
+                                                                            \
+  product(bool, CMSEdenChunksRecordAlways, true,                            \
+          "Always record eden chunks used for the parallel initial mark "   \
+          "or remark of eden")                                              \
+                                                                            \
+  product(bool, CMSConcurrentMTEnabled, true,                               \
+          "Whether multi-threaded concurrent work enabled "                 \
+          "(effective only if ParNewGC)")                                   \
+                                                                            \
+  product(bool, CMSPrecleaningEnabled, true,                                \
+          "Whether concurrent precleaning enabled")                         \
+                                                                            \
+  product(uintx, CMSPrecleanIter, 3,                                        \
+          "Maximum number of precleaning iteration passes")                 \
+          range(0, 9)                                                       \
+                                                                            \
+  product(uintx, CMSPrecleanDenominator, 3,                                 \
+          "CMSPrecleanNumerator:CMSPrecleanDenominator yields convergence " \
+          "ratio")                                                          \
+          range(1, max_uintx)                                               \
+          constraint(CMSPrecleanDenominatorConstraintFunc,AfterErgo)        \
+                                                                            \
+  product(uintx, CMSPrecleanNumerator, 2,                                   \
+          "CMSPrecleanNumerator:CMSPrecleanDenominator yields convergence " \
+          "ratio")                                                          \
+          range(0, max_uintx-1)                                             \
+          constraint(CMSPrecleanNumeratorConstraintFunc,AfterErgo)          \
+                                                                            \
+  product(bool, CMSPrecleanRefLists1, true,                                 \
+          "Preclean ref lists during (initial) preclean phase")             \
+                                                                            \
+  product(bool, CMSPrecleanRefLists2, false,                                \
+          "Preclean ref lists during abortable preclean phase")             \
+                                                                            \
+  product(bool, CMSPrecleanSurvivors1, false,                               \
+          "Preclean survivors during (initial) preclean phase")             \
+                                                                            \
+  product(bool, CMSPrecleanSurvivors2, true,                                \
+          "Preclean survivors during abortable preclean phase")             \
+                                                                            \
+  product(uintx, CMSPrecleanThreshold, 1000,                                \
+          "Do not iterate again if number of dirty cards is less than this")\
+          range(100, max_uintx)                                             \
+                                                                            \
+  product(bool, CMSCleanOnEnter, true,                                      \
+          "Clean-on-enter optimization for reducing number of dirty cards") \
+                                                                            \
+  product(uintx, CMSRemarkVerifyVariant, 1,                                 \
+          "Choose variant (1,2) of verification following remark")          \
+          range(1, 2)                                                       \
+                                                                            \
+  product(size_t, CMSScheduleRemarkEdenSizeThreshold, 2*M,                  \
+          "If Eden size is below this, do not try to schedule remark")      \
+          range(0, max_uintx)                                               \
+                                                                            \
+  product(uintx, CMSScheduleRemarkEdenPenetration, 50,                      \
+          "The Eden occupancy percentage (0-100) at which "                 \
+          "to try and schedule remark pause")                               \
+          range(0, 100)                                                     \
+                                                                            \
+  product(uintx, CMSScheduleRemarkSamplingRatio, 5,                         \
+          "Start sampling eden top at least before young gen "              \
+          "occupancy reaches 1/<ratio> of the size at which "               \
+          "we plan to schedule remark")                                     \
+          range(1, max_uintx)                                               \
+                                                                            \
+  product(uintx, CMSSamplingGrain, 16*K,                                    \
+          "The minimum distance between eden samples for CMS (see above)")  \
+          range(ObjectAlignmentInBytes, max_uintx)                          \
+          constraint(CMSSamplingGrainConstraintFunc,AfterMemoryInit)        \
+                                                                            \
+  product(bool, CMSScavengeBeforeRemark, false,                             \
+          "Attempt scavenge before the CMS remark step")                    \
+                                                                            \
+  product(uintx, CMSWorkQueueDrainThreshold, 10,                            \
+          "Don't drain below this size per parallel worker/thief")          \
+          range(1, max_juint)                                               \
+          constraint(CMSWorkQueueDrainThresholdConstraintFunc,AfterErgo)    \
+                                                                            \
+  manageable(intx, CMSWaitDuration, 2000,                                   \
+          "Time in milliseconds that CMS thread waits for young GC")        \
+          range(min_jint, max_jint)                                         \
+                                                                            \
+  develop(uintx, CMSCheckInterval, 1000,                                    \
+          "Interval in milliseconds that CMS thread checks if it "          \
+          "should start a collection cycle")                                \
+                                                                            \
+  product(bool, CMSYield, true,                                             \
+          "Yield between steps of CMS")                                     \
+                                                                            \
+  product(size_t, CMSBitMapYieldQuantum, 10*M,                              \
+          "Bitmap operations should process at most this many bits "        \
+          "between yields")                                                 \
+          range(1, max_uintx)                                               \
+          constraint(CMSBitMapYieldQuantumConstraintFunc,AfterMemoryInit)   \
+                                                                            \
+  product(bool, CMSPrintChunksInDump, false,                                \
+          "If logging for the \"gc\" and \"promotion\" tags is enabled on"  \
+          "trace level include more detailed information about the"         \
+          "free chunks")                                                    \
+                                                                            \
+  product(bool, CMSPrintObjectsInDump, false,                               \
+          "If logging for the \"gc\" and \"promotion\" tags is enabled on"  \
+          "trace level include more detailed information about the"         \
+          "allocated objects")                                              \
+                                                                            \
+  diagnostic(bool, FLSVerifyAllHeapReferences, false,                       \
+          "Verify that all references across the FLS boundary "             \
+          "are to valid objects")                                           \
+                                                                            \
+  diagnostic(bool, FLSVerifyLists, false,                                   \
+          "Do lots of (expensive) FreeListSpace verification")              \
+                                                                            \
+  diagnostic(bool, FLSVerifyIndexTable, false,                              \
+          "Do lots of (expensive) FLS index table verification")            \
+                                                                            \
+  product(uintx, CMSTriggerRatio, 80,                                       \
+          "Percentage of MinHeapFreeRatio in CMS generation that is "       \
+          "allocated before a CMS collection cycle commences")              \
+          range(0, 100)                                                     \
+                                                                            \
+  product(uintx, CMSBootstrapOccupancy, 50,                                 \
+          "Percentage CMS generation occupancy at which to "                \
+          "initiate CMS collection for bootstrapping collection stats")     \
+          range(0, 100)                                                     \
+                                                                            \
+  product(intx, CMSInitiatingOccupancyFraction, -1,                         \
+          "Percentage CMS generation occupancy to start a CMS collection "  \
+          "cycle. A negative value means that CMSTriggerRatio is used")     \
+          range(min_intx, 100)                                              \
+                                                                            \
+  manageable(intx, CMSTriggerInterval, -1,                                  \
+          "Commence a CMS collection cycle (at least) every so many "       \
+          "milliseconds (0 permanently, -1 disabled)")                      \
+          range(-1, max_intx)                                               \
+                                                                            \
+  product(bool, UseCMSInitiatingOccupancyOnly, false,                       \
+          "Only use occupancy as a criterion for starting a CMS collection")\
+                                                                            \
+  product(uintx, CMSIsTooFullPercentage, 98,                                \
+          "An absolute ceiling above which CMS will always consider the "   \
+          "unloading of classes when class unloading is enabled")           \
+          range(0, 100)                                                     \
+                                                                            \
+  develop(bool, CMSTestInFreeList, false,                                   \
+          "Check if the coalesced range is already in the "                 \
+          "free lists as claimed")                                          \
+                                                                            \
+  notproduct(bool, CMSVerifyReturnedBytes, false,                           \
+          "Check that all the garbage collected was returned to the "       \
+          "free lists")                                                     \
+                                                                            \
+  diagnostic(bool, BindCMSThreadToCPU, false,                               \
+          "Bind CMS Thread to CPU if possible")                             \
+                                                                            \
+  diagnostic(uintx, CPUForCMSThread, 0,                                     \
+          "When BindCMSThreadToCPU is true, the CPU to bind CMS thread to") \
+          range(0, max_juint)                                               \
+                                                                            \
+  product(uintx, CMSCoordinatorYieldSleepCount, 10,                         \
+          "Number of times the coordinator GC thread will sleep while "     \
+          "yielding before giving up and resuming GC")                      \
+          range(0, max_juint)                                               \
+                                                                            \
+  product(uintx, CMSYieldSleepCount, 0,                                     \
+          "Number of times a GC thread (minus the coordinator) "            \
+          "will sleep while yielding before giving up and resuming GC")     \
+          range(0, max_juint)                                               \
+                                                                            \
+  product(bool, ParGCUseLocalOverflow, false,                               \
+          "Instead of a global overflow list, use local overflow stacks")   \
+                                                                            \
+  product(bool, ParGCTrimOverflow, true,                                    \
+          "Eagerly trim the local overflow lists "                          \
+          "(when ParGCUseLocalOverflow)")                                   \
+                                                                            \
+  notproduct(bool, ParGCWorkQueueOverflowALot, false,                       \
+          "Simulate work queue overflow in ParNew")                         \
+                                                                            \
+  notproduct(uintx, ParGCWorkQueueOverflowInterval, 1000,                   \
+          "An `interval' counter that determines how frequently "           \
+          "we simulate overflow; a smaller number increases frequency")     \
+                                                                            \
+  product(uintx, ParGCDesiredObjsFromOverflowList, 20,                      \
+          "The desired number of objects to claim from the overflow list")  \
+          range(0, max_uintx)                                               \
+                                                                            \
+  diagnostic(uintx, ParGCStridesPerThread, 2,                               \
+          "The number of strides per worker thread that we divide up the "  \
+          "card table scanning work into")                                  \
+          range(1, max_uintx)                                               \
+          constraint(ParGCStridesPerThreadConstraintFunc,AfterErgo)         \
+                                                                            \
+  diagnostic(intx, ParGCCardsPerStrideChunk, 256,                           \
+          "The number of cards in each chunk of the parallel chunks used "  \
+          "during card table scanning")                                     \
+          range(1, max_intx)                                                \
+          constraint(ParGCCardsPerStrideChunkConstraintFunc,AfterMemoryInit)
+
+#endif // SHARE_GC_CMS_CMS_GLOBALS_HPP
--- a/src/hotspot/share/gc/g1/g1_globals.cpp	Fri Apr 06 13:54:54 2018 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,40 +0,0 @@
-/*
- * Copyright (c) 2001, 2016, 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
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
- * or visit www.oracle.com if you need additional information or have any
- * questions.
- *
- */
-
-#include "precompiled.hpp"
-#include "gc/g1/g1_globals.hpp"
-
-G1_FLAGS(MATERIALIZE_DEVELOPER_FLAG, \
-         MATERIALIZE_PD_DEVELOPER_FLAG, \
-         MATERIALIZE_PRODUCT_FLAG, \
-         MATERIALIZE_PD_PRODUCT_FLAG,     \
-         MATERIALIZE_DIAGNOSTIC_FLAG, \
-         MATERIALIZE_PD_DIAGNOSTIC_FLAG, \
-         MATERIALIZE_EXPERIMENTAL_FLAG, \
-         MATERIALIZE_NOTPRODUCT_FLAG,  \
-         MATERIALIZE_MANAGEABLE_FLAG, \
-         MATERIALIZE_PRODUCT_RW_FLAG, \
-         IGNORE_RANGE, \
-         IGNORE_CONSTRAINT, \
-         IGNORE_WRITEABLE)
--- a/src/hotspot/share/gc/g1/g1_globals.hpp	Fri Apr 06 13:54:54 2018 +0200
+++ b/src/hotspot/share/gc/g1/g1_globals.hpp	Fri Apr 06 13:55:25 2018 +0200
@@ -25,25 +25,25 @@
 #ifndef SHARE_VM_GC_G1_G1_GLOBALS_HPP
 #define SHARE_VM_GC_G1_G1_GLOBALS_HPP
 
-#include "runtime/globals.hpp"
 #include <float.h> // for DBL_MAX
 //
 // Defines all globals flags used by the garbage-first compiler.
 //
 
-#define G1_FLAGS(develop, \
-                 develop_pd, \
-                 product, \
-                 product_pd, \
-                 diagnostic, \
-                 diagnostic_pd, \
-                 experimental, \
-                 notproduct, \
-                 manageable, \
-                 product_rw, \
-                 range, \
-                 constraint, \
-                 writeable) \
+#define GC_G1_FLAGS(develop,                                                \
+                    develop_pd,                                             \
+                    product,                                                \
+                    product_pd,                                             \
+                    diagnostic,                                             \
+                    diagnostic_pd,                                          \
+                    experimental,                                           \
+                    notproduct,                                             \
+                    manageable,                                             \
+                    product_rw,                                             \
+                    lp64_product,                                           \
+                    range,                                                  \
+                    constraint,                                             \
+                    writeable)                                              \
                                                                             \
   product(bool, G1UseAdaptiveIHOP, true,                                    \
           "Adaptively adjust the initiating heap occupancy from the "       \
@@ -303,18 +303,4 @@
   develop(bool, G1VerifyBitmaps, false,                                     \
           "Verifies the consistency of the marking bitmaps")
 
-G1_FLAGS(DECLARE_DEVELOPER_FLAG, \
-         DECLARE_PD_DEVELOPER_FLAG, \
-         DECLARE_PRODUCT_FLAG, \
-         DECLARE_PD_PRODUCT_FLAG, \
-         DECLARE_DIAGNOSTIC_FLAG, \
-         DECLARE_PD_DIAGNOSTIC_FLAG, \
-         DECLARE_EXPERIMENTAL_FLAG, \
-         DECLARE_NOTPRODUCT_FLAG, \
-         DECLARE_MANAGEABLE_FLAG, \
-         DECLARE_PRODUCT_RW_FLAG, \
-         IGNORE_RANGE, \
-         IGNORE_CONSTRAINT, \
-         IGNORE_WRITEABLE)
-
 #endif // SHARE_VM_GC_G1_G1_GLOBALS_HPP
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/hotspot/share/gc/parallel/parallel_globals.hpp	Fri Apr 06 13:55:25 2018 +0200
@@ -0,0 +1,83 @@
+/*
+ * 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ *
+ */
+
+#ifndef SHARE_GC_PARALLEL_PARALLEL_GLOBALS_HPP
+#define SHARE_GC_PARALLEL_PARALLEL_GLOBALS_HPP
+
+#define GC_PARALLEL_FLAGS(develop,                                          \
+                          develop_pd,                                       \
+                          product,                                          \
+                          product_pd,                                       \
+                          diagnostic,                                       \
+                          diagnostic_pd,                                    \
+                          experimental,                                     \
+                          notproduct,                                       \
+                          manageable,                                       \
+                          product_rw,                                       \
+                          lp64_product,                                     \
+                          range,                                            \
+                          constraint,                                       \
+                          writeable)                                        \
+  product(uintx, HeapMaximumCompactionInterval, 20,                         \
+          "How often should we maximally compact the heap (not allowing "   \
+          "any dead space)")                                                \
+          range(0, max_uintx)                                               \
+                                                                            \
+  product(uintx, HeapFirstMaximumCompactionCount, 3,                        \
+          "The collection count for the first maximum compaction")          \
+          range(0, max_uintx)                                               \
+                                                                            \
+  product(bool, UseMaximumCompactionOnSystemGC, true,                       \
+          "Use maximum compaction in the Parallel Old garbage collector "   \
+          "for a system GC")                                                \
+                                                                            \
+  product(uintx, ParallelOldDeadWoodLimiterMean, 50,                        \
+          "The mean used by the parallel compact dead wood "                \
+          "limiter (a number between 0-100)")                               \
+          range(0, 100)                                                     \
+                                                                            \
+  product(uintx, ParallelOldDeadWoodLimiterStdDev, 80,                      \
+          "The standard deviation used by the parallel compact dead wood "  \
+          "limiter (a number between 0-100)")                               \
+          range(0, 100)                                                     \
+                                                                            \
+  develop(bool, TraceGCTaskManager, false,                                  \
+          "Trace actions of the GC task manager")                           \
+                                                                            \
+  develop(bool, TraceGCTaskQueue, false,                                    \
+          "Trace actions of the GC task queues")                            \
+                                                                            \
+  develop(bool, TraceParallelOldGCMarkingPhase, false,                      \
+          "Trace marking phase in ParallelOldGC")                           \
+                                                                            \
+  develop(bool, TraceParallelOldGCDensePrefix, false,                       \
+          "Trace dense prefix computation for ParallelOldGC")               \
+                                                                            \
+  develop(uintx, GCWorkerDelayMillis, 0,                                    \
+          "Delay in scheduling GC workers (in milliseconds)")               \
+                                                                            \
+  product(bool, PSChunkLargeArrays, true,                                   \
+          "Process large arrays in chunks")
+
+#endif // SHARE_GC_PARALLEL_PARALLEL_GLOBALS_HPP
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/hotspot/share/gc/serial/serial_globals.hpp	Fri Apr 06 13:55:25 2018 +0200
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ *
+ */
+
+#ifndef SHARE_GC_SERIAL_SERIAL_GLOBALS_HPP
+#define SHARE_GC_SERIAL_SERIAL_GLOBALS_HPP
+
+#define GC_SERIAL_FLAGS(develop,                                            \
+                        develop_pd,                                         \
+                        product,                                            \
+                        product_pd,                                         \
+                        diagnostic,                                         \
+                        diagnostic_pd,                                      \
+                        experimental,                                       \
+                        notproduct,                                         \
+                        manageable,                                         \
+                        product_rw,                                         \
+                        lp64_product,                                       \
+                        range,                                              \
+                        constraint,                                         \
+                        writeable)
+
+#endif // SHARE_GC_SERIAL_SERIAL_GLOBALS_HPP
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/hotspot/share/gc/shared/gc_globals.hpp	Fri Apr 06 13:55:25 2018 +0200
@@ -0,0 +1,771 @@
+/*
+ * 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ *
+ */
+
+#ifndef SHARE_GC_SHARED_GC_GLOBALS_HPP
+#define SHARE_GC_SHARED_GC_GLOBALS_HPP
+
+#include "gc/serial/serial_globals.hpp"
+#include "utilities/macros.hpp"
+#if INCLUDE_ALL_GCS
+#include "gc/cms/cms_globals.hpp"
+#include "gc/g1/g1_globals.hpp"
+#include "gc/parallel/parallel_globals.hpp"
+#endif
+
+#define GC_FLAGS(develop,                                                   \
+                 develop_pd,                                                \
+                 product,                                                   \
+                 product_pd,                                                \
+                 diagnostic,                                                \
+                 diagnostic_pd,                                             \
+                 experimental,                                              \
+                 notproduct,                                                \
+                 manageable,                                                \
+                 product_rw,                                                \
+                 lp64_product,                                              \
+                 range,                                                     \
+                 constraint,                                                \
+                 writeable)                                                 \
+                                                                            \
+  ALL_GCS_ONLY(GC_CMS_FLAGS(                                                \
+    develop,                                                                \
+    develop_pd,                                                             \
+    product,                                                                \
+    product_pd,                                                             \
+    diagnostic,                                                             \
+    diagnostic_pd,                                                          \
+    experimental,                                                           \
+    notproduct,                                                             \
+    manageable,                                                             \
+    product_rw,                                                             \
+    lp64_product,                                                           \
+    range,                                                                  \
+    constraint,                                                             \
+    writeable))                                                             \
+                                                                            \
+  ALL_GCS_ONLY(GC_G1_FLAGS(                                                 \
+    develop,                                                                \
+    develop_pd,                                                             \
+    product,                                                                \
+    product_pd,                                                             \
+    diagnostic,                                                             \
+    diagnostic_pd,                                                          \
+    experimental,                                                           \
+    notproduct,                                                             \
+    manageable,                                                             \
+    product_rw,                                                             \
+    lp64_product,                                                           \
+    range,                                                                  \
+    constraint,                                                             \
+    writeable))                                                             \
+                                                                            \
+  ALL_GCS_ONLY(GC_PARALLEL_FLAGS(                                           \
+    develop,                                                                \
+    develop_pd,                                                             \
+    product,                                                                \
+    product_pd,                                                             \
+    diagnostic,                                                             \
+    diagnostic_pd,                                                          \
+    experimental,                                                           \
+    notproduct,                                                             \
+    manageable,                                                             \
+    product_rw,                                                             \
+    lp64_product,                                                           \
+    range,                                                                  \
+    constraint,                                                             \
+    writeable))                                                             \
+                                                                            \
+  GC_SERIAL_FLAGS(                                                          \
+    develop,                                                                \
+    develop_pd,                                                             \
+    product,                                                                \
+    product_pd,                                                             \
+    diagnostic,                                                             \
+    diagnostic_pd,                                                          \
+    experimental,                                                           \
+    notproduct,                                                             \
+    manageable,                                                             \
+    product_rw,                                                             \
+    lp64_product,                                                           \
+    range,                                                                  \
+    constraint,                                                             \
+    writeable)                                                              \
+                                                                            \
+  /* gc */                                                                  \
+                                                                            \
+  product(bool, UseConcMarkSweepGC, false,                                  \
+          "Use Concurrent Mark-Sweep GC in the old generation")             \
+                                                                            \
+  product(bool, UseSerialGC, false,                                         \
+          "Use the Serial garbage collector")                               \
+                                                                            \
+  product(bool, UseG1GC, false,                                             \
+          "Use the Garbage-First garbage collector")                        \
+                                                                            \
+  product(bool, UseParallelGC, false,                                       \
+          "Use the Parallel Scavenge garbage collector")                    \
+                                                                            \
+  product(bool, UseParallelOldGC, false,                                    \
+          "Use the Parallel Old garbage collector")                         \
+                                                                            \
+  product(uint, ParallelGCThreads, 0,                                       \
+          "Number of parallel threads parallel gc will use")                \
+          constraint(ParallelGCThreadsConstraintFunc,AfterErgo)             \
+                                                                            \
+  diagnostic(bool, UseSemaphoreGCThreadsSynchronization, true,              \
+            "Use semaphore synchronization for the GC Threads, "            \
+            "instead of synchronization based on mutexes")                  \
+                                                                            \
+  product(bool, UseDynamicNumberOfGCThreads, true,                          \
+          "Dynamically choose the number of threads up to a maximum of "    \
+          "ParallelGCThreads parallel collectors will use for garbage "     \
+          "collection work")                                                \
+                                                                            \
+  diagnostic(bool, InjectGCWorkerCreationFailure, false,                    \
+             "Inject thread creation failures for "                         \
+             "UseDynamicNumberOfGCThreads")                                 \
+                                                                            \
+  diagnostic(bool, ForceDynamicNumberOfGCThreads, false,                    \
+          "Force dynamic selection of the number of "                       \
+          "parallel threads parallel gc will use to aid debugging")         \
+                                                                            \
+  product(size_t, HeapSizePerGCThread, ScaleForWordSize(64*M),              \
+          "Size of heap (bytes) per GC thread used in calculating the "     \
+          "number of GC threads")                                           \
+          range((size_t)os::vm_page_size(), (size_t)max_uintx)              \
+                                                                            \
+  product(uint, ConcGCThreads, 0,                                           \
+          "Number of threads concurrent gc will use")                       \
+          constraint(ConcGCThreadsConstraintFunc,AfterErgo)                 \
+                                                                            \
+  product(uint, GCTaskTimeStampEntries, 200,                                \
+          "Number of time stamp entries per gc worker thread")              \
+          range(1, max_jint)                                                \
+                                                                            \
+  product(bool, AlwaysTenure, false,                                        \
+          "Always tenure objects in eden (ParallelGC only)")                \
+                                                                            \
+  product(bool, NeverTenure, false,                                         \
+          "Never tenure objects in eden, may tenure on overflow "           \
+          "(ParallelGC only)")                                              \
+                                                                            \
+  product(bool, ScavengeBeforeFullGC, true,                                 \
+          "Scavenge youngest generation before each full GC.")              \
+                                                                            \
+  product(bool, ExplicitGCInvokesConcurrent, false,                         \
+          "A System.gc() request invokes a concurrent collection; "         \
+          "(effective only when using concurrent collectors)")              \
+                                                                            \
+  product(bool, GCLockerInvokesConcurrent, false,                           \
+          "The exit of a JNI critical section necessitating a scavenge, "   \
+          "also kicks off a background concurrent collection")              \
+                                                                            \
+  product(uintx, GCLockerEdenExpansionPercent, 5,                           \
+          "How much the GC can expand the eden by while the GC locker "     \
+          "is active (as a percentage)")                                    \
+          range(0, 100)                                                     \
+                                                                            \
+  diagnostic(uintx, GCLockerRetryAllocationCount, 2,                        \
+          "Number of times to retry allocations when "                      \
+          "blocked by the GC locker")                                       \
+          range(0, max_uintx)                                               \
+                                                                            \
+  product(uintx, ParallelGCBufferWastePct, 10,                              \
+          "Wasted fraction of parallel allocation buffer")                  \
+          range(0, 100)                                                     \
+                                                                            \
+  product(uintx, TargetPLABWastePct, 10,                                    \
+          "Target wasted space in last buffer as percent of overall "       \
+          "allocation")                                                     \
+          range(1, 100)                                                     \
+                                                                            \
+  product(uintx, PLABWeight, 75,                                            \
+          "Percentage (0-100) used to weight the current sample when "      \
+          "computing exponentially decaying average for ResizePLAB")        \
+          range(0, 100)                                                     \
+                                                                            \
+  product(bool, ResizePLAB, true,                                           \
+          "Dynamically resize (survivor space) promotion LAB's")            \
+                                                                            \
+  product(int, ParGCArrayScanChunk, 50,                                     \
+          "Scan a subset of object array and push remainder, if array is "  \
+          "bigger than this")                                               \
+          range(1, max_jint/3)                                              \
+                                                                            \
+  product(uintx, OldPLABWeight, 50,                                         \
+          "Percentage (0-100) used to weight the current sample when "      \
+          "computing exponentially decaying average for resizing "          \
+          "OldPLABSize")                                                    \
+          range(0, 100)                                                     \
+                                                                            \
+  product(bool, ResizeOldPLAB, true,                                        \
+          "Dynamically resize (old gen) promotion LAB's")                   \
+                                                                            \
+  product(bool, AlwaysPreTouch, false,                                      \
+          "Force all freshly committed pages to be pre-touched")            \
+                                                                            \
+  product(size_t, PreTouchParallelChunkSize, 1 * G,                         \
+          "Per-thread chunk size for parallel memory pre-touch.")           \
+          range(1, SIZE_MAX / 2)                                            \
+                                                                            \
+  /* where does the range max value of (max_jint - 1) come from? */         \
+  product(size_t, MarkStackSizeMax, NOT_LP64(4*M) LP64_ONLY(512*M),         \
+          "Maximum size of marking stack")                                  \
+          range(1, (max_jint - 1))                                          \
+                                                                            \
+  product(size_t, MarkStackSize, NOT_LP64(32*K) LP64_ONLY(4*M),             \
+          "Size of marking stack")                                          \
+          constraint(MarkStackSizeConstraintFunc,AfterErgo)                 \
+                                                                            \
+  develop(bool, VerifyBlockOffsetArray, false,                              \
+          "Do (expensive) block offset array verification")                 \
+                                                                            \
+  diagnostic(bool, BlockOffsetArrayUseUnallocatedBlock, false,              \
+          "Maintain _unallocated_block in BlockOffsetArray "                \
+          "(currently applicable only to CMS collector)")                   \
+                                                                            \
+  product(intx, RefDiscoveryPolicy, 0,                                      \
+          "Select type of reference discovery policy: "                     \
+          "reference-based(0) or referent-based(1)")                        \
+          range(ReferenceProcessor::DiscoveryPolicyMin,                     \
+                ReferenceProcessor::DiscoveryPolicyMax)                     \
+                                                                            \
+  product(bool, ParallelRefProcEnabled, false,                              \
+          "Enable parallel reference processing whenever possible")         \
+                                                                            \
+  product(bool, ParallelRefProcBalancingEnabled, true,                      \
+          "Enable balancing of reference processing queues")                \
+                                                                            \
+  product(uintx, InitiatingHeapOccupancyPercent, 45,                        \
+          "The percent occupancy (IHOP) of the current old generation "     \
+          "capacity above which a concurrent mark cycle will be initiated " \
+          "Its value may change over time if adaptive IHOP is enabled, "    \
+          "otherwise the value remains constant. "                          \
+          "In the latter case a value of 0 will result as frequent as "     \
+          "possible concurrent marking cycles. A value of 100 disables "    \
+          "concurrent marking. "                                            \
+          "Fragmentation waste in the old generation is not considered "    \
+          "free space in this calculation. (G1 collector only)")            \
+          range(0, 100)                                                     \
+                                                                            \
+  notproduct(bool, ScavengeALot, false,                                     \
+          "Force scavenge at every Nth exit from the runtime system "       \
+          "(N=ScavengeALotInterval)")                                       \
+                                                                            \
+  develop(bool, FullGCALot, false,                                          \
+          "Force full gc at every Nth exit from the runtime system "        \
+          "(N=FullGCALotInterval)")                                         \
+                                                                            \
+  notproduct(bool, GCALotAtAllSafepoints, false,                            \
+          "Enforce ScavengeALot/GCALot at all potential safepoints")        \
+                                                                            \
+  notproduct(bool, PromotionFailureALot, false,                             \
+          "Use promotion failure handling on every youngest generation "    \
+          "collection")                                                     \
+                                                                            \
+  develop(uintx, PromotionFailureALotCount, 1000,                           \
+          "Number of promotion failures occurring at PLAB "                 \
+          "refill attempts (ParNew) or promotion attempts "                 \
+          "(other young collectors)")                                       \
+                                                                            \
+  develop(uintx, PromotionFailureALotInterval, 5,                           \
+          "Total collections between promotion failures a lot")             \
+                                                                            \
+  experimental(uintx, WorkStealingSleepMillis, 1,                           \
+          "Sleep time when sleep is used for yields")                       \
+                                                                            \
+  experimental(uintx, WorkStealingYieldsBeforeSleep, 5000,                  \
+          "Number of yields before a sleep is done during work stealing")   \
+                                                                            \
+  experimental(uintx, WorkStealingHardSpins, 4096,                          \
+          "Number of iterations in a spin loop between checks on "          \
+          "time out of hard spin")                                          \
+                                                                            \
+  experimental(uintx, WorkStealingSpinToYieldRatio, 10,                     \
+          "Ratio of hard spins to calls to yield")                          \
+                                                                            \
+  develop(uintx, ObjArrayMarkingStride, 2048,                               \
+          "Number of object array elements to push onto the marking stack " \
+          "before pushing a continuation entry")                            \
+                                                                            \
+  develop(bool, MetadataAllocationFailALot, false,                          \
+          "Fail metadata allocations at intervals controlled by "           \
+          "MetadataAllocationFailALotInterval")                             \
+                                                                            \
+  develop(uintx, MetadataAllocationFailALotInterval, 1000,                  \
+          "Metadata allocation failure a lot interval")                     \
+                                                                            \
+  notproduct(bool, ExecuteInternalVMTests, false,                           \
+          "Enable execution of internal VM tests")                          \
+                                                                            \
+  notproduct(bool, VerboseInternalVMTests, false,                           \
+          "Turn on logging for internal VM tests.")                         \
+                                                                            \
+  product(bool, ExecutingUnitTests, false,                                  \
+          "Whether the JVM is running unit tests or not")                   \
+                                                                            \
+  product_pd(bool, UseTLAB, "Use thread-local object allocation")           \
+                                                                            \
+  product_pd(bool, ResizeTLAB,                                              \
+          "Dynamically resize TLAB size for threads")                       \
+                                                                            \
+  product(bool, ZeroTLAB, false,                                            \
+          "Zero out the newly created TLAB")                                \
+                                                                            \
+  product(bool, TLABStats, true,                                            \
+          "Provide more detailed and expensive TLAB statistics.")           \
+                                                                            \
+  product_pd(bool, NeverActAsServerClassMachine,                            \
+          "Never act like a server-class machine")                          \
+                                                                            \
+  product(bool, AlwaysActAsServerClassMachine, false,                       \
+          "Always act like a server-class machine")                         \
+                                                                            \
+  product_pd(uint64_t, MaxRAM,                                              \
+          "Real memory size (in bytes) used to set maximum heap size")      \
+          range(0, 0XFFFFFFFFFFFFFFFF)                                      \
+                                                                            \
+  product(bool, AggressiveHeap, false,                                      \
+          "Optimize heap options for long-running memory intensive apps")   \
+                                                                            \
+  product(size_t, ErgoHeapSizeLimit, 0,                                     \
+          "Maximum ergonomically set heap size (in bytes); zero means use " \
+          "MaxRAM * MaxRAMPercentage / 100")                                \
+          range(0, max_uintx)                                               \
+                                                                            \
+  product(uintx, MaxRAMFraction, 4,                                         \
+          "Maximum fraction (1/n) of real memory used for maximum heap "    \
+          "size. "                                                          \
+          "Deprecated, use MaxRAMPercentage instead")                       \
+          range(1, max_uintx)                                               \
+                                                                            \
+  product(uintx, MinRAMFraction, 2,                                         \
+          "Minimum fraction (1/n) of real memory used for maximum heap "    \
+          "size on systems with small physical memory size. "               \
+          "Deprecated, use MinRAMPercentage instead")                       \
+          range(1, max_uintx)                                               \
+                                                                            \
+  product(uintx, InitialRAMFraction, 64,                                    \
+          "Fraction (1/n) of real memory used for initial heap size. "      \
+          "Deprecated, use InitialRAMPercentage instead")                   \
+          range(1, max_uintx)                                               \
+                                                                            \
+  product(double, MaxRAMPercentage, 25.0,                                   \
+          "Maximum percentage of real memory used for maximum heap size")   \
+          range(0.0, 100.0)                                                 \
+                                                                            \
+  product(double, MinRAMPercentage, 50.0,                                   \
+          "Minimum percentage of real memory used for maximum heap"         \
+          "size on systems with small physical memory size")                \
+          range(0.0, 100.0)                                                 \
+                                                                            \
+  product(double, InitialRAMPercentage, 1.5625,                             \
+          "Percentage of real memory used for initial heap size")           \
+          range(0.0, 100.0)                                                 \
+                                                                            \
+  product(int, ActiveProcessorCount, -1,                                    \
+          "Specify the CPU count the VM should use and report as active")   \
+                                                                            \
+  develop(uintx, MaxVirtMemFraction, 2,                                     \
+          "Maximum fraction (1/n) of virtual memory used for ergonomically "\
+          "determining maximum heap size")                                  \
+                                                                            \
+  product(bool, UseAdaptiveSizePolicy, true,                                \
+          "Use adaptive generation sizing policies")                        \
+                                                                            \
+  product(bool, UsePSAdaptiveSurvivorSizePolicy, true,                      \
+          "Use adaptive survivor sizing policies")                          \
+                                                                            \
+  product(bool, UseAdaptiveGenerationSizePolicyAtMinorCollection, true,     \
+          "Use adaptive young-old sizing policies at minor collections")    \
+                                                                            \
+  product(bool, UseAdaptiveGenerationSizePolicyAtMajorCollection, true,     \
+          "Use adaptive young-old sizing policies at major collections")    \
+                                                                            \
+  product(bool, UseAdaptiveSizePolicyWithSystemGC, false,                   \
+          "Include statistics from System.gc() for adaptive size policy")   \
+                                                                            \
+  product(bool, UseAdaptiveGCBoundary, false,                               \
+          "Allow young-old boundary to move")                               \
+                                                                            \
+  develop(intx, PSAdaptiveSizePolicyResizeVirtualSpaceAlot, -1,             \
+          "Resize the virtual spaces of the young or old generations")      \
+          range(-1, 1)                                                      \
+                                                                            \
+  product(uintx, AdaptiveSizeThroughPutPolicy, 0,                           \
+          "Policy for changing generation size for throughput goals")       \
+          range(0, 1)                                                       \
+                                                                            \
+  product(uintx, AdaptiveSizePolicyInitializingSteps, 20,                   \
+          "Number of steps where heuristics is used before data is used")   \
+          range(0, max_uintx)                                               \
+                                                                            \
+  develop(uintx, AdaptiveSizePolicyReadyThreshold, 5,                       \
+          "Number of collections before the adaptive sizing is started")    \
+                                                                            \
+  product(uintx, AdaptiveSizePolicyOutputInterval, 0,                       \
+          "Collection interval for printing information; zero means never") \
+          range(0, max_uintx)                                               \
+                                                                            \
+  product(bool, UseAdaptiveSizePolicyFootprintGoal, true,                   \
+          "Use adaptive minimum footprint as a goal")                       \
+                                                                            \
+  product(uintx, AdaptiveSizePolicyWeight, 10,                              \
+          "Weight given to exponential resizing, between 0 and 100")        \
+          range(0, 100)                                                     \
+                                                                            \
+  product(uintx, AdaptiveTimeWeight,       25,                              \
+          "Weight given to time in adaptive policy, between 0 and 100")     \
+          range(0, 100)                                                     \
+                                                                            \
+  product(uintx, PausePadding, 1,                                           \
+          "How much buffer to keep for pause time")                         \
+          range(0, max_juint)                                               \
+                                                                            \
+  product(uintx, PromotedPadding, 3,                                        \
+          "How much buffer to keep for promotion failure")                  \
+          range(0, max_juint)                                               \
+                                                                            \
+  product(uintx, SurvivorPadding, 3,                                        \
+          "How much buffer to keep for survivor overflow")                  \
+          range(0, max_juint)                                               \
+                                                                            \
+  product(uintx, ThresholdTolerance, 10,                                    \
+          "Allowed collection cost difference between generations")         \
+          range(0, 100)                                                     \
+                                                                            \
+  product(uintx, AdaptiveSizePolicyCollectionCostMargin, 50,                \
+          "If collection costs are within margin, reduce both by full "     \
+          "delta")                                                          \
+          range(0, 100)                                                     \
+                                                                            \
+  product(uintx, YoungGenerationSizeIncrement, 20,                          \
+          "Adaptive size percentage change in young generation")            \
+          range(0, 100)                                                     \
+                                                                            \
+  product(uintx, YoungGenerationSizeSupplement, 80,                         \
+          "Supplement to YoungedGenerationSizeIncrement used at startup")   \
+          range(0, 100)                                                     \
+                                                                            \
+  product(uintx, YoungGenerationSizeSupplementDecay, 8,                     \
+          "Decay factor to YoungedGenerationSizeSupplement")                \
+          range(1, max_uintx)                                               \
+                                                                            \
+  product(uintx, TenuredGenerationSizeIncrement, 20,                        \
+          "Adaptive size percentage change in tenured generation")          \
+          range(0, 100)                                                     \
+                                                                            \
+  product(uintx, TenuredGenerationSizeSupplement, 80,                       \
+          "Supplement to TenuredGenerationSizeIncrement used at startup")   \
+          range(0, 100)                                                     \
+                                                                            \
+  product(uintx, TenuredGenerationSizeSupplementDecay, 2,                   \
+          "Decay factor to TenuredGenerationSizeIncrement")                 \
+          range(1, max_uintx)                                               \
+                                                                            \
+  product(uintx, MaxGCPauseMillis, max_uintx - 1,                           \
+          "Adaptive size policy maximum GC pause time goal in millisecond, "\
+          "or (G1 Only) the maximum GC time per MMU time slice")            \
+          range(1, max_uintx - 1)                                           \
+          constraint(MaxGCPauseMillisConstraintFunc,AfterErgo)              \
+                                                                            \
+  product(uintx, GCPauseIntervalMillis, 0,                                  \
+          "Time slice for MMU specification")                               \
+          constraint(GCPauseIntervalMillisConstraintFunc,AfterErgo)         \
+                                                                            \
+  product(uintx, MaxGCMinorPauseMillis, max_uintx,                          \
+          "Adaptive size policy maximum GC minor pause time goal "          \
+          "in millisecond")                                                 \
+          range(0, max_uintx)                                               \
+                                                                            \
+  product(uintx, GCTimeRatio, 99,                                           \
+          "Adaptive size policy application time to GC time ratio")         \
+          range(0, max_juint)                                               \
+                                                                            \
+  product(uintx, AdaptiveSizeDecrementScaleFactor, 4,                       \
+          "Adaptive size scale down factor for shrinking")                  \
+          range(1, max_uintx)                                               \
+                                                                            \
+  product(bool, UseAdaptiveSizeDecayMajorGCCost, true,                      \
+          "Adaptive size decays the major cost for long major intervals")   \
+                                                                            \
+  product(uintx, AdaptiveSizeMajorGCDecayTimeScale, 10,                     \
+          "Time scale over which major costs decay")                        \
+          range(0, max_uintx)                                               \
+                                                                            \
+  product(uintx, MinSurvivorRatio, 3,                                       \
+          "Minimum ratio of young generation/survivor space size")          \
+          range(3, max_uintx)                                               \
+                                                                            \
+  product(uintx, InitialSurvivorRatio, 8,                                   \
+          "Initial ratio of young generation/survivor space size")          \
+          range(0, max_uintx)                                               \
+                                                                            \
+  product(size_t, BaseFootPrintEstimate, 256*M,                             \
+          "Estimate of footprint other than Java Heap")                     \
+          range(0, max_uintx)                                               \
+                                                                            \
+  product(bool, UseGCOverheadLimit, true,                                   \
+          "Use policy to limit of proportion of time spent in GC "          \
+          "before an OutOfMemory error is thrown")                          \
+                                                                            \
+  product(uintx, GCTimeLimit, 98,                                           \
+          "Limit of the proportion of time spent in GC before "             \
+          "an OutOfMemoryError is thrown (used with GCHeapFreeLimit)")      \
+          range(0, 100)                                                     \
+                                                                            \
+  product(uintx, GCHeapFreeLimit, 2,                                        \
+          "Minimum percentage of free space after a full GC before an "     \
+          "OutOfMemoryError is thrown (used with GCTimeLimit)")             \
+          range(0, 100)                                                     \
+                                                                            \
+  develop(uintx, AdaptiveSizePolicyGCTimeLimitThreshold, 5,                 \
+          "Number of consecutive collections before gc time limit fires")   \
+          range(1, max_uintx)                                               \
+                                                                            \
+  product(intx, PrefetchCopyIntervalInBytes, -1,                            \
+          "How far ahead to prefetch destination area (<= 0 means off)")    \
+          range(-1, max_jint)                                               \
+                                                                            \
+  product(intx, PrefetchScanIntervalInBytes, -1,                            \
+          "How far ahead to prefetch scan area (<= 0 means off)")           \
+          range(-1, max_jint)                                               \
+                                                                            \
+  product(intx, PrefetchFieldsAhead, -1,                                    \
+          "How many fields ahead to prefetch in oop scan (<= 0 means off)") \
+          range(-1, max_jint)                                               \
+                                                                            \
+  diagnostic(bool, VerifyDuringStartup, false,                              \
+          "Verify memory system before executing any Java code "            \
+          "during VM initialization")                                       \
+                                                                            \
+  diagnostic(bool, VerifyBeforeExit, trueInDebug,                           \
+          "Verify system before exiting")                                   \
+                                                                            \
+  diagnostic(bool, VerifyBeforeGC, false,                                   \
+          "Verify memory system before GC")                                 \
+                                                                            \
+  diagnostic(bool, VerifyAfterGC, false,                                    \
+          "Verify memory system after GC")                                  \
+                                                                            \
+  diagnostic(bool, VerifyDuringGC, false,                                   \
+          "Verify memory system during GC (between phases)")                \
+                                                                            \
+  diagnostic(ccstrlist, VerifyGCType, "",                                   \
+             "GC type(s) to verify when Verify*GC is enabled."              \
+             "Available types are collector specific.")                     \
+                                                                            \
+  diagnostic(ccstrlist, VerifySubSet, "",                                   \
+          "Memory sub-systems to verify when Verify*GC flag(s) "            \
+          "are enabled. One or more sub-systems can be specified "          \
+          "in a comma separated string. Sub-systems are: "                  \
+          "threads, heap, symbol_table, string_table, codecache, "          \
+          "dictionary, classloader_data_graph, metaspace, jni_handles, "    \
+          "codecache_oops")                                                 \
+                                                                            \
+  diagnostic(bool, GCParallelVerificationEnabled, true,                     \
+          "Enable parallel memory system verification")                     \
+                                                                            \
+  diagnostic(bool, DeferInitialCardMark, false,                             \
+          "When +ReduceInitialCardMarks, explicitly defer any that "        \
+          "may arise from new_pre_store_barrier")                           \
+                                                                            \
+  product(bool, UseCondCardMark, false,                                     \
+          "Check for already marked card before updating card table")       \
+                                                                            \
+  diagnostic(bool, VerifyRememberedSets, false,                             \
+          "Verify GC remembered sets")                                      \
+                                                                            \
+  diagnostic(bool, VerifyObjectStartArray, true,                            \
+          "Verify GC object start array if verify before/after")            \
+                                                                            \
+  product(bool, DisableExplicitGC, false,                                   \
+          "Ignore calls to System.gc()")                                    \
+                                                                            \
+  product(bool, BindGCTaskThreadsToCPUs, false,                             \
+          "Bind GCTaskThreads to CPUs if possible")                         \
+                                                                            \
+  product(bool, UseGCTaskAffinity, false,                                   \
+          "Use worker affinity when asking for GCTasks")                    \
+                                                                            \
+  product(bool, PrintGC, false,                                             \
+          "Print message at garbage collection. "                           \
+          "Deprecated, use -Xlog:gc instead.")                              \
+                                                                            \
+  product(bool, PrintGCDetails, false,                                      \
+          "Print more details at garbage collection. "                      \
+          "Deprecated, use -Xlog:gc* instead.")                             \
+                                                                            \
+  develop(intx, ConcGCYieldTimeout, 0,                                      \
+          "If non-zero, assert that GC threads yield within this "          \
+          "number of milliseconds")                                         \
+          range(0, max_intx)                                                \
+                                                                            \
+  notproduct(intx, ScavengeALotInterval,     1,                             \
+          "Interval between which scavenge will occur with +ScavengeALot")  \
+                                                                            \
+  notproduct(intx, FullGCALotInterval,     1,                               \
+          "Interval between which full gc will occur with +FullGCALot")     \
+                                                                            \
+  notproduct(intx, FullGCALotStart,     0,                                  \
+          "For which invocation to start FullGCAlot")                       \
+                                                                            \
+  notproduct(intx, FullGCALotDummies,  32*K,                                \
+          "Dummy object allocated with +FullGCALot, forcing all objects "   \
+          "to move")                                                        \
+                                                                            \
+  /* gc parameters */                                                       \
+  product(size_t, InitialHeapSize, 0,                                       \
+          "Initial heap size (in bytes); zero means use ergonomics")        \
+          constraint(InitialHeapSizeConstraintFunc,AfterErgo)               \
+                                                                            \
+  product(size_t, MaxHeapSize, ScaleForWordSize(96*M),                      \
+          "Maximum heap size (in bytes)")                                   \
+          constraint(MaxHeapSizeConstraintFunc,AfterErgo)                   \
+                                                                            \
+  product(size_t, OldSize, ScaleForWordSize(4*M),                           \
+          "Initial tenured generation size (in bytes)")                     \
+          range(0, max_uintx)                                               \
+                                                                            \
+  product(size_t, NewSize, ScaleForWordSize(1*M),                           \
+          "Initial new generation size (in bytes)")                         \
+          constraint(NewSizeConstraintFunc,AfterErgo)                       \
+                                                                            \
+  product(size_t, MaxNewSize, max_uintx,                                    \
+          "Maximum new generation size (in bytes), max_uintx means set "    \
+          "ergonomically")                                                  \
+          range(0, max_uintx)                                               \
+                                                                            \
+  product_pd(size_t, HeapBaseMinAddress,                                    \
+          "OS specific low limit for heap base address")                    \
+          constraint(HeapBaseMinAddressConstraintFunc,AfterErgo)            \
+                                                                            \
+  product(size_t, PretenureSizeThreshold, 0,                                \
+          "Maximum size in bytes of objects allocated in DefNew "           \
+          "generation; zero means no maximum")                              \
+          range(0, max_uintx)                                               \
+                                                                            \
+  product(size_t, MinTLABSize, 2*K,                                         \
+          "Minimum allowed TLAB size (in bytes)")                           \
+          range(1, max_uintx/2)                                             \
+          constraint(MinTLABSizeConstraintFunc,AfterMemoryInit)             \
+                                                                            \
+  product(size_t, TLABSize, 0,                                              \
+          "Starting TLAB size (in bytes); zero means set ergonomically")    \
+          constraint(TLABSizeConstraintFunc,AfterMemoryInit)                \
+                                                                            \
+  product(size_t, YoungPLABSize, 4096,                                      \
+          "Size of young gen promotion LAB's (in HeapWords)")               \
+          constraint(YoungPLABSizeConstraintFunc,AfterMemoryInit)           \
+                                                                            \
+  product(size_t, OldPLABSize, 1024,                                        \
+          "Size of old gen promotion LAB's (in HeapWords), or Number "      \
+          "of blocks to attempt to claim when refilling CMS LAB's")         \
+          constraint(OldPLABSizeConstraintFunc,AfterMemoryInit)             \
+                                                                            \
+  product(uintx, TLABAllocationWeight, 35,                                  \
+          "Allocation averaging weight")                                    \
+          range(0, 100)                                                     \
+                                                                            \
+  /* Limit the lower bound of this flag to 1 as it is used  */              \
+  /* in a division expression.                              */              \
+  product(uintx, TLABWasteTargetPercent, 1,                                 \
+          "Percentage of Eden that can be wasted")                          \
+          range(1, 100)                                                     \
+                                                                            \
+  product(uintx, TLABRefillWasteFraction,    64,                            \
+          "Maximum TLAB waste at a refill (internal fragmentation)")        \
+          range(1, max_juint)                                               \
+                                                                            \
+  product(uintx, TLABWasteIncrement,    4,                                  \
+          "Increment allowed waste at slow allocation")                     \
+          range(0, max_jint)                                                \
+          constraint(TLABWasteIncrementConstraintFunc,AfterMemoryInit)      \
+                                                                            \
+  product(uintx, SurvivorRatio, 8,                                          \
+          "Ratio of eden/survivor space size")                              \
+          range(1, max_uintx-2)                                             \
+          constraint(SurvivorRatioConstraintFunc,AfterMemoryInit)           \
+                                                                            \
+  product(uintx, NewRatio, 2,                                               \
+          "Ratio of old/new generation sizes")                              \
+          range(0, max_uintx-1)                                             \
+                                                                            \
+  product_pd(size_t, NewSizeThreadIncrease,                                 \
+          "Additional size added to desired new generation size per "       \
+          "non-daemon thread (in bytes)")                                   \
+          range(0, max_uintx)                                               \
+                                                                            \
+  product(uintx, QueuedAllocationWarningCount, 0,                           \
+          "Number of times an allocation that queues behind a GC "          \
+          "will retry before printing a warning")                           \
+          range(0, max_uintx)                                               \
+                                                                            \
+  diagnostic(uintx, VerifyGCStartAt,   0,                                   \
+          "GC invoke count where +VerifyBefore/AfterGC kicks in")           \
+          range(0, max_uintx)                                               \
+                                                                            \
+  diagnostic(intx, VerifyGCLevel,     0,                                    \
+          "Generation level at which to start +VerifyBefore/AfterGC")       \
+          range(0, 1)                                                       \
+                                                                            \
+  product(uintx, MaxTenuringThreshold,    15,                               \
+          "Maximum value for tenuring threshold")                           \
+          range(0, markOopDesc::max_age + 1)                                \
+          constraint(MaxTenuringThresholdConstraintFunc,AfterErgo)          \
+                                                                            \
+  product(uintx, InitialTenuringThreshold,    7,                            \
+          "Initial value for tenuring threshold")                           \
+          range(0, markOopDesc::max_age + 1)                                \
+          constraint(InitialTenuringThresholdConstraintFunc,AfterErgo)      \
+                                                                            \
+  product(uintx, TargetSurvivorRatio,    50,                                \
+          "Desired percentage of survivor space used after scavenge")       \
+          range(0, 100)                                                     \
+                                                                            \
+  product(uintx, MarkSweepDeadRatio,     5,                                 \
+          "Percentage (0-100) of the old gen allowed as dead wood. "        \
+          "Serial mark sweep treats this as both the minimum and maximum "  \
+          "value. "                                                         \
+          "CMS uses this value only if it falls back to mark sweep. "       \
+          "Par compact uses a variable scale based on the density of the "  \
+          "generation and treats this as the maximum value when the heap "  \
+          "is either completely full or completely empty.  Par compact "    \
+          "also has a smaller default value; see arguments.cpp.")           \
+          range(0, 100)                                                     \
+                                                                            \
+  product(uint, MarkSweepAlwaysCompactCount,     4,                         \
+          "How often should we fully compact the heap (ignoring the dead "  \
+          "space parameters)")                                              \
+          range(1, max_juint)                                               \
+                                                                            \
+  develop(uintx, GCExpandToAllocateDelayMillis, 0,                          \
+          "Delay between expansion and allocation (in milliseconds)")       \
+                                                                            \
+  product(uintx, GCDrainStackTargetSize, 64,                                \
+          "Number of entries we will try to leave on the stack "            \
+          "during parallel gc")                                             \
+          range(0, max_juint)
+
+#endif // SHARE_GC_SHARED_GC_GLOBALS_HPP
--- a/src/hotspot/share/runtime/commandLineFlagConstraintList.cpp	Fri Apr 06 13:54:54 2018 +0200
+++ b/src/hotspot/share/runtime/commandLineFlagConstraintList.cpp	Fri Apr 06 13:55:25 2018 +0200
@@ -33,9 +33,6 @@
 #include "runtime/commandLineFlagConstraintsRuntime.hpp"
 #include "runtime/os.hpp"
 #include "utilities/macros.hpp"
-#if INCLUDE_ALL_GCS
-#include "gc/g1/g1_globals.hpp"
-#endif
 #ifdef COMPILER1
 #include "c1/c1_globals.hpp"
 #endif
@@ -280,20 +277,20 @@
 void CommandLineFlagConstraintList::init(void) {
   _constraints = new (ResourceObj::C_HEAP, mtArguments) GrowableArray<CommandLineFlagConstraint*>(INITIAL_CONSTRAINTS_SIZE, true);
 
-  emit_constraint_no(NULL RUNTIME_FLAGS(EMIT_CONSTRAINT_DEVELOPER_FLAG,
-                                        EMIT_CONSTRAINT_PD_DEVELOPER_FLAG,
-                                        EMIT_CONSTRAINT_PRODUCT_FLAG,
-                                        EMIT_CONSTRAINT_PD_PRODUCT_FLAG,
-                                        EMIT_CONSTRAINT_DIAGNOSTIC_FLAG,
-                                        EMIT_CONSTRAINT_PD_DIAGNOSTIC_FLAG,
-                                        EMIT_CONSTRAINT_EXPERIMENTAL_FLAG,
-                                        EMIT_CONSTRAINT_NOTPRODUCT_FLAG,
-                                        EMIT_CONSTRAINT_MANAGEABLE_FLAG,
-                                        EMIT_CONSTRAINT_PRODUCT_RW_FLAG,
-                                        EMIT_CONSTRAINT_LP64_PRODUCT_FLAG,
-                                        IGNORE_RANGE,
-                                        EMIT_CONSTRAINT_CHECK,
-                                        IGNORE_WRITEABLE));
+  emit_constraint_no(NULL VM_FLAGS(EMIT_CONSTRAINT_DEVELOPER_FLAG,
+                                   EMIT_CONSTRAINT_PD_DEVELOPER_FLAG,
+                                   EMIT_CONSTRAINT_PRODUCT_FLAG,
+                                   EMIT_CONSTRAINT_PD_PRODUCT_FLAG,
+                                   EMIT_CONSTRAINT_DIAGNOSTIC_FLAG,
+                                   EMIT_CONSTRAINT_PD_DIAGNOSTIC_FLAG,
+                                   EMIT_CONSTRAINT_EXPERIMENTAL_FLAG,
+                                   EMIT_CONSTRAINT_NOTPRODUCT_FLAG,
+                                   EMIT_CONSTRAINT_MANAGEABLE_FLAG,
+                                   EMIT_CONSTRAINT_PRODUCT_RW_FLAG,
+                                   EMIT_CONSTRAINT_LP64_PRODUCT_FLAG,
+                                   IGNORE_RANGE,
+                                   EMIT_CONSTRAINT_CHECK,
+                                   IGNORE_WRITEABLE));
 
   EMIT_CONSTRAINTS_FOR_GLOBALS_EXT
 
@@ -333,22 +330,6 @@
                                    EMIT_CONSTRAINT_CHECK,
                                    IGNORE_WRITEABLE));
 #endif // COMPILER2
-
-#if INCLUDE_ALL_GCS
-  emit_constraint_no(NULL G1_FLAGS(EMIT_CONSTRAINT_DEVELOPER_FLAG,
-                                   EMIT_CONSTRAINT_PD_DEVELOPER_FLAG,
-                                   EMIT_CONSTRAINT_PRODUCT_FLAG,
-                                   EMIT_CONSTRAINT_PD_PRODUCT_FLAG,
-                                   EMIT_CONSTRAINT_DIAGNOSTIC_FLAG,
-                                   EMIT_CONSTRAINT_PD_DIAGNOSTIC_FLAG,
-                                   EMIT_CONSTRAINT_EXPERIMENTAL_FLAG,
-                                   EMIT_CONSTRAINT_NOTPRODUCT_FLAG,
-                                   EMIT_CONSTRAINT_MANAGEABLE_FLAG,
-                                   EMIT_CONSTRAINT_PRODUCT_RW_FLAG,
-                                   IGNORE_RANGE,
-                                   EMIT_CONSTRAINT_CHECK,
-                                   IGNORE_WRITEABLE));
-#endif // INCLUDE_ALL_GCS
 }
 
 CommandLineFlagConstraint* CommandLineFlagConstraintList::find(const char* name) {
--- a/src/hotspot/share/runtime/commandLineFlagRangeList.cpp	Fri Apr 06 13:54:54 2018 +0200
+++ b/src/hotspot/share/runtime/commandLineFlagRangeList.cpp	Fri Apr 06 13:55:25 2018 +0200
@@ -335,20 +335,20 @@
 
   _ranges = new (ResourceObj::C_HEAP, mtArguments) GrowableArray<CommandLineFlagRange*>(INITIAL_RANGES_SIZE, true);
 
-  emit_range_no(NULL RUNTIME_FLAGS(EMIT_RANGE_DEVELOPER_FLAG,
-                                   EMIT_RANGE_PD_DEVELOPER_FLAG,
-                                   EMIT_RANGE_PRODUCT_FLAG,
-                                   EMIT_RANGE_PD_PRODUCT_FLAG,
-                                   EMIT_RANGE_DIAGNOSTIC_FLAG,
-                                   EMIT_RANGE_PD_DIAGNOSTIC_FLAG,
-                                   EMIT_RANGE_EXPERIMENTAL_FLAG,
-                                   EMIT_RANGE_NOTPRODUCT_FLAG,
-                                   EMIT_RANGE_MANAGEABLE_FLAG,
-                                   EMIT_RANGE_PRODUCT_RW_FLAG,
-                                   EMIT_RANGE_LP64_PRODUCT_FLAG,
-                                   EMIT_RANGE_CHECK,
-                                   IGNORE_CONSTRAINT,
-                                   IGNORE_WRITEABLE));
+  emit_range_no(NULL VM_FLAGS(EMIT_RANGE_DEVELOPER_FLAG,
+                              EMIT_RANGE_PD_DEVELOPER_FLAG,
+                              EMIT_RANGE_PRODUCT_FLAG,
+                              EMIT_RANGE_PD_PRODUCT_FLAG,
+                              EMIT_RANGE_DIAGNOSTIC_FLAG,
+                              EMIT_RANGE_PD_DIAGNOSTIC_FLAG,
+                              EMIT_RANGE_EXPERIMENTAL_FLAG,
+                              EMIT_RANGE_NOTPRODUCT_FLAG,
+                              EMIT_RANGE_MANAGEABLE_FLAG,
+                              EMIT_RANGE_PRODUCT_RW_FLAG,
+                              EMIT_RANGE_LP64_PRODUCT_FLAG,
+                              EMIT_RANGE_CHECK,
+                              IGNORE_CONSTRAINT,
+                              IGNORE_WRITEABLE));
 
   EMIT_RANGES_FOR_GLOBALS_EXT
 
@@ -401,22 +401,6 @@
                               IGNORE_CONSTRAINT,
                               IGNORE_WRITEABLE));
 #endif // COMPILER2
-
-#if INCLUDE_ALL_GCS
-  emit_range_no(NULL G1_FLAGS(EMIT_RANGE_DEVELOPER_FLAG,
-                              EMIT_RANGE_PD_DEVELOPER_FLAG,
-                              EMIT_RANGE_PRODUCT_FLAG,
-                              EMIT_RANGE_PD_PRODUCT_FLAG,
-                              EMIT_RANGE_DIAGNOSTIC_FLAG,
-                              EMIT_RANGE_PD_DIAGNOSTIC_FLAG,
-                              EMIT_RANGE_EXPERIMENTAL_FLAG,
-                              EMIT_RANGE_NOTPRODUCT_FLAG,
-                              EMIT_RANGE_MANAGEABLE_FLAG,
-                              EMIT_RANGE_PRODUCT_RW_FLAG,
-                              EMIT_RANGE_CHECK,
-                              IGNORE_CONSTRAINT,
-                              IGNORE_WRITEABLE));
-#endif // INCLUDE_ALL_GCS
 }
 
 CommandLineFlagRange* CommandLineFlagRangeList::find(const char* name) {
--- a/src/hotspot/share/runtime/commandLineFlagWriteableList.cpp	Fri Apr 06 13:54:54 2018 +0200
+++ b/src/hotspot/share/runtime/commandLineFlagWriteableList.cpp	Fri Apr 06 13:55:25 2018 +0200
@@ -23,14 +23,9 @@
  */
 
 #include "precompiled.hpp"
+#include "gc/shared/plab.hpp"
 #include "runtime/commandLineFlagWriteableList.hpp"
 #include "runtime/os.hpp"
-#if INCLUDE_ALL_GCS
-#include "gc/cms/concurrentMarkSweepGeneration.inline.hpp"
-#include "gc/g1/g1_globals.hpp"
-#include "gc/g1/heapRegionBounds.inline.hpp"
-#include "gc/shared/plab.hpp"
-#endif // INCLUDE_ALL_GCS
 #ifdef COMPILER1
 #include "c1/c1_globals.hpp"
 #endif // COMPILER1
@@ -122,20 +117,20 @@
 
   _controls = new (ResourceObj::C_HEAP, mtArguments) GrowableArray<CommandLineFlagWriteable*>(INITIAL_WRITEABLES_SIZE, true);
 
-  emit_writeable_no(NULL RUNTIME_FLAGS(EMIT_WRITEABLE_DEVELOPER_FLAG,
-                                   EMIT_WRITEABLE_PD_DEVELOPER_FLAG,
-                                   EMIT_WRITEABLE_PRODUCT_FLAG,
-                                   EMIT_WRITEABLE_PD_PRODUCT_FLAG,
-                                   EMIT_WRITEABLE_DIAGNOSTIC_FLAG,
-                                   EMIT_WRITEABLE_PD_DIAGNOSTIC_FLAG,
-                                   EMIT_WRITEABLE_EXPERIMENTAL_FLAG,
-                                   EMIT_WRITEABLE_NOTPRODUCT_FLAG,
-                                   EMIT_WRITEABLE_MANAGEABLE_FLAG,
-                                   EMIT_WRITEABLE_PRODUCT_RW_FLAG,
-                                   EMIT_WRITEABLE_LP64_PRODUCT_FLAG,
-                                   IGNORE_RANGE,
-                                   IGNORE_CONSTRAINT,
-                                   EMIT_WRITEABLE));
+  emit_writeable_no(NULL VM_FLAGS(EMIT_WRITEABLE_DEVELOPER_FLAG,
+                                  EMIT_WRITEABLE_PD_DEVELOPER_FLAG,
+                                  EMIT_WRITEABLE_PRODUCT_FLAG,
+                                  EMIT_WRITEABLE_PD_PRODUCT_FLAG,
+                                  EMIT_WRITEABLE_DIAGNOSTIC_FLAG,
+                                  EMIT_WRITEABLE_PD_DIAGNOSTIC_FLAG,
+                                  EMIT_WRITEABLE_EXPERIMENTAL_FLAG,
+                                  EMIT_WRITEABLE_NOTPRODUCT_FLAG,
+                                  EMIT_WRITEABLE_MANAGEABLE_FLAG,
+                                  EMIT_WRITEABLE_PRODUCT_RW_FLAG,
+                                  EMIT_WRITEABLE_LP64_PRODUCT_FLAG,
+                                  IGNORE_RANGE,
+                                  IGNORE_CONSTRAINT,
+                                  EMIT_WRITEABLE));
 
   EMIT_WRITEABLES_FOR_GLOBALS_EXT
 
@@ -188,22 +183,6 @@
                               IGNORE_CONSTRAINT,
                               EMIT_WRITEABLE));
 #endif // COMPILER2
-
-#if INCLUDE_ALL_GCS
-  emit_writeable_no(NULL G1_FLAGS(EMIT_WRITEABLE_DEVELOPER_FLAG,
-                              EMIT_WRITEABLE_PD_DEVELOPER_FLAG,
-                              EMIT_WRITEABLE_PRODUCT_FLAG,
-                              EMIT_WRITEABLE_PD_PRODUCT_FLAG,
-                              EMIT_WRITEABLE_DIAGNOSTIC_FLAG,
-                              EMIT_WRITEABLE_PD_DIAGNOSTIC_FLAG,
-                              EMIT_WRITEABLE_EXPERIMENTAL_FLAG,
-                              EMIT_WRITEABLE_NOTPRODUCT_FLAG,
-                              EMIT_WRITEABLE_MANAGEABLE_FLAG,
-                              EMIT_WRITEABLE_PRODUCT_RW_FLAG,
-                              IGNORE_RANGE,
-                              IGNORE_CONSTRAINT,
-                              EMIT_WRITEABLE));
-#endif // INCLUDE_ALL_GCS
 }
 
 CommandLineFlagWriteable* CommandLineFlagWriteableList::find(const char* name) {
--- a/src/hotspot/share/runtime/globals.cpp	Fri Apr 06 13:54:54 2018 +0200
+++ b/src/hotspot/share/runtime/globals.cpp	Fri Apr 06 13:55:25 2018 +0200
@@ -39,9 +39,6 @@
 #include "utilities/macros.hpp"
 #include "utilities/ostream.hpp"
 #include "utilities/stringUtils.hpp"
-#if INCLUDE_ALL_GCS
-#include "gc/g1/g1_globals.hpp"
-#endif // INCLUDE_ALL_GCS
 #ifdef COMPILER1
 #include "c1/c1_globals.hpp"
 #endif
@@ -52,20 +49,20 @@
 #include "opto/c2_globals.hpp"
 #endif
 
-RUNTIME_FLAGS(MATERIALIZE_DEVELOPER_FLAG, \
-              MATERIALIZE_PD_DEVELOPER_FLAG, \
-              MATERIALIZE_PRODUCT_FLAG, \
-              MATERIALIZE_PD_PRODUCT_FLAG, \
-              MATERIALIZE_DIAGNOSTIC_FLAG, \
-              MATERIALIZE_PD_DIAGNOSTIC_FLAG, \
-              MATERIALIZE_EXPERIMENTAL_FLAG, \
-              MATERIALIZE_NOTPRODUCT_FLAG, \
-              MATERIALIZE_MANAGEABLE_FLAG, \
-              MATERIALIZE_PRODUCT_RW_FLAG, \
-              MATERIALIZE_LP64_PRODUCT_FLAG, \
-              IGNORE_RANGE, \
-              IGNORE_CONSTRAINT, \
-              IGNORE_WRITEABLE)
+VM_FLAGS(MATERIALIZE_DEVELOPER_FLAG, \
+         MATERIALIZE_PD_DEVELOPER_FLAG, \
+         MATERIALIZE_PRODUCT_FLAG, \
+         MATERIALIZE_PD_PRODUCT_FLAG, \
+         MATERIALIZE_DIAGNOSTIC_FLAG, \
+         MATERIALIZE_PD_DIAGNOSTIC_FLAG, \
+         MATERIALIZE_EXPERIMENTAL_FLAG, \
+         MATERIALIZE_NOTPRODUCT_FLAG, \
+         MATERIALIZE_MANAGEABLE_FLAG, \
+         MATERIALIZE_PRODUCT_RW_FLAG, \
+         MATERIALIZE_LP64_PRODUCT_FLAG, \
+         IGNORE_RANGE, \
+         IGNORE_CONSTRAINT, \
+         IGNORE_WRITEABLE)
 
 RUNTIME_OS_FLAGS(MATERIALIZE_DEVELOPER_FLAG, \
                  MATERIALIZE_PD_DEVELOPER_FLAG, \
@@ -870,20 +867,21 @@
 #define ARCH_NOTPRODUCT_FLAG_STRUCT(     type, name, value, doc) { #type, XSTR(name), (void*) &name, NOT_PRODUCT_ARG(doc) Flag::Flags(Flag::DEFAULT | Flag::KIND_ARCH | Flag::KIND_NOT_PRODUCT) },
 
 static Flag flagTable[] = {
- RUNTIME_FLAGS(RUNTIME_DEVELOP_FLAG_STRUCT, \
-               RUNTIME_PD_DEVELOP_FLAG_STRUCT, \
-               RUNTIME_PRODUCT_FLAG_STRUCT, \
-               RUNTIME_PD_PRODUCT_FLAG_STRUCT, \
-               RUNTIME_DIAGNOSTIC_FLAG_STRUCT, \
-               RUNTIME_PD_DIAGNOSTIC_FLAG_STRUCT, \
-               RUNTIME_EXPERIMENTAL_FLAG_STRUCT, \
-               RUNTIME_NOTPRODUCT_FLAG_STRUCT, \
-               RUNTIME_MANAGEABLE_FLAG_STRUCT, \
-               RUNTIME_PRODUCT_RW_FLAG_STRUCT, \
-               RUNTIME_LP64_PRODUCT_FLAG_STRUCT, \
-               IGNORE_RANGE, \
-               IGNORE_CONSTRAINT, \
-               IGNORE_WRITEABLE)
+  VM_FLAGS(RUNTIME_DEVELOP_FLAG_STRUCT, \
+           RUNTIME_PD_DEVELOP_FLAG_STRUCT, \
+           RUNTIME_PRODUCT_FLAG_STRUCT, \
+           RUNTIME_PD_PRODUCT_FLAG_STRUCT, \
+           RUNTIME_DIAGNOSTIC_FLAG_STRUCT, \
+           RUNTIME_PD_DIAGNOSTIC_FLAG_STRUCT, \
+           RUNTIME_EXPERIMENTAL_FLAG_STRUCT, \
+           RUNTIME_NOTPRODUCT_FLAG_STRUCT, \
+           RUNTIME_MANAGEABLE_FLAG_STRUCT, \
+           RUNTIME_PRODUCT_RW_FLAG_STRUCT, \
+           RUNTIME_LP64_PRODUCT_FLAG_STRUCT, \
+           IGNORE_RANGE, \
+           IGNORE_CONSTRAINT, \
+           IGNORE_WRITEABLE)
+
  RUNTIME_OS_FLAGS(RUNTIME_DEVELOP_FLAG_STRUCT, \
                   RUNTIME_PD_DEVELOP_FLAG_STRUCT, \
                   RUNTIME_PRODUCT_FLAG_STRUCT, \
@@ -894,21 +892,6 @@
                   IGNORE_RANGE, \
                   IGNORE_CONSTRAINT, \
                   IGNORE_WRITEABLE)
-#if INCLUDE_ALL_GCS
- G1_FLAGS(RUNTIME_DEVELOP_FLAG_STRUCT, \
-          RUNTIME_PD_DEVELOP_FLAG_STRUCT, \
-          RUNTIME_PRODUCT_FLAG_STRUCT, \
-          RUNTIME_PD_PRODUCT_FLAG_STRUCT, \
-          RUNTIME_DIAGNOSTIC_FLAG_STRUCT, \
-          RUNTIME_PD_DIAGNOSTIC_FLAG_STRUCT, \
-          RUNTIME_EXPERIMENTAL_FLAG_STRUCT, \
-          RUNTIME_NOTPRODUCT_FLAG_STRUCT, \
-          RUNTIME_MANAGEABLE_FLAG_STRUCT, \
-          RUNTIME_PRODUCT_RW_FLAG_STRUCT, \
-          IGNORE_RANGE, \
-          IGNORE_CONSTRAINT, \
-          IGNORE_WRITEABLE)
-#endif // INCLUDE_ALL_GCS
 #if INCLUDE_JVMCI
  JVMCI_FLAGS(JVMCI_DEVELOP_FLAG_STRUCT, \
              JVMCI_PD_DEVELOP_FLAG_STRUCT, \
--- a/src/hotspot/share/runtime/globals.hpp	Fri Apr 06 13:54:54 2018 +0200
+++ b/src/hotspot/share/runtime/globals.hpp	Fri Apr 06 13:55:25 2018 +0200
@@ -25,6 +25,7 @@
 #ifndef SHARE_VM_RUNTIME_GLOBALS_HPP
 #define SHARE_VM_RUNTIME_GLOBALS_HPP
 
+#include "gc/shared/gc_globals.hpp"
 #include "utilities/align.hpp"
 #include "utilities/globalDefinitions.hpp"
 #include "utilities/macros.hpp"
@@ -1385,936 +1386,17 @@
   develop(bool, TraceCompiledIC, false,                                     \
           "Trace changes of compiled IC")                                   \
                                                                             \
-  /* gc */                                                                  \
-                                                                            \
-  product(bool, UseSerialGC, false,                                         \
-          "Use the Serial garbage collector")                               \
-                                                                            \
-  product(bool, UseG1GC, false,                                             \
-          "Use the Garbage-First garbage collector")                        \
-                                                                            \
-  product(bool, UseParallelGC, false,                                       \
-          "Use the Parallel Scavenge garbage collector")                    \
-                                                                            \
-  product(bool, UseParallelOldGC, false,                                    \
-          "Use the Parallel Old garbage collector")                         \
-                                                                            \
-  product(uintx, HeapMaximumCompactionInterval, 20,                         \
-          "How often should we maximally compact the heap (not allowing "   \
-          "any dead space)")                                                \
-          range(0, max_uintx)                                               \
-                                                                            \
-  product(uintx, HeapFirstMaximumCompactionCount, 3,                        \
-          "The collection count for the first maximum compaction")          \
-          range(0, max_uintx)                                               \
-                                                                            \
-  product(bool, UseMaximumCompactionOnSystemGC, true,                       \
-          "Use maximum compaction in the Parallel Old garbage collector "   \
-          "for a system GC")                                                \
-                                                                            \
-  product(uintx, ParallelOldDeadWoodLimiterMean, 50,                        \
-          "The mean used by the parallel compact dead wood "                \
-          "limiter (a number between 0-100)")                               \
-          range(0, 100)                                                     \
-                                                                            \
-  product(uintx, ParallelOldDeadWoodLimiterStdDev, 80,                      \
-          "The standard deviation used by the parallel compact dead wood "  \
-          "limiter (a number between 0-100)")                               \
-          range(0, 100)                                                     \
-                                                                            \
-  product(uint, ParallelGCThreads, 0,                                       \
-          "Number of parallel threads parallel gc will use")                \
-          constraint(ParallelGCThreadsConstraintFunc,AfterErgo)             \
-                                                                            \
-  diagnostic(bool, UseSemaphoreGCThreadsSynchronization, true,              \
-            "Use semaphore synchronization for the GC Threads, "            \
-            "instead of synchronization based on mutexes")                  \
-                                                                            \
-  product(bool, UseDynamicNumberOfGCThreads, true,                          \
-          "Dynamically choose the number of threads up to a maximum of "    \
-          "ParallelGCThreads parallel collectors will use for garbage "     \
-          "collection work")                                                \
-                                                                            \
-  diagnostic(bool, InjectGCWorkerCreationFailure, false,                    \
-             "Inject thread creation failures for "                         \
-             "UseDynamicNumberOfGCThreads")                                 \
-                                                                            \
-  diagnostic(bool, ForceDynamicNumberOfGCThreads, false,                    \
-          "Force dynamic selection of the number of "                       \
-          "parallel threads parallel gc will use to aid debugging")         \
-                                                                            \
-  product(size_t, HeapSizePerGCThread, ScaleForWordSize(64*M),              \
-          "Size of heap (bytes) per GC thread used in calculating the "     \
-          "number of GC threads")                                           \
-          range((size_t)os::vm_page_size(), (size_t)max_uintx)              \
-                                                                            \
-  product(uint, ConcGCThreads, 0,                                           \
-          "Number of threads concurrent gc will use")                       \
-          constraint(ConcGCThreadsConstraintFunc,AfterErgo)                 \
-                                                                            \
-  product(uint, GCTaskTimeStampEntries, 200,                                \
-          "Number of time stamp entries per gc worker thread")              \
-          range(1, max_jint)                                                \
-                                                                            \
-  product(bool, AlwaysTenure, false,                                        \
-          "Always tenure objects in eden (ParallelGC only)")                \
-                                                                            \
-  product(bool, NeverTenure, false,                                         \
-          "Never tenure objects in eden, may tenure on overflow "           \
-          "(ParallelGC only)")                                              \
-                                                                            \
-  product(bool, ScavengeBeforeFullGC, true,                                 \
-          "Scavenge youngest generation before each full GC.")              \
-                                                                            \
-  product(bool, UseConcMarkSweepGC, false,                                  \
-          "Use Concurrent Mark-Sweep GC in the old generation")             \
-                                                                            \
-  product(bool, ExplicitGCInvokesConcurrent, false,                         \
-          "A System.gc() request invokes a concurrent collection; "         \
-          "(effective only when using concurrent collectors)")              \
-                                                                            \
-  product(bool, GCLockerInvokesConcurrent, false,                           \
-          "The exit of a JNI critical section necessitating a scavenge, "   \
-          "also kicks off a background concurrent collection")              \
-                                                                            \
-  product(uintx, GCLockerEdenExpansionPercent, 5,                           \
-          "How much the GC can expand the eden by while the GC locker "     \
-          "is active (as a percentage)")                                    \
-          range(0, 100)                                                     \
-                                                                            \
-  diagnostic(uintx, GCLockerRetryAllocationCount, 2,                        \
-          "Number of times to retry allocations when "                      \
-          "blocked by the GC locker")                                       \
-          range(0, max_uintx)                                               \
-                                                                            \
-  product(bool, UseCMSBestFit, true,                                        \
-          "Use CMS best fit allocation strategy")                           \
-                                                                            \
-  product(uintx, ParallelGCBufferWastePct, 10,                              \
-          "Wasted fraction of parallel allocation buffer")                  \
-          range(0, 100)                                                     \
-                                                                            \
-  product(uintx, TargetPLABWastePct, 10,                                    \
-          "Target wasted space in last buffer as percent of overall "       \
-          "allocation")                                                     \
-          range(1, 100)                                                     \
-                                                                            \
-  product(uintx, PLABWeight, 75,                                            \
-          "Percentage (0-100) used to weight the current sample when "      \
-          "computing exponentially decaying average for ResizePLAB")        \
-          range(0, 100)                                                     \
-                                                                            \
-  product(bool, ResizePLAB, true,                                           \
-          "Dynamically resize (survivor space) promotion LAB's")            \
-                                                                            \
-  product(int, ParGCArrayScanChunk, 50,                                     \
-          "Scan a subset of object array and push remainder, if array is "  \
-          "bigger than this")                                               \
-          range(1, max_jint/3)                                              \
-                                                                            \
-  product(bool, ParGCUseLocalOverflow, false,                               \
-          "Instead of a global overflow list, use local overflow stacks")   \
-                                                                            \
-  product(bool, ParGCTrimOverflow, true,                                    \
-          "Eagerly trim the local overflow lists "                          \
-          "(when ParGCUseLocalOverflow)")                                   \
-                                                                            \
-  notproduct(bool, ParGCWorkQueueOverflowALot, false,                       \
-          "Simulate work queue overflow in ParNew")                         \
-                                                                            \
-  notproduct(uintx, ParGCWorkQueueOverflowInterval, 1000,                   \
-          "An `interval' counter that determines how frequently "           \
-          "we simulate overflow; a smaller number increases frequency")     \
-                                                                            \
-  product(uintx, ParGCDesiredObjsFromOverflowList, 20,                      \
-          "The desired number of objects to claim from the overflow list")  \
-          range(0, max_uintx)                                               \
-                                                                            \
-  diagnostic(uintx, ParGCStridesPerThread, 2,                               \
-          "The number of strides per worker thread that we divide up the "  \
-          "card table scanning work into")                                  \
-          range(1, max_uintx)                                               \
-          constraint(ParGCStridesPerThreadConstraintFunc,AfterErgo)         \
-                                                                            \
-  diagnostic(intx, ParGCCardsPerStrideChunk, 256,                           \
-          "The number of cards in each chunk of the parallel chunks used "  \
-          "during card table scanning")                                     \
-          range(1, max_intx)                                                \
-          constraint(ParGCCardsPerStrideChunkConstraintFunc,AfterMemoryInit)\
-                                                                            \
-  product(uintx, OldPLABWeight, 50,                                         \
-          "Percentage (0-100) used to weight the current sample when "      \
-          "computing exponentially decaying average for resizing "          \
-          "OldPLABSize")                                                    \
-          range(0, 100)                                                     \
-                                                                            \
-  product(bool, ResizeOldPLAB, true,                                        \
-          "Dynamically resize (old gen) promotion LAB's")                   \
-                                                                            \
-  product(size_t, CMSOldPLABMax, 1024,                                      \
-          "Maximum size of CMS gen promotion LAB caches per worker "        \
-          "per block size")                                                 \
-          range(1, max_uintx)                                               \
-          constraint(CMSOldPLABMaxConstraintFunc,AfterMemoryInit)           \
-                                                                            \
-  product(size_t, CMSOldPLABMin, 16,                                        \
-          "Minimum size of CMS gen promotion LAB caches per worker "        \
-          "per block size")                                                 \
-          range(1, max_uintx)                                               \
-          constraint(CMSOldPLABMinConstraintFunc,AfterMemoryInit)           \
-                                                                            \
-  product(uintx, CMSOldPLABNumRefills, 4,                                   \
-          "Nominal number of refills of CMS gen promotion LAB cache "       \
-          "per worker per block size")                                      \
-          range(1, max_uintx)                                               \
-                                                                            \
-  product(bool, CMSOldPLABResizeQuicker, false,                             \
-          "React on-the-fly during a scavenge to a sudden "                 \
-          "change in block demand rate")                                    \
-                                                                            \
-  product(uintx, CMSOldPLABToleranceFactor, 4,                              \
-          "The tolerance of the phase-change detector for on-the-fly "      \
-          "PLAB resizing during a scavenge")                                \
-          range(1, max_uintx)                                               \
-                                                                            \
-  product(uintx, CMSOldPLABReactivityFactor, 2,                             \
-          "The gain in the feedback loop for on-the-fly PLAB resizing "     \
-          "during a scavenge")                                              \
-          range(1, max_uintx)                                               \
-                                                                            \
-  product(bool, AlwaysPreTouch, false,                                      \
-          "Force all freshly committed pages to be pre-touched")            \
-                                                                            \
-  product(size_t, PreTouchParallelChunkSize, 1 * G,                         \
-          "Per-thread chunk size for parallel memory pre-touch.")           \
-          range(1, SIZE_MAX / 2)                                            \
-                                                                            \
-  product_pd(size_t, CMSYoungGenPerWorker,                                  \
-          "The maximum size of young gen chosen by default per GC worker "  \
-          "thread available")                                               \
-          range(1, max_uintx)                                               \
-                                                                            \
-  product(uintx, CMSIncrementalSafetyFactor, 10,                            \
-          "Percentage (0-100) used to add conservatism when computing the " \
-          "duty cycle")                                                     \
-          range(0, 100)                                                     \
-                                                                            \
-  product(uintx, CMSExpAvgFactor, 50,                                       \
-          "Percentage (0-100) used to weight the current sample when "      \
-          "computing exponential averages for CMS statistics")              \
-          range(0, 100)                                                     \
-                                                                            \
-  product(uintx, CMS_FLSWeight, 75,                                         \
-          "Percentage (0-100) used to weight the current sample when "      \
-          "computing exponentially decaying averages for CMS FLS "          \
-          "statistics")                                                     \
-          range(0, 100)                                                     \
-                                                                            \
-  product(uintx, CMS_FLSPadding, 1,                                         \
-          "The multiple of deviation from mean to use for buffering "       \
-          "against volatility in free list demand")                         \
-          range(0, max_juint)                                               \
-                                                                            \
-  product(uintx, FLSCoalescePolicy, 2,                                      \
-          "CMS: aggressiveness level for coalescing, increasing "           \
-          "from 0 to 4")                                                    \
-          range(0, 4)                                                       \
-                                                                            \
-  product(bool, FLSAlwaysCoalesceLarge, false,                              \
-          "CMS: larger free blocks are always available for coalescing")    \
-                                                                            \
-  product(double, FLSLargestBlockCoalesceProximity, 0.99,                   \
-          "CMS: the smaller the percentage the greater the coalescing "     \
-          "force")                                                          \
-          range(0.0, 1.0)                                                   \
-                                                                            \
-  product(double, CMSSmallCoalSurplusPercent, 1.05,                         \
-          "CMS: the factor by which to inflate estimated demand of small "  \
-          "block sizes to prevent coalescing with an adjoining block")      \
-          range(0.0, DBL_MAX)                                               \
-                                                                            \
-  product(double, CMSLargeCoalSurplusPercent, 0.95,                         \
-          "CMS: the factor by which to inflate estimated demand of large "  \
-          "block sizes to prevent coalescing with an adjoining block")      \
-          range(0.0, DBL_MAX)                                               \
-                                                                            \
-  product(double, CMSSmallSplitSurplusPercent, 1.10,                        \
-          "CMS: the factor by which to inflate estimated demand of small "  \
-          "block sizes to prevent splitting to supply demand for smaller "  \
-          "blocks")                                                         \
-          range(0.0, DBL_MAX)                                               \
-                                                                            \
-  product(double, CMSLargeSplitSurplusPercent, 1.00,                        \
-          "CMS: the factor by which to inflate estimated demand of large "  \
-          "block sizes to prevent splitting to supply demand for smaller "  \
-          "blocks")                                                         \
-          range(0.0, DBL_MAX)                                               \
-                                                                            \
-  product(bool, CMSExtrapolateSweep, false,                                 \
-          "CMS: cushion for block demand during sweep")                     \
-                                                                            \
-  product(uintx, CMS_SweepWeight, 75,                                       \
-          "Percentage (0-100) used to weight the current sample when "      \
-          "computing exponentially decaying average for inter-sweep "       \
-          "duration")                                                       \
-          range(0, 100)                                                     \
-                                                                            \
-  product(uintx, CMS_SweepPadding, 1,                                       \
-          "The multiple of deviation from mean to use for buffering "       \
-          "against volatility in inter-sweep duration")                     \
-          range(0, max_juint)                                               \
-                                                                            \
-  product(uintx, CMS_SweepTimerThresholdMillis, 10,                         \
-          "Skip block flux-rate sampling for an epoch unless inter-sweep "  \
-          "duration exceeds this threshold in milliseconds")                \
-          range(0, max_uintx)                                               \
-                                                                            \
-  product(bool, CMSClassUnloadingEnabled, true,                             \
-          "Whether class unloading enabled when using CMS GC")              \
-                                                                            \
-  product(uintx, CMSClassUnloadingMaxInterval, 0,                           \
-          "When CMS class unloading is enabled, the maximum CMS cycle "     \
-          "count for which classes may not be unloaded")                    \
-          range(0, max_uintx)                                               \
-                                                                            \
-  product(uintx, CMSIndexedFreeListReplenish, 4,                            \
-          "Replenish an indexed free list with this number of chunks")      \
-          range(1, max_uintx)                                               \
-                                                                            \
-  product(bool, CMSReplenishIntermediate, true,                             \
-          "Replenish all intermediate free-list caches")                    \
-                                                                            \
-  product(bool, CMSSplitIndexedFreeListBlocks, true,                        \
-          "When satisfying batched demand, split blocks from the "          \
-          "IndexedFreeList whose size is a multiple of requested size")     \
-                                                                            \
-  product(bool, CMSLoopWarn, false,                                         \
-          "Warn in case of excessive CMS looping")                          \
-                                                                            \
-  /* where does the range max value of (max_jint - 1) come from? */         \
-  product(size_t, MarkStackSizeMax, NOT_LP64(4*M) LP64_ONLY(512*M),         \
-          "Maximum size of marking stack")                                  \
-          range(1, (max_jint - 1))                                          \
-                                                                            \
-  product(size_t, MarkStackSize, NOT_LP64(32*K) LP64_ONLY(4*M),             \
-          "Size of marking stack")                                          \
-          constraint(MarkStackSizeConstraintFunc,AfterErgo)                 \
-                                                                            \
-  notproduct(bool, CMSMarkStackOverflowALot, false,                         \
-          "Simulate frequent marking stack / work queue overflow")          \
-                                                                            \
-  notproduct(uintx, CMSMarkStackOverflowInterval, 1000,                     \
-          "An \"interval\" counter that determines how frequently "         \
-          "to simulate overflow; a smaller number increases frequency")     \
-                                                                            \
-  product(uintx, CMSMaxAbortablePrecleanLoops, 0,                           \
-          "Maximum number of abortable preclean iterations, if > 0")        \
-          range(0, max_uintx)                                               \
-                                                                            \
-  product(intx, CMSMaxAbortablePrecleanTime, 5000,                          \
-          "Maximum time in abortable preclean (in milliseconds)")           \
-          range(0, max_intx)                                                \
-                                                                            \
-  product(uintx, CMSAbortablePrecleanMinWorkPerIteration, 100,              \
-          "Nominal minimum work per abortable preclean iteration")          \
-          range(0, max_uintx)                                               \
-                                                                            \
-  manageable(intx, CMSAbortablePrecleanWaitMillis, 100,                     \
-          "Time that we sleep between iterations when not given "           \
-          "enough work per iteration")                                      \
-          range(0, max_intx)                                                \
-                                                                            \
-  /* 4096 = CardTable::card_size_in_words * BitsPerWord */                  \
-  product(size_t, CMSRescanMultiple, 32,                                    \
-          "Size (in cards) of CMS parallel rescan task")                    \
-          range(1, SIZE_MAX / 4096)                                         \
-          constraint(CMSRescanMultipleConstraintFunc,AfterMemoryInit)       \
-                                                                            \
-  /* 4096 = CardTable::card_size_in_words * BitsPerWord */                  \
-  product(size_t, CMSConcMarkMultiple, 32,                                  \
-          "Size (in cards) of CMS concurrent MT marking task")              \
-          range(1, SIZE_MAX / 4096)                                         \
-          constraint(CMSConcMarkMultipleConstraintFunc,AfterMemoryInit)     \
-                                                                            \
-  product(bool, CMSAbortSemantics, false,                                   \
-          "Whether abort-on-overflow semantics is implemented")             \
-                                                                            \
-  product(bool, CMSParallelInitialMarkEnabled, true,                        \
-          "Use the parallel initial mark.")                                 \
-                                                                            \
-  product(bool, CMSParallelRemarkEnabled, true,                             \
-          "Whether parallel remark enabled (only if ParNewGC)")             \
-                                                                            \
-  product(bool, CMSParallelSurvivorRemarkEnabled, true,                     \
-          "Whether parallel remark of survivor space "                      \
-          "enabled (effective only if CMSParallelRemarkEnabled)")           \
-                                                                            \
-  product(bool, CMSPLABRecordAlways, true,                                  \
-          "Always record survivor space PLAB boundaries (effective only "   \
-          "if CMSParallelSurvivorRemarkEnabled)")                           \
-                                                                            \
-  product(bool, CMSEdenChunksRecordAlways, true,                            \
-          "Always record eden chunks used for the parallel initial mark "   \
-          "or remark of eden")                                              \
-                                                                            \
-  product(bool, CMSConcurrentMTEnabled, true,                               \
-          "Whether multi-threaded concurrent work enabled "                 \
-          "(effective only if ParNewGC)")                                   \
-                                                                            \
-  product(bool, CMSPrecleaningEnabled, true,                                \
-          "Whether concurrent precleaning enabled")                         \
-                                                                            \
-  product(uintx, CMSPrecleanIter, 3,                                        \
-          "Maximum number of precleaning iteration passes")                 \
-          range(0, 9)                                                       \
-                                                                            \
-  product(uintx, CMSPrecleanDenominator, 3,                                 \
-          "CMSPrecleanNumerator:CMSPrecleanDenominator yields convergence " \
-          "ratio")                                                          \
-          range(1, max_uintx)                                               \
-          constraint(CMSPrecleanDenominatorConstraintFunc,AfterErgo)        \
-                                                                            \
-  product(uintx, CMSPrecleanNumerator, 2,                                   \
-          "CMSPrecleanNumerator:CMSPrecleanDenominator yields convergence " \
-          "ratio")                                                          \
-          range(0, max_uintx-1)                                             \
-          constraint(CMSPrecleanNumeratorConstraintFunc,AfterErgo)          \
-                                                                            \
-  product(bool, CMSPrecleanRefLists1, true,                                 \
-          "Preclean ref lists during (initial) preclean phase")             \
-                                                                            \
-  product(bool, CMSPrecleanRefLists2, false,                                \
-          "Preclean ref lists during abortable preclean phase")             \
-                                                                            \
-  product(bool, CMSPrecleanSurvivors1, false,                               \
-          "Preclean survivors during (initial) preclean phase")             \
-                                                                            \
-  product(bool, CMSPrecleanSurvivors2, true,                                \
-          "Preclean survivors during abortable preclean phase")             \
-                                                                            \
-  product(uintx, CMSPrecleanThreshold, 1000,                                \
-          "Do not iterate again if number of dirty cards is less than this")\
-          range(100, max_uintx)                                             \
-                                                                            \
-  product(bool, CMSCleanOnEnter, true,                                      \
-          "Clean-on-enter optimization for reducing number of dirty cards") \
-                                                                            \
-  product(uintx, CMSRemarkVerifyVariant, 1,                                 \
-          "Choose variant (1,2) of verification following remark")          \
-          range(1, 2)                                                       \
-                                                                            \
-  product(size_t, CMSScheduleRemarkEdenSizeThreshold, 2*M,                  \
-          "If Eden size is below this, do not try to schedule remark")      \
-          range(0, max_uintx)                                               \
-                                                                            \
-  product(uintx, CMSScheduleRemarkEdenPenetration, 50,                      \
-          "The Eden occupancy percentage (0-100) at which "                 \
-          "to try and schedule remark pause")                               \
-          range(0, 100)                                                     \
-                                                                            \
-  product(uintx, CMSScheduleRemarkSamplingRatio, 5,                         \
-          "Start sampling eden top at least before young gen "              \
-          "occupancy reaches 1/<ratio> of the size at which "               \
-          "we plan to schedule remark")                                     \
-          range(1, max_uintx)                                               \
-                                                                            \
-  product(uintx, CMSSamplingGrain, 16*K,                                    \
-          "The minimum distance between eden samples for CMS (see above)")  \
-          range(ObjectAlignmentInBytes, max_uintx)                          \
-          constraint(CMSSamplingGrainConstraintFunc,AfterMemoryInit)        \
-                                                                            \
-  product(bool, CMSScavengeBeforeRemark, false,                             \
-          "Attempt scavenge before the CMS remark step")                    \
-                                                                            \
-  product(uintx, CMSWorkQueueDrainThreshold, 10,                            \
-          "Don't drain below this size per parallel worker/thief")          \
-          range(1, max_juint)                                               \
-          constraint(CMSWorkQueueDrainThresholdConstraintFunc,AfterErgo)    \
-                                                                            \
-  manageable(intx, CMSWaitDuration, 2000,                                   \
-          "Time in milliseconds that CMS thread waits for young GC")        \
-          range(min_jint, max_jint)                                         \
-                                                                            \
-  develop(uintx, CMSCheckInterval, 1000,                                    \
-          "Interval in milliseconds that CMS thread checks if it "          \
-          "should start a collection cycle")                                \
-                                                                            \
-  product(bool, CMSYield, true,                                             \
-          "Yield between steps of CMS")                                     \
-                                                                            \
-  product(size_t, CMSBitMapYieldQuantum, 10*M,                              \
-          "Bitmap operations should process at most this many bits "        \
-          "between yields")                                                 \
-          range(1, max_uintx)                                               \
-          constraint(CMSBitMapYieldQuantumConstraintFunc,AfterMemoryInit)   \
-                                                                            \
-  product(bool, CMSPrintChunksInDump, false,                                \
-          "If logging for the \"gc\" and \"promotion\" tags is enabled on"  \
-          "trace level include more detailed information about the"         \
-          "free chunks")                \
-                                                                            \
-  product(bool, CMSPrintObjectsInDump, false,                               \
-          "If logging for the \"gc\" and \"promotion\" tags is enabled on"  \
-          "trace level include more detailed information about the"         \
-          "allocated objects")                                              \
-                                                                            \
-  diagnostic(bool, FLSVerifyAllHeapReferences, false,                       \
-          "Verify that all references across the FLS boundary "             \
-          "are to valid objects")                                           \
-                                                                            \
-  diagnostic(bool, FLSVerifyLists, false,                                   \
-          "Do lots of (expensive) FreeListSpace verification")              \
-                                                                            \
-  diagnostic(bool, FLSVerifyIndexTable, false,                              \
-          "Do lots of (expensive) FLS index table verification")            \
-                                                                            \
   develop(bool, FLSVerifyDictionary, false,                                 \
           "Do lots of (expensive) FLS dictionary verification")             \
                                                                             \
-  develop(bool, VerifyBlockOffsetArray, false,                              \
-          "Do (expensive) block offset array verification")                 \
-                                                                            \
-  diagnostic(bool, BlockOffsetArrayUseUnallocatedBlock, false,              \
-          "Maintain _unallocated_block in BlockOffsetArray "                \
-          "(currently applicable only to CMS collector)")                   \
-                                                                            \
-  product(intx, RefDiscoveryPolicy, 0,                                      \
-          "Select type of reference discovery policy: "                     \
-          "reference-based(0) or referent-based(1)")                        \
-          range(ReferenceProcessor::DiscoveryPolicyMin,                     \
-                ReferenceProcessor::DiscoveryPolicyMax)                     \
-                                                                            \
-  product(bool, ParallelRefProcEnabled, false,                              \
-          "Enable parallel reference processing whenever possible")         \
-                                                                            \
-  product(bool, ParallelRefProcBalancingEnabled, true,                      \
-          "Enable balancing of reference processing queues")                \
-                                                                            \
-  product(uintx, CMSTriggerRatio, 80,                                       \
-          "Percentage of MinHeapFreeRatio in CMS generation that is "       \
-          "allocated before a CMS collection cycle commences")              \
-          range(0, 100)                                                     \
-                                                                            \
-  product(uintx, CMSBootstrapOccupancy, 50,                                 \
-          "Percentage CMS generation occupancy at which to "                \
-          "initiate CMS collection for bootstrapping collection stats")     \
-          range(0, 100)                                                     \
-                                                                            \
-  product(intx, CMSInitiatingOccupancyFraction, -1,                         \
-          "Percentage CMS generation occupancy to start a CMS collection "  \
-          "cycle. A negative value means that CMSTriggerRatio is used")     \
-          range(min_intx, 100)                                              \
-                                                                            \
-  product(uintx, InitiatingHeapOccupancyPercent, 45,                        \
-          "The percent occupancy (IHOP) of the current old generation "     \
-          "capacity above which a concurrent mark cycle will be initiated " \
-          "Its value may change over time if adaptive IHOP is enabled, "    \
-          "otherwise the value remains constant. "                          \
-          "In the latter case a value of 0 will result as frequent as "     \
-          "possible concurrent marking cycles. A value of 100 disables "    \
-          "concurrent marking. "                                            \
-          "Fragmentation waste in the old generation is not considered "    \
-          "free space in this calculation. (G1 collector only)")            \
-          range(0, 100)                                                     \
-                                                                            \
-  manageable(intx, CMSTriggerInterval, -1,                                  \
-          "Commence a CMS collection cycle (at least) every so many "       \
-          "milliseconds (0 permanently, -1 disabled)")                      \
-          range(-1, max_intx)                                               \
-                                                                            \
-  product(bool, UseCMSInitiatingOccupancyOnly, false,                       \
-          "Only use occupancy as a criterion for starting a CMS collection")\
-                                                                            \
-  product(uintx, CMSIsTooFullPercentage, 98,                                \
-          "An absolute ceiling above which CMS will always consider the "   \
-          "unloading of classes when class unloading is enabled")           \
-          range(0, 100)                                                     \
-                                                                            \
-  develop(bool, CMSTestInFreeList, false,                                   \
-          "Check if the coalesced range is already in the "                 \
-          "free lists as claimed")                                          \
-                                                                            \
-  notproduct(bool, CMSVerifyReturnedBytes, false,                           \
-          "Check that all the garbage collected was returned to the "       \
-          "free lists")                                                     \
-                                                                            \
-  notproduct(bool, ScavengeALot, false,                                     \
-          "Force scavenge at every Nth exit from the runtime system "       \
-          "(N=ScavengeALotInterval)")                                       \
-                                                                            \
-  develop(bool, FullGCALot, false,                                          \
-          "Force full gc at every Nth exit from the runtime system "        \
-          "(N=FullGCALotInterval)")                                         \
-                                                                            \
-  notproduct(bool, GCALotAtAllSafepoints, false,                            \
-          "Enforce ScavengeALot/GCALot at all potential safepoints")        \
-                                                                            \
-  notproduct(bool, PromotionFailureALot, false,                             \
-          "Use promotion failure handling on every youngest generation "    \
-          "collection")                                                     \
-                                                                            \
-  develop(uintx, PromotionFailureALotCount, 1000,                           \
-          "Number of promotion failures occurring at PLAB "                 \
-          "refill attempts (ParNew) or promotion attempts "                 \
-          "(other young collectors)")                                       \
-                                                                            \
-  develop(uintx, PromotionFailureALotInterval, 5,                           \
-          "Total collections between promotion failures a lot")             \
-                                                                            \
-  experimental(uintx, WorkStealingSleepMillis, 1,                           \
-          "Sleep time when sleep is used for yields")                       \
-                                                                            \
-  experimental(uintx, WorkStealingYieldsBeforeSleep, 5000,                  \
-          "Number of yields before a sleep is done during work stealing")   \
-                                                                            \
-  experimental(uintx, WorkStealingHardSpins, 4096,                          \
-          "Number of iterations in a spin loop between checks on "          \
-          "time out of hard spin")                                          \
-                                                                            \
-  experimental(uintx, WorkStealingSpinToYieldRatio, 10,                     \
-          "Ratio of hard spins to calls to yield")                          \
-                                                                            \
-  develop(uintx, ObjArrayMarkingStride, 2048,                               \
-          "Number of object array elements to push onto the marking stack " \
-          "before pushing a continuation entry")                            \
-                                                                            \
-  develop(bool, MetadataAllocationFailALot, false,                          \
-          "Fail metadata allocations at intervals controlled by "           \
-          "MetadataAllocationFailALotInterval")                             \
-                                                                            \
-  develop(uintx, MetadataAllocationFailALotInterval, 1000,                  \
-          "Metadata allocation failure a lot interval")                     \
-                                                                            \
-  notproduct(bool, ExecuteInternalVMTests, false,                           \
-          "Enable execution of internal VM tests")                          \
-                                                                            \
-  notproduct(bool, VerboseInternalVMTests, false,                           \
-          "Turn on logging for internal VM tests.")                         \
-                                                                            \
-  product(bool, ExecutingUnitTests, false,                                  \
-          "Whether the JVM is running unit tests or not")                   \
-                                                                            \
-  product_pd(bool, UseTLAB, "Use thread-local object allocation")           \
-                                                                            \
-  product_pd(bool, ResizeTLAB,                                              \
-          "Dynamically resize TLAB size for threads")                       \
-                                                                            \
-  product(bool, ZeroTLAB, false,                                            \
-          "Zero out the newly created TLAB")                                \
-                                                                            \
-  product(bool, TLABStats, true,                                            \
-          "Provide more detailed and expensive TLAB statistics.")           \
-                                                                            \
-  product_pd(bool, NeverActAsServerClassMachine,                            \
-          "Never act like a server-class machine")                          \
-                                                                            \
-  product(bool, AlwaysActAsServerClassMachine, false,                       \
-          "Always act like a server-class machine")                         \
-                                                                            \
-  product_pd(uint64_t, MaxRAM,                                              \
-          "Real memory size (in bytes) used to set maximum heap size")      \
-          range(0, 0XFFFFFFFFFFFFFFFF)                                      \
-                                                                            \
-  product(bool, AggressiveHeap, false,                                      \
-          "Optimize heap options for long-running memory intensive apps")   \
-                                                                            \
-  product(size_t, ErgoHeapSizeLimit, 0,                                     \
-          "Maximum ergonomically set heap size (in bytes); zero means use " \
-          "MaxRAM * MaxRAMPercentage / 100")                                \
-          range(0, max_uintx)                                               \
-                                                                            \
-  product(uintx, MaxRAMFraction, 4,                                         \
-          "Maximum fraction (1/n) of real memory used for maximum heap "    \
-          "size. "                                                          \
-          "Deprecated, use MaxRAMPercentage instead")                       \
-          range(1, max_uintx)                                               \
-                                                                            \
-  product(uintx, MinRAMFraction, 2,                                         \
-          "Minimum fraction (1/n) of real memory used for maximum heap "    \
-          "size on systems with small physical memory size. "               \
-          "Deprecated, use MinRAMPercentage instead")                       \
-          range(1, max_uintx)                                               \
-                                                                            \
-  product(uintx, InitialRAMFraction, 64,                                    \
-          "Fraction (1/n) of real memory used for initial heap size. "      \
-          "Deprecated, use InitialRAMPercentage instead")                   \
-          range(1, max_uintx)                                               \
-                                                                            \
-  product(double, MaxRAMPercentage, 25.0,                                   \
-          "Maximum percentage of real memory used for maximum heap size")   \
-          range(0.0, 100.0)                                                 \
-                                                                            \
-  product(double, MinRAMPercentage, 50.0,                                   \
-          "Minimum percentage of real memory used for maximum heap"         \
-          "size on systems with small physical memory size")                \
-          range(0.0, 100.0)                                                 \
-                                                                            \
-  product(double, InitialRAMPercentage, 1.5625,                             \
-          "Percentage of real memory used for initial heap size")           \
-          range(0.0, 100.0)                                                 \
-                                                                            \
-  product(int, ActiveProcessorCount, -1,                                    \
-          "Specify the CPU count the VM should use and report as active")   \
-                                                                            \
-  develop(uintx, MaxVirtMemFraction, 2,                                     \
-          "Maximum fraction (1/n) of virtual memory used for ergonomically "\
-          "determining maximum heap size")                                  \
-                                                                            \
-  product(bool, UseAdaptiveSizePolicy, true,                                \
-          "Use adaptive generation sizing policies")                        \
-                                                                            \
-  product(bool, UsePSAdaptiveSurvivorSizePolicy, true,                      \
-          "Use adaptive survivor sizing policies")                          \
-                                                                            \
-  product(bool, UseAdaptiveGenerationSizePolicyAtMinorCollection, true,     \
-          "Use adaptive young-old sizing policies at minor collections")    \
-                                                                            \
-  product(bool, UseAdaptiveGenerationSizePolicyAtMajorCollection, true,     \
-          "Use adaptive young-old sizing policies at major collections")    \
-                                                                            \
-  product(bool, UseAdaptiveSizePolicyWithSystemGC, false,                   \
-          "Include statistics from System.gc() for adaptive size policy")   \
-                                                                            \
-  product(bool, UseAdaptiveGCBoundary, false,                               \
-          "Allow young-old boundary to move")                               \
-                                                                            \
-  develop(intx, PSAdaptiveSizePolicyResizeVirtualSpaceAlot, -1,             \
-          "Resize the virtual spaces of the young or old generations")      \
-          range(-1, 1)                                                      \
-                                                                            \
-  product(uintx, AdaptiveSizeThroughPutPolicy, 0,                           \
-          "Policy for changing generation size for throughput goals")       \
-          range(0, 1)                                                       \
-                                                                            \
-  product(uintx, AdaptiveSizePolicyInitializingSteps, 20,                   \
-          "Number of steps where heuristics is used before data is used")   \
-          range(0, max_uintx)                                               \
-                                                                            \
-  develop(uintx, AdaptiveSizePolicyReadyThreshold, 5,                       \
-          "Number of collections before the adaptive sizing is started")    \
-                                                                            \
-  product(uintx, AdaptiveSizePolicyOutputInterval, 0,                       \
-          "Collection interval for printing information; zero means never") \
-          range(0, max_uintx)                                               \
-                                                                            \
-  product(bool, UseAdaptiveSizePolicyFootprintGoal, true,                   \
-          "Use adaptive minimum footprint as a goal")                       \
-                                                                            \
-  product(uintx, AdaptiveSizePolicyWeight, 10,                              \
-          "Weight given to exponential resizing, between 0 and 100")        \
-          range(0, 100)                                                     \
-                                                                            \
-  product(uintx, AdaptiveTimeWeight,       25,                              \
-          "Weight given to time in adaptive policy, between 0 and 100")     \
-          range(0, 100)                                                     \
-                                                                            \
-  product(uintx, PausePadding, 1,                                           \
-          "How much buffer to keep for pause time")                         \
-          range(0, max_juint)                                               \
-                                                                            \
-  product(uintx, PromotedPadding, 3,                                        \
-          "How much buffer to keep for promotion failure")                  \
-          range(0, max_juint)                                               \
-                                                                            \
-  product(uintx, SurvivorPadding, 3,                                        \
-          "How much buffer to keep for survivor overflow")                  \
-          range(0, max_juint)                                               \
-                                                                            \
-  product(uintx, ThresholdTolerance, 10,                                    \
-          "Allowed collection cost difference between generations")         \
-          range(0, 100)                                                     \
-                                                                            \
-  product(uintx, AdaptiveSizePolicyCollectionCostMargin, 50,                \
-          "If collection costs are within margin, reduce both by full "     \
-          "delta")                                                          \
-          range(0, 100)                                                     \
-                                                                            \
-  product(uintx, YoungGenerationSizeIncrement, 20,                          \
-          "Adaptive size percentage change in young generation")            \
-          range(0, 100)                                                     \
-                                                                            \
-  product(uintx, YoungGenerationSizeSupplement, 80,                         \
-          "Supplement to YoungedGenerationSizeIncrement used at startup")   \
-          range(0, 100)                                                     \
-                                                                            \
-  product(uintx, YoungGenerationSizeSupplementDecay, 8,                     \
-          "Decay factor to YoungedGenerationSizeSupplement")                \
-          range(1, max_uintx)                                               \
-                                                                            \
-  product(uintx, TenuredGenerationSizeIncrement, 20,                        \
-          "Adaptive size percentage change in tenured generation")          \
-          range(0, 100)                                                     \
-                                                                            \
-  product(uintx, TenuredGenerationSizeSupplement, 80,                       \
-          "Supplement to TenuredGenerationSizeIncrement used at startup")   \
-          range(0, 100)                                                     \
-                                                                            \
-  product(uintx, TenuredGenerationSizeSupplementDecay, 2,                   \
-          "Decay factor to TenuredGenerationSizeIncrement")                 \
-          range(1, max_uintx)                                               \
-                                                                            \
-  product(uintx, MaxGCPauseMillis, max_uintx - 1,                           \
-          "Adaptive size policy maximum GC pause time goal in millisecond, "\
-          "or (G1 Only) the maximum GC time per MMU time slice")            \
-          range(1, max_uintx - 1)                                           \
-          constraint(MaxGCPauseMillisConstraintFunc,AfterErgo)              \
-                                                                            \
-  product(uintx, GCPauseIntervalMillis, 0,                                  \
-          "Time slice for MMU specification")                               \
-          constraint(GCPauseIntervalMillisConstraintFunc,AfterErgo)         \
-                                                                            \
-  product(uintx, MaxGCMinorPauseMillis, max_uintx,                          \
-          "Adaptive size policy maximum GC minor pause time goal "          \
-          "in millisecond")                                                 \
-          range(0, max_uintx)                                               \
-                                                                            \
-  product(uintx, GCTimeRatio, 99,                                           \
-          "Adaptive size policy application time to GC time ratio")         \
-          range(0, max_juint)                                               \
-                                                                            \
-  product(uintx, AdaptiveSizeDecrementScaleFactor, 4,                       \
-          "Adaptive size scale down factor for shrinking")                  \
-          range(1, max_uintx)                                               \
-                                                                            \
-  product(bool, UseAdaptiveSizeDecayMajorGCCost, true,                      \
-          "Adaptive size decays the major cost for long major intervals")   \
-                                                                            \
-  product(uintx, AdaptiveSizeMajorGCDecayTimeScale, 10,                     \
-          "Time scale over which major costs decay")                        \
-          range(0, max_uintx)                                               \
-                                                                            \
-  product(uintx, MinSurvivorRatio, 3,                                       \
-          "Minimum ratio of young generation/survivor space size")          \
-          range(3, max_uintx)                                               \
-                                                                            \
-  product(uintx, InitialSurvivorRatio, 8,                                   \
-          "Initial ratio of young generation/survivor space size")          \
-          range(0, max_uintx)                                               \
-                                                                            \
-  product(size_t, BaseFootPrintEstimate, 256*M,                             \
-          "Estimate of footprint other than Java Heap")                     \
-          range(0, max_uintx)                                               \
-                                                                            \
-  product(bool, UseGCOverheadLimit, true,                                   \
-          "Use policy to limit of proportion of time spent in GC "          \
-          "before an OutOfMemory error is thrown")                          \
-                                                                            \
-  product(uintx, GCTimeLimit, 98,                                           \
-          "Limit of the proportion of time spent in GC before "             \
-          "an OutOfMemoryError is thrown (used with GCHeapFreeLimit)")      \
-          range(0, 100)                                                     \
-                                                                            \
-  product(uintx, GCHeapFreeLimit, 2,                                        \
-          "Minimum percentage of free space after a full GC before an "     \
-          "OutOfMemoryError is thrown (used with GCTimeLimit)")             \
-          range(0, 100)                                                     \
-                                                                            \
-  develop(uintx, AdaptiveSizePolicyGCTimeLimitThreshold, 5,                 \
-          "Number of consecutive collections before gc time limit fires")   \
-          range(1, max_uintx)                                               \
-                                                                            \
-  product(intx, PrefetchCopyIntervalInBytes, -1,                            \
-          "How far ahead to prefetch destination area (<= 0 means off)")    \
-          range(-1, max_jint)                                               \
-                                                                            \
-  product(intx, PrefetchScanIntervalInBytes, -1,                            \
-          "How far ahead to prefetch scan area (<= 0 means off)")           \
-          range(-1, max_jint)                                               \
-                                                                            \
-  product(intx, PrefetchFieldsAhead, -1,                                    \
-          "How many fields ahead to prefetch in oop scan (<= 0 means off)") \
-          range(-1, max_jint)                                               \
-                                                                            \
-  diagnostic(bool, VerifyDuringStartup, false,                              \
-          "Verify memory system before executing any Java code "            \
-          "during VM initialization")                                       \
-                                                                            \
-  diagnostic(bool, VerifyBeforeExit, trueInDebug,                           \
-          "Verify system before exiting")                                   \
-                                                                            \
-  diagnostic(bool, VerifyBeforeGC, false,                                   \
-          "Verify memory system before GC")                                 \
-                                                                            \
-  diagnostic(bool, VerifyAfterGC, false,                                    \
-          "Verify memory system after GC")                                  \
-                                                                            \
-  diagnostic(bool, VerifyDuringGC, false,                                   \
-          "Verify memory system during GC (between phases)")                \
-                                                                            \
-  diagnostic(ccstrlist, VerifyGCType, "",                                   \
-             "GC type(s) to verify when Verify*GC is enabled."              \
-             "Available types are collector specific.")                     \
-                                                                            \
-  diagnostic(ccstrlist, VerifySubSet, "",                                   \
-          "Memory sub-systems to verify when Verify*GC flag(s) "            \
-          "are enabled. One or more sub-systems can be specified "          \
-          "in a comma separated string. Sub-systems are: "                  \
-          "threads, heap, symbol_table, string_table, codecache, "          \
-          "dictionary, classloader_data_graph, metaspace, jni_handles, "    \
-          "codecache_oops")                                                 \
-                                                                            \
-  diagnostic(bool, GCParallelVerificationEnabled, true,                     \
-          "Enable parallel memory system verification")                     \
-                                                                            \
-  diagnostic(bool, DeferInitialCardMark, false,                             \
-          "When +ReduceInitialCardMarks, explicitly defer any that "        \
-          "may arise from new_pre_store_barrier")                           \
-                                                                            \
-  product(bool, UseCondCardMark, false,                                     \
-          "Check for already marked card before updating card table")       \
-                                                                            \
-  diagnostic(bool, VerifyRememberedSets, false,                             \
-          "Verify GC remembered sets")                                      \
-                                                                            \
-  diagnostic(bool, VerifyObjectStartArray, true,                            \
-          "Verify GC object start array if verify before/after")            \
-                                                                            \
-  product(bool, DisableExplicitGC, false,                                   \
-          "Ignore calls to System.gc()")                                    \
                                                                             \
   notproduct(bool, CheckMemoryInitialization, false,                        \
           "Check memory initialization")                                    \
                                                                             \
-  diagnostic(bool, BindCMSThreadToCPU, false,                               \
-          "Bind CMS Thread to CPU if possible")                             \
-                                                                            \
-  diagnostic(uintx, CPUForCMSThread, 0,                                     \
-          "When BindCMSThreadToCPU is true, the CPU to bind CMS thread to") \
-          range(0, max_juint)                                               \
-                                                                            \
-  product(bool, BindGCTaskThreadsToCPUs, false,                             \
-          "Bind GCTaskThreads to CPUs if possible")                         \
-                                                                            \
-  product(bool, UseGCTaskAffinity, false,                                   \
-          "Use worker affinity when asking for GCTasks")                    \
-                                                                            \
   product(uintx, ProcessDistributionStride, 4,                              \
           "Stride through processors when distributing processes")          \
           range(0, max_juint)                                               \
                                                                             \
-  product(uintx, CMSCoordinatorYieldSleepCount, 10,                         \
-          "Number of times the coordinator GC thread will sleep while "     \
-          "yielding before giving up and resuming GC")                      \
-          range(0, max_juint)                                               \
-                                                                            \
-  product(uintx, CMSYieldSleepCount, 0,                                     \
-          "Number of times a GC thread (minus the coordinator) "            \
-          "will sleep while yielding before giving up and resuming GC")     \
-          range(0, max_juint)                                               \
-                                                                            \
-  product(bool, PrintGC, false,                                             \
-          "Print message at garbage collection. "                           \
-          "Deprecated, use -Xlog:gc instead.")                              \
-                                                                            \
-  product(bool, PrintGCDetails, false,                                      \
-          "Print more details at garbage collection. "                      \
-          "Deprecated, use -Xlog:gc* instead.")                             \
-                                                                            \
-  develop(intx, ConcGCYieldTimeout, 0,                                      \
-          "If non-zero, assert that GC threads yield within this "          \
-          "number of milliseconds")                                         \
-          range(0, max_intx)                                                \
-                                                                            \
   develop(bool, TraceFinalizerRegistration, false,                          \
           "Trace registration of final references")                         \
                                                                             \
@@ -2336,18 +1418,6 @@
   manageable(bool, PrintClassHistogram, false,                              \
           "Print a histogram of class instances")                           \
                                                                             \
-  develop(bool, TraceGCTaskManager, false,                                  \
-          "Trace actions of the GC task manager")                           \
-                                                                            \
-  develop(bool, TraceGCTaskQueue, false,                                    \
-          "Trace actions of the GC task queues")                            \
-                                                                            \
-  develop(bool, TraceParallelOldGCMarkingPhase, false,                      \
-          "Trace marking phase in ParallelOldGC")                           \
-                                                                            \
-  develop(bool, TraceParallelOldGCDensePrefix, false,                       \
-          "Trace dense prefix computation for ParallelOldGC")               \
-                                                                            \
   develop(bool, IgnoreLibthreadGPFault, false,                              \
           "Suppress workaround for libthread GP fault")                     \
                                                                             \
@@ -2982,19 +2052,6 @@
           "(+ProfileIntervals)")                                            \
           range(0, max_intx)                                                \
                                                                             \
-  notproduct(intx, ScavengeALotInterval,     1,                             \
-          "Interval between which scavenge will occur with +ScavengeALot")  \
-                                                                            \
-  notproduct(intx, FullGCALotInterval,     1,                               \
-          "Interval between which full gc will occur with +FullGCALot")     \
-                                                                            \
-  notproduct(intx, FullGCALotStart,     0,                                  \
-          "For which invocation to start FullGCAlot")                       \
-                                                                            \
-  notproduct(intx, FullGCALotDummies,  32*K,                                \
-          "Dummy object allocated with +FullGCALot, forcing all objects "   \
-          "to move")                                                        \
-                                                                            \
   develop(intx, DontYieldALotInterval,    10,                               \
           "Interval between which yields will be dropped (milliseconds)")   \
                                                                             \
@@ -3064,88 +2121,6 @@
           "Size in K to allocate for the Profile Nodes of each thread")     \
           range(0, 1024)                                                    \
                                                                             \
-  /* gc parameters */                                                       \
-  product(size_t, InitialHeapSize, 0,                                       \
-          "Initial heap size (in bytes); zero means use ergonomics")        \
-          constraint(InitialHeapSizeConstraintFunc,AfterErgo)               \
-                                                                            \
-  product(size_t, MaxHeapSize, ScaleForWordSize(96*M),                      \
-          "Maximum heap size (in bytes)")                                   \
-          constraint(MaxHeapSizeConstraintFunc,AfterErgo)                   \
-                                                                            \
-  product(size_t, OldSize, ScaleForWordSize(4*M),                           \
-          "Initial tenured generation size (in bytes)")                     \
-          range(0, max_uintx)                                               \
-                                                                            \
-  product(size_t, NewSize, ScaleForWordSize(1*M),                           \
-          "Initial new generation size (in bytes)")                         \
-          constraint(NewSizeConstraintFunc,AfterErgo)                       \
-                                                                            \
-  product(size_t, MaxNewSize, max_uintx,                                    \
-          "Maximum new generation size (in bytes), max_uintx means set "    \
-          "ergonomically")                                                  \
-          range(0, max_uintx)                                               \
-                                                                            \
-  product_pd(size_t, HeapBaseMinAddress,                                    \
-          "OS specific low limit for heap base address")                    \
-          constraint(HeapBaseMinAddressConstraintFunc,AfterErgo)            \
-                                                                            \
-  product(size_t, PretenureSizeThreshold, 0,                                \
-          "Maximum size in bytes of objects allocated in DefNew "           \
-          "generation; zero means no maximum")                              \
-          range(0, max_uintx)                                               \
-                                                                            \
-  product(size_t, MinTLABSize, 2*K,                                         \
-          "Minimum allowed TLAB size (in bytes)")                           \
-          range(1, max_uintx/2)                                             \
-          constraint(MinTLABSizeConstraintFunc,AfterMemoryInit)             \
-                                                                            \
-  product(size_t, TLABSize, 0,                                              \
-          "Starting TLAB size (in bytes); zero means set ergonomically")    \
-          constraint(TLABSizeConstraintFunc,AfterMemoryInit)                \
-                                                                            \
-  product(size_t, YoungPLABSize, 4096,                                      \
-          "Size of young gen promotion LAB's (in HeapWords)")               \
-          constraint(YoungPLABSizeConstraintFunc,AfterMemoryInit)           \
-                                                                            \
-  product(size_t, OldPLABSize, 1024,                                        \
-          "Size of old gen promotion LAB's (in HeapWords), or Number "      \
-          "of blocks to attempt to claim when refilling CMS LAB's")         \
-          constraint(OldPLABSizeConstraintFunc,AfterMemoryInit)             \
-                                                                            \
-  product(uintx, TLABAllocationWeight, 35,                                  \
-          "Allocation averaging weight")                                    \
-          range(0, 100)                                                     \
-                                                                            \
-  /* Limit the lower bound of this flag to 1 as it is used  */              \
-  /* in a division expression.                              */              \
-  product(uintx, TLABWasteTargetPercent, 1,                                 \
-          "Percentage of Eden that can be wasted")                          \
-          range(1, 100)                                                     \
-                                                                            \
-  product(uintx, TLABRefillWasteFraction,    64,                            \
-          "Maximum TLAB waste at a refill (internal fragmentation)")        \
-          range(1, max_juint)                                               \
-                                                                            \
-  product(uintx, TLABWasteIncrement,    4,                                  \
-          "Increment allowed waste at slow allocation")                     \
-          range(0, max_jint)                                                \
-          constraint(TLABWasteIncrementConstraintFunc,AfterMemoryInit)      \
-                                                                            \
-  product(uintx, SurvivorRatio, 8,                                          \
-          "Ratio of eden/survivor space size")                              \
-          range(1, max_uintx-2)                                             \
-          constraint(SurvivorRatioConstraintFunc,AfterMemoryInit)           \
-                                                                            \
-  product(uintx, NewRatio, 2,                                               \
-          "Ratio of old/new generation sizes")                              \
-          range(0, max_uintx-1)                                             \
-                                                                            \
-  product_pd(size_t, NewSizeThreadIncrease,                                 \
-          "Additional size added to desired new generation size per "       \
-          "non-daemon thread (in bytes)")                                   \
-          range(0, max_uintx)                                               \
-                                                                            \
   product_pd(size_t, MetaspaceSize,                                         \
           "Initial threshold (in bytes) at which a garbage collection "     \
           "is done to reduce Metaspace usage")                              \
@@ -3208,63 +2183,6 @@
           "The maximum expansion of Metaspace without full GC (in bytes)")  \
           range(0, max_uintx)                                               \
                                                                             \
-  product(uintx, QueuedAllocationWarningCount, 0,                           \
-          "Number of times an allocation that queues behind a GC "          \
-          "will retry before printing a warning")                           \
-          range(0, max_uintx)                                               \
-                                                                            \
-  diagnostic(uintx, VerifyGCStartAt,   0,                                   \
-          "GC invoke count where +VerifyBefore/AfterGC kicks in")           \
-          range(0, max_uintx)                                               \
-                                                                            \
-  diagnostic(intx, VerifyGCLevel,     0,                                    \
-          "Generation level at which to start +VerifyBefore/AfterGC")       \
-          range(0, 1)                                                       \
-                                                                            \
-  product(uintx, MaxTenuringThreshold,    15,                               \
-          "Maximum value for tenuring threshold")                           \
-          range(0, markOopDesc::max_age + 1)                                \
-          constraint(MaxTenuringThresholdConstraintFunc,AfterErgo)          \
-                                                                            \
-  product(uintx, InitialTenuringThreshold,    7,                            \
-          "Initial value for tenuring threshold")                           \
-          range(0, markOopDesc::max_age + 1)                                \
-          constraint(InitialTenuringThresholdConstraintFunc,AfterErgo)      \
-                                                                            \
-  product(uintx, TargetSurvivorRatio,    50,                                \
-          "Desired percentage of survivor space used after scavenge")       \
-          range(0, 100)                                                     \
-                                                                            \
-  product(uintx, MarkSweepDeadRatio,     5,                                 \
-          "Percentage (0-100) of the old gen allowed as dead wood. "        \
-          "Serial mark sweep treats this as both the minimum and maximum "  \
-          "value. "                                                         \
-          "CMS uses this value only if it falls back to mark sweep. "       \
-          "Par compact uses a variable scale based on the density of the "  \
-          "generation and treats this as the maximum value when the heap "  \
-          "is either completely full or completely empty.  Par compact "    \
-          "also has a smaller default value; see arguments.cpp.")           \
-          range(0, 100)                                                     \
-                                                                            \
-  product(uint, MarkSweepAlwaysCompactCount,     4,                         \
-          "How often should we fully compact the heap (ignoring the dead "  \
-          "space parameters)")                                              \
-          range(1, max_juint)                                               \
-                                                                            \
-  develop(uintx, GCExpandToAllocateDelayMillis, 0,                          \
-          "Delay between expansion and allocation (in milliseconds)")       \
-                                                                            \
-  develop(uintx, GCWorkerDelayMillis, 0,                                    \
-          "Delay in scheduling GC workers (in milliseconds)")               \
-                                                                            \
-  product(bool, PSChunkLargeArrays, true,                                   \
-          "Process large arrays in chunks")                                 \
-                                                                            \
-  product(uintx, GCDrainStackTargetSize, 64,                                \
-          "Number of entries we will try to leave on the stack "            \
-          "during parallel gc")                                             \
-          range(0, max_juint)                                               \
-                                                                            \
   /* stack parameters */                                                    \
   product_pd(intx, StackYellowPages,                                        \
           "Number of yellow zone (recoverable overflows) pages of size "    \
@@ -4066,7 +2984,52 @@
           "On internal errors, include registers in error report.")         \
                                                                             \
 
-
+#define VM_FLAGS(develop,                                                   \
+                 develop_pd,                                                \
+                 product,                                                   \
+                 product_pd,                                                \
+                 diagnostic,                                                \
+                 diagnostic_pd,                                             \
+                 experimental,                                              \
+                 notproduct,                                                \
+                 manageable,                                                \
+                 product_rw,                                                \
+                 lp64_product,                                              \
+                 range,                                                     \
+                 constraint,                                                \
+                 writeable)                                                 \
+                                                                            \
+  RUNTIME_FLAGS(                                                            \
+    develop,                                                                \
+    develop_pd,                                                             \
+    product,                                                                \
+    product_pd,                                                             \
+    diagnostic,                                                             \
+    diagnostic_pd,                                                          \
+    experimental,                                                           \
+    notproduct,                                                             \
+    manageable,                                                             \
+    product_rw,                                                             \
+    lp64_product,                                                           \
+    range,                                                                  \
+    constraint,                                                             \
+    writeable)                                                              \
+                                                                            \
+  GC_FLAGS(                                                                 \
+    develop,                                                                \
+    develop_pd,                                                             \
+    product,                                                                \
+    product_pd,                                                             \
+    diagnostic,                                                             \
+    diagnostic_pd,                                                          \
+    experimental,                                                           \
+    notproduct,                                                             \
+    manageable,                                                             \
+    product_rw,                                                             \
+    lp64_product,                                                           \
+    range,                                                                  \
+    constraint,                                                             \
+    writeable)                                                              \
 
 /*
  *  Macros for factoring of globals
@@ -4126,20 +3089,20 @@
 
 #define IGNORE_WRITEABLE(type)
 
-RUNTIME_FLAGS(DECLARE_DEVELOPER_FLAG, \
-              DECLARE_PD_DEVELOPER_FLAG, \
-              DECLARE_PRODUCT_FLAG, \
-              DECLARE_PD_PRODUCT_FLAG, \
-              DECLARE_DIAGNOSTIC_FLAG, \
-              DECLARE_PD_DIAGNOSTIC_FLAG, \
-              DECLARE_EXPERIMENTAL_FLAG, \
-              DECLARE_NOTPRODUCT_FLAG, \
-              DECLARE_MANAGEABLE_FLAG, \
-              DECLARE_PRODUCT_RW_FLAG, \
-              DECLARE_LP64_PRODUCT_FLAG, \
-              IGNORE_RANGE, \
-              IGNORE_CONSTRAINT, \
-              IGNORE_WRITEABLE)
+VM_FLAGS(DECLARE_DEVELOPER_FLAG, \
+         DECLARE_PD_DEVELOPER_FLAG, \
+         DECLARE_PRODUCT_FLAG, \
+         DECLARE_PD_PRODUCT_FLAG, \
+         DECLARE_DIAGNOSTIC_FLAG, \
+         DECLARE_PD_DIAGNOSTIC_FLAG, \
+         DECLARE_EXPERIMENTAL_FLAG, \
+         DECLARE_NOTPRODUCT_FLAG, \
+         DECLARE_MANAGEABLE_FLAG, \
+         DECLARE_PRODUCT_RW_FLAG, \
+         DECLARE_LP64_PRODUCT_FLAG, \
+         IGNORE_RANGE, \
+         IGNORE_CONSTRAINT, \
+         IGNORE_WRITEABLE)
 
 RUNTIME_OS_FLAGS(DECLARE_DEVELOPER_FLAG, \
                  DECLARE_PD_DEVELOPER_FLAG, \
--- a/src/hotspot/share/runtime/globals_extension.hpp	Fri Apr 06 13:54:54 2018 +0200
+++ b/src/hotspot/share/runtime/globals_extension.hpp	Fri Apr 06 13:55:25 2018 +0200
@@ -28,9 +28,6 @@
 #include "runtime/globals.hpp"
 #include "utilities/macros.hpp"
 #include "utilities/macros.hpp"
-#if INCLUDE_ALL_GCS
-#include "gc/g1/g1_globals.hpp"
-#endif
 #if INCLUDE_JVMCI
 #include "jvmci/jvmci_globals.hpp"
 #endif
@@ -96,21 +93,22 @@
 #define ARCH_NOTPRODUCT_FLAG_MEMBER(type, name, value, doc)      FLAG_MEMBER(name),
 
 typedef enum {
- RUNTIME_FLAGS(RUNTIME_DEVELOP_FLAG_MEMBER, \
-               RUNTIME_PD_DEVELOP_FLAG_MEMBER, \
-               RUNTIME_PRODUCT_FLAG_MEMBER, \
-               RUNTIME_PD_PRODUCT_FLAG_MEMBER, \
-               RUNTIME_DIAGNOSTIC_FLAG_MEMBER, \
-               RUNTIME_PD_DIAGNOSTIC_FLAG_MEMBER, \
-               RUNTIME_EXPERIMENTAL_FLAG_MEMBER, \
-               RUNTIME_NOTPRODUCT_FLAG_MEMBER, \
-               RUNTIME_MANAGEABLE_FLAG_MEMBER, \
-               RUNTIME_PRODUCT_RW_FLAG_MEMBER, \
-               RUNTIME_LP64_PRODUCT_FLAG_MEMBER, \
-               IGNORE_RANGE, \
-               IGNORE_CONSTRAINT, \
-               IGNORE_WRITEABLE)
- RUNTIME_OS_FLAGS(RUNTIME_DEVELOP_FLAG_MEMBER, \
+ VM_FLAGS(RUNTIME_DEVELOP_FLAG_MEMBER, \
+          RUNTIME_PD_DEVELOP_FLAG_MEMBER, \
+          RUNTIME_PRODUCT_FLAG_MEMBER, \
+          RUNTIME_PD_PRODUCT_FLAG_MEMBER, \
+          RUNTIME_DIAGNOSTIC_FLAG_MEMBER, \
+          RUNTIME_PD_DIAGNOSTIC_FLAG_MEMBER, \
+          RUNTIME_EXPERIMENTAL_FLAG_MEMBER, \
+          RUNTIME_NOTPRODUCT_FLAG_MEMBER, \
+          RUNTIME_MANAGEABLE_FLAG_MEMBER, \
+          RUNTIME_PRODUCT_RW_FLAG_MEMBER, \
+          RUNTIME_LP64_PRODUCT_FLAG_MEMBER, \
+          IGNORE_RANGE, \
+          IGNORE_CONSTRAINT, \
+          IGNORE_WRITEABLE)
+
+ RUNTIME_OS_FLAGS(RUNTIME_DEVELOP_FLAG_MEMBER,    \
                   RUNTIME_PD_DEVELOP_FLAG_MEMBER, \
                   RUNTIME_PRODUCT_FLAG_MEMBER, \
                   RUNTIME_PD_PRODUCT_FLAG_MEMBER, \
@@ -120,21 +118,6 @@
                   IGNORE_RANGE, \
                   IGNORE_CONSTRAINT, \
                   IGNORE_WRITEABLE)
-#if INCLUDE_ALL_GCS
- G1_FLAGS(RUNTIME_DEVELOP_FLAG_MEMBER, \
-          RUNTIME_PD_DEVELOP_FLAG_MEMBER, \
-          RUNTIME_PRODUCT_FLAG_MEMBER, \
-          RUNTIME_PD_PRODUCT_FLAG_MEMBER, \
-          RUNTIME_DIAGNOSTIC_FLAG_MEMBER, \
-          RUNTIME_PD_DIAGNOSTIC_FLAG_MEMBER, \
-          RUNTIME_EXPERIMENTAL_FLAG_MEMBER, \
-          RUNTIME_NOTPRODUCT_FLAG_MEMBER, \
-          RUNTIME_MANAGEABLE_FLAG_MEMBER, \
-          RUNTIME_PRODUCT_RW_FLAG_MEMBER, \
-          IGNORE_RANGE, \
-          IGNORE_CONSTRAINT, \
-          IGNORE_WRITEABLE)
-#endif // INCLUDE_ALL_GCS
 #if INCLUDE_JVMCI
  JVMCI_FLAGS(JVMCI_DEVELOP_FLAG_MEMBER, \
              JVMCI_PD_DEVELOP_FLAG_MEMBER, \
@@ -239,20 +222,21 @@
 #define ARCH_NOTPRODUCT_FLAG_MEMBER_WITH_TYPE(type, name, value, doc)      FLAG_MEMBER_WITH_TYPE(name,type),
 
 typedef enum {
- RUNTIME_FLAGS(RUNTIME_DEVELOP_FLAG_MEMBER_WITH_TYPE,
-               RUNTIME_PD_DEVELOP_FLAG_MEMBER_WITH_TYPE,
-               RUNTIME_PRODUCT_FLAG_MEMBER_WITH_TYPE,
-               RUNTIME_PD_PRODUCT_FLAG_MEMBER_WITH_TYPE,
-               RUNTIME_DIAGNOSTIC_FLAG_MEMBER_WITH_TYPE,
-               RUNTIME_PD_DIAGNOSTIC_FLAG_MEMBER_WITH_TYPE,
-               RUNTIME_EXPERIMENTAL_FLAG_MEMBER_WITH_TYPE,
-               RUNTIME_NOTPRODUCT_FLAG_MEMBER_WITH_TYPE,
-               RUNTIME_MANAGEABLE_FLAG_MEMBER_WITH_TYPE,
-               RUNTIME_PRODUCT_RW_FLAG_MEMBER_WITH_TYPE,
-               RUNTIME_LP64_PRODUCT_FLAG_MEMBER_WITH_TYPE,
-               IGNORE_RANGE,
-               IGNORE_CONSTRAINT,
-               IGNORE_WRITEABLE)
+  VM_FLAGS(RUNTIME_DEVELOP_FLAG_MEMBER_WITH_TYPE,
+           RUNTIME_PD_DEVELOP_FLAG_MEMBER_WITH_TYPE,
+           RUNTIME_PRODUCT_FLAG_MEMBER_WITH_TYPE,
+           RUNTIME_PD_PRODUCT_FLAG_MEMBER_WITH_TYPE,
+           RUNTIME_DIAGNOSTIC_FLAG_MEMBER_WITH_TYPE,
+           RUNTIME_PD_DIAGNOSTIC_FLAG_MEMBER_WITH_TYPE,
+           RUNTIME_EXPERIMENTAL_FLAG_MEMBER_WITH_TYPE,
+           RUNTIME_NOTPRODUCT_FLAG_MEMBER_WITH_TYPE,
+           RUNTIME_MANAGEABLE_FLAG_MEMBER_WITH_TYPE,
+           RUNTIME_PRODUCT_RW_FLAG_MEMBER_WITH_TYPE,
+           RUNTIME_LP64_PRODUCT_FLAG_MEMBER_WITH_TYPE,
+           IGNORE_RANGE,
+           IGNORE_CONSTRAINT,
+           IGNORE_WRITEABLE)
+
  RUNTIME_OS_FLAGS(RUNTIME_DEVELOP_FLAG_MEMBER_WITH_TYPE,
                   RUNTIME_PD_DEVELOP_FLAG_MEMBER_WITH_TYPE,
                   RUNTIME_PRODUCT_FLAG_MEMBER_WITH_TYPE,
@@ -263,21 +247,6 @@
                   IGNORE_RANGE,
                   IGNORE_CONSTRAINT,
                   IGNORE_WRITEABLE)
-#if INCLUDE_ALL_GCS
- G1_FLAGS(RUNTIME_DEVELOP_FLAG_MEMBER_WITH_TYPE,
-          RUNTIME_PD_DEVELOP_FLAG_MEMBER_WITH_TYPE,
-          RUNTIME_PRODUCT_FLAG_MEMBER_WITH_TYPE,
-          RUNTIME_PD_PRODUCT_FLAG_MEMBER_WITH_TYPE,
-          RUNTIME_DIAGNOSTIC_FLAG_MEMBER_WITH_TYPE,
-          RUNTIME_PD_DIAGNOSTIC_FLAG_MEMBER_WITH_TYPE,
-          RUNTIME_EXPERIMENTAL_FLAG_MEMBER_WITH_TYPE,
-          RUNTIME_NOTPRODUCT_FLAG_MEMBER_WITH_TYPE,
-          RUNTIME_MANAGEABLE_FLAG_MEMBER_WITH_TYPE,
-          RUNTIME_PRODUCT_RW_FLAG_MEMBER_WITH_TYPE,
-          IGNORE_RANGE,
-          IGNORE_CONSTRAINT,
-          IGNORE_WRITEABLE)
-#endif // INCLUDE_ALL_GCS
 #if INCLUDE_JVMCI
  JVMCI_FLAGS(JVMCI_DEVELOP_FLAG_MEMBER_WITH_TYPE,
              JVMCI_PD_DEVELOP_FLAG_MEMBER_WITH_TYPE,