Squashed commit of the following:

commit 44766de Merge: 975e741 fe89ec5 Author: Marius Pirvu <[email protected]> Date: Tue Nov 19 09:18:48 2024 -0500 Merge pull request eclipse-openj9#20614 from JamesKingdon/trampolineResetFix Reset trampoline pointers to top of space commit 975e741 Merge: 9618d90 9f566fa Author: Peter Shipton <[email protected]> Date: Tue Nov 19 08:34:48 2024 -0500 Merge pull request eclipse-openj9#20631 from tajila/jfr3 Disable JFR JCL APIs commit 9618d90 Merge: 8f240e6 36dc396 Author: Dmitri Pivkine <[email protected]> Date: Mon Nov 18 21:45:37 2024 -0500 Merge pull request eclipse-openj9#20630 from amicic/VLHGC_barrier_32bit Don't use Offheap APIs for 32 bit commit 9f566fa Author: tajila <[email protected]> Date: Mon Nov 18 20:05:47 2024 -0500 Disable JFR JCL APIs Disable JFR JCL APIs until JFR natives are implemented. Related to: eclipse-openj9#20607 Signed-off-by: tajila <[email protected]> commit 8f240e6 Merge: 7534b4e 6662a08 Author: Keith W. Campbell <[email protected]> Date: Mon Nov 18 20:05:46 2024 -0500 Merge pull request eclipse-openj9#20621 from tajila/jfr2 Fix conditon in JFR buffer test commit 6662a08 Author: tajila <[email protected]> Date: Mon Nov 18 15:49:59 2024 -0500 Fix conditon in JFR buffer test Signed-off-by: tajila <[email protected]> commit 36dc396 Author: Aleksandar Micic <[email protected]> Date: Mon Nov 18 19:11:09 2024 -0500 Don't use Offheap APIs for 32 bit A couple of Offheap APIs are guarded with 64 bit compile flag. A more accurate fix would be to guard them with Offheap specific build flag (and do not compile the whole dir for 32bit), but it would require more complex changes. Signed-off-by: Aleksandar Micic <[email protected]> commit 7534b4e Merge: 3d719d4 276f38f Author: Graham Chapman <[email protected]> Date: Mon Nov 18 18:14:00 2024 -0500 Merge pull request eclipse-openj9#20620 from tajila/jfr3 Release jfrSampler lock before acquiring VMaccess commit 3d719d4 Merge: 247d6ec c0ff1fc Author: Peter Shipton <[email protected]> Date: Mon Nov 18 17:17:42 2024 -0500 Merge pull request eclipse-openj9#20622 from AdamBrousseau/cuda_docker_non_dockerhub Pull cuda image from nvcr commit 247d6ec Merge: 068838e fee4aeb Author: Aleksandar Micic <[email protected]> Date: Mon Nov 18 16:55:50 2024 -0500 Merge pull request eclipse-openj9#20514 from LinHu2016/coding-std-update2 Clean up MethodTypesIterator class commit 068838e Merge: d98d498 3dc8eb4 Author: Aleksandar Micic <[email protected]> Date: Mon Nov 18 16:46:15 2024 -0500 Merge pull request eclipse-openj9#20564 from LinHu2016/off-heap-incremental4 New vm/gc API j9gc_objaccess_indexableDataDisplacement commit c0ff1fc Author: Adam Brousseau <[email protected]> Date: Mon Nov 18 16:03:35 2024 -0500 Pull cuda image from nvcr In the event we are rate-limited or restricted from pulling from DockerHub, this should work around the problem by pulling from Nvidia's site. Issue runtimes/automation/122 Signed-off-by: Adam Brousseau <[email protected]> commit 3dc8eb4 Author: lhu <[email protected]> Date: Fri Nov 8 11:50:32 2024 -0500 New vm/gc API j9gc_objaccess_indexableDataDisplacement new API j9gc_objaccess_indexableDataDisplacement used by the JIT. Returns the displacement for the data of moved array object. For adjacent Array and 0 size array, displacement = dst - src For Off-heap Array, displacement = 0 should only be called for off-heap eanbled case. Signed-off-by: lhu <[email protected]> commit d98d498 Merge: 77f153d ee35ed5 Author: Graham Chapman <[email protected]> Date: Mon Nov 18 14:52:20 2024 -0500 Merge pull request eclipse-openj9#20611 from tajila/jfr2 Prevent writes to free'd JFR buffer commit 77f153d Merge: 038df36 326a800 Author: Marius Pirvu <[email protected]> Date: Mon Nov 18 14:09:15 2024 -0500 Merge pull request eclipse-openj9#20592 from luke-li-2003/ServerCacheReflectClass Cache Client's Reflect Class Pointers at JITServer commit 276f38f Author: tajila <[email protected]> Date: Mon Nov 18 13:59:52 2024 -0500 Release jfrSampler lock before acquiring VMaccess Signed-off-by: tajila <[email protected]> commit ee35ed5 Author: tajila <[email protected]> Date: Sun Nov 17 16:06:08 2024 -0500 Prevent writes to free'd JFR buffer Also, check that threadObject is not NULL before dereference. Signed-off-by: tajila <[email protected]> commit 038df36 Merge: 224374d 0573107 Author: Aleksandar Micic <[email protected]> Date: Mon Nov 18 11:12:43 2024 -0500 Merge pull request eclipse-openj9#20596 from LinHu2016/off-heap-incremental6 Update verbose GC for off-heap commit 224374d Merge: 6289c28 d56338f Author: Babneet Singh <[email protected]> Date: Mon Nov 18 10:20:28 2024 -0500 Merge pull request eclipse-openj9#20606 from ThanHenderson/omr-unnamed Fix OMR_GLUE unnamed spelling mistake commit 6289c28 Merge: efaa4f6 1af5097 Author: Tobi <[email protected]> Date: Mon Nov 18 09:56:54 2024 -0500 Merge pull request eclipse-openj9#20605 from pshipton/cracbean Move CRaCMXBeanImpl and export jdk.crac.management commit 1af5097 Author: Peter Shipton <[email protected]> Date: Fri Nov 15 14:28:45 2024 -0500 Move CRaCMXBeanImpl and export jdk.crac.management Issue eclipse-openj9#20587 Signed-off-by: Peter Shipton <[email protected]> commit 326a800 Author: Luke Li <[email protected]> Date: Thu Nov 14 16:13:54 2024 -0500 Remove J9Class Occurrences in Vector API Substitute uses of J9Class in the vector API with TR_OpaqueClassBlock with frontend references. The Vector API, being a part of the optimizer, should never use the inside of a J9Class Signed-off-by: Luke Li <[email protected]> commit a97a4ba Author: Luke Li <[email protected]> Date: Mon Oct 28 09:31:53 2024 -0400 Remove Server VM Access Request in VectorAPIExpansion.cpp The server should make a specific request to the client in getJ9ClassFromClassNode() and getVectorSizeFromVectorSpecies(), instead of requesting a pointer from the KnownObjectTable as that requires VM Access and will cause a fatal assertion fail at J9KnownObjectTable.cpp:207. Signed-off-by: Luke Li <[email protected]> commit fe89ec5 Author: James Kingdon <[email protected]> Date: Fri Nov 15 15:24:35 2024 -0500 Reset trampoline pointers to top of space After flushing the code cache under FSD there is a call to resetTrampolines. The _trampolineAllocationMark and _trampolineReservationMark need to be reset to their starting positions but were incorrectly set to the end of the trampoline space. As a result all active segments at the time of the cache flush are marked as full (assuming a platform that uses trampolines). This can be seen by taking a JIT verbose log with option `codecache` which will show CODECACHE: CodeCache 00007E759000C660 marked as full in reserveSpaceForTrampoline commit d56338f Author: Nathan Henderson <[email protected]> Date: Fri Nov 15 11:32:46 2024 -0800 Fix OMR_GLUE unnamed spelling mistake Signed-off-by: Nathan Henderson <[email protected]> commit 0573107 Author: lhu <[email protected]> Date: Tue Nov 12 12:09:29 2024 -0500 Update verbose GC for off-heap -new outputOffHeapInfo in CopyForward and Mark for balancedGC <offheap candidates="xxx" cleared="xxx" />" - output offheap-objects in MemoryInfo <offheap-objects objects="xxx" bytes="xxx" /> Signed-off-by: lhu <[email protected]> commit fee4aeb Author: lhu <[email protected]> Date: Tue Nov 5 10:51:09 2024 -0500 Clean up MethodTypesIterator class Use consistent data types and code formatting Signed-off-by: lhu <[email protected]>
h3110n3rv3 · Nov 19, 2024 · 09434fe · 09434fe
1 parent 4270c4b
commit 09434fe
Show file tree

