Fix unnamed module spelling mistake

ThanHenderson · ThanHenderson · commit 681725ef53cd · 2024-11-15T11:28:44.000-08:00
Signed-off-by: Nathan Henderson &lt;nathan.henderson@ibm.com&gt;
diff --git a/runtime/gc_base/RootScanner.cpp b/runtime/gc_base/RootScanner.cpp
@@ -102,7 +102,7 @@ MM_RootScanner::scanModularityObjects(J9ClassLoader * classLoader)
 		}
 
 		if (classLoader == _javaVM->systemClassLoader) {
-			doSlot(&_javaVM->unamedModuleForSystemLoader->moduleObject);
+			doSlot(&_javaVM->unnamedModuleForSystemLoader->moduleObject);
 		}
 	}
 }
diff --git a/runtime/gc_glue_java/ConcurrentMarkingDelegate.cpp b/runtime/gc_glue_java/ConcurrentMarkingDelegate.cpp
@@ -439,7 +439,7 @@ MM_ConcurrentMarkingDelegate::concurrentClassMark(MM_EnvironmentBase *env, bool
 					}
 
 					if (classLoader == _javaVM->systemClassLoader) {
-						_markingScheme->markObject(env, _javaVM->unamedModuleForSystemLoader->moduleObject);
+						_markingScheme->markObject(env, _javaVM->unnamedModuleForSystemLoader->moduleObject);
 					}
 				}
 
diff --git a/runtime/gc_glue_java/MarkingDelegate.cpp b/runtime/gc_glue_java/MarkingDelegate.cpp
@@ -425,7 +425,7 @@ MM_MarkingDelegate::completeMarking(MM_EnvironmentBase *env)
 									}
 
 									if (classLoader == javaVM->systemClassLoader) {
-										_markingScheme->markObjectNoCheck(env, (omrobjectptr_t )javaVM->unamedModuleForSystemLoader->moduleObject);
+										_markingScheme->markObjectNoCheck(env, (omrobjectptr_t )javaVM->unnamedModuleForSystemLoader->moduleObject);
 									}
 								}
 							}
diff --git a/runtime/gc_glue_java/MetronomeDelegate.cpp b/runtime/gc_glue_java/MetronomeDelegate.cpp
@@ -1046,7 +1046,7 @@ MM_MetronomeDelegate::doClassTracing(MM_EnvironmentRealtime *env)
 						}
 
 						if (classLoader == _javaVM->systemClassLoader) {
-							didWork |= _markingScheme->markObject(env, _javaVM->unamedModuleForSystemLoader->moduleObject);
+							didWork |= _markingScheme->markObject(env, _javaVM->unnamedModuleForSystemLoader->moduleObject);
 						}
 					}
 				}
diff --git a/runtime/gc_vlhgc/CopyForwardScheme.cpp b/runtime/gc_vlhgc/CopyForwardScheme.cpp
@@ -2697,7 +2697,7 @@ MM_CopyForwardScheme::scanClassLoaderObjectSlots(MM_EnvironmentVLHGC *env, MM_Al
 				}
 
 				if (success && (classLoader == _javaVM->systemClassLoader)) {
-					success = copyAndForward(env, reservingContext, classLoaderObject, (J9Object **)&(_javaVM->unamedModuleForSystemLoader->moduleObject));
+					success = copyAndForward(env, reservingContext, classLoaderObject, (J9Object **)&(_javaVM->unnamedModuleForSystemLoader->moduleObject));
 				}
 			}
 		}
@@ -4447,7 +4447,7 @@ MM_CopyForwardScheme::scanRoots(MM_EnvironmentVLHGC* env)
 									}
 
 									if (success && (classLoader == _javaVM->systemClassLoader)) {
-										success = copyAndForward(env, getContextForHeapAddress(_javaVM->unamedModuleForSystemLoader->moduleObject), (J9Object **)&(_javaVM->unamedModuleForSystemLoader->moduleObject));
+										success = copyAndForward(env, getContextForHeapAddress(_javaVM->unnamedModuleForSystemLoader->moduleObject), (J9Object **)&(_javaVM->unnamedModuleForSystemLoader->moduleObject));
 									}
 								}
 							}
