Merge pull request eclipse-openj9#20112 from a7ehuo/PR-valuetypes-nul…

…l-restricted-array

Fix null restricted array related issues for value types

runtime/compiler/codegen/J9RecognizedMethodsEnum.hpp

@@ -483,6 +483,9 @@
    LastVectorMethod = LastVectorIntrinsicMethod,
 
    java_lang_reflect_Array_getLength,
+   jdk_internal_value_ValueClass_newArrayInstance,
+   jdk_internal_value_ValueClass_newNullRestrictedArray,
+   jdk_internal_value_NullRestrictedCheckedType_of,
    java_lang_reflect_Method_invoke,
    java_util_Arrays_fill,
    java_util_Arrays_equals,

runtime/compiler/control/JITClientCompilationThread.cpp

@@ -617,6 +617,12 @@ handleServerMessage(JITServer::ClientStream *client, TR_J9VM *fe, JITServer::Mes
          client->write(response, fe->getArrayClassFromComponentClass(clazz));
          }
          break;
+      case MessageType::VM_getNullRestrictedArrayClassFromComponentClass:
+         {
+         auto clazz = std::get<0>(client->getRecvData<TR_OpaqueClassBlock *>());
+         client->write(response, fe->getNullRestrictedArrayClassFromComponentClass(clazz));
+         }
+         break;
       case MessageType::VM_matchRAMclassFromROMclass:
          {
          J9ROMClass *clazz = std::get<0>(client->getRecvData<J9ROMClass *>());

runtime/compiler/control/JITServerHelpers.cpp

@@ -969,6 +969,7 @@ JITServerHelpers::cacheRemoteROMClass(ClientSessionData *clientSessionData, J9Cl
    classInfoStruct._classNameIdentifyingLoader = std::get<22>(classInfoTuple);
    classInfoStruct._arrayElementSize = std::get<23>(classInfoTuple);
    classInfoStruct._defaultValueSlotAddress = std::get<24>(classInfoTuple);
+   classInfoStruct._nullRestrictedArrayClass = std::get<26>(classInfoTuple);
 
    auto result = clientSessionData->getROMClassMap().insert({ clazz, classInfoStruct });
 
@@ -1031,6 +1032,7 @@ JITServerHelpers::packRemoteROMClassInfo(J9Class *clazz, J9VMThread *vmThread, T
    TR_OpaqueClassBlock *hostClass = fe->convertClassPtrToClassOffset(clazz->hostClass);
    TR_OpaqueClassBlock *componentClass = fe->getComponentClassFromArrayClass((TR_OpaqueClassBlock *)clazz);
    TR_OpaqueClassBlock *arrayClass = fe->getArrayClassFromComponentClass((TR_OpaqueClassBlock *)clazz);
+   TR_OpaqueClassBlock *nullRestrictedArrayClass = fe->getNullRestrictedArrayClassFromComponentClass((TR_OpaqueClassBlock *)clazz);
    uintptr_t totalInstanceSize = clazz->totalInstanceSize;
    uintptr_t cp = fe->getConstantPoolFromClass((TR_OpaqueClassBlock *)clazz);
    uintptr_t classFlags = fe->getClassFlagsValue((TR_OpaqueClassBlock *)clazz);
@@ -1082,7 +1084,7 @@ JITServerHelpers::packRemoteROMClassInfo(J9Class *clazz, J9VMThread *vmThread, T
       classHasFinalFields, classDepthAndFlags, classInitialized, byteOffsetToLockword, leafComponentClass,
       classLoader, hostClass, componentClass, arrayClass, totalInstanceSize, clazz->romClass,
       cp, classFlags, classChainOffsetIdentifyingLoader, origROMMethods, classNameIdentifyingLoader, arrayElementSize,
-      defaultValueSlotAddress, romClassHash
+      defaultValueSlotAddress, romClassHash, nullRestrictedArrayClass
    );
    }
 
@@ -1261,6 +1263,9 @@ JITServerHelpers::getROMClassData(const ClientSessionData::ClassInfo &classInfo,
       case CLASSINFO_DEFAULT_VALUE_SLOT_ADDRESS:
          *(j9object_t **)data = classInfo._defaultValueSlotAddress;
          break;
+      case CLASSINFO_NULLRESTRICTED_ARRAY_CLASS :
+         *(TR_OpaqueClassBlock **)data = classInfo._nullRestrictedArrayClass;
+         break;
       default:
          TR_ASSERT(false, "Class Info not supported %u\n", dataType);
          break;

runtime/compiler/control/JITServerHelpers.hpp

@@ -57,6 +57,7 @@ class JITServerHelpers
       CLASSINFO_CLASS_CHAIN_OFFSET_IDENTIFYING_LOADER,
       CLASSINFO_ARRAY_ELEMENT_SIZE,
       CLASSINFO_DEFAULT_VALUE_SLOT_ADDRESS,
+      CLASSINFO_NULLRESTRICTED_ARRAY_CLASS,
       };
 
    // NOTE: when adding new elements to this tuple, add them to the end,
@@ -88,7 +89,8 @@ class JITServerHelpers
       std::string,                       // 22: _classNameIdentifyingLoader
       int32_t,                           // 23: _arrayElementSize
       j9object_t *,                      // 24: _defaultValueSlotAddress
-      std::string                        // 25: optional hash of packedROMClass
+      std::string,                       // 25: optional hash of packedROMClass
+      TR_OpaqueClassBlock *              // 26: _nullRestrictedArrayClass
       >;
 
    // Packs a ROMClass to be transferred to the server.

runtime/compiler/env/J9ClassEnv.cpp

@@ -902,6 +902,29 @@ J9::ClassEnv::isValueBasedOrValueTypeClass(TR_OpaqueClassBlock *clazz)
    return J9_ARE_ANY_BITS_SET(j9class->classFlags, J9_CLASS_DISALLOWS_LOCKING_FLAGS);
    }
 
+bool
+J9::ClassEnv::isArrayNullRestricted(TR::Compilation *comp,TR_OpaqueClassBlock *arrayClass)
+   {
+#if defined(J9VM_OPT_JITSERVER)
+   if (auto stream = comp->getStream())
+      {
+      uintptr_t classFlags = 0;
+      JITServerHelpers::getAndCacheRAMClassInfo((J9Class *)arrayClass, TR::compInfoPT->getClientData(), stream, JITServerHelpers::CLASSINFO_CLASS_FLAGS, (void *)&classFlags);
+#ifdef DEBUG
+      stream->write(JITServer::MessageType::ClassEnv_classFlagsValue, clazz);
+      uintptr_t classFlagsRemote = std::get<0>(stream->read<uintptr_t>());
+      // Check that class flags from remote call is equal to the cached ones
+      classFlags = classFlags & J9ClassArrayIsNullRestricted;
+      classFlagsRemote = classFlagsRemote & J9ClassArrayIsNullRestricted;
+      TR_ASSERT_FATAL(classFlags == classFlagsRemote, "remote call class flags is not equal to cached class flags");
+#endif
+      return J9_ARE_ALL_BITS_SET(classFlags, J9ClassArrayIsNullRestricted);
+      }
+#endif /* defined(J9VM_OPT_JITSERVER) */
+   J9ArrayClass *j9class = reinterpret_cast<J9ArrayClass*>(arrayClass);
+   return J9_IS_J9ARRAYCLASS_NULL_RESTRICTED(j9class);
+   }
+
 bool
 J9::ClassEnv::classHasIdentity(TR_OpaqueClassBlock *clazz)
    {

runtime/compiler/env/J9ClassEnv.hpp

@@ -96,6 +96,7 @@ class OMR_EXTENSIBLE ClassEnv : public OMR::ClassEnvConnector
    bool isPrimitiveValueTypeClass(TR_OpaqueClassBlock *);
    bool isValueTypeClassFlattened(TR_OpaqueClassBlock *clazz);
    bool isValueBasedOrValueTypeClass(TR_OpaqueClassBlock *);
+   bool isArrayNullRestricted(TR::Compilation *comp, TR_OpaqueClassBlock *arrayClass);
 
    /** \brief
     *    Returns the size of the flattened array element

runtime/compiler/env/VMJ9.cpp

@@ -7107,6 +7107,13 @@ TR_J9VM::getArrayClassFromComponentClass(TR_OpaqueClassBlock * componentClass)
    return convertClassPtrToClassOffset(TR::Compiler->cls.convertClassOffsetToClassPtr(componentClass)->arrayClass);
    }
 
+TR_OpaqueClassBlock *
+TR_J9VM::getNullRestrictedArrayClassFromComponentClass(TR_OpaqueClassBlock * componentClass)
+   {
+   J9Class *clazz = TR::Compiler->cls.convertClassOffsetToClassPtr(componentClass);
+   return convertClassPtrToClassOffset(J9CLASS_GET_NULLRESTRICTED_ARRAY(clazz));
+   }
+
 TR_OpaqueClassBlock *
 TR_J9VM::getLeafComponentClassFromArrayClass(TR_OpaqueClassBlock * arrayClass)
    {
@@ -9285,6 +9292,27 @@ TR_J9SharedCacheVM::getArrayClassFromComponentClass(TR_OpaqueClassBlock * compon
       return NULL;
    }
 
+TR_OpaqueClassBlock *
+TR_J9SharedCacheVM::getNullRestrictedArrayClassFromComponentClass(TR_OpaqueClassBlock * componentClass)
+   {
+   TR::Compilation* comp = _compInfoPT->getCompilation();
+   TR_ASSERT(comp, "Should be called only within a compilation");
+
+   bool validated = false;
+   TR_OpaqueClassBlock *nullRestrictedArrayClass = TR_J9VM::getNullRestrictedArrayClassFromComponentClass(componentClass);
+
+   if (comp->getOption(TR_UseSymbolValidationManager))
+      {
+      validated = comp->getSymbolValidationManager()->addArrayClassFromComponentClassRecord(nullRestrictedArrayClass, componentClass);
+      }
+   else
+      {
+      validated = ((TR_ResolvedRelocatableJ9Method *) comp->getCurrentMethod())->validateArbitraryClass(comp, (J9Class *) componentClass);
+      }
+
+   return validated ? nullRestrictedArrayClass : NULL;
+   }
+
 TR_OpaqueClassBlock *
 TR_J9SharedCacheVM::getLeafComponentClassFromArrayClass(TR_OpaqueClassBlock * arrayClass)
    {

runtime/compiler/env/VMJ9.h

@@ -1559,6 +1559,16 @@ class TR_J9VM : public TR_J9VMBase
 
    virtual TR_OpaqueClassBlock * getComponentClassFromArrayClass(TR_OpaqueClassBlock * arrayClass);
    virtual TR_OpaqueClassBlock * getArrayClassFromComponentClass(TR_OpaqueClassBlock *componentClass);
+   /** \brief
+     *     Retrieves the nullRestrictedArrayClass from the array component class.
+     *
+     *  \param componentClass
+     *     The array component class
+     *
+     *  \return
+     *     A pointer to nullRestrictedArrayClass if it exists, otherwise NULL
+     */
+   virtual TR_OpaqueClassBlock * getNullRestrictedArrayClassFromComponentClass(TR_OpaqueClassBlock *componentClass);
    virtual TR_OpaqueClassBlock * getLeafComponentClassFromArrayClass(TR_OpaqueClassBlock * arrayClass);
    virtual int32_t               getNewArrayTypeFromClass(TR_OpaqueClassBlock *clazz);
    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
    virtual bool               isPrimitiveClass(TR_OpaqueClassBlock *clazz);
    virtual TR_OpaqueClassBlock * getComponentClassFromArrayClass(TR_OpaqueClassBlock * arrayClass);
    virtual TR_OpaqueClassBlock * getArrayClassFromComponentClass(TR_OpaqueClassBlock *componentClass);
+   /** \brief
+     *     Retrieves the nullRestrictedArrayClass from the array component class.
+     *
+     *  \param componentClass
+     *     The array component class
+     *
+     *  \return
+     *     A pointer to nullRestrictedArrayClass if it exists, otherwise NULL
+     */
+   virtual TR_OpaqueClassBlock * getNullRestrictedArrayClassFromComponentClass(TR_OpaqueClassBlock *componentClass);
    virtual TR_OpaqueClassBlock * getLeafComponentClassFromArrayClass(TR_OpaqueClassBlock * arrayClass);
    virtual TR_OpaqueClassBlock * getBaseComponentClass(TR_OpaqueClassBlock * clazz, int32_t & numDims);
    virtual TR_OpaqueClassBlock * getClassFromNewArrayType(int32_t arrayType);

runtime/compiler/env/VMJ9Server.cpp

@@ -1171,6 +1171,30 @@ TR_J9ServerVM::getArrayClassFromComponentClass(TR_OpaqueClassBlock *componentCla
    return arrayClass;
    }
 
+TR_OpaqueClassBlock *
+TR_J9ServerVM::getNullRestrictedArrayClassFromComponentClass(TR_OpaqueClassBlock *componentClass)
+   {
+   JITServer::ServerStream *stream = _compInfoPT->getMethodBeingCompiled()->_stream;
+   TR_OpaqueClassBlock *nullRestrictedArrayClass = NULL;
+   JITServerHelpers::getAndCacheRAMClassInfo((J9Class *)componentClass, _compInfoPT->getClientData(), stream, JITServerHelpers::CLASSINFO_NULLRESTRICTED_ARRAY_CLASS, (void *)&nullRestrictedArrayClass);
+   if (!nullRestrictedArrayClass)
+      {
+      stream->write(JITServer::MessageType::VM_getNullRestrictedArrayClassFromComponentClass, componentClass);
+      nullRestrictedArrayClass = std::get<0>(stream->read<TR_OpaqueClassBlock *>());
+      if (nullRestrictedArrayClass)
+         {
+         // if client initialized nullRestrictedArrayClass, cache the new value
+         OMR::CriticalSection getRemoteROMClass(_compInfoPT->getClientData()->getROMMapMonitor());
+         auto it = _compInfoPT->getClientData()->getROMClassMap().find((J9Class*) componentClass);
+         if (it != _compInfoPT->getClientData()->getROMClassMap().end())
+            {
+            it->second._nullRestrictedArrayClass = nullRestrictedArrayClass;
+            }
+         }
+      }
+   return nullRestrictedArrayClass;
+   }
+
 J9Class *
 TR_J9ServerVM::matchRAMclassFromROMclass(J9ROMClass *clazz, TR::Compilation *comp)
    {
@@ -3292,6 +3316,26 @@ TR_J9SharedCacheServerVM::getArrayClassFromComponentClass(TR_OpaqueClassBlock *
    return validated ? arrayClass : NULL;
    }
 
+TR_OpaqueClassBlock *
+TR_J9SharedCacheServerVM::getNullRestrictedArrayClassFromComponentClass(TR_OpaqueClassBlock * componentClass)
+   {
+   TR::Compilation* comp = _compInfoPT->getCompilation();
+   TR_ASSERT(comp, "Should be called only within a compilation");
+
+   bool validated = false;
+   TR_OpaqueClassBlock *nullRestrictedArrayClass = TR_J9ServerVM::getNullRestrictedArrayClassFromComponentClass(componentClass);
+
+   if (comp->getOption(TR_UseSymbolValidationManager))
+      {
+      validated = comp->getSymbolValidationManager()->addArrayClassFromComponentClassRecord(nullRestrictedArrayClass, componentClass);
+      }
+   else
+      {
+      validated = ((TR_ResolvedRelocatableJ9JITServerMethod *) comp->getCurrentMethod())->validateArbitraryClass(comp, (J9Class *) componentClass);
+      }
+   return validated ? nullRestrictedArrayClass : NULL;
+   }
+
 TR_OpaqueClassBlock *
 TR_J9SharedCacheServerVM::getLeafComponentClassFromArrayClass(TR_OpaqueClassBlock * arrayClass)
    {

runtime/compiler/env/VMJ9Server.hpp

@@ -126,6 +126,16 @@ class TR_J9ServerVM: public TR_J9VM
    virtual bool isCloneable(TR_OpaqueClassBlock *clazzPointer) override;
    virtual bool canAllocateInlineClass(TR_OpaqueClassBlock *clazz) override;
    virtual TR_OpaqueClassBlock * getArrayClassFromComponentClass(TR_OpaqueClassBlock *componentClass) override;
+   /** \brief
+     *     Retrieves the nullRestrictedArrayClass from the array component class.
+     *
+     *  \param componentClass
+     *     The array component class
+     *
+     *  \return
+     *     A pointer to nullRestrictedArrayClass if it exists, otherwise NULL
+     */
+   virtual TR_OpaqueClassBlock * getNullRestrictedArrayClassFromComponentClass(TR_OpaqueClassBlock *componentClass) override;
    virtual J9Class * matchRAMclassFromROMclass(J9ROMClass *clazz, TR::Compilation *comp) override;
    virtual int32_t * getCurrentLocalsMapForDLT(TR::Compilation *comp) override;
    virtual uintptr_t getReferenceFieldAt(uintptr_t objectPointer, uintptr_t offsetFromHeader) override;
@@ -345,6 +355,16 @@ class TR_J9SharedCacheServerVM: public TR_J9ServerVM
    virtual bool isPrimitiveClass(TR_OpaqueClassBlock *clazzPointer) override;
    virtual TR_OpaqueClassBlock *getComponentClassFromArrayClass(TR_OpaqueClassBlock *arrayClass) override;
    virtual TR_OpaqueClassBlock *getArrayClassFromComponentClass(TR_OpaqueClassBlock *componentClass) override;
+   /** \brief
+     *     Retrieves the nullRestrictedArrayClass from the array component class.
+     *
+     *  \param componentClass
+     *     The array component class
+     *
+     *  \return
+     *     A pointer to nullRestrictedArrayClass if it exists, otherwise NULL
+     */
+   virtual TR_OpaqueClassBlock * getNullRestrictedArrayClassFromComponentClass(TR_OpaqueClassBlock *componentClass) override;
    virtual TR_OpaqueClassBlock *getLeafComponentClassFromArrayClass(TR_OpaqueClassBlock *arrayClass) override;
    virtual TR_OpaqueClassBlock *getBaseComponentClass(TR_OpaqueClassBlock *clazz, int32_t & numDims) override;
    virtual TR_OpaqueClassBlock *getClassFromNewArrayType(int32_t arrayType) override;

runtime/compiler/env/j9method.cpp

@@ -3847,6 +3847,19 @@ void TR_ResolvedJ9Method::construct()
       {  TR::unknownMethod}
       };
 
+   static X ValueClassMethods[] =
+      {
+      {x(TR::jdk_internal_value_ValueClass_newArrayInstance, "newArrayInstance", "(Ljdk/internal/value/CheckedType;I)[Ljava/lang/Object;")},
+      {x(TR::jdk_internal_value_ValueClass_newNullRestrictedArray, "newNullRestrictedArray", "(Ljava/lang/Class;I)[Ljava/lang/Object;")},
+      {  TR::unknownMethod}
+      };
+
+   static X NullRestrictedCheckedTypeMethods[] =
+      {
+      {x(TR::jdk_internal_value_NullRestrictedCheckedType_of, "of", "(Ljava/lang/Class;)Ljdk/internal/value/NullRestrictedCheckedType;")},
+      {  TR::unknownMethod}
+      };
+
    static X SpreadHandleMethods[] =
       {
       {x(TR::java_lang_invoke_SpreadHandle_numArgsToPassThrough,  "numArgsToPassThrough",   "()I")},
@@ -4183,6 +4196,7 @@ void TR_ResolvedJ9Method::construct()
       { "sun/nio/cs/ISO_8859_1$Decoder", EncodeMethods },
       { "java/io/ByteArrayOutputStream", ByteArrayOutputStreamMethods },
       { "java/lang/ScopedValue$Carrier", ScopedValueMethods },
+      { "jdk/internal/value/ValueClass", ValueClassMethods },
       { 0 }
       };
 
@@ -4311,6 +4325,7 @@ void TR_ResolvedJ9Method::construct()
       {
       { "java/lang/invoke/ConvertHandle$FilterHelpers", ConvertHandleFilterHelpersMethods },
       { "java/lang/invoke/DirectMethodHandle$Accessor", DirectMethodHandleAccessorMethods },
+      { "jdk/internal/value/NullRestrictedCheckedType", NullRestrictedCheckedTypeMethods },
       { 0 }
       };
 

runtime/compiler/net/CommunicationStream.hpp

@@ -128,7 +128,7 @@ class CommunicationStream
    // likely to lose an increment when merging/rebasing/etc.
    //
    static const uint8_t MAJOR_NUMBER = 1;
-   static const uint16_t MINOR_NUMBER = 68; // ID: +/QzEedP8cjGovxgYECy
+   static const uint16_t MINOR_NUMBER = 69; // ID: SMN6DXY0b2X1Z76N9825
    static const uint8_t PATCH_NUMBER = 0;
    static uint32_t CONFIGURATION_FLAGS;
 

runtime/compiler/net/MessageTypes.cpp

@@ -122,6 +122,7 @@ const char *messageNames[] =
    "VM_classInitIsFinished",
    "VM_getClassFromNewArrayType",
    "VM_getArrayClassFromComponentClass",
+   "VM_getNullRestrictedArrayClassFromComponentClass",
    "VM_matchRAMclassFromROMclass",
    "VM_getInt32FieldAt",
    "VM_getInt64FieldAt",

runtime/compiler/net/MessageTypes.hpp

@@ -131,6 +131,7 @@ enum MessageType : uint16_t
    VM_classInitIsFinished,
    VM_getClassFromNewArrayType,
    VM_getArrayClassFromComponentClass,
+   VM_getNullRestrictedArrayClassFromComponentClass,
    VM_matchRAMclassFromROMclass,
    VM_getInt32FieldAt,
    VM_getInt64FieldAt,