Value type null restricted array support

- create a null restricted array field for every RAM class that could support a flattened field (implicitly constructed) - implement JVM_IsNullRestrictedArray and JVM_NewNullRestrictedArray - Update exception thrown when null is set to a null restricted array from NullPointerException to ArrayStoreException as described in https://openjdk.org/jeps/8316779 Signed-off-by: Theresa Mammarella <[email protected]>
eclipse-openj9 · Aug 2, 2024 · 340d9c0 · 340d9c0
1 parent 795fef0
commit 340d9c0
Show file tree

Hide file tree

Showing 17 changed files with 226 additions and 84 deletions.
diff --git a/runtime/codert_vm/cnathelp.cpp b/runtime/codert_vm/cnathelp.cpp
@@ -40,7 +40,7 @@
 extern "C" {
 
 void* J9FASTCALL
-old_slow_jitThrowNullPointerException(J9VMThread *currentThread);
+old_slow_jitThrowArrayStoreException(J9VMThread *currentThread);
 
 J9_EXTERN_BUILDER_SYMBOL(throwCurrentExceptionFromJIT);
 J9_EXTERN_BUILDER_SYMBOL(handlePopFramesFromJIT);
@@ -1001,7 +1001,7 @@ old_fast_jitLoadFlattenableArrayElement(J9VMThread *currentThread)
 	value = (j9object_t) currentThread->javaVM->internalVMFunctions->loadFlattenableArrayElement(currentThread, arrayObject, index, true);
 	if (NULL == value) {
 		J9ArrayClass *arrayObjectClass = (J9ArrayClass *)J9OBJECT_CLAZZ(currentThread, arrayObject);
-		if (J9_IS_J9CLASS_PRIMITIVE_VALUETYPE(arrayObjectClass->componentType)) {
+		if (J9_IS_J9CLASS_ALLOW_DEFAULT_VALUE(arrayObjectClass->componentType)) {
 			goto slow;
 		}
 	}
@@ -1068,7 +1068,7 @@ old_fast_jitStoreFlattenableArrayElement(J9VMThread *currentThread)
 		goto slow;
 	}
 	arrayrefClass = (J9ArrayClass *) J9OBJECT_CLAZZ(currentThread, arrayref);
-	if ((J9_IS_J9CLASS_PRIMITIVE_VALUETYPE(arrayrefClass->componentType)) && (NULL == value)) {
+	if ((J9_IS_J9CLASS_ALLOW_DEFAULT_VALUE(arrayrefClass->componentType)) && (NULL == value)) {
 		goto slow;
 	}
 	currentThread->javaVM->internalVMFunctions->storeFlattenableArrayElement(currentThread, arrayref, index, value);
@@ -1474,11 +1474,10 @@ old_fast_jitCheckCast(J9VMThread *currentThread)
 			slowPath = (void*)old_slow_jitCheckCast;
 		}
 	}
-#if defined(J9VM_OPT_VALHALLA_FLATTENABLE_VALUE_TYPES)
-	else if (J9_IS_J9CLASS_PRIMITIVE_VALUETYPE(castClass)) {
-		slowPath = (void*)old_slow_jitThrowNullPointerException;
-	}
-#endif /* defined(J9VM_OPT_VALHALLA_FLATTENABLE_VALUE_TYPES) */
+	/* In the future Valhalla checkcast needs to throw exception on
+	 * null restricted checkedType if obj is null,
+	 * see issue https://github.com/eclipse-openj9/openj9/issues/19764
+	 */
 	return slowPath;
 }
 
@@ -1505,8 +1504,8 @@ old_fast_jitCheckCastForArrayStore(J9VMThread *currentThread)
 		}
 	}
 #if defined(J9VM_OPT_VALHALLA_FLATTENABLE_VALUE_TYPES)
-	else if (J9_IS_J9CLASS_PRIMITIVE_VALUETYPE(castClass)) {
-		slowPath = (void*)old_slow_jitThrowNullPointerException;
+	else if (J9_IS_J9ARRAYCLASS_NULL_RESTRICTED(castClass)) {
+		slowPath = (void*)old_slow_jitThrowArrayStoreException;
 	}
 #endif /* defined(J9VM_OPT_VALHALLA_FLATTENABLE_VALUE_TYPES) */
 	return slowPath;
@@ -3610,11 +3609,10 @@ fast_jitCheckCast(J9VMThread *currentThread, J9Class *castClass, j9object_t obje
 			slowPath = (void*)old_slow_jitCheckCast;
 		}
 	}
