--- old/src/hotspot/cpu/aarch64/globals_aarch64.hpp	2020-04-05 21:34:43.421649469 -0700
+++ new/src/hotspot/cpu/aarch64/globals_aarch64.hpp	2020-04-05 21:34:43.077636520 -0700
@@ -75,42 +75,47 @@
 define_pd_global(intx, InlineSmallCode,          1000);
 #endif
 
-#define ARCH_FLAGS(develop, \
-                   product, \
-                   diagnostic, \
-                   experimental, \
-                   notproduct, \
-                   range, \
-                   constraint) \
-                                                                        \
-  product(bool, NearCpool, true,                                        \
-         "constant pool is close to instructions")                      \
-                                                                        \
-  product(bool, UseBarriersForVolatile, false,                          \
-          "Use memory barriers to implement volatile accesses")         \
-  product(bool, UseNeon, false,                                         \
-          "Use Neon for CRC32 computation")                             \
-  product(bool, UseCRC32, false,                                        \
-          "Use CRC32 instructions for CRC32 computation")               \
-  product(bool, UseSIMDForMemoryOps, false,                             \
-          "Use SIMD instructions in generated memory move code")        \
-  product(bool, UseSIMDForArrayEquals, true,                            \
-          "Use SIMD instructions in generated array equals code")       \
-  product(bool, UseSimpleArrayEquals, false,                            \
-          "Use simpliest and shortest implementation for array equals") \
-  product(bool, AvoidUnalignedAccesses, false,                          \
-          "Avoid generating unaligned memory accesses")                 \
-  product(bool, UseLSE, false,                                          \
-          "Use LSE instructions")                                       \
-  product(bool, UseBlockZeroing, true,                                  \
-          "Use DC ZVA for block zeroing")                               \
-  product(intx, BlockZeroingLowLimit, 256,                              \
-          "Minimum size in bytes when block zeroing will be used")      \
-          range(1, max_jint)                                            \
-  product(bool, TraceTraps, false, "Trace all traps the signal handler")\
-  product(int, SoftwarePrefetchHintDistance, -1,                        \
-          "Use prfm hint with specified distance in compiled code."     \
-          "Value -1 means off.")                                        \
-          range(-1, 4096)
+#include "runtime/flags/jvmFlag.hpp"
+PRODUCT_FLAG(bool,     NearCpool, true, JVMFlag::DEFAULT,
+                       "constant pool is close to instructions");
+
+PRODUCT_FLAG(bool,     UseBarriersForVolatile, false, JVMFlag::DEFAULT,
+                       "Use memory barriers to implement volatile accesses");
+
+PRODUCT_FLAG(bool,     UseNeon, false, JVMFlag::DEFAULT,
+                       "Use Neon for CRC32 computation");
+
+PRODUCT_FLAG(bool,     UseCRC32, false, JVMFlag::DEFAULT,
+                       "Use CRC32 instructions for CRC32 computation");
+
+PRODUCT_FLAG(bool,     UseSIMDForMemoryOps, false, JVMFlag::DEFAULT,
+                       "Use SIMD instructions in generated memory move code");
+
+PRODUCT_FLAG(bool,     UseSIMDForArrayEquals, true, JVMFlag::DEFAULT,
+                       "Use SIMD instructions in generated array equals code");
+
+PRODUCT_FLAG(bool,     UseSimpleArrayEquals, false, JVMFlag::DEFAULT,
+                       "Use simpliest and shortest implementation for array equals");
+
+PRODUCT_FLAG(bool,     AvoidUnalignedAccesses, false, JVMFlag::DEFAULT,
+                       "Avoid generating unaligned memory accesses");
+
+PRODUCT_FLAG(bool,     UseLSE, false, JVMFlag::DEFAULT,
+                       "Use LSE instructions");
+
+PRODUCT_FLAG(bool,     UseBlockZeroing, true, JVMFlag::DEFAULT,
+                       "Use DC ZVA for block zeroing");
+
+PRODUCT_FLAG(intx,     BlockZeroingLowLimit, 256, JVMFlag::RANGE,
+                       "Minimum size in bytes when block zeroing will be used");
+   FLAG_RANGE(         BlockZeroingLowLimit, 1, max_jint);
+
+PRODUCT_FLAG(bool,     TraceTraps, false, JVMFlag::DEFAULT,
+                       "Trace all traps the signal handler");
+
+PRODUCT_FLAG(int,      SoftwarePrefetchHintDistance, -1, JVMFlag::RANGE,
+                       "Use prfm hint with specified distance in compiled code."
+                       "Value -1 means off.");
+   FLAG_RANGE(         SoftwarePrefetchHintDistance, -1, 4096);
 
 #endif // CPU_AARCH64_GLOBALS_AARCH64_HPP