Hide file tree

Showing 37 changed files with 437 additions and 75 deletions.
diff --git a/buildenv/jenkins/common/build.groovy b/buildenv/jenkins/common/build.groovy
@@ -828,7 +828,7 @@ def create_docker_image_locally()
         echo 'ARG image
             ARG cuda_ver=12.2.0
             ARG cuda_distro=ubi8
-            FROM nvidia/cuda:${cuda_ver}-devel-${cuda_distro} as cuda
+            FROM nvcr.io/nvidia/cuda:${cuda_ver}-devel-${cuda_distro} as cuda
             FROM $image
             RUN mkdir -p /usr/local/cuda/nvvm
             COPY --from=cuda /usr/local/cuda/include         /usr/local/cuda/include

diff --git a/jcl/src/java.base/share/classes/java/lang/System.java b/jcl/src/java.base/share/classes/java/lang/System.java
@@ -736,7 +736,10 @@ private static void ensureProperties(boolean isInitialization) {
 	/*[ENDIF] CRIU_SUPPORT */
 
 	/*[IF JFR_SUPPORT]*/
+	/* Enables openj9 JFR tests. */
 	initializedProperties.put("org.eclipse.openj9.jfr.isJFREnabled", "true"); //$NON-NLS-1$ //$NON-NLS-2$
+	/* TODO disable JFR JCL APIs until JFR natives are implemented. */
+	initializedProperties.put("jfr.unsupported.vm", "true"); //$NON-NLS-1$ //$NON-NLS-2$
 	/*[ENDIF] JFR_SUPPORT */
 
 	String[] list = getPropertyList();

diff --git a/.../java.management/share/classes/com/ibm/java/lang/management/internal/ManagementUtils.java b/.../java.management/share/classes/com/ibm/java/lang/management/internal/ManagementUtils.java
@@ -775,7 +775,7 @@ static void registerAll() {
 				.validateAndRegister();
 
 /*[IF CRAC_SUPPORT]*/
-			create(jdk.crac.management.CRaCMXBean.CRAC_MXBEAN_NAME, jdk.crac.management.CRaCMXBeanImpl.getInstance())
+			create(jdk.crac.management.CRaCMXBean.CRAC_MXBEAN_NAME, jdk.crac.management.internal.CRaCMXBeanImpl.getInstance())
 				.addInterface(jdk.crac.management.CRaCMXBean.class)
 				.validateAndRegister();
 /*[ENDIF] CRAC_SUPPORT */

diff --git a/.../jdk.management/share/classes/com/ibm/lang/management/internal/PlatformMBeanProvider.java b/.../jdk.management/share/classes/com/ibm/lang/management/internal/PlatformMBeanProvider.java
@@ -112,7 +112,7 @@ public final class PlatformMBeanProvider extends sun.management.spi.PlatformMBea
 		}
 
 /*[IF CRAC_SUPPORT]*/
-		ComponentBuilder.create(jdk.crac.management.CRaCMXBean.CRAC_MXBEAN_NAME, jdk.crac.management.CRaCMXBeanImpl.getInstance()) // $NON-NLS-1$
+		ComponentBuilder.create(jdk.crac.management.CRaCMXBean.CRAC_MXBEAN_NAME, jdk.crac.management.internal.CRaCMXBeanImpl.getInstance()) // $NON-NLS-1$
 			.addInterface(jdk.crac.management.CRaCMXBean.class)
 			.register(allComponents);
 /*[ENDIF] CRAC_SUPPORT */

diff --git a/jcl/src/jdk.management/share/classes/jdk/crac/management/CRaCMXBean.java b/jcl/src/jdk.management/share/classes/jdk/crac/management/CRaCMXBean.java
@@ -23,6 +23,7 @@
 package jdk.crac.management;
 
 import java.lang.management.PlatformManagedObject;
+import jdk.crac.management.internal.CRaCMXBeanImpl;
 
 /**
  * A management interface of the CRaC functionality in the Java virtual machine.

diff --git a/...s/jdk/crac/management/CRaCMXBeanImpl.java → ...c/management/internal/CRaCMXBeanImpl.java b/...s/jdk/crac/management/CRaCMXBeanImpl.java → ...c/management/internal/CRaCMXBeanImpl.java
@@ -20,11 +20,12 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR Apache-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0 OR GPL-2.0-only WITH OpenJDK-assembly-exception-1.0
  */
-package jdk.crac.management;
+package jdk.crac.management.internal;
 
 import java.util.concurrent.TimeUnit;
 import javax.management.MalformedObjectNameException;
 import javax.management.ObjectName;
+import jdk.crac.management.CRaCMXBean;
 import openj9.internal.criu.InternalCRIUSupport;
 
 /**

diff --git a/jcl/src/jdk.management/share/classes/module-info.java.extra b/jcl/src/jdk.management/share/classes/module-info.java.extra
@@ -22,6 +22,9 @@
  */
 
 exports com.ibm.lang.management;
-exports openj9.lang.management;
 exports com.ibm.virtualization.management;
+/*[IF CRAC_SUPPORT]*/
+exports jdk.crac.management;
+/*[ENDIF] CRAC_SUPPORT */
+exports openj9.lang.management;
 provides sun.management.spi.PlatformMBeanProvider with com.ibm.lang.management.internal.PlatformMBeanProvider;
diff --git a/runtime/compiler/control/JITClientCompilationThread.cpp b/runtime/compiler/control/JITClientCompilationThread.cpp
@@ -555,6 +555,16 @@ handleServerMessage(JITServer::ClientStream *client, TR_J9VM *fe, JITServer::Mes
 #else
          vmInfo._isNonPortableRestoreMode = false;
 #endif /* defined(J9VM_OPT_CRIU_SUPPORT) */
+         vmInfo._voidReflectClassPtr = javaVM->voidReflectClass;
+         vmInfo._booleanReflectClassPtr = javaVM->booleanReflectClass;
+         vmInfo._charReflectClassPtr = javaVM->charReflectClass;
+         vmInfo._floatReflectClassPtr = javaVM->floatReflectClass;
+         vmInfo._doubleReflectClassPtr = javaVM->doubleReflectClass;
+         vmInfo._byteReflectClassPtr = javaVM->byteReflectClass;
+         vmInfo._shortReflectClassPtr = javaVM->shortReflectClass;
+         vmInfo._intReflectClassPtr = javaVM->intReflectClass;
+         vmInfo._longReflectClassPtr = javaVM->longReflectClass;
+
          client->write(response, vmInfo, listOfCacheDescriptors, comp->getPersistentInfo()->getJITServerAOTCacheName());
          }
          break;
@@ -2885,6 +2895,41 @@ handleServerMessage(JITServer::ClientStream *client, TR_J9VM *fe, JITServer::Mes
          client->write(response, knownObjectTableDumpInfoList);
          }
          break;
+      case MessageType::KnownObjectTable_getOpaqueClass:
+         {
+         TR::KnownObjectTable::Index knotIndex =
+            std::get<0>(client->getRecvData<TR::KnownObjectTable::Index>());
+
+         uintptr_t clazz = 0;
+            {
+            TR::VMAccessCriticalSection getJ9ClassFromKnownObjectIndex(fe);
+
+            uintptr_t javaLangClass = knot->getPointer(knotIndex);
+            clazz = (uintptr_t)fe->getInt64Field(javaLangClass, "vmRef");
+            }
+
+         client->write(response, clazz);
+         }
+         break;
+      case MessageType::KnownObjectTable_getVectorBitSize:
+         {
+         TR::KnownObjectTable::Index knotIndex =
+            std::get<0>(client->getRecvData<TR::KnownObjectTable::Index>());
+
+         int32_t vectorBitSize = 0;
+            {
+            TR::VMAccessCriticalSection getVBSFromKnownObjectIndex(fe);
+
+            uintptr_t vectorSpeciesLocation = knot->getPointer(knotIndex);
+            uintptr_t vectorShapeLocation = fe->getReferenceField(vectorSpeciesLocation,
+                                                            "vectorShape",
+                                                            "Ljdk/incubator/vector/VectorShape;");
+            vectorBitSize = fe->getInt32Field(vectorShapeLocation, "vectorBitSize");
+            }
+
+         client->write(response, vectorBitSize);
+         }
+         break;
       case MessageType::AOTCache_getROMClassBatch:
          {
          auto recv = client->getRecvData<std::vector<J9Class *>>();

diff --git a/runtime/compiler/env/VMJ9.cpp b/runtime/compiler/env/VMJ9.cpp
@@ -1307,11 +1307,13 @@ TR_J9VMBase::getReferenceElement(uintptr_t objectPointer, intptr_t elementIndex)
    return (uintptr_t)J9JAVAARRAYOFOBJECT_LOAD(vmThread(), objectPointer, elementIndex);
    }
 
-TR_arrayTypeCode TR_J9VMBase::getPrimitiveArrayTypeCode(TR_OpaqueClassBlock* clazz)
+TR_arrayTypeCode
+TR_J9VMBase::getPrimitiveArrayTypeCode(TR_OpaqueClassBlock* clazz)
    {
    TR_ASSERT(isPrimitiveClass(clazz), "Expect primitive class in TR_J9VMBase::getPrimitiveArrayType");
 
    J9Class* j9clazz = (J9Class*)clazz;
+
    if (j9clazz == jitConfig->javaVM->booleanReflectClass)
       return atype_boolean;
    else if (j9clazz == jitConfig->javaVM->charReflectClass)
@@ -1335,6 +1337,31 @@ TR_arrayTypeCode TR_J9VMBase::getPrimitiveArrayTypeCode(TR_OpaqueClassBlock* cla
       }
    }
 
+TR::DataType
+TR_J9VMBase::getClassPrimitiveDataType(TR_OpaqueClassBlock* clazz)
+   {
+   J9Class *j9class = TR::Compiler->cls.convertClassOffsetToClassPtr(clazz);
+   if (!j9class)
+      return TR::NoType;
+
+   J9JavaVM *vm = getJ9JITConfig()->javaVM;
+
+   if (j9class == vm->floatReflectClass)
+      return TR::Float;
+   else if (j9class == vm->doubleReflectClass)
+      return TR::Double;
+   else if (j9class == vm->byteReflectClass)
+      return TR::Int8;
+   else if (j9class == vm->shortReflectClass)
+      return TR::Int16;
+   else if (j9class == vm->intReflectClass)
+      return TR::Int32;
+   else if (j9class == vm->longReflectClass)
+      return TR::Int64;
+   else
+      return TR::NoType;
+   }
+
 TR_OpaqueClassBlock *
 TR_J9VMBase::getClassFromJavaLangClass(uintptr_t objectPointer)
    {

diff --git a/runtime/compiler/env/VMJ9.h b/runtime/compiler/env/VMJ9.h
@@ -669,6 +669,7 @@ class TR_J9VMBase : public TR_FrontEnd
 
    virtual TR_OpaqueClassBlock *getClassFromJavaLangClass(uintptr_t objectPointer);
    virtual TR_arrayTypeCode    getPrimitiveArrayTypeCode(TR_OpaqueClassBlock* clazz);
+   virtual TR::DataType        getClassPrimitiveDataType(TR_OpaqueClassBlock* clazz);
    virtual TR_OpaqueClassBlock * getSystemClassFromClassName(const char * name, int32_t length, bool callSiteVettedForAOT=false) { return 0; }
    virtual TR_OpaqueClassBlock * getByteArrayClass();
 

diff --git a/runtime/compiler/env/VMJ9Server.cpp b/runtime/compiler/env/VMJ9Server.cpp
@@ -2616,6 +2616,65 @@ TR_J9ServerVM::isOffHeapAllocationEnabled()
    return vmInfo->_isOffHeapAllocationEnabled;
    }
 
+
+TR_arrayTypeCode
+TR_J9ServerVM::getPrimitiveArrayTypeCode(TR_OpaqueClassBlock* clazz)
+   {
+   TR_ASSERT(isPrimitiveClass(clazz), "Expect primitive class in TR_J9VMBase::getPrimitiveArrayType");
+
+   J9Class* j9clazz = (J9Class*)clazz;
+
+   auto stream = _compInfoPT->getStream();
+   auto vmInfo = _compInfoPT->getClientData()->getOrCacheVMInfo(stream);
+   if (j9clazz == vmInfo->_booleanReflectClassPtr)
+      return atype_boolean;
+   else if (j9clazz == vmInfo->_charReflectClassPtr)
+      return atype_char;
+   else if (j9clazz == vmInfo->_floatReflectClassPtr)
+      return atype_float;
+   else if (j9clazz == vmInfo->_doubleReflectClassPtr)
+      return atype_double;
+   else if (j9clazz == vmInfo->_byteReflectClassPtr)
+      return atype_byte;
+   else if (j9clazz == vmInfo->_shortReflectClassPtr)
+      return atype_short;
+   else if (j9clazz == vmInfo->_intReflectClassPtr)
+      return atype_int;
+   else if (j9clazz == vmInfo->_longReflectClassPtr)
+      return atype_long;
+   else
+      {
+      TR_ASSERT(false, "TR_arrayTypeCode is not defined for the j9clazz");
+      return (TR_arrayTypeCode)0;
+      }
+   }
+
+TR::DataType
+TR_J9ServerVM::getClassPrimitiveDataType(TR_OpaqueClassBlock* clazz)
+   {
+   J9Class *j9class = TR::Compiler->cls.convertClassOffsetToClassPtr(clazz);
+
+   if (!j9class) return TR::NoType;
+
+   auto vmInfo = _compInfoPT->getClientData()->getOrCacheVMInfo(_compInfoPT->getStream());
+
+   if (j9class == vmInfo->_floatReflectClassPtr)
+      return TR::Float;
+   else if (j9class == vmInfo->_doubleReflectClassPtr)
+      return TR::Double;
+   else if (j9class == vmInfo->_byteReflectClassPtr)
+      return TR::Int8;
+   else if (j9class == vmInfo->_shortReflectClassPtr)
+      return TR::Int16;
+   else if (j9class == vmInfo->_intReflectClassPtr)
+      return TR::Int32;
+   else if (j9class == vmInfo->_longReflectClassPtr)
+      return TR::Int64;
+   else
+      return TR::NoType;
+   }
+
+
 bool
 TR_J9SharedCacheServerVM::isClassLibraryMethod(TR_OpaqueMethodBlock *method, bool vettedForAOT)
    {

diff --git a/runtime/compiler/env/VMJ9Server.hpp b/runtime/compiler/env/VMJ9Server.hpp
@@ -265,6 +265,9 @@ class TR_J9ServerVM: public TR_J9VM
    virtual bool isIndexableDataAddrPresent() override;
    virtual bool isOffHeapAllocationEnabled() override;
 
+   virtual TR_arrayTypeCode       getPrimitiveArrayTypeCode(TR_OpaqueClassBlock* clazz) override;
+   virtual TR::DataType           getClassPrimitiveDataType(TR_OpaqueClassBlock* clazz) override;
+
 private:
    bool instanceOfOrCheckCastHelper(J9Class *instanceClass, J9Class* castClass, bool cacheUpdate);
    bool checkCHTableIfClassInfoExistsAndHasBeenExtended(TR_OpaqueClassBlock *clazz, bool &bClassHasBeenExtended);

diff --git a/runtime/compiler/net/CommunicationStream.hpp b/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 = 71; // ID:1QMsN16q0acJzn1qRQHY
+   static const uint16_t MINOR_NUMBER = 72; // ID: PB545sJS3QOBXIIPV5JZ
    static const uint8_t PATCH_NUMBER = 0;
    static uint32_t CONFIGURATION_FLAGS;
 

diff --git a/runtime/compiler/net/MessageTypes.cpp b/runtime/compiler/net/MessageTypes.cpp
@@ -259,6 +259,8 @@ const char *messageNames[] =
    "KnownObjectTable_createSymRefWithKnownObject",
    "KnownObjectTable_getReferenceField",
    "KnownObjectTable_getKnownObjectTableDumpInfo",
+   "KnownObjectTable_getOpaqueClass",
+   "KnownObjectTable_getVectorBitSize",
    "AOTCache_getROMClassBatch",
    "AOTCacheMap_request",
    "AOTCacheMap_reply"

diff --git a/runtime/compiler/net/MessageTypes.hpp b/runtime/compiler/net/MessageTypes.hpp
@@ -284,12 +284,17 @@ enum MessageType : uint16_t
    KnownObjectTable_createSymRefWithKnownObject,
    KnownObjectTable_getReferenceField,
    KnownObjectTable_getKnownObjectTableDumpInfo,
+   // for getting a J9Class from KnownObjectTable
+   KnownObjectTable_getOpaqueClass,
+   // for getting a vectorBitSize from KnownObjectTable
+   KnownObjectTable_getVectorBitSize,
 
    AOTCache_getROMClassBatch,
 
    AOTCacheMap_request,
    AOTCacheMap_reply,
 
+
    MessageType_MAXTYPE
    };
    extern const char *messageNames[];