Setup the ability to interpret polymorphic signature intrinsics

gilles-duboscq · gilles-duboscq · commit 5dece067d9a7 · 2025-10-30T17:21:38.000+01:00
* Polymorphic signature method instantiations have an "intrinsic" field
  set denoting which kind of intrinsic type it is.
* The interpreter can dispatch to `IntrinsicRoot.execute` for
  intrinsics.
* Stack walking knows about this interpeter method
* The special interpreter methods should be marked as `@NeverInline` and
  don't need to be added as root.
* Add support in the interpreter for `invokeBasic`
diff --git a/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/interpreter/InterpreterSupport.java b/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/interpreter/InterpreterSupport.java
@@ -64,16 +64,14 @@ public static InterpreterSupport singleton() {
         return ImageSingletons.lookup(InterpreterSupport.class);
     }
 
-    /*
-     * Check if a given argument matches the inner class Interpreter.Root (holder of the interpreter
-     * dispatch loop).
+    /**
+     * Check if a given frame should be processed by {@link #getInterpretedMethodFrameInfo}.
      */
-    public abstract boolean isInterpreterRoot(Class<?> clazz);
+    public abstract boolean isInterpreterRoot(FrameInfoQueryResult frameInfo);
 
     /**
-     * Transforms an interpreter (root) frame into a frame of the interpreted method. The passed
-     * frame must be an interpreter root e.g. {@code isInterpreterRoot(frameInfo.getSourceClass())}
-     * otherwise a fatal exception is thrown.
+     * Transforms an interpreter (root) frame into a frame of the interpreted method. An error is
+     * thrown if the passed frame is not an {@link #isInterpreterRoot interpreter root}.
      *
      * @param frameInfo interpreter root frame
      * @param sp stack pointer of the interpreter frame
diff --git a/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/methodhandles/MethodHandleInterpreterUtils.java b/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/methodhandles/MethodHandleInterpreterUtils.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2020, 2020, 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.
+ */
+package com.oracle.svm.core.methodhandles;
+
+import java.lang.invoke.MethodHandle;
+
+import com.oracle.svm.core.SubstrateUtil;
+import com.oracle.svm.core.invoke.Target_java_lang_invoke_MemberName;
+
+public final class MethodHandleInterpreterUtils {
+    private MethodHandleInterpreterUtils() {
+    }
+
+    public static Target_java_lang_invoke_MemberName extractVMEntry(MethodHandle handle) {
+        Target_java_lang_invoke_LambdaForm lform = SubstrateUtil.cast(handle, Target_java_lang_invoke_MethodHandle.class).internalForm();
+        return lform.vmentry;
+    }
+}
diff --git a/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/stack/JavaStackFrameVisitor.java b/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/stack/JavaStackFrameVisitor.java
@@ -59,15 +59,9 @@ protected boolean visitDeoptimizedFrame(Pointer originalSP, CodePointer deoptStu
         return true;
     }
 
