diff --git a/jcl/src/java.base/share/classes/openj9/internal/foreign/abi/InternalUpcallHandler.java b/jcl/src/java.base/share/classes/openj9/internal/foreign/abi/InternalUpcallHandler.java
index f085de39dd5..264b5f53497 100644
--- a/jcl/src/java.base/share/classes/openj9/internal/foreign/abi/InternalUpcallHandler.java
+++ b/jcl/src/java.base/share/classes/openj9/internal/foreign/abi/InternalUpcallHandler.java
@@ -144,7 +144,7 @@ private long getUpcallThunkAddr(MethodHandle target, ResourceScope sessionOrScop
* is only alive for a MemorySession(JDK19)/ResourceScope(JDK17/18) specified in java, which means the upcall handler
* and its UpcallMHMetaData object will be cleaned up automatically once their session/scope is closed.
*/
- metaData = new UpcallMHMetaData(target, sessionOrScope);
+ metaData = new UpcallMHMetaData(target, argLayoutCount, sessionOrScope);
return allocateUpcallStub(metaData, nativeSignatureStrs);
}
diff --git a/jcl/src/java.base/share/classes/openj9/internal/foreign/abi/UpcallMHMetaData.java b/jcl/src/java.base/share/classes/openj9/internal/foreign/abi/UpcallMHMetaData.java
index b75a11cfea8..8fc4d0c86d5 100644
--- a/jcl/src/java.base/share/classes/openj9/internal/foreign/abi/UpcallMHMetaData.java
+++ b/jcl/src/java.base/share/classes/openj9/internal/foreign/abi/UpcallMHMetaData.java
@@ -50,6 +50,11 @@ final class UpcallMHMetaData {
* by MethodHandleResolver.upcallLinkCallerMethod().
*/
private Object[] invokeCache;
+ /* The argument array stores the memory specific argument(struct/pointer) object
+ * being allocated in native for upcall to stop GC from updating the previously
+ * allocated argument reference when allocating the next argument.
+ */
+ private Object[] nativeArgArray;
/*[IF JAVA_SPEC_VERSION >= 19]*/
private MemorySession session;
@@ -68,21 +73,22 @@ final class UpcallMHMetaData {
}
/*[IF JAVA_SPEC_VERSION >= 19]*/
- UpcallMHMetaData(MethodHandle targetHandle, MemorySession session)
+ UpcallMHMetaData(MethodHandle targetHandle, int nativeArgCount, MemorySession session)
/*[ELSE] JAVA_SPEC_VERSION >= 19 */
- UpcallMHMetaData(MethodHandle targetHandle, ResourceScope scope)
+ UpcallMHMetaData(MethodHandle targetHandle, int nativeArgCount, ResourceScope scope)
/*[ENDIF] JAVA_SPEC_VERSION >= 19 */
{
calleeMH = targetHandle;
calleeType = targetHandle.type();
+ nativeArgArray = new Object[nativeArgCount];
/* Only hold the confined session/scope (owned by the current thread)
- * will be used to construct a MemorySegment object for argument in
- * the native dispatcher in upcall.
+ * or the shared session/scope will be used to construct a MemorySegment
+ * object for argument in the native dispatcher in upcall.
*/
/*[IF JAVA_SPEC_VERSION >= 19]*/
- this.session = ((session != null) && (session.ownerThread() != null)) ? session : null;
+ this.session = ((session != null) && (session.ownerThread() != null)) ? session : MemorySession.openShared();
/*[ELSE] JAVA_SPEC_VERSION >= 19 */
- this.scope = ((scope != null) && (scope.ownerThread() != null)) ? scope : null;;
+ this.scope = ((scope != null) && (scope.ownerThread() != null)) ? scope : ResourceScope.newSharedScope();
/*[ENDIF] JAVA_SPEC_VERSION >= 19 */
}
}
diff --git a/runtime/oti/vmconstantpool.xml b/runtime/oti/vmconstantpool.xml
index c946328511b..6c2c886b670 100644
--- a/runtime/oti/vmconstantpool.xml
+++ b/runtime/oti/vmconstantpool.xml
@@ -424,6 +424,8 @@ SPDX-License-Identifier: EPL-2.0 OR Apache-2.0 OR GPL-2.0 WITH Classpath-excepti
+
+
diff --git a/runtime/vm/OutOfLineINL_openj9_internal_foreign_abi_UpCallMHMetaData.cpp b/runtime/vm/OutOfLineINL_openj9_internal_foreign_abi_UpCallMHMetaData.cpp
index 87a755aaf1e..7aa33ca86c4 100644
--- a/runtime/vm/OutOfLineINL_openj9_internal_foreign_abi_UpCallMHMetaData.cpp
+++ b/runtime/vm/OutOfLineINL_openj9_internal_foreign_abi_UpCallMHMetaData.cpp
@@ -39,14 +39,15 @@ OutOfLineINL_openj9_internal_foreign_abi_UpcallMHMetaData_resolveUpcallDataField
J9JavaVM *vm = currentThread->javaVM;
J9ConstantPool *jclConstantPool = (J9ConstantPool *)vm->jclConstantPool;
#if JAVA_SPEC_VERSION >= 18
- const int cpEntryNum = 8;
-#else /* JAVA_SPEC_VERSION >= 18 */
const int cpEntryNum = 9;
+#else /* JAVA_SPEC_VERSION >= 18 */
+ const int cpEntryNum = 10;
#endif /* JAVA_SPEC_VERSION >= 18 */
U_16 cpIndex[cpEntryNum] = {
J9VMCONSTANTPOOL_OPENJ9INTERNALFOREIGNABIUPCALLMHMETADATA_CALLEEMH,
J9VMCONSTANTPOOL_OPENJ9INTERNALFOREIGNABIUPCALLMHMETADATA_CALLEETYPE,
J9VMCONSTANTPOOL_OPENJ9INTERNALFOREIGNABIUPCALLMHMETADATA_INVOKECACHE,
+ J9VMCONSTANTPOOL_OPENJ9INTERNALFOREIGNABIUPCALLMHMETADATA_NATIVEARGARRAY,
#if JAVA_SPEC_VERSION >= 19
J9VMCONSTANTPOOL_OPENJ9INTERNALFOREIGNABIUPCALLMHMETADATA_SESSION,
#else /* JAVA_SPEC_VERSION >= 19 */
diff --git a/runtime/vm/UpcallVMHelpers.cpp b/runtime/vm/UpcallVMHelpers.cpp
index 88ab90953ae..8d683519433 100644
--- a/runtime/vm/UpcallVMHelpers.cpp
+++ b/runtime/vm/UpcallVMHelpers.cpp
@@ -41,9 +41,9 @@ extern void restoreCallInFrameHelper(J9VMThread *currentThread);
static U_64 JNICALL native2InterpJavaUpcallImpl(J9UpcallMetaData *data, void *argsListPointer);
static J9VMThread * getCurrentThread(J9UpcallMetaData *data, bool *isCurThrdAllocated);
static void convertUpcallReturnValue(J9UpcallMetaData *data, U_8 returnType, U_64 *returnStorage);
+static bool storeMemArgObjectsToJavaArray(J9UpcallMetaData *data, void *argsListPointer, J9VMThread *currentThread);
static j9object_t createMemAddressObject(J9UpcallMetaData *data, I_64 offset);
-static j9object_t createMemSegmentObject(J9UpcallMetaData *data, I_64 offset, U_32 sigTypeSize, j9object_t sessionOrScopeObject);
-static j9object_t getSessionOrScopeObject(J9UpcallMetaData *data);
+static j9object_t createMemSegmentObject(J9UpcallMetaData *data, I_64 offset, U_32 sigTypeSize);
static I_64 getNativeAddrFromMemAddressObject(J9UpcallMetaData *data, j9object_t memAddrObject);
static I_64 getNativeAddrFromMemSegmentObject(J9UpcallMetaData *data, j9object_t memAddrObject);
@@ -223,9 +223,7 @@ native2InterpJavaUpcallImpl(J9UpcallMetaData *data, void *argsListPointer)
J9VMThread *currentThread = NULL;
bool isCurThrdAllocated = false;
bool throwOOM = false;
- J9Method* thrLiterals = NULL;
U_64 returnStorage = 0;
- j9object_t sessionOrScopeObject = NULL;
/* Determine whether to use the current thread or create a new one
* when there is no java thread attached to the native thread
@@ -244,20 +242,21 @@ native2InterpJavaUpcallImpl(J9UpcallMetaData *data, void *argsListPointer)
returnsObject = (J9NtcPointer == returnType) || (J9NtcStruct == returnType);
if (buildCallInStackFrameHelper(currentThread, &newELS, returnsObject)) {
+ j9object_t mhMetaData = NULL;
+ j9object_t nativeArgArray = NULL;
- /* Save the current executing method and restore later after the memory allocation
- * for pointer/struct in the argument list.
- */
- thrLiterals = currentThread->literals;
+ /* Store the allocated memory objects for the struct/pointer arguments to the java array */
+ if (!storeMemArgObjectsToJavaArray(data, argsListPointer, currentThread)) {
+ throwOOM = true;
+ goto done;
+ }
+ mhMetaData = J9_JNI_UNWRAP_REFERENCE(data->mhMetaData);
+ nativeArgArray = J9VMOPENJ9INTERNALFOREIGNABIUPCALLMHMETADATA_NATIVEARGARRAY(currentThread, mhMetaData);
/* The argument list of the upcall method handle on the stack includes the target method handle,
* the method arguments and the appendix which is set via MethodHandleResolver.upcallLinkCallerMethod().
- *
- * Note: push the target method handle on the special frame so as to avoid updating the address
- * on the stack by GC when allocating memory for the next pointer/struct of the argument list.
*/
- j9object_t calleeHandle = J9VMOPENJ9INTERNALFOREIGNABIUPCALLMHMETADATA_CALLEEMH(currentThread, J9_JNI_UNWRAP_REFERENCE(data->mhMetaData));
- PUSH_OBJECT_IN_SPECIAL_FRAME(currentThread, calleeHandle);
+ *(j9object_t*)--(currentThread->sp) = J9VMOPENJ9INTERNALFOREIGNABIUPCALLMHMETADATA_CALLEEMH(currentThread, mhMetaData);
for (I_32 argIndex = 0; argIndex < paramCount; argIndex++) {
U_8 argSigType = sigArray[argIndex].type & J9_FFI_UPCALL_SIG_TYPE_MASK;
@@ -270,13 +269,13 @@ native2InterpJavaUpcallImpl(J9UpcallMetaData *data, void *argsListPointer)
case J9_FFI_UPCALL_SIG_TYPE_CHAR:
{
I_8 argValue = *(I_8*)getArgPointer(nativeSig, argsListPointer, argIndex);
- *(I_32*)--currentThread->sp = (I_32)argValue;
+ *(I_32*)--(currentThread->sp) = (I_32)argValue;
break;
}
case J9_FFI_UPCALL_SIG_TYPE_SHORT:
{
I_16 argValue = *(I_16*)getArgPointer(nativeSig, argsListPointer, argIndex);
- *(I_32*)--currentThread->sp = (I_32)argValue;
+ *(I_32*)--(currentThread->sp) = (I_32)argValue;
break;
}
#else
@@ -298,58 +297,23 @@ native2InterpJavaUpcallImpl(J9UpcallMetaData *data, void *argsListPointer)
argValue = argValue >> J9_FFI_UPCALL_SIG_TYPE_32_BIT;
}
#endif /* !defined(J9VM_ENV_LITTLE_ENDIAN) */
- *(I_32*)--currentThread->sp = (I_32)argValue;
+ *(I_32*)--(currentThread->sp) = (I_32)argValue;
break;
}
case J9_FFI_UPCALL_SIG_TYPE_INT64: /* Fall through */
case J9_FFI_UPCALL_SIG_TYPE_DOUBLE:
currentThread->sp -= 2;
- *(I_64*)currentThread->sp = *(I_64*)getArgPointer(nativeSig, argsListPointer, argIndex);
- break;
- case J9_FFI_UPCALL_SIG_TYPE_POINTER:
- {
- I_64 offset = *(I_64*)getArgPointer(nativeSig, argsListPointer, argIndex);
- j9object_t memAddrObject = createMemAddressObject(data, offset);
- if (NULL == memAddrObject) {
- /* The OOM exception set in createMemAddressObject() will be thrown in the interpreter
- * after returning from the native function in downcall.
- */
- throwOOM = true;
- goto done;
- }
- /* Push the object on the special frame so as to avoid updating the address on the stack
- * by GC when allocating memory for the next pointer/struct of the argument list.
- */
- PUSH_OBJECT_IN_SPECIAL_FRAME(currentThread, memAddrObject);
+ *(I_64*)(currentThread->sp) = *(I_64*)getArgPointer(nativeSig, argsListPointer, argIndex);
break;
- }
+ case J9_FFI_UPCALL_SIG_TYPE_POINTER: /* Fall through */
case J9_FFI_UPCALL_SIG_TYPE_STRUCT:
- {
- I_64 offset = (I_64)(intptr_t)getArgPointer(nativeSig, argsListPointer, argIndex);
- j9object_t memSegmtObject = createMemSegmentObject(data, offset, sigArray[argIndex].sizeInByte, sessionOrScopeObject);
- if (NULL == memSegmtObject) {
- /* The OOM exception set in createMemSegmentObject() will be thrown in the interpreter
- * after returning from the native function in downcall.
- */
- throwOOM = true;
- goto done;
- }
- /* Push the object on the special frame so as to avoid updating the address on the stack
- * by GC when allocating memory for the next pointer/struct of the argument list.
- */
- PUSH_OBJECT_IN_SPECIAL_FRAME(currentThread, memSegmtObject);
+ *(j9object_t*)--(currentThread->sp) = J9JAVAARRAYOFOBJECT_LOAD(currentThread, nativeArgArray, argIndex);
break;
- }
default:
Assert_VM_unreachable();
break;
}
}
- /* Only restore the literals and keep the unchanged arguments on the stack which
- * are passed over to native2InterpreterTransition() in the interpreter so as to
- * invoke the upcall method handle.
- */
- currentThread->literals = thrLiterals;
/* Place mhMetaData as the return value to native2InterpreterTransition() when calling into
* the interpreter so as to set the invoke cache array (MemberName and appendix)
@@ -362,7 +326,9 @@ native2InterpJavaUpcallImpl(J9UpcallMetaData *data, void *argsListPointer)
done:
restoreCallInFrameHelper(currentThread);
}
+
VM_VMAccess::inlineExitVMToJNI(currentThread);
+
/* Transfer the exception from the locally created upcall thread to the downcall thread
* as the upcall thread will be cleaned up before the dispatcher exits; otherwise
* the current thread's exception can be brought back to the interpreter in downcall.
@@ -403,7 +369,7 @@ native2InterpJavaUpcallImpl(J9UpcallMetaData *data, void *argsListPointer)
* The function is to handle the situation when there is no Java thread for the current native thread
* which is directly created in native code without a Java thread attached to it.
*
- * @param vm a pointer to J9UpcallMetaData
+ * @param data a pointer to J9UpcallMetaData
* @param isCurThrdAllocated a pointer to a flag indicating whether the current thread is allocated locally
* @return a pointer to J9VMThread
*/
@@ -489,6 +455,63 @@ convertUpcallReturnValue(J9UpcallMetaData *data, U_8 returnType, U_64 *returnSto
}
}
+/**
+ * @brief Allocate memory related objects for the struct/pointer arguments
+ * to store them to the java array before placing them on the java stack
+ * for upcall.
+ *
+ * @param data a pointer to J9UpcallMetaData
+ * @param argsListPointer a pointer to the argument list
+ * @param currentThread a pointer to J9VMThread
+ * @return true if the storing operation is completed; otherwise return false;
+ */
+static bool
+storeMemArgObjectsToJavaArray(J9UpcallMetaData *data, void *argsListPointer, J9VMThread *currentThread)
+{
+ J9UpcallNativeSignature *nativeSig = data->nativeFuncSignature;
+ J9UpcallSigType *sigArray = nativeSig->sigArray;
+ I_32 paramCount = (I_32)(nativeSig->numSigs - 1); /* The last element is for the return type. */
+ bool result = true;
+
+ for (I_32 argIndex = 0; argIndex < paramCount; argIndex++) {
+ U_8 argSigType = sigArray[argIndex].type & J9_FFI_UPCALL_SIG_TYPE_MASK;
+ j9object_t memArgObject = NULL;
+ j9object_t nativeArgArray = NULL;
+
+ if ((J9_FFI_UPCALL_SIG_TYPE_POINTER == argSigType)
+ || (J9_FFI_UPCALL_SIG_TYPE_STRUCT == argSigType)
+ ) {
+ if (J9_FFI_UPCALL_SIG_TYPE_POINTER == argSigType) {
+ I_64 offset = *(I_64*)getArgPointer(nativeSig, argsListPointer, argIndex);
+ memArgObject = createMemAddressObject(data, offset);
+ } else { /* J9_FFI_UPCALL_SIG_TYPE_STRUCT */
+ I_64 offset = (I_64)(intptr_t)getArgPointer(nativeSig, argsListPointer, argIndex);
+ memArgObject = createMemSegmentObject(data, offset, sigArray[argIndex].sizeInByte);
+ }
+
+ if (NULL == memArgObject) {
+ /* The OOM exception set in createMemAddressObject/createMemSegmentObject will be
+ * thrown in the interpreter after returning from the native function in downcall.
+ */
+ result = false;
+ goto done;
+ }
+ }
+
+ /* Store the struct/pointer object (or null in the case of the primitive types) in the
+ * java array so as to avoid being updated by GC(which is triggered by J9AllocateObject
+ * in createMemAddressObject/createMemSegmentObject) when allocating memory for the next
+ * struct/pointer of the argument list.
+ */
+ nativeArgArray = J9VMOPENJ9INTERNALFOREIGNABIUPCALLMHMETADATA_NATIVEARGARRAY(currentThread,
+ J9_JNI_UNWRAP_REFERENCE(data->mhMetaData));
+ J9JAVAARRAYOFOBJECT_STORE(currentThread, nativeArgArray, argIndex, memArgObject);
+ }
+
+done:
+ return result;
+}
+
/**
* @brief Generate an object of the MemoryAddress's subclass on the heap
* with the specified native address to the value.
@@ -541,38 +564,26 @@ createMemAddressObject(J9UpcallMetaData *data, I_64 offset)
* @param data a pointer to J9UpcallMetaData
* @param offset the native address to the requested struct
* @param sigTypeSize the byte size of the requested struct
- * @param sessionOrScopeObject the session/scope object intended for MemorySegment related arguments
* @return a MemorySegment object
*/
static j9object_t
-createMemSegmentObject(J9UpcallMetaData *data, I_64 offset, U_32 sigTypeSize, j9object_t sessionOrScopeObject)
+createMemSegmentObject(J9UpcallMetaData *data, I_64 offset, U_32 sigTypeSize)
{
J9JavaVM *vm = data->vm;
J9VMThread *downCallThread = data->downCallThread;
J9VMThread *currentThread = currentVMThread(vm);
MM_ObjectAllocationAPI objectAllocate(currentThread);
j9object_t memSegmtObject = NULL;
+ j9object_t mhMetaData = NULL;
J9Class *memSegmtClass = J9VMJDKINTERNALFOREIGNNATIVEMEMORYSEGMENTIMPL(vm);
- if (NULL == sessionOrScopeObject) {
- sessionOrScopeObject = getSessionOrScopeObject(data);
- if (NULL == sessionOrScopeObject) {
- /* The OOM exception will be thrown when returning back to the interpreter
- * after returning from the native function in downcall.
- */
- goto done;
- }
- }
-
/* To wrap up an object of the MemorySegment's subclass as an argument on the java stack,
* this object is directly allocated on the heap with the passed-in native address(offset)
* set to this object.
*/
memSegmtObject = objectAllocate.inlineAllocateObject(currentThread, memSegmtClass, true, false);
if (NULL == memSegmtObject) {
- PUSH_OBJECT_IN_SPECIAL_FRAME(currentThread, sessionOrScopeObject);
memSegmtObject = vm->memoryManagerFunctions->J9AllocateObject(currentThread, memSegmtClass, J9_GC_ALLOCATE_OBJECT_NON_INSTRUMENTABLE);
- sessionOrScopeObject = POP_OBJECT_IN_SPECIAL_FRAME(currentThread);
if (NULL == memSegmtObject) {
/* Directly set the OOM error to the downcall thread to bring it up back to the interpreter
* in downcall when the upcall thread is the same as the downcall thread; otherwise, the OOM
@@ -583,74 +594,22 @@ createMemSegmentObject(J9UpcallMetaData *data, I_64 offset, U_32 sigTypeSize, j9
goto done;
}
}
+ mhMetaData = J9_JNI_UNWRAP_REFERENCE(data->mhMetaData);
J9VMJDKINTERNALFOREIGNNATIVEMEMORYSEGMENTIMPL_SET_MIN(currentThread, memSegmtObject, offset);
J9VMJDKINTERNALFOREIGNNATIVEMEMORYSEGMENTIMPL_SET_LENGTH(currentThread, memSegmtObject, sigTypeSize);
#if JAVA_SPEC_VERSION >= 19
- J9VMJDKINTERNALFOREIGNNATIVEMEMORYSEGMENTIMPL_SET_SESSION(currentThread, memSegmtObject, sessionOrScopeObject);
+ J9VMJDKINTERNALFOREIGNNATIVEMEMORYSEGMENTIMPL_SET_SESSION(currentThread, memSegmtObject,
+ J9VMOPENJ9INTERNALFOREIGNABIUPCALLMHMETADATA_SESSION(currentThread, mhMetaData));
#else /* JAVA_SPEC_VERSION >= 19 */
- J9VMJDKINTERNALFOREIGNNATIVEMEMORYSEGMENTIMPL_SET_SCOPE(currentThread, memSegmtObject, sessionOrScopeObject);
+ J9VMJDKINTERNALFOREIGNNATIVEMEMORYSEGMENTIMPL_SET_SCOPE(currentThread, memSegmtObject,
+ J9VMOPENJ9INTERNALFOREIGNABIUPCALLMHMETADATA_SCOPE(currentThread, mhMetaData));
#endif /* JAVA_SPEC_VERSION >= 19 */
done:
return memSegmtObject;
}
-/**
- * @brief Get the surrounding session/scope owned by the current thread;
- * otherwise, create a shared session/scope object if the surrounding
- * session/scope is null or the current thread is created locally.
- *
- * @param data a pointer to J9UpcallMetaData
- * @return a MemorySession(JDK19+)/ResourceScope(JDK17/18) object
- */
-static j9object_t
-getSessionOrScopeObject(J9UpcallMetaData *data)
-{
- J9JavaVM *vm = data->vm;
- J9VMThread *downCallThread = data->downCallThread;
- J9VMThread *currentThread = currentVMThread(vm);
- j9object_t mhMetaData = J9_JNI_UNWRAP_REFERENCE(data->mhMetaData);
- j9object_t sessionOrScopeObject = NULL;
-
- /* Get the confined session/scope of the current thread in java if the thread is not created locally in native. */
- if (J9_ARE_NO_BITS_SET(currentThread->privateFlags, J9_PRIVATE_FLAGS_FFI_UPCALL_THREAD)) {
-#if JAVA_SPEC_VERSION >= 19
- sessionOrScopeObject = J9VMOPENJ9INTERNALFOREIGNABIUPCALLMHMETADATA_SESSION(currentThread, mhMetaData);
-#else /* JAVA_SPEC_VERSION >= 19 */
- sessionOrScopeObject = J9VMOPENJ9INTERNALFOREIGNABIUPCALLMHMETADATA_SCOPE(currentThread, mhMetaData);
-#endif /* JAVA_SPEC_VERSION >= 19 */
- }
-
- /* The object of the MemorySession's(JDK19+)/ResourceScope's(JDK17/18) subclass is set as a field value
- * of the MemorySegment object created in native, which is validated in OpenJDK before returning the
- * native memory address from MemorySegment.address() in java.
- */
- if (NULL == sessionOrScopeObject) {
-#if JAVA_SPEC_VERSION >= 19
- J9Class *sessionOrScopeClass = J9VMJDKINTERNALFOREIGNSHAREDSESSION(vm);
-#else /* JAVA_SPEC_VERSION >= 19 */
- J9Class *sessionOrScopeClass = J9VMJDKINTERNALFOREIGNSHAREDSCOPE(vm);
-#endif /* JAVA_SPEC_VERSION >= 19 */
- MM_ObjectAllocationAPI objectAllocate(currentThread);
-
- sessionOrScopeObject = objectAllocate.inlineAllocateObject(currentThread, sessionOrScopeClass, true, false);
- if (NULL == sessionOrScopeObject) {
- sessionOrScopeObject = vm->memoryManagerFunctions->J9AllocateObject(currentThread, sessionOrScopeClass, J9_GC_ALLOCATE_OBJECT_NON_INSTRUMENTABLE);
- if (NULL == sessionOrScopeObject) {
- /* Directly set the OOM error to the downcall thread to bring it up back to the interpreter
- * in downcall when the upcall thread is the same as the downcall thread; otherwise, the OOM
- * error should be still set to the downcall thread given the locally created native thread
- * in upcall will be cleaned up before the dispatcher exists and returns to the interpreter.
- */
- setHeapOutOfMemoryError(downCallThread);
- }
- }
- }
-
- return sessionOrScopeObject;
-}
-
/**
* @brief Get the native address to the requested value from a MemoryAddress object.
*