Add API getDefaultValueSlotAddress

runtime/compiler/control/JITClientCompilationThread.cpp

@@ -2079,6 +2079,13 @@ handleServerMessage(JITServer::ClientStream *client, TR_J9VM *fe, JITServer::Mes
          client->write(response, TR::Compiler->cls.flattenedArrayElementSize(comp, arrayClass));
          }
          break;
+      case MessageType::ClassEnv_getDefaultValueSlotAddress:
+         {
+         auto recv = client->getRecvData<TR_OpaqueClassBlock *>();
+         auto clazz = std::get<0>(recv);
+         client->write(response, TR::Compiler->cls.getDefaultValueSlotAddress(comp, clazz));
+         }
+         break;
       case MessageType::ClassEnv_enumerateFields:
          {
          auto recv = client->getRecvData<TR_OpaqueClassBlock *>();

runtime/compiler/control/JITServerHelpers.cpp

@@ -575,6 +575,7 @@ JITServerHelpers::cacheRemoteROMClass(ClientSessionData *clientSessionData, J9Cl
    auto &origROMMethods = std::get<21>(classInfoTuple);
    classInfoStruct._classNameIdentifyingLoader = std::get<22>(classInfoTuple);
    classInfoStruct._arrayElementSize = std::get<23>(classInfoTuple);
+   classInfoStruct._defaultValueSlotAddress = std::get<24>(classInfoTuple);
 
    auto result = clientSessionData->getROMClassMap().insert({ clazz, classInfoStruct });
 
@@ -663,12 +664,21 @@ JITServerHelpers::packRemoteROMClassInfo(J9Class *clazz, J9VMThread *vmThread, T
 
    int32_t arrayElementSize = vmThread->javaVM->internalVMFunctions->arrayElementSize((J9ArrayClass*)clazz);
 
+   // getDefaultValueSlotAddress can only be called if the value type class is initialized
+   j9object_t* defaultValueSlotAddress = NULL;
+   if (TR::Compiler->om.areValueTypesEnabled() &&
+       classInitialized &&
+       TR::Compiler->cls.isValueTypeClass(TR::Compiler->cls.convertClassPtrToClassOffset(clazz)))
+      {
+      defaultValueSlotAddress = vmThread->javaVM->internalVMFunctions->getDefaultValueSlotAddress(clazz);
+      }
+
    return std::make_tuple(
       packedROMClassStr, methodsOfClass, baseClass, numDims, parentClass,
       TR::Compiler->cls.getITable((TR_OpaqueClassBlock *)clazz), methodTracingInfo,
       classHasFinalFields, classDepthAndFlags, classInitialized, byteOffsetToLockword, leafComponentClass,
       classLoader, hostClass, componentClass, arrayClass, totalInstanceSize, clazz->romClass,
-      cp, classFlags, classChainOffsetIdentifyingLoader, origROMMethods, classNameIdentifyingLoader, arrayElementSize
+      cp, classFlags, classChainOffsetIdentifyingLoader, origROMMethods, classNameIdentifyingLoader, arrayElementSize, defaultValueSlotAddress
    );
    }
 
@@ -841,6 +851,9 @@ JITServerHelpers::getROMClassData(const ClientSessionData::ClassInfo &classInfo,
       case CLASSINFO_ARRAY_ELEMENT_SIZE:
          *(int32_t *)data = classInfo._arrayElementSize;
          break;
+      case CLASSINFO_DEFAULT_VALUE_SLOT_ADDRESS:
+         *(j9object_t **)data = classInfo._defaultValueSlotAddress;
+         break;
       default:
          TR_ASSERT(false, "Class Info not supported %u\n", dataType);
          break;

runtime/compiler/control/JITServerHelpers.hpp

@@ -55,6 +55,7 @@ class JITServerHelpers
       CLASSINFO_CONSTANT_POOL,
       CLASSINFO_CLASS_CHAIN_OFFSET_IDENTIFYING_LOADER,
       CLASSINFO_ARRAY_ELEMENT_SIZE,
+      CLASSINFO_DEFAULT_VALUE_SLOT_ADDRESS,
       };
 
    // NOTE: when adding new elements to this tuple, add them to the end,
@@ -84,7 +85,8 @@ class JITServerHelpers
       uintptr_t,                         // 20: _classChainOffsetIdentifyingLoader
       std::vector<J9ROMMethod *>,        // 21: _origROMMethods
       std::string,                       // 22: _classNameIdentifyingLoader
-      int32_t                            // 23: _arrayElementSize
+      int32_t,                           // 23: _arrayElementSize
+      j9object_t *                       // 24: _defaultValueSlotAddress
       >;
 
    // Packs a ROMClass to be transferred to the server.

runtime/compiler/env/J9ClassEnv.cpp

@@ -589,7 +589,7 @@ J9::ClassEnv::enumerateFields(TR::Region &region, TR_OpaqueClassBlock *opaqueCla
 #if defined(J9VM_OPT_JITSERVER)
    if (comp->isOutOfProcessCompilation())
       {
-      auto stream = TR::CompilationInfo::getStream();
+      auto stream = comp->getStream();
       stream->write(JITServer::MessageType::ClassEnv_enumerateFields, opaqueClazz);
       auto recv = stream->read<std::vector<TR::TypeLayoutEntry>, std::vector<std::string>, std::vector<std::string>>();
       auto &entries = std::get<0>(recv);
@@ -981,7 +981,7 @@ bool
 J9::ClassEnv::isClassRefPrimitiveValueType(TR::Compilation *comp, TR_OpaqueClassBlock *cpContextClass, int32_t cpIndex)
    {
 #if defined(J9VM_OPT_JITSERVER)
-   if (auto stream = TR::CompilationInfo::getStream())
+   if (auto stream = comp->getStream())
       {
       stream->write(JITServer::MessageType::ClassEnv_isClassRefPrimitiveValueType, cpContextClass, cpIndex);
       return std::get<0>(stream->read<bool>());
@@ -1025,7 +1025,7 @@ int32_t
 J9::ClassEnv::flattenedArrayElementSize(TR::Compilation *comp, TR_OpaqueClassBlock *arrayClass)
    {
 #if defined(J9VM_OPT_JITSERVER)
-   if (auto stream = TR::CompilationInfo::getStream())
+   if (auto stream = comp->getStream())
       {
       int32_t arrayElementSize = 0;
       JITServerHelpers::getAndCacheRAMClassInfo((J9Class *)arrayClass, TR::compInfoPT->getClientData(), stream, JITServerHelpers::CLASSINFO_ARRAY_ELEMENT_SIZE, (void *)&arrayElementSize);
@@ -1038,3 +1038,44 @@ J9::ClassEnv::flattenedArrayElementSize(TR::Compilation *comp, TR_OpaqueClassBlo
       return vm->internalVMFunctions->arrayElementSize((J9ArrayClass*)self()->convertClassOffsetToClassPtr(arrayClass));
       }
    }
+
+j9object_t*
+J9::ClassEnv::getDefaultValueSlotAddress(TR::Compilation *comp, TR_OpaqueClassBlock *clazz)
+   {
+   TR_ASSERT_FATAL(self()->isClassInitialized(comp, clazz), "clazz %p must be initialized when getDefaultValueSlotAddress is called", clazz);
+
+#if defined(J9VM_OPT_JITSERVER)
+   if (auto stream = comp->getStream())
+      {
+      j9object_t* defaultValueSlotAddress = NULL;
+      ClientSessionData *clientSessionData = TR::compInfoPT->getClientData();
+
+      JITServerHelpers::getAndCacheRAMClassInfo((J9Class *)clazz, clientSessionData, stream, JITServerHelpers::CLASSINFO_DEFAULT_VALUE_SLOT_ADDRESS, (void *)&defaultValueSlotAddress);
+
+      if (!defaultValueSlotAddress)
+         {
+         stream->write(JITServer::MessageType::ClassEnv_getDefaultValueSlotAddress, clazz);
+         defaultValueSlotAddress = std::get<0>(stream->read<j9object_t*>());
+
+         if (defaultValueSlotAddress)
+            {
+            OMR::CriticalSection getRemoteROMClass(clientSessionData->getROMMapMonitor());
+            auto it = clientSessionData->getROMClassMap().find((J9Class*) clazz);
+            if (it != clientSessionData->getROMClassMap().end())
+               {
+               it->second._defaultValueSlotAddress = defaultValueSlotAddress;
+               }
+            }
+         }
+
+      return defaultValueSlotAddress;
+      }
+   else // non-jitserver
+#endif /* defined(J9VM_OPT_JITSERVER) */
+      {
+      J9Class *j9class = reinterpret_cast<J9Class *>(clazz);
+      J9JavaVM *vm = comp->fej9()->getJ9JITConfig()->javaVM;
+
+      return vm->internalVMFunctions->getDefaultValueSlotAddress(j9class);
+      }
+   }

runtime/compiler/env/J9ClassEnv.hpp

@@ -277,6 +277,17 @@ class OMR_EXTENSIBLE ClassEnv : public OMR::ClassEnvConnector
     * 2 concrete classses and false otherwise.
     */
    bool containsZeroOrOneConcreteClass(TR::Compilation *comp, List<TR_PersistentClassInfo>* subClasses);
+
+   /** \brief
+    *     Returns the reference to the address of the default value instance for a value class.
+    *
+    *  \param clazz
+    *     The class that the default value instance belongs to. Must be an initialized value class.
+    *
+    *  \return
+    *     The reference to the address of the default value instance.
+    */
+   j9object_t *getDefaultValueSlotAddress(TR::Compilation *comp, TR_OpaqueClassBlock *clazz);
    };
 
 }

runtime/compiler/net/CommunicationStream.hpp

@@ -97,7 +97,7 @@ class CommunicationStream
    ClientMessage _cMsg;
 
    static const uint8_t MAJOR_NUMBER = 1;
-   static const uint16_t MINOR_NUMBER = 39;
+   static const uint16_t MINOR_NUMBER = 40;
    static const uint8_t PATCH_NUMBER = 0;
    static uint32_t CONFIGURATION_FLAGS;
 

runtime/compiler/net/MessageTypes.cpp

@@ -211,6 +211,7 @@ const char *messageNames[] =
    "ClassEnv_enumerateFields",
    "ClassEnv_isClassRefPrimitiveValueType",
    "ClassEnv_flattenedArrayElementSize",
+   "ClassEnv_getDefaultValueSlotAddress",
    "SharedCache_getClassChainOffsetIdentifyingLoader",
    "SharedCache_rememberClass",
    "SharedCache_addHint",

runtime/compiler/net/MessageTypes.hpp

@@ -224,6 +224,7 @@ enum MessageType : uint16_t
    ClassEnv_enumerateFields,
    ClassEnv_isClassRefPrimitiveValueType,
    ClassEnv_flattenedArrayElementSize,
+   ClassEnv_getDefaultValueSlotAddress,
 
    // For TR_J9SharedCache
    SharedCache_getClassChainOffsetIdentifyingLoader,

runtime/compiler/runtime/JITClientSession.cpp

@@ -415,6 +415,7 @@ ClientSessionData::ClassInfo::ClassInfo(TR_PersistentMemory *persistentMemory) :
    _classNameIdentifyingLoader(),
    _aotCacheClassRecord(NULL),
    _arrayElementSize(0),
+   _defaultValueSlotAddress(NULL),
    _classOfStaticCache(decltype(_classOfStaticCache)::allocator_type(persistentMemory->_persistentAllocator.get())),
    _constantClassPoolCache(decltype(_constantClassPoolCache)::allocator_type(persistentMemory->_persistentAllocator.get())),
    _fieldAttributesCache(decltype(_fieldAttributesCache)::allocator_type(persistentMemory->_persistentAllocator.get())),

runtime/compiler/runtime/JITClientSession.hpp

@@ -210,6 +210,7 @@ class ClientSessionData
       std::string _classNameIdentifyingLoader;
       const AOTCacheClassRecord *_aotCacheClassRecord;
       int32_t _arrayElementSize;
+      j9object_t * _defaultValueSlotAddress;
 
       PersistentUnorderedMap<int32_t, TR_OpaqueClassBlock *> _classOfStaticCache;
       PersistentUnorderedMap<int32_t, TR_OpaqueClassBlock *> _constantClassPoolCache;