diff --git a/runtime/gc_vlhgc/GlobalMarkCardScrubber.cpp b/runtime/gc_vlhgc/GlobalMarkCardScrubber.cpp
@@ -299,9 +299,9 @@ MM_GlobalMarkCardScrubber::scrubClassLoaderObject(MM_EnvironmentVLHGC *env, J9Ob
 			}
 
 			if (classLoader == javaVM->systemClassLoader) {
-				Assert_MM_true(NULL != javaVM->unamedModuleForSystemLoader->moduleObject);
+				Assert_MM_true(NULL != javaVM->unnamedModuleForSystemLoader->moduleObject);
 				if (doScrub) {
-					doScrub = mayScrubReference(env, classLoaderObject, javaVM->unamedModuleForSystemLoader->moduleObject);
+					doScrub = mayScrubReference(env, classLoaderObject, javaVM->unnamedModuleForSystemLoader->moduleObject);
 				}
 			}
 		}
diff --git a/runtime/gc_vlhgc/GlobalMarkingScheme.cpp b/runtime/gc_vlhgc/GlobalMarkingScheme.cpp
@@ -908,9 +908,9 @@ MM_GlobalMarkingScheme::scanClassLoaderObject(MM_EnvironmentVLHGC *env, J9Object
 			}
 
 			if (classLoader == _javaVM->systemClassLoader) {
-				Assert_MM_true(NULL != _javaVM->unamedModuleForSystemLoader->moduleObject);
-				markObject(env, _javaVM->unamedModuleForSystemLoader->moduleObject);
-				rememberReferenceIfRequired(env, classLoaderObject, _javaVM->unamedModuleForSystemLoader->moduleObject);
+				Assert_MM_true(NULL != _javaVM->unnamedModuleForSystemLoader->moduleObject);
+				markObject(env, _javaVM->unnamedModuleForSystemLoader->moduleObject);
+				rememberReferenceIfRequired(env, classLoaderObject, _javaVM->unnamedModuleForSystemLoader->moduleObject);
 			}
 		}
 	}