-    private static FrameSourceInfo interpreterToInterpretedMethodFrame(FrameInfoQueryResult frameInfo, Pointer sp) {
-        InterpreterSupport interpreter = InterpreterSupport.singleton();
-        VMError.guarantee(interpreter.isInterpreterRoot(frameInfo.getSourceClass()));
-        return interpreter.getInterpretedMethodFrameInfo(frameInfo, sp);
-    }
-
     protected final boolean dispatchPossiblyInterpretedFrame(FrameInfoQueryResult frameInfo, Pointer sp) {
-        if (InterpreterSupport.isEnabled() && InterpreterSupport.singleton().isInterpreterRoot(frameInfo.getSourceClass())) {
-            return visitFrame(interpreterToInterpretedMethodFrame(frameInfo, sp), sp);
+        if (InterpreterSupport.isEnabled() && InterpreterSupport.singleton().isInterpreterRoot(frameInfo)) {
+            return visitFrame(InterpreterSupport.singleton().getInterpretedMethodFrameInfo(frameInfo, sp), sp);
         } else {
             return visitFrame(frameInfo, sp);
         }
diff --git a/substratevm/src/com.oracle.svm.interpreter.metadata/src/com/oracle/svm/interpreter/metadata/InterpreterResolvedJavaMethod.java b/substratevm/src/com.oracle.svm.interpreter.metadata/src/com/oracle/svm/interpreter/metadata/InterpreterResolvedJavaMethod.java
@@ -31,8 +31,10 @@
 import static com.oracle.svm.espresso.classfile.Constants.ACC_SYNTHETIC;
 import static com.oracle.svm.espresso.classfile.Constants.ACC_VARARGS;
 import static com.oracle.svm.interpreter.metadata.Bytecodes.BREAKPOINT;
+import static com.oracle.svm.interpreter.metadata.CremaMethodAccess.toJVMCI;
 
 import java.lang.annotation.Annotation;
+import java.lang.reflect.Executable;
 import java.lang.reflect.Modifier;
 import java.lang.reflect.Type;
 import java.util.HashSet;
@@ -45,6 +47,7 @@
 import com.oracle.svm.core.FunctionPointerHolder;
 import com.oracle.svm.core.hub.RuntimeClassLoading;
 import com.oracle.svm.core.hub.registry.SymbolsSupport;
+import com.oracle.svm.core.invoke.Target_java_lang_invoke_MemberName;
 import com.oracle.svm.core.meta.MethodPointer;
 import com.oracle.svm.core.util.VMError;
 import com.oracle.svm.espresso.classfile.Constants;
@@ -739,4 +742,8 @@ public final void reprofile() {
     }
 
     // endregion Unimplemented methods
+
+    public static InterpreterResolvedJavaMethod fromMemberName(Target_java_lang_invoke_MemberName memberName) {
+        return toJVMCI((Executable) memberName.reflectAccess);
+    }
 }
diff --git a/substratevm/src/com.oracle.svm.interpreter/src/com/oracle/svm/interpreter/Interpreter.java b/substratevm/src/com.oracle.svm.interpreter/src/com/oracle/svm/interpreter/Interpreter.java
@@ -266,10 +266,15 @@
 
 import java.lang.invoke.MethodHandle;
 import java.lang.invoke.MethodType;
+import java.util.Objects;
 
+import com.oracle.svm.core.NeverInline;
+import com.oracle.svm.core.invoke.Target_java_lang_invoke_MemberName;
 import com.oracle.svm.core.jdk.InternalVMMethod;
+import com.oracle.svm.core.methodhandles.MethodHandleInterpreterUtils;
 import com.oracle.svm.core.util.VMError;
 import com.oracle.svm.espresso.classfile.ConstantPool;
+import com.oracle.svm.espresso.shared.meta.SignaturePolymorphicIntrinsic;
 import com.oracle.svm.interpreter.debug.DebuggerEvents;
 import com.oracle.svm.interpreter.debug.EventKind;
 import com.oracle.svm.interpreter.debug.SteppingControl;
@@ -364,7 +369,7 @@ public static Object execute(InterpreterResolvedJavaMethod method, InterpreterFr
     public static Object execute(InterpreterResolvedJavaMethod method, Object[] args, boolean forceStayInInterpreter) {
         InterpreterFrame frame = EspressoFrame.allocate(method.getMaxLocals(), method.getMaxStackSize(), args);
 
-        InterpreterUtil.guarantee(!method.isNative(), "trying to interpret native method %s", method);
+        InterpreterUtil.guarantee(!method.isNative() || method.getSignaturePolymorphicIntrinsic() != null, "trying to interpret native method %s", method);
 
         initializeFrame(frame, method);
         return execute0(method, frame, forceStayInInterpreter);
@@ -379,8 +384,13 @@ private static Object execute0(InterpreterResolvedJavaMethod method, Interpreter
                 assert lockTarget != null;
                 InterpreterToVM.monitorEnter(frame, nullCheck(lockTarget));
             }
-            int startTop = startingStackOffset(method.getMaxLocals());
-            return Root.executeBodyFromBCI(frame, method, 0, startTop, stayInInterpreter);
+            SignaturePolymorphicIntrinsic intrinsic = method.getSignaturePolymorphicIntrinsic();
+            if (intrinsic != null) {
+                return IntrinsicRoot.execute(frame, method, intrinsic, stayInInterpreter);
+            } else {
+                int startTop = startingStackOffset(method.getMaxLocals());
+                return Root.executeBodyFromBCI(frame, method, 0, startTop, stayInInterpreter);
+            }
         } finally {
             InterpreterToVM.releaseInterpreterFrameLocks(frame);
         }
@@ -467,8 +477,144 @@ private static void traceInterpreterException(InterpreterResolvedJavaMethod meth
                         .string("/top=").unsigned(top).newline();
     }
 
-    public static final class Root {
+    private static void traceIntrinsicEnter(InterpreterResolvedJavaMethod method, int indent, SignaturePolymorphicIntrinsic intrinsic) {
+        /* arguments to Log methods might have side-effects */
+        if (!InterpreterOptions.InterpreterTraceSupport.getValue()) {
+            return;
+        }
+
+        setLogIndent(indent + 2);
+        traceInterpreter(" ".repeat(indent)) //
+                        .string("[interp] Intrinsic Entered ") //
+                        .string(method.getDeclaringClass().getName()) //
+                        .string("::") //
+                        .string(method.getName()) //
+                        .string(method.getSignature().toMethodDescriptor()) //
+                        .string(" with iid=").string(intrinsic.name()) //
+                        .newline();
+    }
+
+    private static void traceInvokeBasic(InterpreterResolvedJavaMethod target, int indent) {
+        /* arguments to Log methods might have side-effects */
+        if (!InterpreterOptions.InterpreterTraceSupport.getValue()) {
+            return;
+        }
+
+        traceInterpreter(" ".repeat(indent)) //
+                        .string("invokeBasic target=") //
+                        .string(target.getDeclaringClass().getName()) //
+                        .string("::") //
+                        .string(target.getName()) //
+                        .string(target.getSignature().toMethodDescriptor()) //
+                        .newline();
+    }
 
+    private static void traceLinkTo(InterpreterResolvedJavaMethod target, SignaturePolymorphicIntrinsic intrinsic, int indent) {
+        /* arguments to Log methods might have side-effects */
+        if (!InterpreterOptions.InterpreterTraceSupport.getValue()) {
+            return;
+        }
+
+        traceInterpreter(" ".repeat(indent)) //
+                        .string(intrinsic.name())
+                        .string(" target=") //
+                        .string(target.getDeclaringClass().getName()) //
+                        .string("::") //
+                        .string(target.getName()) //
+                        .string(target.getSignature().toMethodDescriptor()) //
+                        .newline();
+    }
+
+    public static final class IntrinsicRoot {
+        @NeverInline("needed far stack walking")
+        public static Object execute(InterpreterFrame frame, InterpreterResolvedJavaMethod method, SignaturePolymorphicIntrinsic intrinsic, boolean forceStayInInterpreter) {
+            int indent = getLogIndent();
+            traceIntrinsicEnter(method, indent, intrinsic);
+            return switch (intrinsic) {
+                case InvokeBasic -> {
+                    MethodHandle mh = (MethodHandle) EspressoFrame.getThis(frame);
+                    Target_java_lang_invoke_MemberName vmentry = MethodHandleInterpreterUtils.extractVMEntry(mh);
+                    InterpreterResolvedJavaMethod target = InterpreterResolvedJavaMethod.fromMemberName(vmentry);
+                    Object[] calleeArgs = frame.getArguments();
+                    // This should integrate with the debugger GR-70801
+                    boolean preferStayInInterpreter = forceStayInInterpreter;
+                    traceInvokeBasic(target, indent);
+                    try {
+                        yield InterpreterToVM.dispatchInvocation(target, calleeArgs, false, forceStayInInterpreter, preferStayInInterpreter, false);
+                    } catch (SemanticJavaException e) {
+                        throw uncheckedThrow(e.getCause());
+                    }
+                }
+                case LinkToStatic, LinkToSpecial, LinkToVirtual, LinkToInterface -> {
+                    InterpreterResolvedJavaMethod resolutionSeed = getLinkToTarget(frame);
+                    InterpreterUnresolvedSignature signature = resolutionSeed.getSignature();
+                    Object[] basicArgs = unbasic(frame, signature, false);
+                    // This should integrate with the debugger GR-70801
+                    boolean preferStayInInterpreter = forceStayInInterpreter;
+                    traceLinkTo(resolutionSeed, intrinsic, indent);
+                    try {
+                        boolean isInvokeInterface = intrinsic == SignaturePolymorphicIntrinsic.LinkToInterface;
+                        boolean isVirtual = isInvokeInterface || intrinsic == SignaturePolymorphicIntrinsic.LinkToVirtual;
+                        Object result = InterpreterToVM.dispatchInvocation(resolutionSeed, basicArgs, isVirtual, forceStayInInterpreter, preferStayInInterpreter, isInvokeInterface);
+                        yield rebasic(result, signature.getReturnKind());
+                    } catch (SemanticJavaException e) {
+                        throw uncheckedThrow(e.getCause());
+                    }
+                }
+                default -> throw VMError.shouldNotReachHere(Objects.toString(intrinsic));
+            };
+        }
+    }
+
+    private static InterpreterResolvedJavaMethod getLinkToTarget(InterpreterFrame frame) {
+        Object[] arguments = frame.getArguments();
+        Target_java_lang_invoke_MemberName memberName = (Target_java_lang_invoke_MemberName) arguments[arguments.length - 1];
+        return InterpreterResolvedJavaMethod.fromMemberName(memberName);
+    }
+
+    private static Object[] unbasic(InterpreterFrame frame, InterpreterUnresolvedSignature targetSig, boolean inclReceiver) {
+        Object[] arguments = frame.getArguments();
+        int parameterCount = targetSig.getParameterCount(inclReceiver);
+        Object[] res = new Object[parameterCount];
+        int start = 0;
+        if (inclReceiver) {
+            res[start++] = arguments[0];
+        }
+        for (int i = start; i < parameterCount; i++) {
+            JavaKind kind = targetSig.getParameterKind(i - start);
+            res[i] = unbasic(arguments[i], kind);
+        }
+        return res;
+    }
+
+    // Transforms ints to sub-words
+    public static Object unbasic(Object arg, JavaKind kind) {
+        return switch (kind) {
+            case Boolean -> (int) arg != 0;
+            case Byte -> (byte) (int) arg;
+            case Char -> (char) (int) arg;
+            case Short -> (short) (int) arg;
+            default -> arg;
+        };
+    }
+
+    private static Object rebasic(Object value, JavaKind returnType) {
+        // @formatter:off
+        return switch (returnType) {
+            case Boolean -> stackIntToBoolean((int) value);
+            case Byte    -> (byte) value;
+            case Short   -> (short) value;
+            case Char    -> (char) value;
+            case Int, Long, Float, Double, Object
+                         -> value;
+            case Void    -> null; // void
+            default      -> throw VMError.shouldNotReachHereAtRuntime();
+        };
+        // @formatter:on
+    }
+
+    public static final class Root {
+        @NeverInline("needed far stack walking")
         private static Object executeBodyFromBCI(InterpreterFrame frame, InterpreterResolvedJavaMethod method, int startBCI, int startTop,
                         boolean forceStayInInterpreter) {
             int curBCI = startBCI;
diff --git a/substratevm/src/com.oracle.svm.interpreter/src/com/oracle/svm/interpreter/InterpreterFeature.java b/substratevm/src/com.oracle.svm.interpreter/src/com/oracle/svm/interpreter/InterpreterFeature.java
@@ -200,20 +200,26 @@ public void beforeAnalysis(BeforeAnalysisAccess access) {
         BuildTimeInterpreterUniverse.freshSingletonInstance();
         AnalysisMethod interpreterRoot = accessImpl.getMetaAccess().lookupJavaType(Interpreter.Root.class).getDeclaredMethods(false)[0];
 
-        accessImpl.registerAsRoot(interpreterRoot, true, "interpreter main loop");
         LocalVariableTable interpreterVariableTable = interpreterRoot.getLocalVariableTable();
-        int interpretedMethodSlot = findLocalSlotByName("method", interpreterVariableTable.getLocalsAt(0)); // parameter
+        int interpreterMethodSlot = findLocalSlotByName("method", interpreterVariableTable.getLocalsAt(0)); // parameter
         int interpreterFrameSlot = findLocalSlotByName("frame", interpreterVariableTable.getLocalsAt(0)); // parameter
         // Local variable, search all locals.
         int bciSlot = findLocalSlotByName("curBCI", interpreterVariableTable.getLocals());
 
-        ImageSingletons.add(InterpreterSupport.class, new InterpreterSupportImpl(bciSlot, interpretedMethodSlot, interpreterFrameSlot));
+        AnalysisMethod intrinsicRoot = accessImpl.getMetaAccess().lookupJavaType(Interpreter.IntrinsicRoot.class).getDeclaredMethods(false)[0];
+
+        LocalVariableTable intrinsicVariableTable = intrinsicRoot.getLocalVariableTable();
+        int intrinsicMethodSlot = findLocalSlotByName("method", intrinsicVariableTable.getLocalsAt(0)); // parameter
+        int intrinsicFrameSlot = findLocalSlotByName("frame", intrinsicVariableTable.getLocalsAt(0)); // parameter
+
+        ImageSingletons.add(InterpreterSupport.class, new InterpreterSupportImpl(bciSlot, interpreterMethodSlot, interpreterFrameSlot, intrinsicMethodSlot, intrinsicFrameSlot));
         ImageSingletons.add(InterpreterDirectivesSupport.class, new InterpreterDirectivesSupportImpl());
         ImageSingletons.add(InterpreterMethodPointerHolder.class, new InterpreterMethodPointerHolder());
 
         // Locals must be available at runtime to retrieve BCI, interpreted method and interpreter
         // frame.
         SubstrateCompilationDirectives.singleton().registerFrameInformationRequired(interpreterRoot);
+        SubstrateCompilationDirectives.singleton().registerFrameInformationRequired(intrinsicRoot);
 
         Method leaveMethod = ReflectionUtil.lookupMethod(InterpreterStubSection.class, "leaveInterpreterStub", CFunctionPointer.class, Pointer.class, long.class, long.class);
         leaveStub = accessImpl.getMetaAccess().lookupJavaMethod(leaveMethod);
diff --git a/substratevm/src/com.oracle.svm.interpreter/src/com/oracle/svm/interpreter/InterpreterSupportImpl.java b/substratevm/src/com.oracle.svm.interpreter/src/com/oracle/svm/interpreter/InterpreterSupportImpl.java
diff --git a/substratevm/src/com.oracle.svm.interpreter/src/com/oracle/svm/interpreter/InterpreterToVM.java b/substratevm/src/com.oracle.svm.interpreter/src/com/oracle/svm/interpreter/InterpreterToVM.java
diff --git a/substratevm/src/com.oracle.svm.interpreter/src/com/oracle/svm/interpreter/ResolvedInvokeDynamicConstant.java b/substratevm/src/com.oracle.svm.interpreter/src/com/oracle/svm/interpreter/ResolvedInvokeDynamicConstant.java
