Revert "Remove duplicate macros between j9nonbuilder.h and j9consts.h"

debugtools/DDR_VM/src/com/ibm/j9ddr/vm29/j9/gc/GCClassArrayClassSlotIterator.java

@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2019 IBM Corp. and others
+ * Copyright (c) 2001, 2014 IBM Corp. and others
  *
  * This program and the accompanying materials are made available under
  * the terms of the Eclipse Public License 2.0 which accompanies this
@@ -29,7 +29,7 @@
 import com.ibm.j9ddr.vm29.pointer.generated.J9ArrayClassPointer;
 import com.ibm.j9ddr.vm29.pointer.generated.J9ClassPointer;
 
-import static com.ibm.j9ddr.vm29.structure.J9JavaAccessFlags.J9AccClassArray;
+import static com.ibm.j9ddr.vm29.structure.J9Consts.*;
 
 public class GCClassArrayClassSlotIterator extends GCIterator
 {
@@ -47,7 +47,7 @@ protected GCClassArrayClassSlotIterator(J9ClassPointer clazz) throws CorruptData
 			slots.add(slot);
 			addresses.add(VoidPointer.cast(clazz.arrayClassEA()));
 		}
-		if(clazz.romClass().modifiers().allBitsIn(J9AccClassArray)) {
+		if(clazz.romClass().modifiers().allBitsIn(J9_JAVA_CLASS_ARRAY)) {
 			J9ArrayClassPointer arrayClass = J9ArrayClassPointer.cast(clazz);
 			slot = arrayClass.componentType();
 			if(slot.notNull()) {

debugtools/DDR_VM/src/com/ibm/j9ddr/vm29/j9/gc/GCObjectModel_V1.java

@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 1991, 2019 IBM Corp. and others
+ * Copyright (c) 1991, 2017 IBM Corp. and others
  *
  * This program and the accompanying materials are made available under
  * the terms of the Eclipse Public License 2.0 which accompanies this
@@ -40,7 +40,6 @@
 
 import static com.ibm.j9ddr.vm29.structure.J9Consts.*;
 import static com.ibm.j9ddr.vm29.structure.J9Object.*;
-import static com.ibm.j9ddr.vm29.structure.J9JavaAccessFlags.*;
 import static com.ibm.j9ddr.vm29.structure.GC_ObjectModel$ScanType.*;
 
 class GCObjectModel_V1 extends GCObjectModel
@@ -268,9 +267,9 @@ private long getScanType(J9ClassPointer clazz) throws CorruptDataException
 		long shape = getClassShape(clazz).longValue();
 
 		if (shape == OBJECT_HEADER_SHAPE_MIXED) {
-			if (J9ClassHelper.classFlags(clazz).anyBitsIn(J9AccClassReferenceMask)) {
+			if (J9ClassHelper.classFlags(clazz).anyBitsIn(J9_JAVA_CLASS_REFERENCE_MASK)) {
 				result = SCAN_REFERENCE_MIXED_OBJECT;
-			} else if (J9ClassHelper.classFlags(clazz).anyBitsIn(J9AccClassGCSpecial)) {
+			} else if (J9ClassHelper.classFlags(clazz).anyBitsIn(J9_JAVA_CLASS_GC_SPECIAL)) {
 				result = getSpecialClassScanType(clazz);
 			} else {
 				result = SCAN_MIXED_OBJECT;
@@ -370,7 +369,7 @@ public UDATA getHeaderSize(J9ObjectPointer object) throws CorruptDataException
 	@Override
 	public UDATA getClassShape(J9ClassPointer clazz) throws CorruptDataException
 	{
-		return new UDATA((J9ClassHelper.classFlags(clazz).longValue() >> J9AccClassRAMShapeShift) & OBJECT_HEADER_SHAPE_MASK);		
+		return new UDATA((J9ClassHelper.classFlags(clazz).longValue() >> J9_JAVA_CLASS_RAM_SHAPE_SHIFT) & OBJECT_HEADER_SHAPE_MASK);		
 	}
 
 	@Override

debugtools/DDR_VM/src/com/ibm/j9ddr/vm29/j9/stackwalker/StackWalker.java

@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2009, 2019 IBM Corp. and others
+ * Copyright (c) 2009, 2018 IBM Corp. and others
  *
  * This program and the accompanying materials are made available under
  * the terms of the Eclipse Public License 2.0 which accompanies this
@@ -813,7 +813,7 @@ public FrameCallbackResult walkFrame(WalkState walkState)
 				if ((walkState.flags & J9_STACKWALK_HIDE_EXCEPTION_FRAMES) != 0) {
 					J9ROMMethodPointer romMethod = J9_ROM_METHOD_FROM_RAM_METHOD(walkState.method);
 
-					if (!romMethod.modifiers().anyBitsIn(J9AccStatic)) {
+					if (!romMethod.modifiers().anyBitsIn(J9_JAVA_STATIC)) {
 						if (J9UTF8Helper.stringValue(romMethod.nameAndSignature().name())
 								.charAt(0) == '<') {
 							if (walkState.arg0EA.at(0).eq(

debugtools/DDR_VM/src/com/ibm/j9ddr/vm29/pointer/helper/J9ClassHelper.java

@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2019 IBM Corp. and others
+ * Copyright (c) 2001, 2018 IBM Corp. and others
  *
  * This program and the accompanying materials are made available under
  * the terms of the Eclipse Public License 2.0 which accompanies this
@@ -80,7 +80,7 @@ public class J9ClassHelper
 
 	public static boolean isArrayClass(J9ClassPointer clazz) throws CorruptDataException
 	{
-		return classDepthAndFlags(clazz).anyBitsIn(J9JavaAccessFlags.J9AccClassRAMArray);
+		return classDepthAndFlags(clazz).anyBitsIn(J9Consts.J9_JAVA_CLASS_RAM_ARRAY);
 	}
 
 	public static String getName(J9ClassPointer clazz) throws CorruptDataException
@@ -353,7 +353,7 @@ public static UDATA size(J9ClassPointer clazz, J9JavaVMPointer vm) throws Corrup
 				}
 
 				// Find the end of the last iTable
-				if (clazz.romClass().modifiers().allBitsIn(J9JavaAccessFlags.J9AccInterface)) {
+				if (clazz.romClass().modifiers().allBitsIn(J9Consts.J9_JAVA_INTERFACE)) {
 					iTable = iTable.add(1);
 				} else {
 					iTable = iTable.add(1).addOffset(iTable.interfaceClass().romClass().romMethodCount().mult(UDATA.SIZEOF));
@@ -428,7 +428,7 @@ public static UDATA classDepthAndFlags(J9ClassPointer j9class) throws CorruptDat
 	}
 
 	public static UDATA classDepth(J9ClassPointer j9class) throws CorruptDataException {
-		return classDepthAndFlags(j9class).bitAnd(J9JavaAccessFlags.J9AccClassDepthMask);
+		return classDepthAndFlags(j9class).bitAnd(J9Consts.J9_JAVA_CLASS_DEPTH_MASK);
 	}
 
 	public static U32 extendedClassFlags(J9ClassPointer j9class) throws CorruptDataException {
@@ -440,7 +440,7 @@ public static UDATA classFlags(J9ClassPointer j9class) throws CorruptDataExcepti
 	}
 
 	public static boolean isObsolete(J9ClassPointer j9class) throws CorruptDataException {
-		return classDepthAndFlags(j9class).allBitsIn(J9JavaAccessFlags.J9AccClassHotSwappedOut);
+		return classDepthAndFlags(j9class).allBitsIn(J9Consts.J9_JAVA_CLASS_HOT_SWAPPED_OUT);
 	}
 
 	public static J9ClassPointer currentClass(J9ClassPointer j9class) throws CorruptDataException {

debugtools/DDR_VM/src/com/ibm/j9ddr/vm29/tools/ddrinteractive/RamClassWalker.java

@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2019 IBM Corp. and others
+ * Copyright (c) 2001, 2018 IBM Corp. and others
  *
  * This program and the accompanying materials are made available under
  * the terms of the Eclipse Public License 2.0 which accompanies this
@@ -99,7 +99,6 @@
 import com.ibm.j9ddr.vm29.structure.J9RAMStringRef;
 import com.ibm.j9ddr.vm29.structure.J9ROMFieldOffsetWalkState;
 import com.ibm.j9ddr.vm29.structure.J9VTableHeader;
-import com.ibm.j9ddr.vm29.structure.J9JavaAccessFlags;
 import com.ibm.j9ddr.vm29.tools.ddrinteractive.IClassWalkCallbacks.SlotType;
 import com.ibm.j9ddr.vm29.types.Scalar;
 import com.ibm.j9ddr.vm29.types.U32;
@@ -225,7 +224,7 @@ private void allSlotsIniTableDo() throws CorruptDataException {
 			 * The iTables for the interface classes do not contain entries for
 			 * methods.
 			 */
-			if (!ramClass.romClass().modifiers().allBitsIn(J9JavaAccessFlags.J9AccInterface)) {
+			if (!ramClass.romClass().modifiers().allBitsIn(J9Consts.J9_JAVA_INTERFACE)) {
 				int methodCount = iTable.interfaceClass().romClass().romMethodCount().intValue();
 				for (int i = 0; i < methodCount; i++) {
 					/*

debugtools/DDR_VM/src/com/ibm/j9ddr/vm29/tools/ddrinteractive/commands/ITableSizeCommand.java

@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2017, 2019 IBM Corp. and others
+ * Copyright (c) 2017, 2018 IBM Corp. and others
  *
  * This program and the accompanying materials are made available under
  * the terms of the Eclipse Public License 2.0 which accompanies this
@@ -38,7 +38,6 @@
 import com.ibm.j9ddr.vm29.types.UDATA;
 import com.ibm.j9ddr.vm29.structure.J9ITable;
 import static com.ibm.j9ddr.vm29.structure.J9Consts.*;
-import static com.ibm.j9ddr.vm29.structure.J9JavaAccessFlags.*;
 
 public class ITableSizeCommand extends Command 
 {
@@ -91,7 +90,7 @@ public void run(String command, String[] args, Context context, PrintStream out)
 			ClassSegmentIterator classSegmentIterator = new ClassSegmentIterator(vm.classMemorySegments());
 			while (classSegmentIterator.hasNext()) {
 				J9ClassPointer clazz = (J9ClassPointer) classSegmentIterator.next();
-				int classDepth = clazz.classDepthAndFlags().bitAnd(J9AccClassDepthMask).intValue();
+				int classDepth = clazz.classDepthAndFlags().bitAnd(J9_JAVA_CLASS_DEPTH_MASK).intValue();
 				J9ITablePointer superITable = J9ITablePointer.NULL;
 				J9ITablePointer startITable = J9ITablePointer.cast(clazz.iTable());
 				if (0 != classDepth) {

debugtools/DDR_VM/src/com/ibm/j9ddr/vm29/tools/ddrinteractive/gccheck/CheckEngine.java

@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2019 IBM Corp. and others
+ * Copyright (c) 2001, 2018 IBM Corp. and others
  *
  * This program and the accompanying materials are made available under
  * the terms of the Eclipse Public License 2.0 which accompanies this
@@ -79,7 +79,7 @@
 import static com.ibm.j9ddr.vm29.structure.J9Object.*;
 import static com.ibm.j9ddr.vm29.structure.J9ROMFieldOffsetWalkState.J9VM_FIELD_OFFSET_WALK_INCLUDE_STATIC;
 import static com.ibm.j9ddr.vm29.structure.J9ROMFieldOffsetWalkState.J9VM_FIELD_OFFSET_WALK_ONLY_OBJECT_SLOTS;
-import static com.ibm.j9ddr.vm29.structure.J9JavaAccessFlags.J9AccClassDying;
+import static com.ibm.j9ddr.vm29.structure.J9Consts.J9_JAVA_CLASS_DYING;
 
 class CheckEngine
 {
@@ -1079,7 +1079,7 @@ private int checkJ9ClassHeader(J9ClassPointer clazz) throws CorruptDataException
 
 	private int checkJ9ClassIsNotUnloaded(J9ClassPointer clazz) throws CorruptDataException
 	{
-		if(!clazz.classDepthAndFlags().bitAnd(J9AccClassDying).eq(0)) {
+		if(!clazz.classDepthAndFlags().bitAnd(J9_JAVA_CLASS_DYING).eq(0)) {
 			return J9MODRON_GCCHK_RC_CLASS_IS_UNLOADED;
 		}
 		return J9MODRON_GCCHK_RC_OK;

debugtools/DDR_VM/src/com/ibm/j9ddr/vm29/tools/ddrinteractive/gccheck/CheckVMThreadStacks.java

@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2019 IBM Corp. and others
+ * Copyright (c) 2001, 2014 IBM Corp. and others
  *
  * This program and the accompanying materials are made available under
  * the terms of the Eclipse Public License 2.0 which accompanies this
@@ -38,7 +38,6 @@
 import com.ibm.j9ddr.vm29.pointer.helper.J9UTF8Helper;
 
 import static com.ibm.j9ddr.vm29.structure.J9Consts.*;
-import static com.ibm.j9ddr.vm29.structure.J9JavaAccessFlags.*;
 import static com.ibm.j9ddr.vm29.tools.ddrinteractive.gccheck.ScanFormatter.formatPointer;
 
 class CheckVMThreadStacks extends Check
@@ -147,7 +146,7 @@ public FrameCallbackResult frameWalkFunction(J9VMThreadPointer walkThread, WalkS
 
 						try {
 							J9ROMMethodPointer romMethod = J9MethodHelper.romMethod(walkState.method);
-							isNative = romMethod.modifiers().allBitsIn(J9AccNative);
+							isNative = romMethod.modifiers().allBitsIn(J9_JAVA_NATIVE);
 							if(!isNative) {
 								bytecodes = J9ROMMethodHelper.bytecodes(romMethod);
 							}

debugtools/DDR_VM/src/com/ibm/j9ddr/vm29/view/dtfj/java/DTFJJavaClass.java

@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 1991, 2019 IBM Corp. and others
+ * Copyright (c) 1991, 2018 IBM Corp. and others
  *
  * This program and the accompanying materials are made available under
  * the terms of the Eclipse Public License 2.0 which accompanies this
@@ -61,7 +61,6 @@
 import com.ibm.j9ddr.vm29.pointer.helper.J9ClassHelper;
 import com.ibm.j9ddr.vm29.pointer.helper.J9UTF8Helper;
 import com.ibm.j9ddr.vm29.structure.J9Consts;
-import com.ibm.j9ddr.vm29.structure.J9JavaAccessFlags;
 import com.ibm.j9ddr.vm29.structure.J9ROMFieldOffsetWalkState;
 import com.ibm.j9ddr.vm29.types.U32;
 import com.ibm.j9ddr.vm29.view.dtfj.DTFJContext;
@@ -542,7 +541,7 @@ public JavaClass getSuperclass() throws CorruptDataException {
 	private boolean isInterface() throws com.ibm.j9ddr.CorruptDataException {
 		if(isInterface == null) {
 			J9ROMClassPointer romclass = j9class.romClass();
-			if(romclass.modifiers().allBitsIn(J9JavaAccessFlags.J9AccInterface)) {
+			if(romclass.modifiers().allBitsIn(J9Consts.J9_JAVA_INTERFACE)) {
 				isInterface = true;
 			} else {
 				isInterface = false;

runtime/bcverify/clconstraints.c

@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 1991, 2019 IBM Corp. and others
+ * Copyright (c) 1991, 2017 IBM Corp. and others
  *
  * This program and the accompanying materials are made available under
  * the terms of the Eclipse Public License 2.0 which accompanies this
@@ -350,7 +350,7 @@ unlinkClassLoadingConstraints (J9JavaVM* jvm)
 				/* mark the constraint as unsatisfied if it refers to a dying loader */
 				J9Class* clazz = constraint->clazz;
 
-				if ((NULL != clazz) && (J9AccClassDying == (J9CLASS_FLAGS(clazz) & J9AccClassDying))) {
+				if ((NULL != clazz) && (J9_JAVA_CLASS_DYING == (J9CLASS_FLAGS(clazz) & J9_JAVA_CLASS_DYING))) {
 					constraint->clazz = NULL;
 				}
 			}

runtime/codert_vm/decomp.cpp

@@ -1000,7 +1000,7 @@ fixStackForNewDecompilation(J9VMThread * currentThread, J9StackWalkState * walkS
 		UDATA resolveFrameType = walkState->resolveFrameFlags & J9_STACK_FLAGS_JIT_FRAME_SUB_TYPE_MASK;
 		switch(resolveFrameType) {
 		case J9_STACK_FLAGS_JIT_STACK_OVERFLOW_RESOLVE_FRAME:
-			if (J9_ARE_ANY_BITS_SET(J9_ROM_METHOD_FROM_RAM_METHOD(walkState->method)->modifiers, J9AccSynchronized)) {
+			if (J9_ARE_ANY_BITS_SET(J9_ROM_METHOD_FROM_RAM_METHOD(walkState->method)->modifiers, J9_JAVA_SYNC)) {
 				Trc_Decomp_addDecompilation_beforeSyncMonitorEnter(currentThread);
 				*pcStoreAddress = (U_8 *) J9_BUILDER_SYMBOL(jitDecompileBeforeMethodMonitorEnter);
 				break;

runtime/codert_vm/fsdcsup.c

@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 1991, 2019 IBM Corp. and others
+ * Copyright (c) 1991, 2014 IBM Corp. and others
  *
  * This program and the accompanying materials are made available under
  * the terms of the Eclipse Public License 2.0 which accompanies this
@@ -37,7 +37,7 @@ jitResetAllUntranslateableMethods(J9VMThread *vmThread)
 				J9Method *method = clazz->ramMethods;
 				UDATA methodCount = clazz->romClass->romMethodCount;
 				while(0 != methodCount) {
-					if(0 == ((J9AccNative | J9AccAbstract) & J9_ROM_METHOD_FROM_RAM_METHOD(method)->modifiers)) {
+					if(0 == ((J9_JAVA_NATIVE | J9_JAVA_ABSTRACT) & J9_ROM_METHOD_FROM_RAM_METHOD(method)->modifiers)) {
 						if(J9_JIT_NEVER_TRANSLATE == (IDATA)method->extra) {
 							/* This call resets the methodRunAddress to the JIT counting send target, and reinitializes the count (extra) field. */
 							vmThread->javaVM->internalVMFunctions->initializeMethodRunAddress(vmThread, method);

runtime/compiler/arm/codegen/J9ARMEvaluator.cpp

@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2000, 2019 IBM Corp. and others
+ * Copyright (c) 2000, 2018 IBM Corp. and others
  *
  * This program and the accompanying materials are made available under
  * the terms of the Eclipse Public License 2.0 which accompanies this
@@ -151,7 +151,7 @@ static TR::Instruction *genTestIsSuper(TR::CodeGenerator *cg,
                                       TR::LabelSymbol    *doneLabel)
    {
    uint32_t base, rotate;
-   uint32_t shiftAmount      = leadingZeroes(J9AccClassDepthMask);
+   uint32_t shiftAmount      = leadingZeroes(J9_JAVA_CLASS_DEPTH_MASK);
    int32_t  superClassOffset = castClassDepth << 2;
    bool     outOfBound       = (superClassOffset > UPPER_IMMED12 || superClassOffset < LOWER_IMMED12);
    bool     regDepth         = !constantIsImmed8r(castClassDepth, &base, &rotate);

runtime/compiler/compile/J9Compilation.cpp

@@ -535,10 +535,10 @@ J9::Compilation::canAllocateInlineOnStack(TR::Node* node, TR_OpaqueClassBlock* &
          return -1;
 
       // Can not inline the allocation on stack if the class is special
-      if (clazz->classDepthAndFlags & (J9AccClassReferenceWeak      |
-                                       J9AccClassReferenceSoft      |
-                                       J9AccClassFinalizeNeeded            |
-                                       J9AccClassOwnableSynchronizer))
+      if (clazz->classDepthAndFlags & (J9_JAVA_CLASS_REFERENCE_WEAK      |
+                                       J9_JAVA_CLASS_REFERENCE_SOFT      |
+                                       J9_JAVA_CLASS_FINALIZE            |
+                                       J9_JAVA_CLASS_OWNABLE_SYNCHRONIZER))
          {
          return -1;
          }
@@ -561,7 +561,7 @@ J9::Compilation::canAllocateInlineClass(TR_OpaqueClassBlock *block)
       return false;
 
    // Can not inline the allocation if the class is an interface or abstract
-   if (clazz->romClass->modifiers & (J9AccAbstract | J9AccInterface))
+   if (clazz->romClass->modifiers & (J9_JAVA_ABSTRACT | J9_JAVA_INTERFACE))
       return false;
 
    return true;

runtime/compiler/control/CompilationThread.cpp

@@ -2561,7 +2561,7 @@ void printAllCounts(J9JavaVM *javaVM)
             {
             J9Method * method = &ramMethods[m];
             J9ROMMethod * romMethod = J9_ROM_METHOD_FROM_RAM_METHOD(method);
-            if (!(romMethod->modifiers & (J9AccNative | J9AccAbstract)) &&
+            if (!(romMethod->modifiers & (J9_JAVA_NATIVE | J9_JAVA_ABSTRACT)) &&
                 method != newInstanceThunk &&
                 !TR::CompilationInfo::isCompiled(method))
                {

runtime/compiler/control/HookedByTheJit.cpp

@@ -30,7 +30,6 @@
 #include "j9cfg.h"
 #include "j9modron.h"
 #include "j9nonbuilder.h"
-#include "j9consts.h"
 #include "mmhook.h"
 #include "mmomrhook.h"
 #include "vmaccess.h"
@@ -841,7 +840,7 @@ void DLTLogic(J9VMThread* vmThread, TR::CompilationInfo *compInfo)
        ((intptrj_t)(walkState.method->constantPool) & J9_STARTPC_JNI_NATIVE) ||
        !J9ROMMETHOD_HAS_BACKWARDS_BRANCHES(romMethod) ||
        TR::CompilationInfo::getJ9MethodVMExtra(walkState.method)==J9_JIT_NEVER_TRANSLATE ||
-       (J9CLASS_FLAGS(J9_CLASS_FROM_METHOD(walkState.method)) & J9AccClassHotSwappedOut) ||
+       (J9CLASS_FLAGS(J9_CLASS_FROM_METHOD(walkState.method)) & J9_JAVA_CLASS_HOT_SWAPPED_OUT) ||
        walkState.bytecodePCOffset<=0)      // FIXME: Deal with loop back on entry later
       {
       dltBlock->methods[idx] = 0;
@@ -2495,7 +2494,7 @@ static void jitHookClassesUnload(J9HookInterface * * hookInterface, UDATA eventN
          // If the romableAotITable field is set to 0, that means this class was not caught
          // by the JIT load hook and has not been loaded.
          //
-         if (J9CLASS_FLAGS(j9clazz) &  J9AccClassDying && j9clazz->romableAotITable !=0 )
+         if (J9CLASS_FLAGS(j9clazz) &  J9_JAVA_CLASS_DYING && j9clazz->romableAotITable !=0 )
             {
             clazz = ((TR_J9VMBase *)fe)->convertClassPtrToClassOffset(j9clazz);
             table->classGotUnloadedPost(fe,clazz); // side-effect: builds the array of visited superclasses
@@ -3156,7 +3155,7 @@ static void updateOverriddenFlag( J9VMThread *vm , J9Class *cl)
 
    J9ROMClass *ROMCl = cl->romClass;
 
-   if(ROMCl->modifiers &  J9AccInterface )   //Do nothing if interface
+   if(ROMCl->modifiers & J9_JAVA_INTERFACE  )   //Do nothing if interface
       return;
 
    int32_t classDepth = J9CLASS_DEPTH(cl) - 1;
@@ -3516,7 +3515,7 @@ static bool updateCHTable(J9VMThread * vmThread, J9Class  * cl)
    if (classDepth >= 0)
       {
       J9Class * superCl = cl->superclasses[classDepth];
-      superCl->classDepthAndFlags |= J9AccClassHasBeenOverridden;
+      superCl->classDepthAndFlags |= J9_JAVA_CLASS_HAS_BEEN_OVERRIDDEN;
 
       TR_OpaqueClassBlock *superClazz = ((TR_J9VMBase *)vm)->convertClassPtrToClassOffset(superCl);
       if (p)
@@ -3534,7 +3533,7 @@ static bool updateCHTable(J9VMThread * vmThread, J9Class  * cl)
          superCl = iTableEntry->interfaceClass;
          if (superCl != cl)
             {
-            superCl->classDepthAndFlags |= J9AccClassHasBeenOverridden;
+            superCl->classDepthAndFlags |= J9_JAVA_CLASS_HAS_BEEN_OVERRIDDEN;
             superClazz = ((TR_J9VMBase *)vm)->convertClassPtrToClassOffset(superCl);
             if (p)
                {
@@ -4004,7 +4003,7 @@ static void jitHookClassLoad(J9HookInterface * * hookInterface, UDATA eventNum,
    // ALI 20031015: I think I have fixed the above todo - we should never
    // get an inconsistent state now.  The following should be unnecessary -
    // verify and remove  FIXME
-   cl->classDepthAndFlags &= ~J9AccClassHasBeenOverridden;
+   cl->classDepthAndFlags &= ~J9_JAVA_CLASS_HAS_BEEN_OVERRIDDEN;
 
    J9ClassLoader *classLoader = cl->classLoader;