diff --git a/runtime/gc_vlhgc/WriteOnceCompactor.cpp b/runtime/gc_vlhgc/WriteOnceCompactor.cpp
@@ -1359,7 +1359,7 @@ MM_WriteOnceCompactor::fixupClassLoaderObject(MM_EnvironmentVLHGC* env, J9Object
 			}
 
 			if (classLoader == _javaVM->systemClassLoader) {
-				slotPtr = &_javaVM->unamedModuleForSystemLoader->moduleObject;
+				slotPtr = &_javaVM->unnamedModuleForSystemLoader->moduleObject;
 
 				originalObject = *slotPtr;
 				J9Object* forwardedObject = getForwardWrapper(env, originalObject, cache);
diff --git a/runtime/j9vm/java11vmi.c b/runtime/j9vm/java11vmi.c
@@ -71,7 +71,7 @@ static UDATA addModuleDefinition(J9VMThread * currentThread, J9Module * fromModu
 static BOOLEAN isPackageDefined(J9VMThread * currentThread, J9ClassLoader * classLoader, const char *packageName);
 static BOOLEAN areNoPackagesDefined(J9VMThread * currentThread, J9ClassLoader * classLoader, const char* const* packages, U_32 numPackages);
 static UDATA exportPackageToAll(J9VMThread * currentThread, J9Module * fromModule, const char *package);
-static UDATA exportPackageToAllUnamed(J9VMThread * currentThread, J9Module * fromModule, const char *package);
+static UDATA exportPackageToAllUnnamed(J9VMThread *currentThread, J9Module *fromModule, const char *package);
 static UDATA exportPackageToModule(J9VMThread * currentThread, J9Module * fromModule, const char *package, J9Module * toModule);
 static void trcModulesCreationPackage(J9VMThread * currentThread, J9Module * fromModule, const char *package);
 static void trcModulesAddModuleExportsToAll(J9VMThread * currentThread, J9Module * fromModule, const char *package);
@@ -281,7 +281,7 @@ createModule(J9VMThread * currentThread, j9object_t moduleObject, J9ClassLoader
 	} else {
 		if (NULL == moduleName) {
 			/* moduleName is passed as NULL for the unnamed module for bootloader created by JVM_SetBootLoaderUnnamedModule() */
-			j9mod = vm->unamedModuleForSystemLoader;
+			j9mod = vm->unnamedModuleForSystemLoader;
 		} else {
 			j9mod = vm->javaBaseModule;
 			j9mod->isLoose = TRUE;
@@ -561,7 +561,7 @@ trcModulesAddModuleExportsToAllUnnamed(J9VMThread * currentThread, J9Module * fr
 }
 
 static UDATA
-exportPackageToAllUnamed(J9VMThread * currentThread, J9Module * fromModule, const char *package)
+exportPackageToAllUnnamed(J9VMThread * currentThread, J9Module * fromModule, const char *package)
 {
 	UDATA retval = ERRCODE_GENERAL_FAILURE;
 	J9Package * const j9package = getPackageDefinition(currentThread, fromModule, package, &retval);
@@ -914,9 +914,9 @@ JVM_DefineModule(JNIEnv * env, jobject module, jboolean isOpen, jstring version,
 							}
 
 #if JAVA_SPEC_VERSION >= 21
-							/* vm->unamedModuleForSystemLoader->moduleObject was saved by JVM_SetBootLoaderUnnamedModule */
+							/* vm->unnamedModuleForSystemLoader->moduleObject was saved by JVM_SetBootLoaderUnnamedModule */
 							{
-								j9object_t moduleObject = vm->unamedModuleForSystemLoader->moduleObject;
+								j9object_t moduleObject = vm->unnamedModuleForSystemLoader->moduleObject;
 								Assert_SC_notNull(moduleObject);
 								J9VMJAVALANGCLASSLOADER_SET_UNNAMEDMODULE(currentThread, systemClassLoader->classLoaderObject, moduleObject);
 								Trc_MODULE_defineModule_setBootloaderUnnamedModule(currentThread);
@@ -1022,7 +1022,7 @@ JVM_AddModuleExports(JNIEnv * env, jobject fromModule, const char *package, jobj
 		J9Module * const j9ToMod = getJ9Module(currentThread, toModule);
 
 		if (isModuleUnnamed(currentThread, J9_JNI_UNWRAP_REFERENCE(toModule))) {
-			rc = exportPackageToAllUnamed(currentThread, j9FromMod, package);
+			rc = exportPackageToAllUnnamed(currentThread, j9FromMod, package);
 		} else {
 			rc = exportPackageToModule(currentThread, j9FromMod, package, j9ToMod);
 		}
@@ -1339,9 +1339,9 @@ JVM_AddModuleExportsToAllUnnamed(JNIEnv * env, jobject fromModule, const char *p
 	{
 		UDATA rc = ERRCODE_GENERAL_FAILURE;
 
-		J9Module * const j9FromMod = getJ9Module(currentThread, fromModule);
+		J9Module *const j9FromMod = getJ9Module(currentThread, fromModule);
 
-		rc = exportPackageToAllUnamed(currentThread, j9FromMod, package);
+		rc = exportPackageToAllUnnamed(currentThread, j9FromMod, package);
 
 		if (ERRCODE_SUCCESS != rc) {
 			throwExceptionHelper(currentThread, rc);
@@ -1501,7 +1501,7 @@ JVM_WaitForReferencePendingList(JNIEnv *env)
 
 /**
  * Adds an unnamed module to the bootLoader
- * JDK21+ saves it to J9JavaVM->unamedModuleForSystemLoader->moduleObject,
+ * JDK21+ saves it to J9JavaVM->unnamedModuleForSystemLoader->moduleObject,
  * and delays bootclassloader.unnamedModule setting until java.base module is created.
  *
  * @param module module
@@ -1539,16 +1539,16 @@ JVM_SetBootLoaderUnnamedModule(JNIEnv *env, jobject module)
 				vmFuncs->setCurrentExceptionUTF(currentThread, J9VMCONSTANTPOOL_JAVALANGILLEGALARGUMENTEXCEPTION, "module was not loaded by the bootclassloader");
 			} else {
 #if JAVA_SPEC_VERSION >= 21
-				J9Module *unamedModuleForSystemLoader = vm->unamedModuleForSystemLoader;
+				J9Module *unnamedModuleForSystemLoader = vm->unnamedModuleForSystemLoader;
 				/* can't set bootclassloader.unnamedModule since bootclassloader hasn't finished the initialization yet */
-				if (NULL == unamedModuleForSystemLoader) {
-					vmFuncs->setCurrentExceptionUTF(currentThread, J9VMCONSTANTPOOL_JAVALANGINTERNALERROR, "unamedModuleForSystemLoader was not initialized");
-				} else if (NULL != unamedModuleForSystemLoader->moduleObject) {
-					vmFuncs->setCurrentExceptionUTF(currentThread, J9VMCONSTANTPOOL_JAVALANGINTERNALERROR, "module is already set in the unamedModuleForSystemLoader");
+				if (NULL == unnamedModuleForSystemLoader) {
+					vmFuncs->setCurrentExceptionUTF(currentThread, J9VMCONSTANTPOOL_JAVALANGINTERNALERROR, "unnamedModuleForSystemLoader was not initialized");
+				} else if (NULL != unnamedModuleForSystemLoader->moduleObject) {
+					vmFuncs->setCurrentExceptionUTF(currentThread, J9VMCONSTANTPOOL_JAVALANGINTERNALERROR, "module is already set in the unnamedModuleForSystemLoader");
 				} else {
 					J9Module *j9mod = createModule(currentThread, modObj, systemClassLoader, NULL /* NULL name field */);
-					unamedModuleForSystemLoader->moduleObject = modObj;
-					Trc_MODULE_setUnamedModuleForSystemLoaderModuleObject(currentThread, j9mod, unamedModuleForSystemLoader);
+					unnamedModuleForSystemLoader->moduleObject = modObj;
+					Trc_MODULE_setUnnamedModuleForSystemLoaderModuleObject(currentThread, j9mod, unnamedModuleForSystemLoader);
 				}
 #else /* JAVA_SPEC_VERSION >= 21 */
 				if (NULL == J9VMJAVALANGCLASSLOADER_UNNAMEDMODULE(currentThread, systemClassLoader->classLoaderObject)) {
diff --git a/runtime/oti/j9.h b/runtime/oti/j9.h
@@ -287,7 +287,7 @@ static const struct { \
 #define internalExitVMToJNI internalReleaseVMAccess
 #endif /* !J9VM_INTERP_ATOMIC_FREE_JNI */
 
-#define J9_IS_J9MODULE_UNNAMED(vm, module) ((NULL == module) || (module == vm->unamedModuleForSystemLoader))
+#define J9_IS_J9MODULE_UNNAMED(vm, module) ((NULL == module) || (module == vm->unnamedModuleForSystemLoader))
 
 #define J9_IS_J9MODULE_OPEN(module) (TRUE == module->isOpen)
 
diff --git a/runtime/oti/j9nonbuilder.h b/runtime/oti/j9nonbuilder.h
@@ -6104,7 +6104,7 @@ typedef struct J9JavaVM {
 	omrthread_monitor_t classLoaderModuleAndLocationMutex;
 	struct J9Pool* modularityPool;
 	struct J9Module *javaBaseModule;
-	struct J9Module *unamedModuleForSystemLoader;
+	struct J9Module *unnamedModuleForSystemLoader;
 	J9ClassPathEntry *modulesPathEntry;
 	jclass jimModules;
 	jmethodID addReads;
diff --git a/runtime/util/module.tdf b/runtime/util/module.tdf
@@ -55,5 +55,5 @@ TraceEvent=Trc_MODULE_addModulePackage Overhead=1 Level=5 Test Template="JVM_Add
 TraceEvent=Trc_MODULE_setPackage Overhead=1 Level=5 Test Template="internally set package/class: %.*s, loader: %s (0x%p), module: %s (0x%p)"
 TraceEvent=Trc_MODULE_invokeHashTableAtPut Overhead=1 Level=5 Test Template="%s invokes hashTableAtPut() : 0x%p->table (0x%p), value (0x%p, 0x%p) collisionIsFailure (%s)"
 TraceEvent=Trc_MODULE_hashTableAtPut NoEnv Overhead=1 Level=5 Test Template="hashTableAtPut() : table (0x%p), value (0x%p) node (0x%p) collisionIsFailure(false)"
-TraceEvent=Trc_MODULE_setUnamedModuleForSystemLoaderModuleObject Overhead=1 Level=5 Template="JVM_SetBootLoaderUnnamedModule() sets unnamed module (0x%p) for unamedModuleForSystemLoader (0x%p)"
+TraceEvent=Trc_MODULE_setUnnamedModuleForSystemLoaderModuleObject Overhead=1 Level=5 Template="JVM_SetBootLoaderUnnamedModule() sets unnamed module (0x%p) for unnamedModuleForSystemLoader (0x%p)"
 TraceEvent=Trc_MODULE_defineModule_setBootloaderUnnamedModule Overhead=1 Level=5 Template="JVM_DefineModule() sets unnamed module for boot loader"
diff --git a/runtime/vm/createramclass.cpp b/runtime/vm/createramclass.cpp
@@ -2470,7 +2470,7 @@ trcModulesSettingPackage(J9VMThread *vmThread, J9Class *ramClass, J9ClassLoader
 	char classLoaderNameBuf[J9VM_PACKAGE_NAME_BUFFER_LENGTH];
 	char *classLoaderNameUTF = NULL;
 
-	if (javaVM->unamedModuleForSystemLoader == ramClass->module) {
+	if (javaVM->unnamedModuleForSystemLoader == ramClass->module) {
 #define SYSTEMLOADER_UNNAMED_NAMED_MODULE   "unnamed module for system loader"
 		memcpy(moduleNameBuf, SYSTEMLOADER_UNNAMED_NAMED_MODULE, sizeof(SYSTEMLOADER_UNNAMED_NAMED_MODULE));
 #undef SYSTEMLOADER_UNNAMED_NAMED_MODULE
@@ -3603,9 +3603,9 @@ internalCreateRAMClassFromROMClass(J9VMThread *vmThread, J9ClassLoader *classLoa
 				 * Therefore J9Class.module should be NULL for classes loaded from classpath by non-bootloaders.
 				 * The call to findModuleForPackage() should correctly set J9Class.module as it would return
 				 * NULL for classes loaded from classpath.
-				 * For bootloader, unnamed module is represented by J9JavaVM.unamedModuleForSystemLoader.
+				 * For bootloader, unnamed module is represented by J9JavaVM.unnamedModuleForSystemLoader.
 				 * Therefore for classes loaded by bootloader from boot classpath,
-				 * J9Class.module should be set to J9JavaVM.unamedModuleForSystemLoader.
+				 * J9Class.module should be set to J9JavaVM.unnamedModuleForSystemLoader.
 				 */
 				bool findModule = false;
 				J9ClassLoader *findModuleClassLoader = classLoader;
@@ -3647,7 +3647,7 @@ internalCreateRAMClassFromROMClass(J9VMThread *vmThread, J9ClassLoader *classLoa
 					}
 
 					if (!findModule) {
-						module = javaVM->unamedModuleForSystemLoader;
+						module = javaVM->unnamedModuleForSystemLoader;
 					}
 				}
 				if (findModule) {
@@ -3657,7 +3657,7 @@ internalCreateRAMClassFromROMClass(J9VMThread *vmThread, J9ClassLoader *classLoa
 					module = findModuleForPackage(vmThread, findModuleClassLoader, J9UTF8_DATA(className), pkgNameLength);
 					omrthread_monitor_exit(classLoaderModuleAndLocationMutex);
 				} else {
-					Assert_VM_true((module == javaVM->unamedModuleForSystemLoader) || (module == hostClass->module));
+					Assert_VM_true((module == javaVM->unnamedModuleForSystemLoader) || (module == hostClass->module));
 				}
 			} else {
 				/* Ignore locationType and assign all classes created before the java.base module is created to java.base.
diff --git a/runtime/vm/jvminit.c b/runtime/vm/jvminit.c
@@ -780,9 +780,9 @@ freeJavaVM(J9JavaVM * vm)
 		vm->modulesPathEntry = NULL;
 	}
 
-	if (NULL != vm->unamedModuleForSystemLoader) {
-		vm->internalVMFunctions->freeJ9Module(vm, vm->unamedModuleForSystemLoader);
-		vm->unamedModuleForSystemLoader = NULL;
+	if (NULL != vm->unnamedModuleForSystemLoader) {
+		vm->internalVMFunctions->freeJ9Module(vm, vm->unnamedModuleForSystemLoader);
+		vm->unnamedModuleForSystemLoader = NULL;
 	}
 
 	if (NULL != vm->modularityPool) {
@@ -2944,12 +2944,12 @@ VMInitStages(J9JavaVM *vm, IDATA stage, void* reserved)
 				}
 				vm->javaBaseModule->classLoader = vm->systemClassLoader;
 
-				vm->unamedModuleForSystemLoader = pool_newElement(vm->modularityPool);
-				if (NULL == vm->unamedModuleForSystemLoader) {
+				vm->unnamedModuleForSystemLoader = pool_newElement(vm->modularityPool);
+				if (NULL == vm->unnamedModuleForSystemLoader) {
 					setErrorJ9dll(PORTLIB, loadInfo, "cannot allocate unnamed module for bootloader", FALSE);
 					goto _error;
 				}
-				vm->unamedModuleForSystemLoader->classLoader = vm->systemClassLoader;
+				vm->unnamedModuleForSystemLoader->classLoader = vm->systemClassLoader;
 
 				patchPathResult = setBootLoaderModulePatchPaths(vm, vm->javaBaseModule, JAVA_BASE_MODULE);
 				if (FALSE == patchPathResult) {
diff --git a/test/functional/Java16andUp/playlist.xml b/test/functional/Java16andUp/playlist.xml
@@ -82,7 +82,7 @@
 	</test>
 
 	<test>
-		<testCaseName>Jep397Tests_testSubClassOfSealedSuperFromDifferentPackageInSameUnamedModule</testCaseName>
+		<testCaseName>Jep397Tests_testSubClassOfSealedSuperFromDifferentPackageInSameUnnamedModule</testCaseName>
 		<disables>
 			<disable>
 				<comment>https://github.com/eclipse-openj9/openj9/issues/14028#issuecomment-988225623</comment>
@@ -91,7 +91,7 @@
 		</disables>
 		<command>$(JAVA_COMMAND) $(JVM_OPTIONS) \
 			-cp $(Q)$(LIB_DIR)$(D)asm.jar$(P)$(RESOURCES_DIR)$(P)$(TESTNG)$(P)$(TEST_RESROOT)$(D)GeneralTest.jar$(Q) \
-			org.testng.TestNG -d $(REPORTDIR) $(Q)$(TEST_RESROOT)$(D)testSubClassOfSealedSuperFromDifferentPackageInSameUnamedModule.xml$(Q) -testnames Jep397Tests_testSubClassOfSealedSuperFromDifferentPackageInSameUnamedModule \
+			org.testng.TestNG -d $(REPORTDIR) $(Q)$(TEST_RESROOT)$(D)testSubClassOfSealedSuperFromDifferentPackageInSameUnnamedModule.xml$(Q) -testnames Jep397Tests_testSubClassOfSealedSuperFromDifferentPackageInSameUnnamedModule \
 			-groups $(TEST_GROUP) \
 			-excludegroups $(DEFAULT_EXCLUDE); \
 			$(TEST_STATUS)
diff --git a/test/functional/Java16andUp/src/org/openj9/test/java/lang/Test_SubClass.java b/test/functional/Java16andUp/src/org/openj9/test/java/lang/Test_SubClass.java
@@ -35,7 +35,7 @@
  * 
  * Verify whether IncompatibleClassChangeError is thrown out when
  * the specified non-public subclass is in a different package from
- * the sealed super class/interface within the same unamed module.
+ * the sealed super class/interface within the same unnamed module.
  */
 @Test(groups = { "level.sanity" })
 public class Test_SubClass {
diff --git a/test/functional/Java16andUp/testSubClassOfSealedSuperFromDifferentPackageInSameUnnamedModule.xml b/test/functional/Java16andUp/testSubClassOfSealedSuperFromDifferentPackageInSameUnnamedModule.xml
@@ -24,7 +24,7 @@
 
 <!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd">
 <suite name="Java16andUp suite" parallel="none" verbose="2">
-	<test name="Jep397Tests_testSubClassOfSealedSuperFromDifferentPackageInSameUnamedModule">
+	<test name="Jep397Tests_testSubClassOfSealedSuperFromDifferentPackageInSameUnnamedModule">
 		<classes>
 			<class name="org.openj9.test.java.lang.Test_SubClass"/>
 		</classes>

Original file line number	Diff line number	Diff line change
`@@ -102,7 +102,7 @@ MM_RootScanner::scanModularityObjects(J9ClassLoader * classLoader)`
`102`	`102`	`}`
`103`	`103`
`104`	`104`	`if (classLoader == _javaVM->systemClassLoader) {`
`105`		`- doSlot(&_javaVM->unamedModuleForSystemLoader->moduleObject);`
	`105`	`+ doSlot(&_javaVM->unnamedModuleForSystemLoader->moduleObject);`
`106`	`106`	`}`
`107`	`107`	`}`
`108`	`108`	`}`
Original file line number	Diff line number	Diff line change
`@@ -439,7 +439,7 @@ MM_ConcurrentMarkingDelegate::concurrentClassMark(MM_EnvironmentBase *env, bool`
`439`	`439`	`}`
`440`	`440`
`441`	`441`	`if (classLoader == _javaVM->systemClassLoader) {`
`442`		`- _markingScheme->markObject(env, _javaVM->unamedModuleForSystemLoader->moduleObject);`
	`442`	`+ _markingScheme->markObject(env, _javaVM->unnamedModuleForSystemLoader->moduleObject);`
`443`	`443`	`}`
`444`	`444`	`}`
`445`	`445`
Original file line number	Diff line number	Diff line change
`@@ -425,7 +425,7 @@ MM_MarkingDelegate::completeMarking(MM_EnvironmentBase *env)`
`425`	`425`	`}`
`426`	`426`
`427`	`427`	`if (classLoader == javaVM->systemClassLoader) {`
`428`		`- _markingScheme->markObjectNoCheck(env, (omrobjectptr_t )javaVM->unamedModuleForSystemLoader->moduleObject);`
	`428`	`+ _markingScheme->markObjectNoCheck(env, (omrobjectptr_t )javaVM->unnamedModuleForSystemLoader->moduleObject);`
`429`	`429`	`}`
`430`	`430`	`}`
`431`	`431`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1046,7 +1046,7 @@ MM_MetronomeDelegate::doClassTracing(MM_EnvironmentRealtime *env)`
`1046`	`1046`	`}`
`1047`	`1047`
`1048`	`1048`	`if (classLoader == _javaVM->systemClassLoader) {`
`1049`		`- didWork \|= _markingScheme->markObject(env, _javaVM->unamedModuleForSystemLoader->moduleObject);`
	`1049`	`+ didWork \|= _markingScheme->markObject(env, _javaVM->unnamedModuleForSystemLoader->moduleObject);`
`1050`	`1050`	`}`
`1051`	`1051`	`}`
`1052`	`1052`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2697,7 +2697,7 @@ MM_CopyForwardScheme::scanClassLoaderObjectSlots(MM_EnvironmentVLHGC *env, MM_Al`
`2697`	`2697`	`}`
`2698`	`2698`
`2699`	`2699`	`if (success && (classLoader == _javaVM->systemClassLoader)) {`
`2700`		`- success = copyAndForward(env, reservingContext, classLoaderObject, (J9Object **)&(_javaVM->unamedModuleForSystemLoader->moduleObject));`
	`2700`	`+ success = copyAndForward(env, reservingContext, classLoaderObject, (J9Object **)&(_javaVM->unnamedModuleForSystemLoader->moduleObject));`
`2701`	`2701`	`}`
`2702`	`2702`	`}`
`2703`	`2703`	`}`
`@@ -4447,7 +4447,7 @@ MM_CopyForwardScheme::scanRoots(MM_EnvironmentVLHGC* env)`
`4447`	`4447`	`}`
`4448`	`4448`
`4449`	`4449`	`if (success && (classLoader == _javaVM->systemClassLoader)) {`
`4450`		`- success = copyAndForward(env, getContextForHeapAddress(_javaVM->unamedModuleForSystemLoader->moduleObject), (J9Object **)&(_javaVM->unamedModuleForSystemLoader->moduleObject));`
	`4450`	`+ success = copyAndForward(env, getContextForHeapAddress(_javaVM->unnamedModuleForSystemLoader->moduleObject), (J9Object **)&(_javaVM->unnamedModuleForSystemLoader->moduleObject));`
`4451`	`4451`	`}`
`4452`	`4452`	`}`
`4453`	`4453`	`}`
Original file line number	Diff line number	Diff line change
`@@ -299,9 +299,9 @@ MM_GlobalMarkCardScrubber::scrubClassLoaderObject(MM_EnvironmentVLHGC *env, J9Ob`
`299`	`299`	`}`
`300`	`300`
`301`	`301`	`if (classLoader == javaVM->systemClassLoader) {`
`302`		`- Assert_MM_true(NULL != javaVM->unamedModuleForSystemLoader->moduleObject);`
	`302`	`+ Assert_MM_true(NULL != javaVM->unnamedModuleForSystemLoader->moduleObject);`
`303`	`303`	`if (doScrub) {`
`304`		`- doScrub = mayScrubReference(env, classLoaderObject, javaVM->unamedModuleForSystemLoader->moduleObject);`
	`304`	`+ doScrub = mayScrubReference(env, classLoaderObject, javaVM->unnamedModuleForSystemLoader->moduleObject);`
`305`	`305`	`}`
`306`	`306`	`}`
`307`	`307`	`}`
Original file line number	Diff line number	Diff line change
`@@ -908,9 +908,9 @@ MM_GlobalMarkingScheme::scanClassLoaderObject(MM_EnvironmentVLHGC *env, J9Object`
`908`	`908`	`}`
`909`	`909`
`910`	`910`	`if (classLoader == _javaVM->systemClassLoader) {`
`911`		`- Assert_MM_true(NULL != _javaVM->unamedModuleForSystemLoader->moduleObject);`
`912`		`- markObject(env, _javaVM->unamedModuleForSystemLoader->moduleObject);`
`913`		`- rememberReferenceIfRequired(env, classLoaderObject, _javaVM->unamedModuleForSystemLoader->moduleObject);`
	`911`	`+ Assert_MM_true(NULL != _javaVM->unnamedModuleForSystemLoader->moduleObject);`
	`912`	`+ markObject(env, _javaVM->unnamedModuleForSystemLoader->moduleObject);`
	`913`	`+ rememberReferenceIfRequired(env, classLoaderObject, _javaVM->unnamedModuleForSystemLoader->moduleObject);`
`914`	`914`	`}`
`915`	`915`	`}`
`916`	`916`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1359,7 +1359,7 @@ MM_WriteOnceCompactor::fixupClassLoaderObject(MM_EnvironmentVLHGC* env, J9Object`
`1359`	`1359`	`}`
`1360`	`1360`
`1361`	`1361`	`if (classLoader == _javaVM->systemClassLoader) {`
`1362`		`- slotPtr = &_javaVM->unamedModuleForSystemLoader->moduleObject;`
	`1362`	`+ slotPtr = &_javaVM->unnamedModuleForSystemLoader->moduleObject;`
`1363`	`1363`
`1364`	`1364`	`originalObject = *slotPtr;`
`1365`	`1365`	`J9Object* forwardedObject = getForwardWrapper(env, originalObject, cache);`