Address review comments

Author: fangerer

compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/replacements/nodes/MethodHandleWithExceptionNode.java

@@ -87,6 +87,7 @@ public WithExceptionNode trySimplify(MethodHandleAccessProvider methodHandleAcce
         return invoke;
     }
 
+    /** {@link MethodHandleNode#tryResolveTargetInvoke}. */
     protected <T extends Invoke> T tryResolveTargetInvoke(GraphAdder adder, InvokeFactory<T> factory, MethodHandleAccessProvider methodHandleAccess, ValueNode... argumentsArray) {
         return MethodHandleNode.tryResolveTargetInvoke(adder, factory, methodHandleAccess, intrinsicMethod, targetMethod, bci, returnStamp, argumentsArray);
     }

substratevm/src/com.oracle.svm.core.foreign/src/com/oracle/svm/core/foreign/ForeignFunctionsRuntime.java

@@ -224,24 +224,20 @@ public void registerSafeArenaAccessorMethod(ResolvedJavaMethod method) {
         neverAccessesSharedArenaMethods.add(method);
     }
 
-    FunctionPointerHolder getDowncallStubPointerHolder(NativeEntryPointInfo nep) {
+    public CFunctionPointer getDowncallStubPointer(NativeEntryPointInfo nep) {
         FunctionPointerHolder holder = downcallStubs.get(nep);
         if (holder == null) {
             throw reportMissingDowncall(nep);
         }
-        return holder;
-    }
-
-    public CFunctionPointer getDowncallStubPointer(NativeEntryPointInfo nep) {
-        return getDowncallStubPointerHolder(nep).functionPointer;
+        return holder.functionPointer;
     }
 
-    FunctionPointerHolder getDowncallStubInvokerPointerHolder(MethodType methodType) {
+    CFunctionPointer getDowncallStubInvokerPointer(MethodType methodType) {
         FunctionPointerHolder holder = downcallStubInvokers.get(methodType);
         if (holder == null) {
             throw reportMissingDowncall(methodType);
         }
-        return holder;
+        return holder.functionPointer;
     }
 
     CFunctionPointer getUpcallStubPointer(JavaEntryPointInfo jep) {
@@ -331,6 +327,9 @@ void freeTrampoline(long addr) {
     private MissingForeignRegistrationError reportMissingDowncall(NativeEntryPointInfo nep) {
         LinkRequest currentLinkRequest = null;
         for (LinkRequest linkRequest : currentLinkRequests) {
+            if (!Thread.currentThread().equals(linkRequest.requester)) {
+                continue;
+            }
             NativeEntryPointInfo nativeEntryPointInfo = abiUtils.makeNativeEntrypoint(linkRequest.functionDescriptor, linkRequest.linkerOptions);
             if (nep.equals(nativeEntryPointInfo)) {
                 currentLinkRequest = linkRequest;
@@ -391,10 +390,10 @@ private static MissingForeignRegistrationError report(boolean upcall, LinkReques
                                         "upcallStub"));
     }
 
-    record LinkRequest(boolean upcall, FunctionDescriptor functionDescriptor, LinkerOptions linkerOptions) implements AutoCloseable, JsonPrintable {
+    record LinkRequest(boolean upcall, FunctionDescriptor functionDescriptor, LinkerOptions linkerOptions, Thread requester) implements AutoCloseable, JsonPrintable {
 
         static LinkRequest create(boolean upcall, FunctionDescriptor functionDescriptor, LinkerOptions linkerOptions) {
-            LinkRequest linkRequest = new LinkRequest(upcall, functionDescriptor, linkerOptions);
+            LinkRequest linkRequest = new LinkRequest(upcall, functionDescriptor, linkerOptions, Thread.currentThread());
             ForeignFunctionsRuntime.singleton().currentLinkRequests.push(linkRequest);
             return linkRequest;
         }
@@ -438,8 +437,10 @@ public void printJson(JsonWriter writer) throws IOException {
     @Override
     public Object linkToNative(Object... args) throws Throwable {
         Target_jdk_internal_foreign_abi_NativeEntryPoint nep = (Target_jdk_internal_foreign_abi_NativeEntryPoint) args[args.length - 1];
-        /* The nep argument will be dropped in the invoked function */
-        return ((StubInvokerPointer) nep.downcallInvokerPointerHolder.functionPointer).invoke(nep.downcallStubPointerHolder.functionPointer, args);
+        StubInvokerPointer invoker = (StubInvokerPointer) nep.downcallInvokerPointer;
+        CFunctionPointer stub = nep.downcallStubPointer;
+        /* The nep argument will be dropped in the invoked downcall stub */
+        return invoker.invoke(stub, args);
     }
 
     @Override

substratevm/src/com.oracle.svm.core.foreign/src/com/oracle/svm/core/foreign/NativeEntryPointHelper.java

@@ -25,31 +25,6 @@
 
 package com.oracle.svm.core.foreign;
 
-/*
- * Copyright (c) 2026, 2026, Oracle and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation.  Oracle designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Oracle in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
- * or visit www.oracle.com if you need additional information or have any
- * questions.
- */
-
 import java.lang.invoke.MethodType;
 import java.util.Arrays;
 import java.util.Objects;
@@ -58,7 +33,6 @@
 import org.graalvm.nativeimage.Platforms;
 
 import com.oracle.svm.shared.util.BasedOnJDKClass;
-import com.oracle.svm.shared.util.VMError;
 import com.oracle.svm.util.GuestAccess;
 import com.oracle.svm.util.GuestElements;
 import com.oracle.svm.util.JVMCIReflectionUtil;
@@ -69,7 +43,7 @@
 
 @BasedOnJDKClass(NativeEntryPoint.class)
 @BasedOnJDKClass(className = "jdk.internal.foreign.abi.SoftReferenceCache")
-@BasedOnJDKClass(className = "jdk.internal.foreign.abi.NativeEntryPoint$CacheKey")
+@BasedOnJDKClass(className = "jdk.internal.foreign.abi.NativeEntryPoint", innerClass = "CacheKey")
 @Platforms(Platform.HOSTED_ONLY.class)
 public final class NativeEntryPointHelper {
 
@@ -105,11 +79,14 @@ public static NativeEntryPointInfo extractNativeEntryPointInfo(JavaConstant nati
         }
 
         /*
-         * Any instance of NativeEntryPoint is created via 'NativeEntryPoint.make' and will
-         * therefore be added to NEP_CACHE. Further, the keys of NEP_CACHE are strongly referenced.
-         * This means that there must be a cache key for any NativeEntryPoint that exists.
+         * In the common case, any instance of NativeEntryPoint is created via
+         * 'NativeEntryPoint.make' and will therefore be added to NEP_CACHE and the keys of
+         * NEP_CACHE are strongly referenced. However, we are defensive and do not fail if we
+         * couldn't find the key.
          */
-        VMError.guarantee(cacheKeyConstant != null, "Cannot extract info for NativeEntryPoint because it is not in NEP_CACHE");
+        if (cacheKeyConstant == null) {
+            return null;
+        }
 
         /*
          * Field 'CacheKey.abi' is ignored because the ABIDescriptor is JDK's equivalent of our

substratevm/src/com.oracle.svm.core.foreign/src/com/oracle/svm/core/foreign/NativeEntryPointInfo.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023, 2024, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2023, 2026, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -28,7 +28,8 @@
 import java.util.Arrays;
 import java.util.Objects;
 
-import com.oracle.svm.core.FunctionPointerHolder;
+import org.graalvm.nativeimage.c.function.CFunctionPointer;
+
 import com.oracle.svm.shared.util.VMError;
 
 import jdk.internal.foreign.abi.ABIDescriptor;
@@ -113,8 +114,8 @@ public static Target_jdk_internal_foreign_abi_NativeEntryPoint makeEntryPoint(
                     boolean needsTransition,
                     boolean allowHeapAccess) {
         var info = make(argMoves, returnMoves, methodType, needsReturnBuffer, capturedStateMask, needsTransition, allowHeapAccess);
-        FunctionPointerHolder holder = ForeignFunctionsRuntime.singleton().getDowncallStubPointerHolder(info);
-        return new Target_jdk_internal_foreign_abi_NativeEntryPoint(info.methodType(), holder, capturedStateMask);
+        CFunctionPointer downcallStubPointer = ForeignFunctionsRuntime.singleton().getDowncallStubPointer(info);
+        return new Target_jdk_internal_foreign_abi_NativeEntryPoint(info.methodType(), downcallStubPointer, capturedStateMask);
     }
 
     public MethodType methodType() {

substratevm/src/com.oracle.svm.core.foreign/src/com/oracle/svm/core/foreign/SubstrateForeignUtil.java

@@ -40,7 +40,6 @@
 import com.oracle.svm.configure.UnresolvedAccessCondition;
 import com.oracle.svm.configure.config.ForeignConfiguration.ConfigurationFunctionDescriptor;
 import com.oracle.svm.configure.config.ForeignConfiguration.StubDesc;
-import com.oracle.svm.shared.AlwaysInline;
 import com.oracle.svm.core.ArenaIntrinsics;
 import com.oracle.svm.core.NeverInline;
 import com.oracle.svm.core.SubstrateOptions;
@@ -49,6 +48,7 @@
 import com.oracle.svm.core.nodes.foreign.ScopedMemExceptionHandlerClusterNode.ExceptionInputNode;
 import com.oracle.svm.core.nodes.foreign.ScopedMemExceptionHandlerClusterNode.ExceptionPathNode;
 import com.oracle.svm.core.nodes.foreign.ScopedMemExceptionHandlerClusterNode.RegularPathNode;
+import com.oracle.svm.shared.AlwaysInline;
 import com.oracle.svm.shared.util.LogUtils;
 import com.oracle.svm.shared.util.VMError;
 
@@ -61,7 +61,7 @@
 /**
  * For details on the implementation of shared arenas on substrate see
  * {@link Target_jdk_internal_misc_ScopedMemoryAccess}.
- *
+ * <p>
  * Note that this code should only be called by substitutions in
  * {@link Target_jdk_internal_misc_ScopedMemoryAccess}.
  */
@@ -111,7 +111,7 @@ public static void checkValidStateRawInRuntimeCompiledCode(MemorySessionImpl ses
 
     /**
      * Handles exceptions related to memory sessions within a specific arena scope.
-     *
+     * <p>
      * This method checks if the {@link java.lang.foreign.Arena} associated with {@code session} is
      * in a valid state. If validation fails, it logs the exception and propagates it through the
      * exception path.
@@ -205,12 +205,12 @@ private static String memoryLayoutToString(MemoryLayout memoryLayout) {
     }
 
     @NeverInline("inlining cut off")
-    static IllegalArgumentException getSymbolIsNullException(MemorySegment symbol) {
-        return new IllegalArgumentException("Symbol is NULL: " + symbol);
+    static void throwSymbolIsNullException(MemorySegment symbol) {
+        throw new IllegalArgumentException("Symbol is NULL: " + symbol);
     }
 
     @NeverInline("inlining cut off")
-    static IllegalArgumentException getHeapSegmentNotAllowedException(MemorySegment segment) {
-        return new IllegalArgumentException("Heap segment not allowed: " + segment);
+    static void throwHeapSegmentNotAllowedException(MemorySegment segment) {
+        throw new IllegalArgumentException("Heap segment not allowed: " + segment);
     }
 }

substratevm/src/com.oracle.svm.core.foreign/src/com/oracle/svm/core/foreign/Target_jdk_internal_foreign_abi_NativeEntryPoint.java

@@ -27,12 +27,14 @@
 import java.lang.invoke.MethodType;
 
 import org.graalvm.nativeimage.MissingForeignRegistrationError;
+import org.graalvm.nativeimage.c.function.CFunctionPointer;
 import org.graalvm.nativeimage.hosted.FieldValueTransformer;
 
-import com.oracle.svm.core.FunctionPointerHolder;
 import com.oracle.svm.core.annotate.RecomputeFieldValue;
 import com.oracle.svm.core.annotate.Substitute;
 import com.oracle.svm.core.annotate.TargetClass;
+import com.oracle.svm.core.util.UserError;
+import com.oracle.svm.core.util.UserError.UserException;
 import com.oracle.svm.shared.util.VMError;
 import com.oracle.svm.util.GuestAccess;
 
@@ -42,10 +44,9 @@
 import jdk.vm.ci.meta.JavaConstant;
 
 /**
- * Packs the address of a {@link com.oracle.svm.hosted.foreign.DowncallStub} with some extra
+ * Packs the address of a {@code com.oracle.svm.hosted.foreign.DowncallStub} with some extra
  * information.
  */
-@SuppressWarnings("javadoc")
 @TargetClass(value = NativeEntryPoint.class, onlyWith = ForeignAPIPredicates.Enabled.class)
 @Substitute
 public final class Target_jdk_internal_foreign_abi_NativeEntryPoint {
@@ -55,18 +56,18 @@ public final class Target_jdk_internal_foreign_abi_NativeEntryPoint {
     private MethodType methodType;
 
     @RecomputeFieldValue(isFinal = true, kind = RecomputeFieldValue.Kind.Custom, declClass = DowncallAddressTransformer.class) //
-    final FunctionPointerHolder downcallStubPointerHolder;
+    final CFunctionPointer downcallStubPointer;
 
     @RecomputeFieldValue(kind = RecomputeFieldValue.Kind.Reset) //
     final int captureMask;
 
     @RecomputeFieldValue(isFinal = true, kind = RecomputeFieldValue.Kind.Custom, declClass = DowncallInvokerAddressTransformer.class) //
-    final FunctionPointerHolder downcallInvokerPointerHolder;
+    final CFunctionPointer downcallInvokerPointer;
 
-    Target_jdk_internal_foreign_abi_NativeEntryPoint(MethodType methodType, FunctionPointerHolder downcallStubPointerHolder, int captureMask) {
+    Target_jdk_internal_foreign_abi_NativeEntryPoint(MethodType methodType, CFunctionPointer downcallStubPointer, int captureMask) {
         this.methodType = methodType;
-        this.downcallStubPointerHolder = downcallStubPointerHolder;
-        this.downcallInvokerPointerHolder = ForeignFunctionsRuntime.singleton().getDowncallStubInvokerPointerHolder(methodType);
+        this.downcallStubPointer = downcallStubPointer;
+        this.downcallInvokerPointer = ForeignFunctionsRuntime.singleton().getDowncallStubInvokerPointer(methodType);
         this.captureMask = captureMask;
     }
 
@@ -92,8 +93,8 @@ public static Target_jdk_internal_foreign_abi_NativeEntryPoint make(ABIDescripto
          * construction in the NativeEntryPointInfo.make function.
          */
         boolean allowHeapAccess = false;
-        for (int i = 0; i < argMoves.length; i++) {
-            if (argMoves[i] == null) {
+        for (VMStorage argMove : argMoves) {
+            if (argMove == null) {
                 allowHeapAccess = true;
                 break;
             }
@@ -109,35 +110,43 @@ public MethodType type() {
     static final class MethodTypeTransformer implements FieldValueTransformer {
         @Override
         public Object transform(Object receiver, Object originalValue) {
-            VMError.guarantee(receiver.getClass() == NativeEntryPoint.class);
+            assert receiver.getClass() == NativeEntryPoint.class;
             return ((NativeEntryPoint) receiver).type();
         }
     }
 
     static final class DowncallAddressTransformer implements FieldValueTransformer {
         @Override
         public Object transform(Object receiver, Object originalValue) {
-            VMError.guarantee(receiver.getClass() == NativeEntryPoint.class);
+            assert receiver.getClass() == NativeEntryPoint.class;
             try {
                 JavaConstant nativeEntryPoint = GuestAccess.get().getSnippetReflection().forObject(receiver);
                 NativeEntryPointInfo nativeEntryPointInfo = NativeEntryPointHelper.extractNativeEntryPointInfo(nativeEntryPoint);
-                return ForeignFunctionsRuntime.singleton().getDowncallStubPointerHolder(nativeEntryPointInfo);
+                VMError.guarantee(nativeEntryPointInfo != null, "Cannot extract info for NativeEntryPoint because it is not in NEP_CACHE");
+                return ForeignFunctionsRuntime.singleton().getDowncallStubPointer(nativeEntryPointInfo);
             } catch (MissingForeignRegistrationError e) {
-                // explicitly catch and rethrow with VMError; otherwise, it may be ignored
-                throw VMError.shouldNotReachHere(e);
+                throw rethrowMissingForeignRegistrationError(e);
             }
         }
+
+        static UserException rethrowMissingForeignRegistrationError(MissingForeignRegistrationError e) {
+            /*
+             * MissingForeignRegistrationError is a LinkageError, which are deliberately ignored in
+             * the ImageHeapScanner when reading a hosted field value. Therefore, explicitly catch
+             * and rethrow with UserError.
+             */
+            throw UserError.abort(e, "Missing downcall stub registration");
+        }
     }
 
     static final class DowncallInvokerAddressTransformer implements FieldValueTransformer {
         @Override
         public Object transform(Object receiver, Object originalValue) {
-            VMError.guarantee(receiver.getClass() == NativeEntryPoint.class);
+            assert receiver.getClass() == NativeEntryPoint.class;
             try {
-                return ForeignFunctionsRuntime.singleton().getDowncallStubInvokerPointerHolder(((NativeEntryPoint) receiver).type());
+                return ForeignFunctionsRuntime.singleton().getDowncallStubInvokerPointer(((NativeEntryPoint) receiver).type());
             } catch (MissingForeignRegistrationError e) {
-                // explicitly catch and rethrow with VMError; otherwise, it may be ignored
-                throw VMError.shouldNotReachHere(e);
+                throw DowncallAddressTransformer.rethrowMissingForeignRegistrationError(e);
             }
         }
     }

substratevm/src/com.oracle.svm.core.foreign/src/com/oracle/svm/core/foreign/Target_jdk_internal_foreign_abi_SharedUtils.java

@@ -34,22 +34,27 @@
 import jdk.internal.foreign.abi.SharedUtils;
 import jdk.internal.vm.annotation.ForceInline;
 
+/**
+ * Substitutions of FFM API helper functions. Those substitutions are not required for correctness.
+ * They prevent the exception path (which is a slow path) from being inlined during method handle
+ * intrinsification and reduce the code size in the intrinsification scope.
+ */
 @TargetClass(value = SharedUtils.class, onlyWith = ForeignAPIPredicates.Enabled.class)
 final class Target_jdk_internal_foreign_abi_SharedUtils {
     @ForceInline
     @Substitute
     public static void checkSymbol(MemorySegment symbol) {
         Objects.requireNonNull(symbol);
         if (MemorySegment.NULL.equals(symbol)) {
-            throw SubstrateForeignUtil.getSymbolIsNullException(symbol);
+            SubstrateForeignUtil.throwSymbolIsNullException(symbol);
         }
     }
 
     @ForceInline
     @Substitute
     public static void checkNative(MemorySegment segment) {
         if (!segment.isNative()) {
-            throw SubstrateForeignUtil.getHeapSegmentNotAllowedException(segment);
+            SubstrateForeignUtil.throwHeapSegmentNotAllowedException(segment);
         }
     }
 }

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/invoke/MethodHandleUtils.java

@@ -28,12 +28,17 @@
 
 import java.lang.invoke.MethodHandle;
 import java.lang.invoke.MethodType;
+import java.lang.reflect.Executable;
+
+import org.graalvm.nativeimage.Platform.HOSTED_ONLY;
+import org.graalvm.nativeimage.Platforms;
 
 import com.oracle.svm.core.ForeignSupport;
 import com.oracle.svm.core.hub.RuntimeClassLoading;
 import com.oracle.svm.core.methodhandles.MethodHandleInterpreterUtils;
 import com.oracle.svm.shared.AlwaysInline;
 
+import jdk.vm.ci.meta.JavaKind;
 import sun.invoke.util.Wrapper;
 
 public class MethodHandleUtils {
@@ -178,4 +183,14 @@ public static ResolvedMember getResolvedMember(Target_java_lang_invoke_MemberNam
         }
         return null;
     }
+
+    @Platforms(HOSTED_ONLY.class)
+    public static Executable getUnboxMethod(JavaKind returnKind, boolean crema, Class<?>... parameterTypes) throws NoSuchMethodException {
+        return MethodHandleUtils.class.getMethod(returnKind + (crema ? "UnboxCrema" : "Unbox"), parameterTypes);
+    }
+
+    @Platforms(HOSTED_ONLY.class)
+    public static Executable getUnboxForeignMethod(JavaKind returnKind) throws NoSuchMethodException {
+        return MethodHandleUtils.class.getMethod(returnKind + "UnboxForeign", Object.class, Object.class);
+    }
 }