diff --git a/docs/reference-manual/native-image/ForeignInterface.md b/docs/reference-manual/native-image/ForeignInterface.md
index e4cbdd514943..98b09e73c975 100644
--- a/docs/reference-manual/native-image/ForeignInterface.md
+++ b/docs/reference-manual/native-image/ForeignInterface.md
@@ -30,14 +30,18 @@ These two kinds of calls are referred to as "downcalls" and "upcalls" respective
 ### Looking Up Native Functions
 
 The FFM API provides the `SymbolLookup` interface to find functions in native libraries by name.
-`SymbolLookup.loaderLookup()` is currently the only supported kind of `SymbolLookup`.
+Native image supports all available symbol lookup methods, i.e., `SymbolLookup.loaderLookup()`, `SymbolLookup.libraryLookup()`, and `Linker.defaultLookup()`.
 
 ### Registering Foreign Calls
 
 In order to perform calls to native code at run time, supporting code must be generated at image build time.
-Therefore, the `native-image` tool must be provided with descriptors that characterize the functions to which downcalls may be performed at run time.
+Therefore, the `native-image` tool must be provided with descriptors that characterize the functions with which downcalls or upcalls can be performed at runtime.
 
-These descriptors can be registered using a custom `Feature`, for example:
+For upcalls, it is recommended to register a specific static method as an upcall target by providing its declaring class and the method name.
+This allows `native-image` to create specialized upcall code that can be orders of magnitude faster than a upcall registered only by function descriptor.
+Whenever possible, this should be the preferred way to register upcalls.
+
+Descriptors and target methods can be registered using a custom `Feature`, for example:
 ```java
 import static java.lang.foreign.ValueLayout.*;
 
@@ -50,6 +54,9 @@ class ForeignRegistrationFeature implements Feature {
     RuntimeForeignAccess.registerForUpcall(FunctionDescriptor.of(JAVA_INT, JAVA_INT, JAVA_INT));
     RuntimeForeignAccess.registerForDowncall(FunctionDescriptor.of(ADDRESS, JAVA_INT, JAVA_INT), Linker.Option.firstVariadicArg(1));
     RuntimeForeignAccess.registerForDowncall(FunctionDescriptor.ofVoid(JAVA_INT), Linker.Option.captureCallState("errno"));
+
+    MethodHandle target = MethodHandles.lookup().findStatic(UserClass.class, "aStaticMethod", MethodType.of(int.class, int.class, int.class));
+    RuntimeForeignAccess.registerForUpcall(target, FunctionDescriptor.of(JAVA_INT, JAVA_INT, JAVA_INT));
   }
 }
 ```
diff --git a/sdk/src/org.graalvm.nativeimage/snapshot.sigtest b/sdk/src/org.graalvm.nativeimage/snapshot.sigtest
index ef23e446d560..41ebca3c11ac 100644
--- a/sdk/src/org.graalvm.nativeimage/snapshot.sigtest
+++ b/sdk/src/org.graalvm.nativeimage/snapshot.sigtest
@@ -1088,6 +1088,7 @@ meth public !varargs static void initializeAtRunTime(java.lang.String[])
 supr java.lang.Object
 
 CLSS public final org.graalvm.nativeimage.hosted.RuntimeForeignAccess
+meth public !varargs static void registerForDirectUpcall(java.lang.invoke.MethodHandle,java.lang.Object,java.lang.Object[])
 meth public !varargs static void registerForDowncall(java.lang.Object,java.lang.Object[])
 meth public !varargs static void registerForUpcall(java.lang.Object,java.lang.Object[])
 supr java.lang.Object
diff --git a/sdk/src/org.graalvm.nativeimage/src/org/graalvm/nativeimage/hosted/RuntimeForeignAccess.java b/sdk/src/org.graalvm.nativeimage/src/org/graalvm/nativeimage/hosted/RuntimeForeignAccess.java
index 9d3586017b23..2b5aa887f6ce 100644
--- a/sdk/src/org.graalvm.nativeimage/src/org/graalvm/nativeimage/hosted/RuntimeForeignAccess.java
+++ b/sdk/src/org.graalvm.nativeimage/src/org/graalvm/nativeimage/hosted/RuntimeForeignAccess.java
@@ -40,6 +40,9 @@
  */
 package org.graalvm.nativeimage.hosted;
 
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodType;
+
 import org.graalvm.nativeimage.ImageSingletons;
 import org.graalvm.nativeimage.Platform;
 import org.graalvm.nativeimage.Platforms;
@@ -86,6 +89,34 @@ public static void registerForUpcall(Object desc, Object... options) {
         ImageSingletons.lookup(RuntimeForeignAccessSupport.class).registerForUpcall(ConfigurationCondition.alwaysTrue(), desc, options);
     }
 
+    /**
+     * Registers a specific static method (denoted by a method handle) as a fast upcall target. This
+     * will create a specialized upcall stub that will invoke only the specified method, which is
+     * much faster than using {@link #registerForUpcall(Object, Object...)}).
+     * <p>
+     * The provided method handle must be a direct method handle. Those are most commonly created
+     * using {@link java.lang.invoke.MethodHandles.Lookup#findStatic(Class, String, MethodType)}.
+     * However, a strict requirement is that it must be possible to create a non-empty descriptor
+     * for the method handle using {@link MethodHandle#describeConstable()}. The denoted static
+     * method will also be registered for reflective access since run-time code will also create a
+     * method handle to denoted static method.
+     * </p>
+     * <p>
+     * Even though this method is weakly typed for compatibility reasons, runtime checks will be
+     * performed to ensure that the arguments have the expected type. It will be deprecated in favor
+     * of strongly typed variant as soon as possible.
+     * </p>
+     *
+     * @param target A direct method handle denoting a static method.
+     * @param desc A {@link java.lang.foreign.FunctionDescriptor} to register for upcalls.
+     * @param options An array of {@link java.lang.foreign.Linker.Option} used for the upcalls.
+     *
+     * @since 24.2
+     */
+    public static void registerForDirectUpcall(MethodHandle target, Object desc, Object... options) {
+        ImageSingletons.lookup(RuntimeForeignAccessSupport.class).registerForDirectUpcall(ConfigurationCondition.alwaysTrue(), target, desc, options);
+    }
+
     private RuntimeForeignAccess() {
     }
 }
diff --git a/sdk/src/org.graalvm.nativeimage/src/org/graalvm/nativeimage/impl/RuntimeForeignAccessSupport.java b/sdk/src/org.graalvm.nativeimage/src/org/graalvm/nativeimage/impl/RuntimeForeignAccessSupport.java
index 96db98ab24be..dd0537c496fc 100644
--- a/sdk/src/org.graalvm.nativeimage/src/org/graalvm/nativeimage/impl/RuntimeForeignAccessSupport.java
+++ b/sdk/src/org.graalvm.nativeimage/src/org/graalvm/nativeimage/impl/RuntimeForeignAccessSupport.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2023, 2024, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * The Universal Permissive License (UPL), Version 1.0
@@ -40,8 +40,12 @@
  */
 package org.graalvm.nativeimage.impl;
 
+import java.lang.invoke.MethodHandle;
+
 public interface RuntimeForeignAccessSupport {
     void registerForDowncall(ConfigurationCondition condition, Object desc, Object... options);
 
     void registerForUpcall(ConfigurationCondition condition, Object desc, Object... options);
+
+    void registerForDirectUpcall(ConfigurationCondition condition, MethodHandle target, Object desc, Object... options);
 }
diff --git a/substratevm/CHANGELOG.md b/substratevm/CHANGELOG.md
index dc702c150655..1f747b21cf83 100644
--- a/substratevm/CHANGELOG.md
+++ b/substratevm/CHANGELOG.md
@@ -10,6 +10,7 @@ At runtime, premain runtime options are set along with main class' arguments in
   The warning is planned to be replaced by an error in GraalVM for JDK 25.
 * (GR-48384) Added a GDB Python script (`gdb-debughelpers.py`) to improve the Native Image debugging experience.
 * (GR-49517) Add support for emitting Windows x64 unwind info. This enables stack walking in native tooling such as debuggers and profilers.
+* (GR-52576) Optimize FFM API upcalls for specifiable static upcall target methods.
 * (GR-56599) Update native image debuginfo from DWARF4 to DWARF5 and store type information for debugging in DWARF type units.
 * (GR-56601) Together with Red Hat, we added experimental support for `jcmd` on Linux and macOS. Add `--enable-monitoring=jcmd` to your build arguments to try it out.
 * (GR-57384) Preserve the origin of a resource included in a native image. The information is included in the report produced by -H:+GenerateEmbeddedResourcesFile.
