Skip to content

Commit f165fd4

Browse files
hzongarohzongaro
authored
Merge pull request eclipse-openj9#20112 from a7ehuo/PR-valuetypes-null-restricted-array
Fix null restricted array related issues for value types
2 parents abe8b1b + f2c432a commit f165fd4

19 files changed

+308
-71
lines changed

‎runtime/compiler/codegen/J9RecognizedMethodsEnum.hpp

+3
Original file line numberDiff line numberDiff line change
@@ -483,6 +483,9 @@
483483
LastVectorMethod = LastVectorIntrinsicMethod,
484484

485485
java_lang_reflect_Array_getLength,
486+
jdk_internal_value_ValueClass_newArrayInstance,
487+
jdk_internal_value_ValueClass_newNullRestrictedArray,
488+
jdk_internal_value_NullRestrictedCheckedType_of,
486489
java_lang_reflect_Method_invoke,
487490
java_util_Arrays_fill,
488491
java_util_Arrays_equals,

‎runtime/compiler/control/JITClientCompilationThread.cpp

+6
Original file line numberDiff line numberDiff line change
@@ -617,6 +617,12 @@ handleServerMessage(JITServer::ClientStream *client, TR_J9VM *fe, JITServer::Mes
617617
client->write(response, fe->getArrayClassFromComponentClass(clazz));
618618
}
619619
break;
620+
case MessageType::VM_getNullRestrictedArrayClassFromComponentClass:
621+
{
622+
auto clazz = std::get<0>(client->getRecvData<TR_OpaqueClassBlock *>());
623+
client->write(response, fe->getNullRestrictedArrayClassFromComponentClass(clazz));
624+
}
625+
break;
620626
case MessageType::VM_matchRAMclassFromROMclass:
621627
{
622628
J9ROMClass *clazz = std::get<0>(client->getRecvData<J9ROMClass *>());

‎runtime/compiler/control/JITServerHelpers.cpp

+6-1
Original file line numberDiff line numberDiff line change
@@ -969,6 +969,7 @@ JITServerHelpers::cacheRemoteROMClass(ClientSessionData *clientSessionData, J9Cl
969969
classInfoStruct._classNameIdentifyingLoader = std::get<22>(classInfoTuple);
970970
classInfoStruct._arrayElementSize = std::get<23>(classInfoTuple);
971971
classInfoStruct._defaultValueSlotAddress = std::get<24>(classInfoTuple);
972+
classInfoStruct._nullRestrictedArrayClass = std::get<26>(classInfoTuple);
972973

973974
auto result = clientSessionData->getROMClassMap().insert({ clazz, classInfoStruct });
974975

@@ -1031,6 +1032,7 @@ JITServerHelpers::packRemoteROMClassInfo(J9Class *clazz, J9VMThread *vmThread, T
10311032
TR_OpaqueClassBlock *hostClass = fe->convertClassPtrToClassOffset(clazz->hostClass);
10321033
TR_OpaqueClassBlock *componentClass = fe->getComponentClassFromArrayClass((TR_OpaqueClassBlock *)clazz);
10331034
TR_OpaqueClassBlock *arrayClass = fe->getArrayClassFromComponentClass((TR_OpaqueClassBlock *)clazz);
1035+
TR_OpaqueClassBlock *nullRestrictedArrayClass = fe->getNullRestrictedArrayClassFromComponentClass((TR_OpaqueClassBlock *)clazz);
10341036
uintptr_t totalInstanceSize = clazz->totalInstanceSize;
10351037
uintptr_t cp = fe->getConstantPoolFromClass((TR_OpaqueClassBlock *)clazz);
10361038
uintptr_t classFlags = fe->getClassFlagsValue((TR_OpaqueClassBlock *)clazz);
@@ -1082,7 +1084,7 @@ JITServerHelpers::packRemoteROMClassInfo(J9Class *clazz, J9VMThread *vmThread, T
10821084
classHasFinalFields, classDepthAndFlags, classInitialized, byteOffsetToLockword, leafComponentClass,
10831085
classLoader, hostClass, componentClass, arrayClass, totalInstanceSize, clazz->romClass,
10841086
cp, classFlags, classChainOffsetIdentifyingLoader, origROMMethods, classNameIdentifyingLoader, arrayElementSize,
1085-
defaultValueSlotAddress, romClassHash
1087+
defaultValueSlotAddress, romClassHash, nullRestrictedArrayClass
10861088
);
10871089
}
10881090

@@ -1261,6 +1263,9 @@ JITServerHelpers::getROMClassData(const ClientSessionData::ClassInfo &classInfo,
12611263
case CLASSINFO_DEFAULT_VALUE_SLOT_ADDRESS:
12621264
*(j9object_t **)data = classInfo._defaultValueSlotAddress;
12631265
break;
1266+
case CLASSINFO_NULLRESTRICTED_ARRAY_CLASS :
1267+
*(TR_OpaqueClassBlock **)data = classInfo._nullRestrictedArrayClass;
1268+
break;
12641269
default:
12651270
TR_ASSERT(false, "Class Info not supported %u\n", dataType);
12661271
break;

‎runtime/compiler/control/JITServerHelpers.hpp

+3-1
Original file line numberDiff line numberDiff line change
@@ -57,6 +57,7 @@ class JITServerHelpers
5757
CLASSINFO_CLASS_CHAIN_OFFSET_IDENTIFYING_LOADER,
5858
CLASSINFO_ARRAY_ELEMENT_SIZE,
5959
CLASSINFO_DEFAULT_VALUE_SLOT_ADDRESS,
60+
CLASSINFO_NULLRESTRICTED_ARRAY_CLASS,
6061
};
6162

6263
// NOTE: when adding new elements to this tuple, add them to the end,
@@ -88,7 +89,8 @@ class JITServerHelpers
8889
std::string, // 22: _classNameIdentifyingLoader
8990
int32_t, // 23: _arrayElementSize
9091
j9object_t *, // 24: _defaultValueSlotAddress
91-
std::string // 25: optional hash of packedROMClass
92+
std::string, // 25: optional hash of packedROMClass
93+
TR_OpaqueClassBlock * // 26: _nullRestrictedArrayClass
9294
>;
9395

9496
// Packs a ROMClass to be transferred to the server.

‎runtime/compiler/env/J9ClassEnv.cpp

+23
Original file line numberDiff line numberDiff line change
@@ -902,6 +902,29 @@ J9::ClassEnv::isValueBasedOrValueTypeClass(TR_OpaqueClassBlock *clazz)
902902
return J9_ARE_ANY_BITS_SET(j9class->classFlags, J9_CLASS_DISALLOWS_LOCKING_FLAGS);
903903
}
904904

905+
bool
906+
J9::ClassEnv::isArrayNullRestricted(TR::Compilation *comp,TR_OpaqueClassBlock *arrayClass)
907+
{
908+
#if defined(J9VM_OPT_JITSERVER)
909+
if (auto stream = comp->getStream())
910+
{
911+
uintptr_t classFlags = 0;
912+
JITServerHelpers::getAndCacheRAMClassInfo((J9Class *)arrayClass, TR::compInfoPT->getClientData(), stream, JITServerHelpers::CLASSINFO_CLASS_FLAGS, (void *)&classFlags);
913+
#ifdef DEBUG
914+
stream->write(JITServer::MessageType::ClassEnv_classFlagsValue, clazz);
915+
uintptr_t classFlagsRemote = std::get<0>(stream->read<uintptr_t>());
916+
// Check that class flags from remote call is equal to the cached ones
917+
classFlags = classFlags & J9ClassArrayIsNullRestricted;
918+
classFlagsRemote = classFlagsRemote & J9ClassArrayIsNullRestricted;
919+
TR_ASSERT_FATAL(classFlags == classFlagsRemote, "remote call class flags is not equal to cached class flags");
920+
#endif
921+
return J9_ARE_ALL_BITS_SET(classFlags, J9ClassArrayIsNullRestricted);
922+
}
923+
#endif /* defined(J9VM_OPT_JITSERVER) */
924+
J9ArrayClass *j9class = reinterpret_cast<J9ArrayClass*>(arrayClass);
925+
return J9_IS_J9ARRAYCLASS_NULL_RESTRICTED(j9class);
926+
}
927+
905928
bool
906929
J9::ClassEnv::classHasIdentity(TR_OpaqueClassBlock *clazz)
907930
{

‎runtime/compiler/env/J9ClassEnv.hpp

+1
Original file line numberDiff line numberDiff line change
@@ -96,6 +96,7 @@ class OMR_EXTENSIBLE ClassEnv : public OMR::ClassEnvConnector
9696
bool isPrimitiveValueTypeClass(TR_OpaqueClassBlock *);
9797
bool isValueTypeClassFlattened(TR_OpaqueClassBlock *clazz);
9898
bool isValueBasedOrValueTypeClass(TR_OpaqueClassBlock *);
99+
bool isArrayNullRestricted(TR::Compilation *comp, TR_OpaqueClassBlock *arrayClass);
99100

100101
/** \brief
101102
* Returns the size of the flattened array element

‎runtime/compiler/env/VMJ9.cpp

+28
Original file line numberDiff line numberDiff line change
@@ -7107,6 +7107,13 @@ TR_J9VM::getArrayClassFromComponentClass(TR_OpaqueClassBlock * componentClass)
71077107
return convertClassPtrToClassOffset(TR::Compiler->cls.convertClassOffsetToClassPtr(componentClass)->arrayClass);
71087108
}
71097109

7110+
TR_OpaqueClassBlock *
7111+
TR_J9VM::getNullRestrictedArrayClassFromComponentClass(TR_OpaqueClassBlock * componentClass)
7112+
{
7113+
J9Class *clazz = TR::Compiler->cls.convertClassOffsetToClassPtr(componentClass);
7114+
return convertClassPtrToClassOffset(J9CLASS_GET_NULLRESTRICTED_ARRAY(clazz));
7115+
}
7116+
71107117
TR_OpaqueClassBlock *
71117118
TR_J9VM::getLeafComponentClassFromArrayClass(TR_OpaqueClassBlock * arrayClass)
71127119
{
@@ -9285,6 +9292,27 @@ TR_J9SharedCacheVM::getArrayClassFromComponentClass(TR_OpaqueClassBlock * compon
92859292
return NULL;
92869293
}
92879294

9295+
TR_OpaqueClassBlock *
9296+
TR_J9SharedCacheVM::getNullRestrictedArrayClassFromComponentClass(TR_OpaqueClassBlock * componentClass)
9297+
{
9298+
TR::Compilation* comp = _compInfoPT->getCompilation();
9299+
TR_ASSERT(comp, "Should be called only within a compilation");
9300+
9301+
bool validated = false;
9302+
TR_OpaqueClassBlock *nullRestrictedArrayClass = TR_J9VM::getNullRestrictedArrayClassFromComponentClass(componentClass);
9303+
9304+
if (comp->getOption(TR_UseSymbolValidationManager))
9305+
{
9306+
validated = comp->getSymbolValidationManager()->addArrayClassFromComponentClassRecord(nullRestrictedArrayClass, componentClass);
9307+
}
9308+
else
9309+
{
9310+
validated = ((TR_ResolvedRelocatableJ9Method *) comp->getCurrentMethod())->validateArbitraryClass(comp, (J9Class *) componentClass);
9311+
}
9312+
9313+
return validated ? nullRestrictedArrayClass : NULL;
9314+
}
9315+
92889316
TR_OpaqueClassBlock *
92899317
TR_J9SharedCacheVM::getLeafComponentClassFromArrayClass(TR_OpaqueClassBlock * arrayClass)
92909318
{

‎runtime/compiler/env/VMJ9.h

+20
Original file line numberDiff line numberDiff line change
@@ -1559,6 +1559,16 @@ class TR_J9VM : public TR_J9VMBase
15591559

15601560
virtual TR_OpaqueClassBlock * getComponentClassFromArrayClass(TR_OpaqueClassBlock * arrayClass);
15611561
virtual TR_OpaqueClassBlock * getArrayClassFromComponentClass(TR_OpaqueClassBlock *componentClass);
1562+
/** \brief
1563+
* Retrieves the nullRestrictedArrayClass from the array component class.
1564+
*
1565+
* \param componentClass
1566+
* The array component class
1567+
*
1568+
* \return
1569+
* A pointer to nullRestrictedArrayClass if it exists, otherwise NULL
1570+
*/
1571+
virtual TR_OpaqueClassBlock * getNullRestrictedArrayClassFromComponentClass(TR_OpaqueClassBlock *componentClass);
15621572
virtual TR_OpaqueClassBlock * getLeafComponentClassFromArrayClass(TR_OpaqueClassBlock * arrayClass);
15631573
virtual int32_t getNewArrayTypeFromClass(TR_OpaqueClassBlock *clazz);
15641574
virtual TR_OpaqueClassBlock * getClassFromSignature(const char * sig, int32_t length, TR_ResolvedMethod *method, bool isVettedForAOT=false);
@@ -1685,6 +1695,16 @@ class TR_J9SharedCacheVM : public TR_J9VM
16851695
virtual bool isPrimitiveClass(TR_OpaqueClassBlock *clazz);
16861696
virtual TR_OpaqueClassBlock * getComponentClassFromArrayClass(TR_OpaqueClassBlock * arrayClass);
16871697
virtual TR_OpaqueClassBlock * getArrayClassFromComponentClass(TR_OpaqueClassBlock *componentClass);
1698+
/** \brief
1699+
* Retrieves the nullRestrictedArrayClass from the array component class.
1700+
*
1701+
* \param componentClass
1702+
* The array component class
1703+
*
1704+
* \return
1705+
* A pointer to nullRestrictedArrayClass if it exists, otherwise NULL
1706+
*/
1707+
virtual TR_OpaqueClassBlock * getNullRestrictedArrayClassFromComponentClass(TR_OpaqueClassBlock *componentClass);
16881708
virtual TR_OpaqueClassBlock * getLeafComponentClassFromArrayClass(TR_OpaqueClassBlock * arrayClass);
16891709
virtual TR_OpaqueClassBlock * getBaseComponentClass(TR_OpaqueClassBlock * clazz, int32_t & numDims);
16901710
virtual TR_OpaqueClassBlock * getClassFromNewArrayType(int32_t arrayType);

‎runtime/compiler/env/VMJ9Server.cpp

+44
Original file line numberDiff line numberDiff line change
@@ -1171,6 +1171,30 @@ TR_J9ServerVM::getArrayClassFromComponentClass(TR_OpaqueClassBlock *componentCla
11711171
return arrayClass;
11721172
}
11731173

1174+
TR_OpaqueClassBlock *
1175+
TR_J9ServerVM::getNullRestrictedArrayClassFromComponentClass(TR_OpaqueClassBlock *componentClass)
1176+
{
1177+
JITServer::ServerStream *stream = _compInfoPT->getMethodBeingCompiled()->_stream;
1178+
TR_OpaqueClassBlock *nullRestrictedArrayClass = NULL;
1179+
JITServerHelpers::getAndCacheRAMClassInfo((J9Class *)componentClass, _compInfoPT->getClientData(), stream, JITServerHelpers::CLASSINFO_NULLRESTRICTED_ARRAY_CLASS, (void *)&nullRestrictedArrayClass);
1180+
if (!nullRestrictedArrayClass)
1181+
{
1182+
stream->write(JITServer::MessageType::VM_getNullRestrictedArrayClassFromComponentClass, componentClass);
1183+
nullRestrictedArrayClass = std::get<0>(stream->read<TR_OpaqueClassBlock *>());
1184+
if (nullRestrictedArrayClass)
1185+
{
1186+
// if client initialized nullRestrictedArrayClass, cache the new value
1187+
OMR::CriticalSection getRemoteROMClass(_compInfoPT->getClientData()->getROMMapMonitor());
1188+
auto it = _compInfoPT->getClientData()->getROMClassMap().find((J9Class*) componentClass);
1189+
if (it != _compInfoPT->getClientData()->getROMClassMap().end())
1190+
{
1191+
it->second._nullRestrictedArrayClass = nullRestrictedArrayClass;
1192+
}
1193+
}
1194+
}
1195+
return nullRestrictedArrayClass;
1196+
}
1197+
11741198
J9Class *
11751199
TR_J9ServerVM::matchRAMclassFromROMclass(J9ROMClass *clazz, TR::Compilation *comp)
11761200
{
@@ -3292,6 +3316,26 @@ TR_J9SharedCacheServerVM::getArrayClassFromComponentClass(TR_OpaqueClassBlock *
32923316
return validated ? arrayClass : NULL;
32933317
}
32943318

3319+
TR_OpaqueClassBlock *
3320+
TR_J9SharedCacheServerVM::getNullRestrictedArrayClassFromComponentClass(TR_OpaqueClassBlock * componentClass)
3321+
{
3322+
TR::Compilation* comp = _compInfoPT->getCompilation();
3323+
TR_ASSERT(comp, "Should be called only within a compilation");
3324+
3325+
bool validated = false;
3326+
TR_OpaqueClassBlock *nullRestrictedArrayClass = TR_J9ServerVM::getNullRestrictedArrayClassFromComponentClass(componentClass);
3327+
3328+
if (comp->getOption(TR_UseSymbolValidationManager))
3329+
{
3330+
validated = comp->getSymbolValidationManager()->addArrayClassFromComponentClassRecord(nullRestrictedArrayClass, componentClass);
3331+
}
3332+
else
3333+
{
3334+
validated = ((TR_ResolvedRelocatableJ9JITServerMethod *) comp->getCurrentMethod())->validateArbitraryClass(comp, (J9Class *) componentClass);
3335+
}
3336+
return validated ? nullRestrictedArrayClass : NULL;
3337+
}
3338+
32953339
TR_OpaqueClassBlock *
32963340
TR_J9SharedCacheServerVM::getLeafComponentClassFromArrayClass(TR_OpaqueClassBlock * arrayClass)
32973341
{

‎runtime/compiler/env/VMJ9Server.hpp

+20
Original file line numberDiff line numberDiff line change
@@ -126,6 +126,16 @@ class TR_J9ServerVM: public TR_J9VM
126126
virtual bool isCloneable(TR_OpaqueClassBlock *clazzPointer) override;
127127
virtual bool canAllocateInlineClass(TR_OpaqueClassBlock *clazz) override;
128128
virtual TR_OpaqueClassBlock * getArrayClassFromComponentClass(TR_OpaqueClassBlock *componentClass) override;
129+
/** \brief
130+
* Retrieves the nullRestrictedArrayClass from the array component class.
131+
*
132+
* \param componentClass
133+
* The array component class
134+
*
135+
* \return
136+
* A pointer to nullRestrictedArrayClass if it exists, otherwise NULL
137+
*/
138+
virtual TR_OpaqueClassBlock * getNullRestrictedArrayClassFromComponentClass(TR_OpaqueClassBlock *componentClass) override;
129139
virtual J9Class * matchRAMclassFromROMclass(J9ROMClass *clazz, TR::Compilation *comp) override;
130140
virtual int32_t * getCurrentLocalsMapForDLT(TR::Compilation *comp) override;
131141
virtual uintptr_t getReferenceFieldAt(uintptr_t objectPointer, uintptr_t offsetFromHeader) override;
@@ -345,6 +355,16 @@ class TR_J9SharedCacheServerVM: public TR_J9ServerVM
345355
virtual bool isPrimitiveClass(TR_OpaqueClassBlock *clazzPointer) override;
346356
virtual TR_OpaqueClassBlock *getComponentClassFromArrayClass(TR_OpaqueClassBlock *arrayClass) override;
347357
virtual TR_OpaqueClassBlock *getArrayClassFromComponentClass(TR_OpaqueClassBlock *componentClass) override;
358+
/** \brief
359+
* Retrieves the nullRestrictedArrayClass from the array component class.
360+
*
361+
* \param componentClass
362+
* The array component class
363+
*
364+
* \return
365+
* A pointer to nullRestrictedArrayClass if it exists, otherwise NULL
366+
*/
367+
virtual TR_OpaqueClassBlock * getNullRestrictedArrayClassFromComponentClass(TR_OpaqueClassBlock *componentClass) override;
348368
virtual TR_OpaqueClassBlock *getLeafComponentClassFromArrayClass(TR_OpaqueClassBlock *arrayClass) override;
349369
virtual TR_OpaqueClassBlock *getBaseComponentClass(TR_OpaqueClassBlock *clazz, int32_t & numDims) override;
350370
virtual TR_OpaqueClassBlock *getClassFromNewArrayType(int32_t arrayType) override;

‎runtime/compiler/env/j9method.cpp

+15
Original file line numberDiff line numberDiff line change
@@ -3847,6 +3847,19 @@ void TR_ResolvedJ9Method::construct()
38473847
{ TR::unknownMethod}
38483848
};
38493849

3850+
static X ValueClassMethods[] =
3851+
{
3852+
{x(TR::jdk_internal_value_ValueClass_newArrayInstance, "newArrayInstance", "(Ljdk/internal/value/CheckedType;I)[Ljava/lang/Object;")},
3853+
{x(TR::jdk_internal_value_ValueClass_newNullRestrictedArray, "newNullRestrictedArray", "(Ljava/lang/Class;I)[Ljava/lang/Object;")},
3854+
{ TR::unknownMethod}
3855+
};
3856+
3857+
static X NullRestrictedCheckedTypeMethods[] =
3858+
{
3859+
{x(TR::jdk_internal_value_NullRestrictedCheckedType_of, "of", "(Ljava/lang/Class;)Ljdk/internal/value/NullRestrictedCheckedType;")},
3860+
{ TR::unknownMethod}
3861+
};
3862+
38503863
static X SpreadHandleMethods[] =
38513864
{
38523865
{x(TR::java_lang_invoke_SpreadHandle_numArgsToPassThrough, "numArgsToPassThrough", "()I")},
@@ -4183,6 +4196,7 @@ void TR_ResolvedJ9Method::construct()
41834196
{ "sun/nio/cs/ISO_8859_1$Decoder", EncodeMethods },
41844197
{ "java/io/ByteArrayOutputStream", ByteArrayOutputStreamMethods },
41854198
{ "java/lang/ScopedValue$Carrier", ScopedValueMethods },
4199+
{ "jdk/internal/value/ValueClass", ValueClassMethods },
41864200
{ 0 }
41874201
};
41884202

@@ -4311,6 +4325,7 @@ void TR_ResolvedJ9Method::construct()
43114325
{
43124326
{ "java/lang/invoke/ConvertHandle$FilterHelpers", ConvertHandleFilterHelpersMethods },
43134327
{ "java/lang/invoke/DirectMethodHandle$Accessor", DirectMethodHandleAccessorMethods },
4328+
{ "jdk/internal/value/NullRestrictedCheckedType", NullRestrictedCheckedTypeMethods },
43144329
{ 0 }
43154330
};
43164331

‎runtime/compiler/net/CommunicationStream.hpp

+1-1
Original file line numberDiff line numberDiff line change
@@ -128,7 +128,7 @@ class CommunicationStream
128128
// likely to lose an increment when merging/rebasing/etc.
129129
//
130130
static const uint8_t MAJOR_NUMBER = 1;
131-
static const uint16_t MINOR_NUMBER = 68; // ID: +/QzEedP8cjGovxgYECy
131+
static const uint16_t MINOR_NUMBER = 69; // ID: SMN6DXY0b2X1Z76N9825
132132
static const uint8_t PATCH_NUMBER = 0;
133133
static uint32_t CONFIGURATION_FLAGS;
134134

‎runtime/compiler/net/MessageTypes.cpp

+1
Original file line numberDiff line numberDiff line change
@@ -122,6 +122,7 @@ const char *messageNames[] =
122122
"VM_classInitIsFinished",
123123
"VM_getClassFromNewArrayType",
124124
"VM_getArrayClassFromComponentClass",
125+
"VM_getNullRestrictedArrayClassFromComponentClass",
125126
"VM_matchRAMclassFromROMclass",
126127
"VM_getInt32FieldAt",
127128
"VM_getInt64FieldAt",

‎runtime/compiler/net/MessageTypes.hpp

+1
Original file line numberDiff line numberDiff line change
@@ -131,6 +131,7 @@ enum MessageType : uint16_t
131131
VM_classInitIsFinished,
132132
VM_getClassFromNewArrayType,
133133
VM_getArrayClassFromComponentClass,
134+
VM_getNullRestrictedArrayClassFromComponentClass,
134135
VM_matchRAMclassFromROMclass,
135136
VM_getInt32FieldAt,
136137
VM_getInt64FieldAt,

0 commit comments

Comments
 (0)