-#if defined(J9VM_OPT_VALHALLA_FLATTENABLE_VALUE_TYPES)
-	else if (J9_IS_J9CLASS_PRIMITIVE_VALUETYPE(castClass)) {
-		slowPath = (void*)old_slow_jitThrowNullPointerException;
-	}
-#endif /* defined(J9VM_OPT_VALHALLA_FLATTENABLE_VALUE_TYPES) */
+	/* In the future Valhalla checkcast needs to throw exception on
+	 * null restricted checkedType if obj is null,
+	 * see issue https://github.com/eclipse-openj9/openj9/issues/19764
+	 */
 	return slowPath;
 }
 
@@ -3638,8 +3636,8 @@ fast_jitCheckCastForArrayStore(J9VMThread *currentThread, J9Class *castClass, j9
 		}
 	}
 #if defined(J9VM_OPT_VALHALLA_FLATTENABLE_VALUE_TYPES)
-	else if (J9_IS_J9CLASS_PRIMITIVE_VALUETYPE(castClass)) {
-		slowPath = (void*)old_slow_jitThrowNullPointerException;
+	else if (J9_IS_J9ARRAYCLASS_NULL_RESTRICTED(castClass)) {
+		slowPath = (void*)old_slow_jitThrowArrayStoreException;
 	}
 #endif /* defined(J9VM_OPT_VALHALLA_FLATTENABLE_VALUE_TYPES) */
 	return slowPath;

diff --git a/runtime/gc_structs/ClassArrayClassSlotIterator.cpp b/runtime/gc_structs/ClassArrayClassSlotIterator.cpp
@@ -46,10 +46,27 @@ GC_ClassArrayClassSlotIterator::nextSlot()
 			classPtr = (J9Class *)_iterateClazz->arrayClass;
 			if (!_isArrayClass) {
 				_state = classArrayClassSlotIterator_state_done;
+				break;
+#if defined(J9VM_OPT_VALHALLA_FLATTENABLE_VALUE_TYPES)
+			} else if (NULL == classPtr) {
+				classPtr = (J9Class *)_iterateClazz->nullRestrictedArrayClass;
+				_state += classArrayClassSlotIterator_state_componentType;
+#endif /* defined(J9VM_OPT_VALHALLA_FLATTENABLE_VALUE_TYPES) */
 			} else {
 				_state += 1;
+#if defined(J9VM_OPT_VALHALLA_FLATTENABLE_VALUE_TYPES)
+				if (NULL == ((J9ArrayClass *)classPtr)->companionArray) {
+					_state += 1; /* skip nullRestrictedArrayClass case */
+				}
+#endif /* defined(J9VM_OPT_VALHALLA_FLATTENABLE_VALUE_TYPES) */
 			}
 			break;
+#if defined(J9VM_OPT_VALHALLA_FLATTENABLE_VALUE_TYPES)
+		case classArrayClassSlotIterator_state_nullRestrictedArrayClass:
+			classPtr = ((J9ArrayClass *)_iterateClazz)->companionArray;
+			_state += 1;
+			break;
+#endif /* defined(J9VM_OPT_VALHALLA_FLATTENABLE_VALUE_TYPES) */
 		case classArrayClassSlotIterator_state_componentType:
 			classPtr = ((J9ArrayClass *)_iterateClazz)->componentType;
 			_state += 1;

diff --git a/runtime/gc_structs/ClassArrayClassSlotIterator.hpp b/runtime/gc_structs/ClassArrayClassSlotIterator.hpp
@@ -46,6 +46,9 @@ class GC_ClassArrayClassSlotIterator
 
 	enum {
 		classArrayClassSlotIterator_state_arrayClass = 0,
+#if defined(J9VM_OPT_VALHALLA_FLATTENABLE_VALUE_TYPES)
+		classArrayClassSlotIterator_state_nullRestrictedArrayClass,
+#endif /* defined(J9VM_OPT_VALHALLA_FLATTENABLE_VALUE_TYPES) */
 		classArrayClassSlotIterator_state_componentType,
 		classArrayClassSlotIterator_state_leafComponentType,
 		classArrayClassSlotIterator_state_done

diff --git a/runtime/gc_structs/ClassLoaderClassesIterator.cpp b/runtime/gc_structs/ClassLoaderClassesIterator.cpp
@@ -111,6 +111,18 @@ GC_ClassLoaderClassesIterator::nextClass()
 			if ( (result->classLoader == _classLoader) && (NULL != result->arrayClass) ) {
 				/* this class is defined in the loader, so follow its array classes */
 				_nextClass = result->arrayClass;
+#if defined(J9VM_OPT_VALHALLA_FLATTENABLE_VALUE_TYPES)
+			} else if ( (result->classLoader == _classLoader) && (NULL != result->nullRestrictedArrayClass) ) {
+				/* class has a nullRestrictedArrayClass but not an arrayClass*/
+				_nextClass = result->nullRestrictedArrayClass;
+			} else if ( (result->classLoader == _classLoader) 
+				&& J9CLASS_IS_ARRAY(result)
+				&& (NULL != ((J9ArrayClass *)result)->companionArray) 
+				&& J9_IS_J9ARRAYCLASS_NULL_RESTRICTED(((J9ArrayClass *)result)->companionArray)
+			) {
+				/* class has both an arrayClass and nullRestrictedArrayClass */
+				_nextClass = ((J9ArrayClass *)result)->companionArray;
+#endif /* defined(J9VM_OPT_VALHALLA_FLATTENABLE_VALUE_TYPES) */
 			} else if (TABLE_CLASSES == _mode) {
 				_nextClass = nextTableClass();
 			} else {

diff --git a/runtime/j9vm/javanextvmi.cpp b/runtime/j9vm/javanextvmi.cpp
@@ -763,15 +763,62 @@ JVM_IsImplicitlyConstructibleClass(JNIEnv *env, jclass cls)
 JNIEXPORT jboolean JNICALL
 JVM_IsNullRestrictedArray(JNIEnv *env, jobject obj)
 {
-	// TODO implement this with https://github.com/eclipse-openj9/openj9/issues/19460
-	return JNI_FALSE;
+	jboolean result = JNI_FALSE;
+	J9VMThread *currentThread = (J9VMThread *)env;
+	J9InternalVMFunctions *vmFuncs = currentThread->javaVM->internalVMFunctions;
+	vmFuncs->internalEnterVMFromJNI(currentThread);
+	if (NULL == obj) {
+		vmFuncs->setCurrentException(currentThread, J9VMCONSTANTPOOL_JAVALANGNULLPOINTEREXCEPTION, NULL);
+	} else {
+		jclass clazz = env->GetObjectClass(obj);
+		J9Class *j9clazz = J9VM_J9CLASS_FROM_JCLASS(currentThread, clazz);
+		if (J9_IS_J9ARRAYCLASS_NULL_RESTRICTED(j9clazz)) {
+			result = JNI_TRUE;
+		}
+	}
+	vmFuncs->internalExitVMToJNI(currentThread);
+	return result;
 }
 
 JNIEXPORT jarray JNICALL
-JVM_NewNullRestrictedArray(JNIEnv *env, jclass cls, jint length)
+JVM_NewNullRestrictedArray(JNIEnv *env, jclass componentType, jint length)
 {
-	assert(!"JVM_NewNullRestrictedArray unimplemented");
-	return NULL;
+	J9VMThread *currentThread = (J9VMThread *)env;
+	J9JavaVM *vm = currentThread->javaVM;
+	J9InternalVMFunctions *vmFuncs = currentThread->javaVM->internalVMFunctions;
+	J9Class *ramClass = NULL;
+	j9object_t newArray = NULL;
+	jarray arrayRef = NULL;
+
+	vmFuncs->internalEnterVMFromJNI(currentThread);
+	ramClass = J9VMJAVALANGCLASS_VMREF(currentThread, J9_JNI_UNWRAP_REFERENCE(componentType));
+
+	if (!(J9_IS_J9CLASS_VALUETYPE(ramClass) && J9_IS_J9CLASS_ALLOW_DEFAULT_VALUE(ramClass))) {
+		vmFuncs->setCurrentException(currentThread, J9VMCONSTANTPOOL_JAVALANGILLEGALARGUMENTEXCEPTION, NULL);
+		goto done;
+	}
+
+	if (NULL == ramClass->nullRestrictedArrayClass) {
+		J9ROMArrayClass *arrayOfObjectsROMClass = (J9ROMArrayClass*)J9ROMIMAGEHEADER_FIRSTCLASS(vm->arrayROMClasses);
+		vmFuncs->internalCreateArrayClassWithOptions(
+			currentThread, arrayOfObjectsROMClass, ramClass, J9_FINDCLASS_FLAG_CLASS_OPTION_NULL_RESTRICTED_ARRAY);
+		if (NULL != currentThread->currentException) {
+			goto done;
+		}
+	}
+
+	newArray = vm->memoryManagerFunctions->J9AllocateIndexableObject(
+			currentThread, ramClass->nullRestrictedArrayClass, length, J9_GC_ALLOCATE_OBJECT_NON_INSTRUMENTABLE);
+
+	if (NULL == newArray) {
+		vmFuncs->setHeapOutOfMemoryError(currentThread);
+		goto done;
+	}
+
+	arrayRef = (jarray)vmFuncs->j9jni_createLocalRef(env, newArray);
+done:
+	vmFuncs->internalExitVMToJNI(currentThread);
+	return arrayRef;
 }
 #endif /* defined(J9VM_OPT_VALHALLA_VALUE_TYPES) */
 

diff --git a/runtime/oti/j9.h b/runtime/oti/j9.h
@@ -331,7 +331,8 @@ static const struct { \
 
 #if defined(J9VM_OPT_VALHALLA_FLATTENABLE_VALUE_TYPES)
 #define J9CLASS_UNPADDED_INSTANCE_SIZE(clazz) J9_VALUETYPE_FLATTENED_SIZE(clazz)
-/* TODO replace with J9_IS_J9CLASS_ALLOW_DEFAULT_VALUE(clazz) J9_ARE_ALL_BITS_SET((clazz)->classFlags, J9ClassAllowsInitialDefaultValue)*/
+#define J9_IS_J9CLASS_ALLOW_DEFAULT_VALUE(clazz) J9_ARE_ALL_BITS_SET((clazz)->classFlags, J9ClassAllowsInitialDefaultValue)
+/* TODO replace with J9_IS_J9CLASS_ALLOW_DEFAULT_VALUE */
 #define J9_IS_J9CLASS_PRIMITIVE_VALUETYPE(clazz) J9_ARE_ALL_BITS_SET((clazz)->classFlags, J9ClassIsPrimitiveValueType)
 #define J9_IS_J9CLASS_FLATTENED(clazz) J9_ARE_ALL_BITS_SET((clazz)->classFlags, J9ClassIsFlattened)
 
@@ -348,14 +349,17 @@ static const struct { \
 		J9_IS_J9CLASS_FLATTENED(fieldClazz) && \
 		(J9_ARE_NO_BITS_SET((romFieldShape)->modifiers, J9AccVolatile) || (J9CLASS_UNPADDED_INSTANCE_SIZE(fieldClazz) <= sizeof(U_64))))
 #define J9_VALUETYPE_FLATTENED_SIZE(clazz) (J9CLASS_HAS_4BYTE_PREPADDING((clazz)) ? ((clazz)->totalInstanceSize - sizeof(U_32)) : (clazz)->totalInstanceSize)
+#define J9_IS_J9ARRAYCLASS_NULL_RESTRICTED(clazz) J9_ARE_ALL_BITS_SET((clazz)->classFlags, J9ClassArrayIsNullRestricted)
 #else /* defined(J9VM_OPT_VALHALLA_FLATTENABLE_VALUE_TYPES) */
 #define J9CLASS_UNPADDED_INSTANCE_SIZE(clazz) ((clazz)->totalInstanceSize)
+#define J9_IS_J9CLASS_ALLOW_DEFAULT_VALUE(clazz) FALSE
 #define J9_IS_J9CLASS_PRIMITIVE_VALUETYPE(clazz) FALSE
 #define J9_IS_J9CLASS_FLATTENED(clazz) FALSE
 #define J9ROMFIELD_IS_NULL_RESTRICTED(romField) FALSE
 #define J9_IS_FIELD_FLATTENED(fieldClazz, romFieldShape) FALSE
 #define J9_IS_NULL_RESTRICTED_FIELD_FLATTENED(fieldClazz, romFieldShape) FALSE
 #define J9_VALUETYPE_FLATTENED_SIZE(clazz)((UDATA) 0) /* It is not possible for this macro to be used since we always check J9_IS_J9CLASS_FLATTENED before ever using it. */
+#define J9_IS_J9ARRAYCLASS_NULL_RESTRICTED(clazz) FALSE
 #endif /* defined(J9VM_OPT_VALHALLA_FLATTENABLE_VALUE_TYPES) */
 #define IS_REF_OR_VAL_SIGNATURE(firstChar) ('L' == (firstChar))
 

diff --git a/runtime/oti/j9consts.h b/runtime/oti/j9consts.h
@@ -449,6 +449,7 @@ extern "C" {
 #define J9_FINDCLASS_FLAG_DO_NOT_SHARE 0x100000
 #define J9_FINDCLASS_FLAG_LAMBDA 0x200000
 #define J9_FINDCLASS_FLAG_LAMBDAFORM 0x400000
+#define J9_FINDCLASS_FLAG_CLASS_OPTION_NULL_RESTRICTED_ARRAY 0x800000
 
 #define J9_FINDKNOWNCLASS_FLAG_INITIALIZE 0x1
 #define J9_FINDKNOWNCLASS_FLAG_EXISTING_ONLY 0x2

diff --git a/runtime/oti/j9nonbuilder.h b/runtime/oti/j9nonbuilder.h
@@ -92,6 +92,7 @@
 #define J9ClassAllowsInitialDefaultValue 0x400000
 #define J9ClassAllowsNonAtomicCreation 0x800000
 #define J9ClassNeedToPruneMemberNames 0x1000000
+#define J9ClassArrayIsNullRestricted 0x2000000
 
 /* @ddr_namespace: map_to_type=J9FieldFlags */
 
@@ -3396,6 +3397,9 @@ typedef struct J9Class {
 	/* A linked list of weak global references to every resolved MemberName whose clazz is this class. */
 	J9MemberNameListNode *memberNames;
 #endif /* defined(J9VM_OPT_OPENJDK_METHODHANDLE) */
+#if defined(J9VM_OPT_VALHALLA_FLATTENABLE_VALUE_TYPES)
+	struct J9Class *nullRestrictedArrayClass;
+#endif /* defined(J9VM_OPT_VALHALLA_FLATTENABLE_VALUE_TYPES) */
 } J9Class;
 
 /* Interface classes can never be instantiated, so the following fields in J9Class will not be used:
@@ -3492,6 +3496,13 @@ typedef struct J9ArrayClass {
 	/* A linked list of weak global references to every resolved MemberName whose clazz is this class. */
 	J9MemberNameListNode *memberNames;
 #endif /* defined(J9VM_OPT_OPENJDK_METHODHANDLE) */
+#if defined(J9VM_OPT_VALHALLA_FLATTENABLE_VALUE_TYPES)
+	/*
+	 * A nullable J9ArrayClass points to its null restricted companion, if one exists.
+	 * A null restricted J9ArrayClass points to its nullable companion, if one exists.
+	 */
+	struct J9Class *companionArray;
+#endif /* defined(J9VM_OPT_VALHALLA_FLATTENABLE_VALUE_TYPES) */
 } J9ArrayClass;
 
 
@@ -4804,6 +4815,7 @@ typedef struct J9InternalVMFunctions {
 	void  (JNICALL *sendInit)(struct J9VMThread *vmContext, j9object_t object, struct J9Class *senderClass, UDATA lookupOptions) ;
 	void  ( *internalAcquireVMAccessNoMutex)(struct J9VMThread * vmThread) ;
 	struct J9Class*  ( *internalCreateArrayClass)(struct J9VMThread* vmThread, struct J9ROMArrayClass* romClass, struct J9Class* elementClass) ;
+	struct J9Class*  ( *internalCreateArrayClassWithOptions)(struct J9VMThread* vmThread, struct J9ROMArrayClass* romClass, struct J9Class* elementClass, UDATA options) ;
 	IDATA  ( *attachSystemDaemonThread)(struct J9JavaVM * vm, struct J9VMThread ** p_env, const char * threadName) ;
 	void  ( *internalAcquireVMAccessClearStatus)(struct J9VMThread * vmThread, UDATA flags) ;
 #if defined(J9VM_OPT_REFLECT)

diff --git a/runtime/oti/vm_api.h b/runtime/oti/vm_api.h
@@ -357,6 +357,18 @@ peekClassHashTable(J9VMThread* currentThread, J9ClassLoader* classLoader, U_8* c
 J9Class*
 internalCreateArrayClass(J9VMThread* vmThread, J9ROMArrayClass* romClass, J9Class* elementClass);
 
+/**
+* @brief
+* @param vmThread
+* @param romClass
+* @param elementClass
+* @param options
+* @return J9Class*
+*/
+J9Class*
+internalCreateArrayClassWithOptions(J9VMThread* vmThread, J9ROMArrayClass* romClass, J9Class* elementClass, UDATA options);
+
+
 /**
  * Load the class with the specified name in a given module
  *

diff --git a/runtime/vm/BytecodeInterpreter.hpp b/runtime/vm/BytecodeInterpreter.hpp
@@ -6890,8 +6890,8 @@ class INTERPRETER_CLASS
 				} else {
 #if defined(J9VM_OPT_VALHALLA_FLATTENABLE_VALUE_TYPES)
 					J9ArrayClass *arrayrefClass = (J9ArrayClass *) J9OBJECT_CLAZZ(_currentThread, arrayref);
-					if (J9_IS_J9CLASS_PRIMITIVE_VALUETYPE(arrayrefClass->componentType) && (NULL == value)) {
-						rc = THROW_NPE;
+					if (J9_IS_J9ARRAYCLASS_NULL_RESTRICTED(arrayrefClass) && (NULL == value)) {
+						rc = THROW_ARRAY_STORE;
 						goto done;
 					}
 #endif /* if defined(J9VM_OPT_VALHALLA_FLATTENABLE_VALUE_TYPES) */

diff --git a/runtime/vm/ValueTypeHelpers.hpp b/runtime/vm/ValueTypeHelpers.hpp
@@ -512,7 +512,6 @@ class VM_ValueTypeHelpers {
 		I_32 srcEndIndex = srcIndex + lengthInSlots;
 		J9Class *srcClazz = J9OBJECT_CLAZZ(currentThread, srcObject);
 		J9Class *destClazz = J9OBJECT_CLAZZ(currentThread, destObject);
-		J9Class *destComponentClass = ((J9ArrayClass *)destClazz)->componentType;
 
 		/* Array elements must be copied backwards if source and destination overlap in memory and source is before destination */
 		if ((srcObject == destObject) && (srcIndex < destIndex) && ((srcIndex + lengthInSlots) > destIndex)) {
@@ -566,8 +565,8 @@ class VM_ValueTypeHelpers {
 				}
 
 				if (typeChecksRequired) {
-					if (J9_IS_J9CLASS_PRIMITIVE_VALUETYPE(destComponentClass) && (NULL == copyObject)) {
-						/* Null objects cannot be stored in an array of primitive value types */
+					if (J9_IS_J9ARRAYCLASS_NULL_RESTRICTED(destClazz) && (NULL == copyObject)) {
+						/* Null objects cannot be stored in an array of null-restricted value types */
 						return -2;
 					}
 					if (!VM_VMHelpers::objectArrayStoreAllowed(currentThread, destObject, copyObject)) {

diff --git a/runtime/vm/classsupport.c b/runtime/vm/classsupport.c
@@ -196,22 +196,27 @@ findPrimitiveArrayClass(J9JavaVM* vm, jchar sigChar)
  */
 J9Class* 
 internalCreateArrayClass(J9VMThread* vmThread, J9ROMArrayClass* romClass, J9Class* elementClass)
+{
+	return internalCreateArrayClassWithOptions(vmThread, romClass, elementClass, 0);
+}
+
+J9Class*
+internalCreateArrayClassWithOptions(J9VMThread* vmThread, J9ROMArrayClass* romClass, J9Class* elementClass, UDATA options)
 {
 	J9Class *result = NULL;
 	j9object_t heapClass = J9VM_J9CLASS_TO_HEAPCLASS(elementClass);
 	j9object_t protectionDomain = NULL;
 	J9ROMClass* arrayRomClass = (J9ROMClass*) romClass;
 	J9JavaVM *const javaVM = vmThread->javaVM;
-	UDATA options = 0;
 	BOOLEAN elementInitSuccess = TRUE;
 
 #if defined(J9VM_OPT_VALHALLA_FLATTENABLE_VALUE_TYPES)
-	/* When creating an array of valuetype elements, the array elements are initialized to the defaultValue of the
-	 * element type. As a result the element type must be fully initialized (if its a valuetype) before creating an
+	/* When creating an array of implicitly constructible valuetype elements, the array elements are initialized to
+	 * the defaultValue of the element type. As a result the element type must be fully initialized before creating an
 	 * instance of the array. Element class init must be done before the arrayClass is created so that in the case
 	 * of an init failure the arrayClass is not temporarily exposed.
 	 */
-	if (J9_IS_J9CLASS_PRIMITIVE_VALUETYPE(elementClass)) {
+	if (J9_IS_J9CLASS_ALLOW_DEFAULT_VALUE(elementClass)) {
 		UDATA initStatus = elementClass->initializeStatus;
 		if ((J9ClassInitSucceeded != initStatus) && ((UDATA)vmThread != initStatus)) {
 			initializeClass(vmThread, elementClass);