diff --git a/substratevm/mx.substratevm/suite.py b/substratevm/mx.substratevm/suite.py
index 18623201ce2f..0b2b476975d8 100644
--- a/substratevm/mx.substratevm/suite.py
+++ b/substratevm/mx.substratevm/suite.py
@@ -719,13 +719,13 @@
             ],
             "requiresConcealed": {
                 "java.base": [
-                    "jdk.internal.loader",
-                    "jdk.internal.reflect",
                     "jdk.internal.foreign",
                     "jdk.internal.foreign.abi",
                     "jdk.internal.foreign.abi.x64",
                     "jdk.internal.foreign.abi.x64.sysv",
                     "jdk.internal.foreign.abi.x64.windows",
+                    "jdk.internal.loader",
+                    "jdk.internal.reflect",
                 ],
                 "jdk.internal.vm.ci" : [
                     "jdk.vm.ci.amd64",
@@ -758,6 +758,9 @@
                 "java.base": [
                     "jdk.internal.foreign",
                     "jdk.internal.foreign.abi",
+                    "jdk.internal.foreign.abi.x64.windows",
+                    "jdk.internal.foreign.abi.x64.sysv",
+                    "jdk.internal.foreign.layout",
                 ],
                 "jdk.internal.vm.ci" : [
                     "jdk.vm.ci.code",
diff --git a/substratevm/src/com.oracle.svm.core.foreign/src/com/oracle/svm/core/foreign/ForeignFunctionsRuntime.java b/substratevm/src/com.oracle.svm.core.foreign/src/com/oracle/svm/core/foreign/ForeignFunctionsRuntime.java
index abf07ec02d15..fca87f363cd7 100644
--- a/substratevm/src/com.oracle.svm.core.foreign/src/com/oracle/svm/core/foreign/ForeignFunctionsRuntime.java
+++ b/substratevm/src/com.oracle.svm.core.foreign/src/com/oracle/svm/core/foreign/ForeignFunctionsRuntime.java
@@ -26,9 +26,11 @@
 
 import static jdk.graal.compiler.core.common.spi.ForeignCallDescriptor.CallSideEffect.HAS_SIDE_EFFECT;
 
+import java.lang.constant.DirectMethodHandleDesc;
 import java.lang.invoke.MethodHandle;
 import java.util.HashMap;
 import java.util.Map;
+import java.util.function.BiConsumer;
 
 import org.graalvm.collections.EconomicMap;
 import org.graalvm.nativeimage.ImageSingletons;
@@ -61,11 +63,15 @@ public static ForeignFunctionsRuntime singleton() {
 
     private final AbiUtils.TrampolineTemplate trampolineTemplate = AbiUtils.singleton().generateTrampolineTemplate();
     private final EconomicMap<NativeEntryPointInfo, FunctionPointerHolder> downcallStubs = EconomicMap.create();
+    private final EconomicMap<DirectMethodHandleDesc, FunctionPointerHolder> directUpcallStubs = EconomicMap.create();
     private final EconomicMap<JavaEntryPointInfo, FunctionPointerHolder> upcallStubs = EconomicMap.create();
 
     private final Map<Long, TrampolineSet> trampolines = new HashMap<>();
     private TrampolineSet currentTrampolineSet;
 
+    // for testing: callback if direct upcall lookup succeeded
+    private BiConsumer<Long, DirectMethodHandleDesc> usingSpecializedUpcallListener;
+
     @Platforms(Platform.HOSTED_ONLY.class)
     public ForeignFunctionsRuntime() {
     }
@@ -82,6 +88,12 @@ public void addUpcallStubPointer(JavaEntryPointInfo jep, CFunctionPointer ptr) {
         VMError.guarantee(upcallStubs.put(jep, new FunctionPointerHolder(ptr)) == null);
     }
 
+    @Platforms(Platform.HOSTED_ONLY.class)
+    public void addDirectUpcallStubPointer(DirectMethodHandleDesc desc, CFunctionPointer ptr) {
+        VMError.guarantee(!directUpcallStubs.containsKey(desc), "Seems like multiple stubs were generated for " + desc);
+        VMError.guarantee(directUpcallStubs.put(desc, new FunctionPointerHolder(ptr)) == null);
+    }
+
     /**
      * We'd rather report the function descriptor than the native method type, but we don't have it
      * available here. One could intercept this exception in
@@ -105,15 +117,61 @@ CFunctionPointer getUpcallStubPointer(JavaEntryPointInfo jep) {
     }
 
     Pointer registerForUpcall(MethodHandle methodHandle, JavaEntryPointInfo jep) {
+        /*
+         * Look up the upcall stub pointer first to avoid unnecessary allocation and synchronization
+         * if it doesn't exist.
+         */
+        CFunctionPointer upcallStubPointer = getUpcallStubPointer(jep);
         synchronized (trampolines) {
             if (currentTrampolineSet == null || !currentTrampolineSet.hasFreeTrampolines()) {
                 currentTrampolineSet = new TrampolineSet(trampolineTemplate);
                 trampolines.put(currentTrampolineSet.base().rawValue(), currentTrampolineSet);
             }
-            return currentTrampolineSet.assignTrampoline(methodHandle, getUpcallStubPointer(jep));
+            return currentTrampolineSet.assignTrampoline(methodHandle, upcallStubPointer);
         }
     }
 
+    /**
+     * Updates the stub address in the upcall trampoline with the address of a direct upcall stub.
+     * The trampoline is identified by the given native address and the direct upcall stub is
+     * identified by the method handle descriptor.
+     *
+     * @param trampolineAddress The address of the upcall trampoline.
+     * @param desc A direct method handle descriptor used to lookup the direct upcall stub.
+     */
+    void patchForDirectUpcall(long trampolineAddress, DirectMethodHandleDesc desc) {
+        FunctionPointerHolder functionPointerHolder = directUpcallStubs.get(desc);
+        if (functionPointerHolder == null) {
+            return;
+        }
+
+        Pointer trampolinePointer = WordFactory.pointer(trampolineAddress);
+        Pointer trampolineSetBase = TrampolineSet.getAllocationBase(trampolinePointer);
+        TrampolineSet trampolineSet = trampolines.get(trampolineSetBase.rawValue());
+        if (trampolineSet == null) {
+            return;
+        }
+        /*
+         * Synchronizing on 'trampolineSet' is not necessary at this point since we are still in the
+         * call context of 'Linker.upcallStub' and the allocated trampoline is owned by the
+         * allocating thread until it returns from the call. Also, the trampoline cannot be free'd
+         * between allocation and patching because the associated arena is still on the stack.
+         */
+        trampolineSet.patchTrampolineForDirectUpcall(trampolinePointer, functionPointerHolder.functionPointer);
+        /*
+         * If we reach this point, everything went fine and the trampoline was patched with the
+         * specialized upcall stub's address. For testing, now report that the lookup and patching
+         * succeeded.
+         */
+        if (usingSpecializedUpcallListener != null) {
+            usingSpecializedUpcallListener.accept(trampolineAddress, desc);
+        }
+    }
+
+    public void setUsingSpecializedUpcallListener(BiConsumer<Long, DirectMethodHandleDesc> listener) {
+        usingSpecializedUpcallListener = listener;
+    }
+
     void freeTrampoline(long addr) {
         synchronized (trampolines) {
             long base = TrampolineSet.getAllocationBase(WordFactory.pointer(addr)).rawValue();
diff --git a/substratevm/src/com.oracle.svm.core.foreign/src/com/oracle/svm/core/foreign/Target_jdk_internal_foreign_abi_AbstractLinker.java b/substratevm/src/com.oracle.svm.core.foreign/src/com/oracle/svm/core/foreign/Target_jdk_internal_foreign_abi_AbstractLinker.java
index 6d60e1a41344..4871809310e8 100644
--- a/substratevm/src/com.oracle.svm.core.foreign/src/com/oracle/svm/core/foreign/Target_jdk_internal_foreign_abi_AbstractLinker.java
+++ b/substratevm/src/com.oracle.svm.core.foreign/src/com/oracle/svm/core/foreign/Target_jdk_internal_foreign_abi_AbstractLinker.java
@@ -24,11 +24,25 @@
  */
 package com.oracle.svm.core.foreign;
 
+import java.lang.constant.DirectMethodHandleDesc;
+import java.lang.constant.MethodHandleDesc;
+import java.lang.foreign.Arena;
+import java.lang.foreign.FunctionDescriptor;
+import java.lang.foreign.MemorySegment;
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodType;
+import java.util.Optional;
+
 import com.oracle.svm.core.annotate.Alias;
 import com.oracle.svm.core.annotate.RecomputeFieldValue;
+import com.oracle.svm.core.annotate.Substitute;
 import com.oracle.svm.core.annotate.TargetClass;
 
 import jdk.internal.foreign.abi.AbstractLinker;
+import jdk.internal.foreign.abi.AbstractLinker.UpcallStubFactory;
+import jdk.internal.foreign.abi.LinkerOptions;
+import jdk.internal.foreign.abi.x64.sysv.SysVx64Linker;
+import jdk.internal.foreign.abi.x64.windows.Windowsx64Linker;
 
 @TargetClass(AbstractLinker.class)
 public final class Target_jdk_internal_foreign_abi_AbstractLinker {
@@ -46,3 +60,55 @@ public final class Target_jdk_internal_foreign_abi_AbstractLinker {
 @TargetClass(className = "jdk.internal.foreign.abi.SoftReferenceCache")
 final class Target_jdk_internal_foreign_abi_SoftReferenceCache {
 }
+
+/**
+ * A decorator for jdk.internal.foreign.abi.UpcallStubFactory which intercepts the call to method
+ * 'makeStub'. It will (1) call the original factory to create the upcall, and (2) then use the
+ * method handle's descriptor to lookup if a specialized (direct) upcall stub is available. If so,
+ * the trampoline will be updated with the specialized stub's address.
+ * 
+ * @param delegate The original upcall stub factory as created by JDK's call arranger.
+ */
+record UpcallStubFactoryDecorator(UpcallStubFactory delegate) implements UpcallStubFactory {
+
+    @Override
+    public MemorySegment makeStub(MethodHandle target, Arena arena) {
+        MemorySegment segment = delegate.makeStub(target, arena);
+
+        /*
+         * We cannot do this in 'UpcallLinker.makeUpcallStub' because that one already gets a
+         * different method handle that will handle parameter/return value bindings. Further, method
+         * handles cannot be compared. If the provided method handle is a DirectMethodHandle, we use
+         * the MH descriptor to check if there is a registered direct upcall stub. Then, we will
+         * patch the already allocated trampoline with a different upcall stub pointer.
+         */
+        Optional<MethodHandleDesc> methodHandleDesc = target.describeConstable();
+        if (methodHandleDesc.isPresent() && methodHandleDesc.get() instanceof DirectMethodHandleDesc desc) {
+            ForeignFunctionsRuntime.singleton().patchForDirectUpcall(segment.address(), desc);
+        }
+        return segment;
+    }
+}
+
+@TargetClass(value = SysVx64Linker.class, onlyWith = ForeignFunctionsEnabled.class)
+final class Target_jdk_internal_foreign_abi_x64_sysv_SysVx64Linker {
+
+    @Substitute
+    UpcallStubFactory arrangeUpcall(MethodType targetType, FunctionDescriptor function, LinkerOptions options) {
+        return new UpcallStubFactoryDecorator(jdk.internal.foreign.abi.x64.sysv.CallArranger.arrangeUpcall(targetType, function, options));
+    }
+}
+
+@TargetClass(value = Windowsx64Linker.class, onlyWith = ForeignFunctionsEnabled.class)
+final class Target_jdk_internal_foreign_abi_x64_windows_Windowsx64Linker {
+
+    @Substitute
+    UpcallStubFactory arrangeUpcall(MethodType targetType, FunctionDescriptor function, LinkerOptions options) {
+        return new UpcallStubFactoryDecorator(jdk.internal.foreign.abi.x64.windows.CallArranger.arrangeUpcall(targetType, function, options));
+    }
+}
+
+/*
+ * GR-58659, GR-58660: add substitutions for LinuxAArch64Linker and MacOsAArch64Linker here once we
+ * support them.
+ */
\ No newline at end of file
diff --git a/substratevm/src/com.oracle.svm.core.foreign/src/com/oracle/svm/core/foreign/TrampolineSet.java b/substratevm/src/com.oracle.svm.core.foreign/src/com/oracle/svm/core/foreign/TrampolineSet.java
index 61974e0518b6..29ec06ea0cf3 100644
--- a/substratevm/src/com.oracle.svm.core.foreign/src/com/oracle/svm/core/foreign/TrampolineSet.java
+++ b/substratevm/src/com.oracle.svm.core.foreign/src/com/oracle/svm/core/foreign/TrampolineSet.java
@@ -26,6 +26,7 @@
 
 import java.lang.invoke.MethodHandle;
 import java.util.ArrayList;
+import java.util.BitSet;
 import java.util.List;
 
 import org.graalvm.nativeimage.CurrentIsolate;
@@ -37,6 +38,7 @@
 import org.graalvm.word.WordFactory;
 
 import com.oracle.svm.core.os.VirtualMemoryProvider;
+import com.oracle.svm.core.util.UnsignedUtils;
 import com.oracle.svm.core.util.VMError;
 
 import jdk.graal.compiler.core.common.NumUtil;
@@ -73,8 +75,22 @@ public static Pointer getAllocationBase(Pointer ptr) {
     private final int trampolineCount = maxTrampolineCount();
     private final PointerBase[] methodHandles = new PointerBase[trampolineCount];
     private final CFunctionPointer[] stubs = new CFunctionPointer[trampolineCount];
+    private final BitSet patchedStubs;
     private final Pointer trampolines;
 
+    private static BitSet initializedPatchedStubs(int nbits) {
+        BitSet patchedStubs = null;
+        assert (patchedStubs = new BitSet(nbits)).isEmpty();
+        return patchedStubs;
+    }
+
+    private boolean getAndSetPatchedStub(int id) {
+        assert patchedStubs != null;
+        boolean res = patchedStubs.get(id);
+        patchedStubs.set(id);
+        return res;
+    }
+
     private PinnedObject pin(Object object) {
         PinnedObject pinned = PinnedObject.create(object);
         pins.add(pinned);
@@ -86,6 +102,7 @@ private PinnedObject pin(Object object) {
 
         assert trampolineCount <= maxTrampolineCount();
         trampolines = prepareTrampolines(pin(methodHandles), pin(stubs), template);
+        this.patchedStubs = initializedPatchedStubs(stubs.length);
     }
 
     Pointer base() {
@@ -103,10 +120,19 @@ Pointer assignTrampoline(MethodHandle methodHandle, CFunctionPointer upcallStubP
 
         methodHandles[id] = pinned.addressOfObject();
         stubs[id] = upcallStubPointer;
+        assert !patchedStubs.get(id);
 
         return trampolines.add(id * AbiUtils.singleton().trampolineSize());
     }
 
+    void patchTrampolineForDirectUpcall(Pointer trampolinePointer, CFunctionPointer directUpcallStubPointer) {
+        VMError.guarantee(trampolinePointer.aboveOrEqual(trampolines), "invalid trampoline pointer");
+        int id = UnsignedUtils.safeToInt(trampolinePointer.subtract(trampolines).unsignedDivide(AbiUtils.singleton().trampolineSize()));
+        VMError.guarantee(id >= 0 && id < stubs.length, "invalid trampoline id");
+        assert !getAndSetPatchedStub(id) : "attempt to patch trampoline twice";
+        stubs[id] = directUpcallStubPointer;
+    }
+
     private Pointer prepareTrampolines(PinnedObject mhsArray, PinnedObject stubsArray, AbiUtils.TrampolineTemplate template) {
         VirtualMemoryProvider memoryProvider = VirtualMemoryProvider.get();
         UnsignedWord pageSize = allocationSize();
@@ -142,6 +168,9 @@ boolean tryFree() {
         }
         VirtualMemoryProvider.get().free(trampolines, allocationSize());
         assigned = FREED;
+        if (patchedStubs != null) {
+            patchedStubs.clear();
+        }
         return true;
     }
 }
diff --git a/substratevm/src/com.oracle.svm.core.foreign/src/com/oracle/svm/core/foreign/UpcallStubsHolder.java b/substratevm/src/com.oracle.svm.core.foreign/src/com/oracle/svm/core/foreign/UpcallStubsHolder.java
index 1a71459d279e..e76dfe455bfe 100644
--- a/substratevm/src/com.oracle.svm.core.foreign/src/com/oracle/svm/core/foreign/UpcallStubsHolder.java
+++ b/substratevm/src/com.oracle.svm.core.foreign/src/com/oracle/svm/core/foreign/UpcallStubsHolder.java
@@ -54,10 +54,14 @@ public static ConstantPool getConstantPool(MetaAccessProvider metaAccess) {
      * </pre>
      */
     @Platforms(Platform.HOSTED_ONLY.class)
-    public static String stubName(JavaEntryPointInfo jep, boolean highLevel) {
+    public static String stubName(JavaEntryPointInfo jep, boolean highLevel, boolean direct) {
         MethodType type = jep.handleType();
 
-        StringBuilder builder = new StringBuilder("upcall");
+        StringBuilder builder = new StringBuilder();
+        if (direct) {
+            builder.append("direct_");
+        }
+        builder.append("upcall");
         builder.append(highLevel ? "High" : "Low");
         builder.append("_");
         for (var param : type.parameterArray()) {
diff --git a/substratevm/src/com.oracle.svm.hosted.foreign/src/com/oracle/svm/hosted/foreign/ForeignFunctionsConfigurationParser.java b/substratevm/src/com.oracle.svm.hosted.foreign/src/com/oracle/svm/hosted/foreign/ForeignFunctionsConfigurationParser.java
index cd3b2b260faa..877a86482c07 100644
--- a/substratevm/src/com.oracle.svm.hosted.foreign/src/com/oracle/svm/hosted/foreign/ForeignFunctionsConfigurationParser.java
+++ b/substratevm/src/com.oracle.svm.hosted.foreign/src/com/oracle/svm/hosted/foreign/ForeignFunctionsConfigurationParser.java
@@ -27,6 +27,9 @@
 import java.lang.foreign.FunctionDescriptor;
 import java.lang.foreign.Linker;
 import java.lang.foreign.Linker.Option;
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.MethodType;
 import java.net.URI;
 import java.util.ArrayList;
 import java.util.List;
@@ -41,6 +44,8 @@
 
 import com.oracle.svm.core.configure.ConfigurationParser;
 import com.oracle.svm.core.util.BasedOnJDKFile;
+import com.oracle.svm.core.util.UserError;
+import com.oracle.svm.hosted.ImageClassLoader;
 
 import jdk.graal.compiler.util.json.JsonParserException;
 
@@ -52,38 +57,68 @@ public class ForeignFunctionsConfigurationParser extends ConfigurationParser {
     private static final String DOWNCALL_OPTION_CRITICAL = "critical";
     private static final String DOWNCALL_OPTION_ALLOW_HEAP_ACCESS = "allowHeapAccess";
 
+    private final ImageClassLoader imageClassLoader;
     private final RuntimeForeignAccessSupport accessSupport;
 
-    public ForeignFunctionsConfigurationParser(RuntimeForeignAccessSupport access) {
+    public ForeignFunctionsConfigurationParser(ImageClassLoader imageClassLoader, RuntimeForeignAccessSupport access) {
         super(true);
+        this.imageClassLoader = imageClassLoader;
         this.accessSupport = access;
     }
 
     @Override
     public void parseAndRegister(Object json, URI origin) {
         var topLevel = asMap(json, "first level of document must be a map");
-        checkAttributes(topLevel, "foreign methods categories", List.of(), List.of("downcalls", "upcalls"));
+        checkAttributes(topLevel, "foreign methods categories", List.of(), List.of("downcalls", "upcalls", "directUpcalls"));
 
-        var downcalls = asList(topLevel.get("downcalls", List.of()), "downcalls must be an array of method signatures");
+        var downcalls = asList(topLevel.get("downcalls", List.of()), "downcalls must be an array of function descriptor and linker options");
         for (Object downcall : downcalls) {
             parseAndRegisterForeignCall(downcall, this::parseDowncallOptions, (descriptor, options) -> accessSupport.registerForDowncall(ConfigurationCondition.alwaysTrue(), descriptor, options));
         }
 
-        var upcalls = asList(topLevel.get("upcalls", List.of()), "upcalls must be an array of method signatures");
+        var upcalls = asList(topLevel.get("upcalls", List.of()), "upcalls must be an array of function descriptor and linker options");
         for (Object upcall : upcalls) {
             parseAndRegisterForeignCall(upcall, this::parseUpcallOptions, (descriptor, options) -> accessSupport.registerForUpcall(ConfigurationCondition.alwaysTrue(), descriptor, options));
         }
+
+        var directUpcalls = asList(topLevel.get("directUpcalls", List.of()), "direct upcalls must be an array of method references, function descriptors, and linker options");
+        for (Object upcall : directUpcalls) {
+            parseAndRegisterDirectUpcall(upcall);
+        }
     }
 
     private void parseAndRegisterForeignCall(Object call, Function<EconomicMap<String, Object>, List<Option>> optionsParser, BiConsumer<Object, Object[]> register) {
         var map = asMap(call, "a foreign call must be a map");
         checkAttributes(map, "foreign call", List.of("descriptor"), List.of("options"));
         var descriptor = parseDescriptor(map.get("descriptor"));
-        var options = map.get("options", EconomicMap.create());
+        var options = map.get("options", EconomicMap.emptyMap());
         List<Option> parsedOptions = optionsParser.apply(asMap(options, "options must be a map"));
         register.accept(descriptor, parsedOptions.toArray());
     }
 
+    private void parseAndRegisterDirectUpcall(Object call) {
+        var map = asMap(call, "a foreign call must be a map");
+        checkAttributes(map, "foreign call", List.of("class", "method", "descriptor"), List.of("options"));
+        String className = asString(map.get("class"));
+        String methodName = asString(map.get("method"));
+        FunctionDescriptor descriptor = parseDescriptor(map.get("descriptor"));
+        var options = parseUpcallOptions(asMap(map.get("options", EconomicMap.emptyMap()), "options must be a map"));
+
+        MethodType methodType = descriptor.toMethodType();
+        try {
+            Class<?> aClass = imageClassLoader.forName(className);
+            MethodHandle methodHandle = MethodHandles.publicLookup().findStatic(aClass, methodName, methodType);
+            accessSupport.registerForDirectUpcall(ConfigurationCondition.alwaysTrue(), methodHandle, descriptor, options.toArray());
+        } catch (ClassNotFoundException e) {
+            throw UserError.abort(e, "Cannot find class '%s' used to register method '%s' for a direct upcall. ",
+                            className, methodName);
+        } catch (NoSuchMethodException | IllegalAccessException e) {
+            throw UserError.abort(e, "Method '%s.%s(%s)' could not be registered as an upcall target method. " +
+                            "Please verify that the method is public, static and that the parameter types match.",
+                            className, methodName, methodType);
+        }
+    }
+
     private FunctionDescriptor parseDescriptor(Object signature) {
         String input = asString(signature, "a function descriptor must be a string");
         return FunctionDescriptorParser.parse(input);
diff --git a/substratevm/src/com.oracle.svm.hosted.foreign/src/com/oracle/svm/hosted/foreign/ForeignFunctionsFeature.java b/substratevm/src/com.oracle.svm.hosted.foreign/src/com/oracle/svm/hosted/foreign/ForeignFunctionsFeature.java
index 04068114ecb4..f673d4329c47 100644
--- a/substratevm/src/com.oracle.svm.hosted.foreign/src/com/oracle/svm/hosted/foreign/ForeignFunctionsFeature.java
+++ b/substratevm/src/com.oracle.svm.hosted.foreign/src/com/oracle/svm/hosted/foreign/ForeignFunctionsFeature.java
@@ -24,27 +24,41 @@
  */
 package com.oracle.svm.hosted.foreign;
 
+import static java.lang.invoke.MethodHandles.exactInvoker;
+import static java.lang.invoke.MethodHandles.insertArguments;
+
+import java.lang.constant.DirectMethodHandleDesc;
+import java.lang.constant.DirectMethodHandleDesc.Kind;
 import java.lang.foreign.FunctionDescriptor;
 import java.lang.foreign.Linker;
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.MethodHandles.Lookup;
+import java.lang.invoke.MethodType;
+import java.lang.reflect.Executable;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.Arrays;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
+import java.util.Objects;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
-import java.util.function.BiConsumer;
-import java.util.function.BiFunction;
-import java.util.function.Function;
+import java.util.function.UnaryOperator;
 
-import org.graalvm.collections.Pair;
 import org.graalvm.nativeimage.ImageSingletons;
 import org.graalvm.nativeimage.Platform;
 import org.graalvm.nativeimage.Platforms;
 import org.graalvm.nativeimage.c.function.CFunctionPointer;
 import org.graalvm.nativeimage.c.type.CIntPointer;
 import org.graalvm.nativeimage.hosted.RuntimeClassInitialization;
+import org.graalvm.nativeimage.hosted.RuntimeReflection;
 import org.graalvm.nativeimage.impl.ConfigurationCondition;
 import org.graalvm.nativeimage.impl.RuntimeForeignAccessSupport;
 
 import com.oracle.graal.pointsto.meta.AnalysisMethod;
+import com.oracle.graal.pointsto.meta.AnalysisUniverse;
 import com.oracle.svm.core.LinkToNativeSupport;
 import com.oracle.svm.core.SubstrateOptions;
 import com.oracle.svm.core.SubstrateUtil;
@@ -55,11 +69,15 @@
 import com.oracle.svm.core.feature.InternalFeature;
 import com.oracle.svm.core.foreign.AbiUtils;
 import com.oracle.svm.core.foreign.ForeignFunctionsRuntime;
+import com.oracle.svm.core.foreign.JavaEntryPointInfo;
 import com.oracle.svm.core.foreign.LinkToNativeSupportImpl;
+import com.oracle.svm.core.foreign.NativeEntryPointInfo;
 import com.oracle.svm.core.foreign.RuntimeSystemLookup;
 import com.oracle.svm.core.graal.meta.SubstrateForeignCallsProvider;
 import com.oracle.svm.core.meta.MethodPointer;
+import com.oracle.svm.core.util.BasedOnJDKFile;
 import com.oracle.svm.core.util.UserError;
+import com.oracle.svm.core.util.VMError;
 import com.oracle.svm.hosted.ConditionalConfigurationRegistry;
 import com.oracle.svm.hosted.FeatureImpl;
 import com.oracle.svm.hosted.ProgressReporter;
@@ -70,6 +88,9 @@
 
 import jdk.graal.compiler.api.replacements.Fold;
 import jdk.graal.compiler.serviceprovider.JavaVersionUtil;
+import jdk.internal.foreign.abi.AbstractLinker;
+import jdk.internal.foreign.abi.LinkerOptions;
+import jdk.vm.ci.meta.MetaAccessProvider;
 import jdk.vm.ci.meta.ResolvedJavaMethod;
 
 @AutomaticallyRegisteredFeature
@@ -87,12 +108,15 @@ public class ForeignFunctionsFeature implements InternalFeature {
     private boolean sealed = false;
     private final RuntimeForeignAccessSupportImpl accessSupport = new RuntimeForeignAccessSupportImpl();
 
-    private final Set<Pair<FunctionDescriptor, Linker.Option[]>> registeredDowncalls = ConcurrentHashMap.newKeySet();
+    private final Set<SharedDesc> registeredDowncalls = ConcurrentHashMap.newKeySet();
     private int downcallCount = -1;
 
-    private final Set<Pair<FunctionDescriptor, Linker.Option[]>> registeredUpcalls = ConcurrentHashMap.newKeySet();
+    private final Set<SharedDesc> registeredUpcalls = ConcurrentHashMap.newKeySet();
     private int upcallCount = -1;
 
+    private final Set<DirectUpcallDesc> registeredDirectUpcalls = ConcurrentHashMap.newKeySet();
+    private int directUpcallCount = -1;
+
     @Fold
     public static ForeignFunctionsFeature singleton() {
         return ImageSingletons.lookup(ForeignFunctionsFeature.class);
@@ -102,17 +126,79 @@ private void checkNotSealed() {
         UserError.guarantee(!sealed, "Registration of foreign functions was closed.");
     }
 
+    /**
+     * Descriptor that represents both, up- and downcalls.
+     */
+    private record SharedDesc(FunctionDescriptor fd, Linker.Option[] options) {
+        @Override
+        public boolean equals(Object o) {
+            if (this == o || !(o instanceof SharedDesc that)) {
+                return this == o;
+            }
+            return Objects.equals(fd, that.fd) && Arrays.equals(options, that.options);
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hash(fd, Arrays.hashCode(options));
+        }
+    }
+
+    private record DirectUpcallDesc(MethodHandle mh, DirectMethodHandleDesc mhDesc, FunctionDescriptor fd, Linker.Option[] options) {
+
+        public SharedDesc toSharedDesc() {
+            return new SharedDesc(fd, options);
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            if (this == o || !(o instanceof DirectUpcallDesc that)) {
+                return this == o;
+            }
+            return Objects.equals(mhDesc, that.mhDesc) && Objects.equals(fd, that.fd) && Arrays.equals(options, that.options);
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hash(mhDesc, fd, Arrays.hashCode(options));
+        }
+    }
+
     private class RuntimeForeignAccessSupportImpl extends ConditionalConfigurationRegistry implements StronglyTypedRuntimeForeignAccessSupport {
+
+        private final Lookup implLookup = ReflectionUtil.readStaticField(MethodHandles.Lookup.class, "IMPL_LOOKUP");
+
         @Override
         public void registerForDowncall(ConfigurationCondition condition, FunctionDescriptor desc, Linker.Option... options) {
             checkNotSealed();
-            registerConditionalConfiguration(condition, (cnd) -> registeredDowncalls.add(Pair.create(desc, options)));
+            registerConditionalConfiguration(condition, (cnd) -> registeredDowncalls.add(new SharedDesc(desc, options)));
         }
 
         @Override
         public void registerForUpcall(ConfigurationCondition condition, FunctionDescriptor desc, Linker.Option... options) {
             checkNotSealed();
-            registerConditionalConfiguration(condition, (ignored) -> registeredUpcalls.add(Pair.create(desc, options)));
+            registerConditionalConfiguration(condition, (ignored) -> registeredUpcalls.add(new SharedDesc(desc, options)));
+        }
+
+        @Override
+        public void registerForDirectUpcall(ConfigurationCondition condition, MethodHandle target, FunctionDescriptor desc, Linker.Option... options) {
+            checkNotSealed();
+            DirectMethodHandleDesc directMethodHandleDesc = target.describeConstable()
+                            .filter(x -> x instanceof DirectMethodHandleDesc dmh && dmh.kind() == Kind.STATIC)
+                            .map(x -> ((DirectMethodHandleDesc) x))
+                            .orElseThrow(() -> new IllegalArgumentException("target must be a direct method handle to a static method"));
+            /*
+             * The call 'implLookup.revealDirect' can only succeed if the method handle is
+             * crackable. The call is expected to succeed because we already call
+             * 'describeConstable' before and this also requires the method handle to be crackable.
+             * Further, since we use Lookup.IMPL_LOOKUP, we also do not expect any access violation
+             * exceptions.
+             */
+            Executable method = implLookup.revealDirect(Objects.requireNonNull(target)).reflectAs(Executable.class, implLookup);
+            registerConditionalConfiguration(condition, (ignored) -> {
+                RuntimeReflection.register(method);
+                registeredDirectUpcalls.add(new DirectUpcallDesc(target, directMethodHandleDesc, desc, options));
+            });
         }
     }
 
@@ -139,64 +225,201 @@ public boolean isInConfiguration(IsInConfigurationAccess access) {
 
     @Override
     public void duringSetup(DuringSetupAccess a) {
+        var access = (FeatureImpl.DuringSetupAccessImpl) a;
         ImageSingletons.add(AbiUtils.class, AbiUtils.create());
         ImageSingletons.add(ForeignFunctionsRuntime.class, new ForeignFunctionsRuntime());
         ImageSingletons.add(RuntimeForeignAccessSupport.class, accessSupport);
         ImageSingletons.add(LinkToNativeSupport.class, new LinkToNativeSupportImpl());
 
-        var access = (FeatureImpl.DuringSetupAccessImpl) a;
-        ConfigurationParser parser = new ForeignFunctionsConfigurationParser(accessSupport);
+        ConfigurationParser parser = new ForeignFunctionsConfigurationParser(access.getImageClassLoader(), accessSupport);
         ConfigurationParserUtils.parseAndRegisterConfigurations(parser, access.getImageClassLoader(), "panama foreign",
                         ConfigurationFiles.Options.ForeignConfigurationFiles, ConfigurationFiles.Options.ForeignResources, ConfigurationFile.FOREIGN.getFileName());
     }
 
+    private interface StubFactory<S, T, U extends ResolvedJavaMethod> {
+        S createKey(T registeredDescriptor);
+
+        U generateStub(S stubDescriptor);
+
+        void registerStub(S stubDescriptor, CFunctionPointer stubPointer);
+    }
+
+    private record DowncallStubFactory(MetaAccessProvider metaAccessProvider) implements StubFactory<NativeEntryPointInfo, SharedDesc, DowncallStub> {
+
+        @Override
+        public NativeEntryPointInfo createKey(SharedDesc registeredDescriptor) {
+            return AbiUtils.singleton().makeNativeEntrypoint(registeredDescriptor.fd, registeredDescriptor.options);
+        }
+
+        @Override
+        public DowncallStub generateStub(NativeEntryPointInfo stubDescriptor) {
+            return new DowncallStub(stubDescriptor, metaAccessProvider);
+        }
+
+        @Override
+        public void registerStub(NativeEntryPointInfo stubDescriptor, CFunctionPointer stubPointer) {
+            ForeignFunctionsRuntime.singleton().addDowncallStubPointer(stubDescriptor, stubPointer);
+        }
+    }
+
     private void createDowncallStubs(FeatureImpl.BeforeAnalysisAccessImpl access) {
         this.downcallCount = createStubs(
                         registeredDowncalls,
                         access,
                         false,
-                        AbiUtils.singleton()::makeNativeEntrypoint,
-                        n -> new DowncallStub(n, access.getMetaAccess().getWrapped()),
-                        ForeignFunctionsRuntime.singleton()::addDowncallStubPointer);
+                        new DowncallStubFactory(access.getMetaAccess().getWrapped())).size();
+    }
+
+    private record DirectUpcall(DirectMethodHandleDesc targetDesc, MethodHandle bindings, JavaEntryPointInfo jep) {
+        @Override
+        public boolean equals(Object o) {
+            if (this == o || !(o instanceof DirectUpcall)) {
+                return this == o;
+            }
+            return Objects.equals(targetDesc, ((DirectUpcall) o).targetDesc);
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hashCode(targetDesc);
+        }
+    }
+
+    private record UpcallStubFactory(AnalysisUniverse universe, MetaAccessProvider metaAccessProvider) implements StubFactory<JavaEntryPointInfo, SharedDesc, UpcallStub> {
+
+        @Override
+        public JavaEntryPointInfo createKey(SharedDesc registeredDescriptor) {
+            return AbiUtils.singleton().makeJavaEntryPoint(registeredDescriptor.fd, registeredDescriptor.options);
+        }
+
+        @Override
+        public UpcallStub generateStub(JavaEntryPointInfo stubDescriptor) {
+            return LowLevelUpcallStub.make(stubDescriptor, universe, metaAccessProvider);
+        }
+
+        @Override
+        public void registerStub(JavaEntryPointInfo stubDescriptor, CFunctionPointer stubPointer) {
+            ForeignFunctionsRuntime.singleton().addUpcallStubPointer(stubDescriptor, stubPointer);
+        }
+    }
+
+    /**
+     * The DirectMethodHandle provided by the "user" is not directly called but will be wrapped into
+     * other method handles that do appropriate argument and result value conversions.
+     *
+     * However, there is no clean way to get access to the MethodHandle that is actually executed by
+     * the upcall stub. This class extracts the 'UpcallStubFactory' and then re-creates an equal
+     * method handle. This one is then passed to the DirectUpcallStub and is there subject for
+     * intrinsification.
+     */
+    private static final class DirectUpcallStubFactory implements StubFactory<DirectUpcall, DirectUpcallDesc, UpcallStub> {
+        private static final String COULD_NOT_EXTRACT_METHOD_HANDLE_FOR_UPCALL = "Could not extract method handle for upcall.";
+
+        private final AnalysisUniverse universe;
+        private final MetaAccessProvider metaAccessProvider;
+        private final Method arrangeUpcallMethod;
+        private final Set<SharedDesc> registeredUpcalls;
+
+        DirectUpcallStubFactory(AnalysisUniverse universe, MetaAccessProvider metaAccessProvider, Set<SharedDesc> registeredUpcalls) {
+            this.universe = universe;
+            this.metaAccessProvider = metaAccessProvider;
+            this.registeredUpcalls = registeredUpcalls;
+            this.arrangeUpcallMethod = ReflectionUtil.lookupMethod(LINKER.getClass(), "arrangeUpcall", MethodType.class, FunctionDescriptor.class, LinkerOptions.class);
+        }
+
+        @BasedOnJDKFile("https://github.com/openjdk/jdk/blob/jdk-24+25/src/java.base/share/classes/jdk/internal/foreign/abi/AbstractLinker.java#L117-L135")
+        @BasedOnJDKFile("https://github.com/openjdk/jdk/blob/jdk-24+25/src/java.base/share/classes/jdk/internal/foreign/abi/UpcallLinker.java#L64-L112")
+        @Override
+        public DirectUpcall createKey(DirectUpcallDesc desc) {
+            LinkerOptions optionSet = LinkerOptions.forUpcall(desc.fd(), desc.options());
+            /*
+             * For each unique link request, 'AbstractLinker.upcallStub' calls
+             * 'AbstractLinker.arrangeUpcall' which produces an upcall stub factory. This factory is
+             * a closure created in 'UpcallLinker.makeFactory' and it closes over the
+             * 'doBindingsMaker' (stored in a private field). This is a unary operator that is
+             * applied to the user-provided method handle. We then re-create a method handle that is
+             * equal to the one created in 'UpcallLinker.makeFactory'. This MH is then invoked from
+             * the specialized upcall stub.
+             */
+            AbstractLinker.UpcallStubFactory upcallStubFactory = ReflectionUtil.invokeMethod(arrangeUpcallMethod, LINKER, desc.fd().toMethodType(), desc.fd(), optionSet);
+            UnaryOperator<MethodHandle> doBindingsMaker = lookupAndReadUnaryOperatorField(upcallStubFactory);
+            MethodHandle doBindings = doBindingsMaker.apply(desc.mh());
+            doBindings = insertArguments(exactInvoker(doBindings.type()), 0, doBindings);
+            JavaEntryPointInfo jepi = AbiUtils.singleton().makeJavaEntryPoint(desc.fd(), desc.options());
+            registeredUpcalls.add(desc.toSharedDesc());
+            return new DirectUpcall(desc.mhDesc(), doBindings, jepi);
+        }
+
+        @Override
+        public UpcallStub generateStub(DirectUpcall directUpcall) {
+            return LowLevelUpcallStub.makeDirect(directUpcall.bindings(), directUpcall.jep(), universe, metaAccessProvider);
+        }
+
+        @Override
+        public void registerStub(DirectUpcall stubDescriptor, CFunctionPointer stubPointer) {
+            ForeignFunctionsRuntime.singleton().addDirectUpcallStubPointer(stubDescriptor.targetDesc(), stubPointer);
+        }
+
+        /**
+         * Looks up a field of type {@link UnaryOperator}, reads its value and returns it. There
+         * must be exactly one such field that is readable. Otherwise, an Error is thrown.
+         */
+        private static UnaryOperator<MethodHandle> lookupAndReadUnaryOperatorField(AbstractLinker.UpcallStubFactory upcallStubFactory) {
+            Class<? extends AbstractLinker.UpcallStubFactory> upcallStubFactoryClass = upcallStubFactory.getClass();
+            List<Field> list = Arrays.stream(upcallStubFactoryClass.getDeclaredFields())
+                            .filter(field -> UnaryOperator.class.isAssignableFrom(field.getType())).toList();
+            if (list.size() != 1) {
+                throw VMError.shouldNotReachHere(COULD_NOT_EXTRACT_METHOD_HANDLE_FOR_UPCALL);
+            }
+            Field candidate = list.getFirst();
+            assert candidate != null;
+
+            UnaryOperator<MethodHandle> value = ReflectionUtil.readField(upcallStubFactoryClass, candidate.getName(), upcallStubFactory);
+            if (value == null) {
+                throw VMError.shouldNotReachHere(COULD_NOT_EXTRACT_METHOD_HANDLE_FOR_UPCALL);
+            }
+
+            return value;
+        }
     }
 
     private void createUpcallStubs(FeatureImpl.BeforeAnalysisAccessImpl access) {
-        this.upcallCount = createStubs(
-                        registeredUpcalls,
-                        access,
-                        true,
-                        AbiUtils.singleton()::makeJavaEntryPoint,
-                        jepi -> LowLevelUpcallStub.make(jepi, access.getUniverse(), access.getMetaAccess().getWrapped()),
-                        ForeignFunctionsRuntime.singleton()::addUpcallStubPointer);
+        Map<DirectUpcall, UpcallStub> directUpcallStubs = createStubs(registeredDirectUpcalls, access, true,
+                        new DirectUpcallStubFactory(access.getUniverse(), access.getMetaAccess().getWrapped(), registeredUpcalls));
+        this.directUpcallCount = directUpcallStubs.size();
+        registeredDirectUpcalls.clear();
+
+        Map<JavaEntryPointInfo, UpcallStub> upcallStubs = createStubs(registeredUpcalls, access, true,
+                        new UpcallStubFactory(access.getUniverse(), access.getMetaAccess().getWrapped()));
+        this.upcallCount = upcallStubs.size();
+        registeredUpcalls.clear();
     }
 
-    private <S> int createStubs(
-                    Set<Pair<FunctionDescriptor, Linker.Option[]>> source,
+    private static final Linker LINKER = Linker.nativeLinker();
+
+    private static <S, T, U extends ResolvedJavaMethod> Map<S, U> createStubs(
+                    Iterable<T> sources,
                     FeatureImpl.BeforeAnalysisAccessImpl access,
                     boolean registerAsEntryPoints,
-                    BiFunction<FunctionDescriptor, Linker.Option[], S> stubGenerator,
-                    Function<S, ResolvedJavaMethod> wrapper,
-                    BiConsumer<S, CFunctionPointer> register) {
+                    StubFactory<S, T, U> factory) {
 
-        Map<S, ResolvedJavaMethod> created = new HashMap<>();
+        Map<S, U> created = new HashMap<>();
 
-        for (Pair<FunctionDescriptor, Linker.Option[]> fdOptionsPair : source) {
-            S nepi = stubGenerator.apply(fdOptionsPair.getLeft(), fdOptionsPair.getRight());
+        for (T source : sources) {
+            S key = factory.createKey(source);
 
-            if (!created.containsKey(nepi)) {
-                ResolvedJavaMethod stub = wrapper.apply(nepi);
+            if (!created.containsKey(key)) {
+                U stub = factory.generateStub(key);
                 AnalysisMethod analysisStub = access.getUniverse().lookup(stub);
                 access.getBigBang().addRootMethod(analysisStub, false, "Foreign stub, registered in " + ForeignFunctionsFeature.class);
                 if (registerAsEntryPoints) {
                     analysisStub.registerAsEntryPoint(CEntryPointData.createCustomUnpublished());
                 }
-                created.put(nepi, analysisStub);
-                register.accept(nepi, new MethodPointer(analysisStub));
+                created.put(key, stub);
+                factory.registerStub(key, new MethodPointer(analysisStub));
             }
         }
-        source.clear();
-
-        return created.size();
+        return created;
     }
 
     @Override
@@ -214,13 +437,13 @@ public void beforeAnalysis(BeforeAnalysisAccess a) {
                         ReflectionUtil.lookupField(
                                         ReflectionUtil.lookupClass(false, "jdk.internal.foreign.abi.DowncallLinker"),
                                         "USE_SPEC"),
-                        (receiver, originalValue) -> false);
+                        (_, _) -> false);
 
         access.registerFieldValueTransformer(
                         ReflectionUtil.lookupField(
                                         ReflectionUtil.lookupClass(false, "jdk.internal.foreign.abi.UpcallLinker"),
                                         "USE_SPEC"),
-                        (receiver, originalValue) -> false);
+                        (_, _) -> false);
 
         RuntimeClassInitialization.initializeAtRunTime(RuntimeSystemLookup.class);
 
@@ -250,4 +473,10 @@ public int getCreatedUpcallStubsCount() {
         assert upcallCount >= 0;
         return upcallCount;
     }
+
+    public int getCreatedDirectUpcallStubsCount() {
+        assert sealed;
+        assert directUpcallCount >= 0;
+        return directUpcallCount;
+    }
 }
diff --git a/substratevm/src/com.oracle.svm.hosted.foreign/src/com/oracle/svm/hosted/foreign/StronglyTypedRuntimeForeignAccessSupport.java b/substratevm/src/com.oracle.svm.hosted.foreign/src/com/oracle/svm/hosted/foreign/StronglyTypedRuntimeForeignAccessSupport.java
index 1850f954dc84..34f86a202923 100644
--- a/substratevm/src/com.oracle.svm.hosted.foreign/src/com/oracle/svm/hosted/foreign/StronglyTypedRuntimeForeignAccessSupport.java
+++ b/substratevm/src/com.oracle.svm.hosted.foreign/src/com/oracle/svm/hosted/foreign/StronglyTypedRuntimeForeignAccessSupport.java
@@ -26,6 +26,7 @@
 
 import java.lang.foreign.FunctionDescriptor;
 import java.lang.foreign.Linker;
+import java.lang.invoke.MethodHandle;
 
 import org.graalvm.nativeimage.impl.ConfigurationCondition;
 import org.graalvm.nativeimage.impl.RuntimeForeignAccessSupport;
@@ -57,7 +58,12 @@ interface Recorder {
         void apply(ConfigurationCondition condition, FunctionDescriptor desc, Linker.Option... options);
     }
 
-    static StronglyTypedRuntimeForeignAccessSupport make(Recorder forDowncalls, Recorder forUpcalls) {
+    @FunctionalInterface
+    interface DirectUpcallRecorder {
+        void apply(ConfigurationCondition condition, MethodHandle target, FunctionDescriptor desc, Linker.Option... options);
+    }
+
+    static StronglyTypedRuntimeForeignAccessSupport make(Recorder forDowncalls, Recorder forUpcalls, DirectUpcallRecorder forDirectUpcalls) {
         return new StronglyTypedRuntimeForeignAccessSupport() {
             @Override
             public void registerForDowncall(ConfigurationCondition condition, FunctionDescriptor desc, Linker.Option... options) {
@@ -68,6 +74,11 @@ public void registerForDowncall(ConfigurationCondition condition, FunctionDescri
             public void registerForUpcall(ConfigurationCondition condition, FunctionDescriptor desc, Linker.Option... options) {
                 forUpcalls.apply(condition, desc, options);
             }
+
+            @Override
+            public void registerForDirectUpcall(ConfigurationCondition condition, MethodHandle target, FunctionDescriptor fd, Linker.Option... options) {
+                forDirectUpcalls.apply(condition, target, fd, options);
+            }
         };
     }
 
@@ -84,4 +95,10 @@ default void registerForUpcall(ConfigurationCondition condition, Object descO, O
     }
 
     void registerForUpcall(ConfigurationCondition condition, FunctionDescriptor desc, Linker.Option... options);
+
+    default void registerForDirectUpcall(ConfigurationCondition condition, MethodHandle target, Object desc, Object... options) {
+        registerForDirectUpcall(condition, target, castDesc(desc), castOptions(options));
+    }
+
+    void registerForDirectUpcall(ConfigurationCondition condition, MethodHandle target, FunctionDescriptor desc, Linker.Option... options);
 }
diff --git a/substratevm/src/com.oracle.svm.hosted.foreign/src/com/oracle/svm/hosted/foreign/UpcallStub.java b/substratevm/src/com.oracle.svm.hosted.foreign/src/com/oracle/svm/hosted/foreign/UpcallStub.java
index cda281ad03e4..aa0e68d40896 100644
--- a/substratevm/src/com.oracle.svm.hosted.foreign/src/com/oracle/svm/hosted/foreign/UpcallStub.java
+++ b/substratevm/src/com.oracle.svm.hosted.foreign/src/com/oracle/svm/hosted/foreign/UpcallStub.java
@@ -46,6 +46,7 @@
 import com.oracle.svm.core.c.function.CEntryPointErrors;
 import com.oracle.svm.core.config.ConfigurationValues;
 import com.oracle.svm.core.foreign.AbiUtils;
+import com.oracle.svm.core.foreign.AbiUtils.Adapter.Result.TypeAdaptation;
 import com.oracle.svm.core.foreign.JavaEntryPointInfo;
 import com.oracle.svm.core.foreign.UpcallStubsHolder;
 import com.oracle.svm.core.graal.code.AssignedLocation;
@@ -73,6 +74,7 @@
 import jdk.graal.compiler.debug.DebugContext;
 import jdk.graal.compiler.java.FrameStateBuilder;
 import jdk.graal.compiler.nodes.CallTargetNode;
+import jdk.graal.compiler.nodes.CallTargetNode.InvokeKind;
 import jdk.graal.compiler.nodes.ConstantNode;
 import jdk.graal.compiler.nodes.DeadEndNode;
 import jdk.graal.compiler.nodes.FrameState;
@@ -89,6 +91,7 @@
 import jdk.graal.compiler.replacements.nodes.WriteRegisterNode;
 import jdk.vm.ci.code.BytecodeFrame;
 import jdk.vm.ci.code.RegisterArray;
+import jdk.vm.ci.meta.JavaConstant;
 import jdk.vm.ci.meta.JavaKind;
 import jdk.vm.ci.meta.MetaAccessProvider;
 import jdk.vm.ci.meta.ResolvedJavaMethod;
@@ -99,8 +102,8 @@
 public abstract class UpcallStub extends NonBytecodeMethod {
     protected final JavaEntryPointInfo jep;
 
-    protected UpcallStub(JavaEntryPointInfo jep, MethodType methodType, MetaAccessProvider metaAccess, boolean highLevel) {
-        super(UpcallStubsHolder.stubName(jep, highLevel),
+    protected UpcallStub(JavaEntryPointInfo jep, MethodType methodType, MetaAccessProvider metaAccess, boolean highLevel, boolean direct) {
+        super(UpcallStubsHolder.stubName(jep, highLevel, direct),
                         true,
                         metaAccess.lookupJavaType(UpcallStubsHolder.class),
                         fromMethodType(methodType, metaAccess),
@@ -139,12 +142,20 @@ final class LowLevelUpcallStub extends UpcallStub implements CustomCallingConven
     private final AssignedLocation[] parametersAssignment;
 
     static LowLevelUpcallStub make(JavaEntryPointInfo jep, AnalysisUniverse universe, MetaAccessProvider metaAccess) {
-        return new LowLevelUpcallStub(jep, AbiUtils.singleton().adapt(jep), universe, metaAccess);
+        TypeAdaptation adapted = AbiUtils.singleton().adapt(jep);
+        AnalysisMethod highLevelStubMethod = universe.lookup(new HighLevelUpcallStub(jep, adapted, metaAccess));
+        return new LowLevelUpcallStub(highLevelStubMethod, jep, adapted, metaAccess, false);
     }
 
-    private LowLevelUpcallStub(JavaEntryPointInfo jep, AbiUtils.Adapter.Result.TypeAdaptation adapted, AnalysisUniverse universe, MetaAccessProvider metaAccess) {
-        super(jep, adapted.callType(), metaAccess, false);
-        this.highLevelStub = universe.lookup(new HighLevelUpcallStub(jep, adapted, metaAccess));
+    static LowLevelUpcallStub makeDirect(MethodHandle target, JavaEntryPointInfo jep, AnalysisUniverse universe, MetaAccessProvider metaAccess) {
+        TypeAdaptation adapted = AbiUtils.singleton().adapt(jep);
+        AnalysisMethod highLevelStubMethod = universe.lookup(new HighLevelDirectUpcallStub(target, jep, adapted, metaAccess));
+        return new LowLevelUpcallStub(highLevelStubMethod, jep, adapted, metaAccess, true);
+    }
+
+    private LowLevelUpcallStub(AnalysisMethod highLevelStubMethod, JavaEntryPointInfo jep, AbiUtils.Adapter.Result.TypeAdaptation adapted, MetaAccessProvider metaAccess, boolean direct) {
+        super(jep, adapted.callType(), metaAccess, false, direct);
+        this.highLevelStub = highLevelStubMethod;
         this.savedRegisters = ImageSingletons.lookup(SubstrateRegisterConfigFactory.class)
                         .newRegisterFactory(SubstrateRegisterConfig.ConfigKind.NATIVE_TO_JAVA, null, ConfigurationValues.getTarget(), SubstrateOptions.PreserveFramePointer.getValue())
                         .getCalleeSaveRegisters();
@@ -270,7 +281,7 @@ public SubstrateCallingConventionType getCallingConvention() {
 
 /** In charge of high-level stuff, mainly invoking the method handle. */
 class HighLevelUpcallStub extends UpcallStub {
-    private static final Method INVOKE = ReflectionUtil.lookupMethod(
+    static final Method INVOKE = ReflectionUtil.lookupMethod(
                     MethodHandle.class,
                     "invokeWithArguments",
                     Object[].class);
@@ -285,7 +296,7 @@ private static MethodType computeType(JavaEntryPointInfo jep, MethodType lowType
     }
 
     HighLevelUpcallStub(JavaEntryPointInfo jep, AbiUtils.Adapter.Result.TypeAdaptation adapted, MetaAccessProvider metaAccess) {
-        super(jep, computeType(jep, adapted.callType()), metaAccess, true);
+        super(jep, computeType(jep, adapted.callType()), metaAccess, true, false);
     }
 
     @Override
@@ -318,3 +329,95 @@ public StructuredGraph buildGraph(DebugContext debug, AnalysisMethod method, Hos
         return kit.finalizeGraph();
     }
 }
+
+/**
+ * Similar to HighLevelUpcallStub but is bound to a constant method handle. This method then acts as
+ * an intrinsification enabler
+ */
+class HighLevelDirectUpcallStub extends UpcallStub {
+
+    private static MethodType computeType(JavaEntryPointInfo jep, MethodType lowType) {
+        /* Inject return buffer */
+        if (jep.buffersReturn()) {
+            lowType = lowType.insertParameterTypes(0, long.class);
+        }
+        /* Inject method handle */
+        return lowType.insertParameterTypes(0, MethodHandle.class);
+    }
+
+    private final MethodHandle target;
+
+    HighLevelDirectUpcallStub(MethodHandle handle, JavaEntryPointInfo jep, AbiUtils.Adapter.Result.TypeAdaptation adapted, MetaAccessProvider metaAccess) {
+        super(jep, computeType(jep, adapted.callType()), metaAccess, true, true);
+        this.target = handle;
+        VMError.guarantee(handle.type().equals(jep.handleType()));
+    }
+
+    @Override
+    public StructuredGraph buildGraph(DebugContext debug, AnalysisMethod method, HostedProviders providers, Purpose purpose) {
+        ForeignGraphKit kit = new ForeignGraphKit(debug, providers, method, purpose);
+        FrameStateBuilder frame = kit.getFrameState();
+
+        List<ValueNode> allArguments = new ArrayList<>(kit.getInitialArguments());
+
+        JavaConstant targetMethodHandle = kit.getSnippetReflection().forObject(target);
+        ConstantNode constMH = kit.createConstant(targetMethodHandle, JavaKind.Object);
+
+        InvokeWithExceptionNode returnValue;
+        /*
+         * Attempt to resolve the target of 'invokeBasic'. This should resolve the call of the
+         * polymorphic signature method 'invokeExact' to the actually implementing method (i.e. the
+         * one generated by the lambda form; usually named 'invokeExact_MT'). The resolved target
+         * has a specialized signature (i.e. no longer takes 'Object[]') and so we omit boxing.
+         * Further, this method is annotated with 'LambdaForm.Compiled' and recognized by
+         * InlineBeforeAnalysis as method handle intrinsification root.
+         * 
+         * If resolving does not work, a call to a generic invocation method will be emitted (same
+         * as in 'UpcallStub'). We will still use the constant method handle as receiver to enable
+         * some optimizations but the method handle will most certainly still be interpreted.
+         */
+        ResolvedJavaMethod resolvedJavaMethod = providers.getConstantReflection().getMethodHandleAccess().resolveInvokeBasicTarget(targetMethodHandle, true);
+        if (resolvedJavaMethod != null) {
+            /*
+             * Replace the dynamically passed receiver handle by the constant handle this stub was
+             * created with. This is necessary to enable the method handle intrinsification.
+             */
+            allArguments.set(0, constMH);
+            frame.clearLocals();
+            InvokeKind invokeKind = resolvedJavaMethod.isStatic() ? InvokeKind.Static : InvokeKind.Virtual;
+            returnValue = kit.createJavaCallWithException(invokeKind, resolvedJavaMethod, allArguments.toArray(ValueNode.EMPTY_ARRAY));
+        } else {
+            // we don't use the argument that is passed from the trampoline to the stubs right now
+            allArguments.removeFirst();
+
+            /*
+             * If adaptations are ever needed for upcalls, they should most likely be applied here
+             */
+            allArguments = kit.boxArguments(allArguments, jep.handleType());
+            ValueNode arguments = kit.packArguments(allArguments);
+            frame.clearLocals();
+            MetaAccessProvider metaAccess = kit.getMetaAccess();
+            returnValue = kit.createJavaCallWithException(CallTargetNode.InvokeKind.Virtual, metaAccess.lookupJavaMethod(HighLevelUpcallStub.INVOKE), constMH, arguments);
+        }
+
+        kit.exceptionPart();
+        /*
+         * Per documentation, it is the user's responsibility to not throw exceptions from upcalls
+         * (e.g. by using MethodHandles#catchException).
+         */
+        kit.append(new CEntryPointLeaveNode(CEntryPointLeaveNode.LeaveAction.ExceptionAbort, kit.exceptionObject()));
+        kit.append(new LoweredDeadEndNode());
+        kit.endInvokeWithException();
+
+        ValueNode unboxedReturn;
+        if (resolvedJavaMethod != null) {
+            unboxedReturn = returnValue;
+        } else {
+            unboxedReturn = kit.unbox(returnValue, jep.cMethodType());
+        }
+        assert JavaKind.fromJavaClass(jep.cMethodType().returnType()) == unboxedReturn.getStackKind();
+        kit.createReturn(unboxedReturn, jep.cMethodType());
+
+        return kit.finalizeGraph();
+    }
+}