Crema: Resolve METHODHANDLE in constant pool

Use the JDK's `MethodHandleNatives.linkMethodHandleConstant` to create
the resolved `MethodHandle`.

Author: gilles-duboscq

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/methodhandles/Target_java_lang_invoke_MethodHandleNatives.java

@@ -223,7 +223,12 @@ public static Target_java_lang_invoke_MemberName resolve(Target_java_lang_invoke
     public static native MethodType findMethodHandleType(Class<?> rtype, Class<?>[] ptypes);
 
     @Delete
-    static native MethodHandle linkMethodHandleConstant(Class<?> callerClass, int refKind, Class<?> defc, String name, Object type);
+    @TargetElement(onlyWith = RuntimeClassLoading.NoRuntimeClassLoading.class, name = "linkMethodHandleConstant")
+    static native MethodHandle linkMethodHandleConstantDeleted(Class<?> callerClass, int refKind, Class<?> defc, String name, Object type);
+
+    @Alias
+    @TargetElement(onlyWith = RuntimeClassLoading.WithRuntimeClassLoading.class)
+    public static native MethodHandle linkMethodHandleConstant(Class<?> callerClass, int refKind, Class<?> defc, String name, Object type);
 }
 
 /**

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/methodhandles/Target_java_lang_invoke_MethodHandles_Lookup.java

@@ -35,13 +35,21 @@
 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.annotate.TargetElement;
 import com.oracle.svm.core.hub.DynamicHub;
+import com.oracle.svm.core.hub.RuntimeClassLoading;
 import com.oracle.svm.core.invoke.Target_java_lang_invoke_MemberName;
 
 @TargetClass(value = MethodHandles.class, innerClass = "Lookup")
 final class Target_java_lang_invoke_MethodHandles_Lookup {
     // Checkstyle: stop
     @Delete //
+    @TargetElement(onlyWith = RuntimeClassLoading.NoRuntimeClassLoading.class, name = "LOOKASIDE_TABLE") //
+    static ConcurrentHashMap<Target_java_lang_invoke_MemberName, MethodHandle> LOOKASIDE_TABLE_DELETED;
+
+    @Alias //
+    @RecomputeFieldValue(kind = RecomputeFieldValue.Kind.NewInstance, declClass = ConcurrentHashMap.class)//
+    @TargetElement(onlyWith = RuntimeClassLoading.WithRuntimeClassLoading.class) //
     static ConcurrentHashMap<Target_java_lang_invoke_MemberName, MethodHandle> LOOKASIDE_TABLE;
     // Checkstyle: resume
 
@@ -87,5 +95,6 @@ private IllegalAccessException makeAccessException(Class<?> targetClass) {
     }
 
     @Delete
+    @TargetElement(onlyWith = RuntimeClassLoading.NoRuntimeClassLoading.class) //
     native MethodHandle linkMethodHandleConstant(byte refKind, Class<?> defc, String name, Object type) throws ReflectiveOperationException;
 }

substratevm/src/com.oracle.svm.interpreter.metadata/src/com/oracle/svm/interpreter/metadata/InterpreterConstantPool.java

@@ -26,6 +26,7 @@
 
 import static com.oracle.svm.interpreter.metadata.Bytecodes.INVOKEDYNAMIC;
 
+import java.lang.invoke.MethodHandle;
 import java.lang.invoke.MethodType;
 import java.util.List;
 
@@ -271,6 +272,12 @@ public String resolveStringAt(int cpi) {
         return (String) resolvedEntry;
     }
 
+    public MethodHandle resolvedMethodHandleAt(int cpi, InterpreterResolvedObjectType accessingClass) {
+        Object resolvedEntry = resolvedAt(cpi, accessingClass);
+        assert resolvedEntry != null;
+        return (MethodHandle) resolvedEntry;
+    }
+
     public MethodType resolvedMethodTypeAt(char cpi, InterpreterResolvedObjectType accessingClass) {
         Object resolvedEntry = resolvedAt(cpi, accessingClass);
         assert resolvedEntry != null;

substratevm/src/com.oracle.svm.interpreter/src/com/oracle/svm/interpreter/Interpreter.java

@@ -264,6 +264,7 @@
 import static com.oracle.svm.interpreter.metadata.Bytecodes.TABLESWITCH;
 import static com.oracle.svm.interpreter.metadata.Bytecodes.WIDE;
 
+import java.lang.invoke.MethodHandle;
 import java.lang.invoke.MethodType;
 
 import com.oracle.svm.core.jdk.InternalVMMethod;
@@ -1212,6 +1213,9 @@ private static void loadConstant(InterpreterFrame frame, InterpreterResolvedJava
             case METHODTYPE -> {
                 putObject(frame, top, resolveMethodType(pool, method, opcode, cpi));
             }
+            case METHODHANDLE -> {
+                putObject(frame, top, resolveMethodHandle(pool, method, opcode, cpi));
+            }
             case INVOKEDYNAMIC -> {
                 // TODO(peterssen): GR-68576 Storing the pre-resolved appendix in the CP is a
                 // workaround for the JDWP debugger until proper INVOKEDYNAMIC resolution is
@@ -1295,6 +1299,15 @@ private static MethodType resolveMethodType(InterpreterConstantPool pool, Interp
         }
     }
 
+    private static MethodHandle resolveMethodHandle(InterpreterConstantPool pool, InterpreterResolvedJavaMethod method, int opcode, char cpi) {
+        assert opcode == LDC || opcode == LDC_W;
+        try {
+            return pool.resolvedMethodHandleAt(cpi, method.getDeclaringClass());
+        } catch (Throwable t) {
+            throw SemanticJavaException.raise(t);
+        }
+    }
+
     // region Class/Method/Field resolution
 
     private static InterpreterResolvedJavaType resolveType(InterpreterResolvedJavaMethod method, int opcode, char cpi) {

substratevm/src/com.oracle.svm.interpreter/src/com/oracle/svm/interpreter/RuntimeInterpreterConstantPool.java

@@ -43,6 +43,7 @@
 import com.oracle.svm.interpreter.metadata.InterpreterResolvedJavaType;
 import com.oracle.svm.interpreter.metadata.InterpreterResolvedObjectType;
 
+import jdk.vm.ci.meta.JavaType;
 import jdk.vm.ci.meta.UnresolvedJavaField;
 import jdk.vm.ci.meta.UnresolvedJavaMethod;
 import jdk.vm.ci.meta.UnresolvedJavaType;
@@ -68,10 +69,52 @@ protected Object resolve(int cpi, InterpreterResolvedObjectType accessingClass)
             case METHOD_REF -> resolveClassMethodRefConstant(cpi, accessingClass);
             case CLASS -> resolveClassConstant(cpi, accessingClass);
             case METHODTYPE -> resolveMethodType(cpi, accessingClass);
+            case METHODHANDLE -> resolveMethodHandle(cpi, accessingClass);
             default -> throw VMError.unimplemented("Unimplemented CP resolution for " + tag);
         };
     }
 
+    private Object resolveMethodHandle(int cpi, InterpreterResolvedObjectType accessingClass) {
+        Object mtype;
+        InterpreterResolvedJavaType mklass;
+        Symbol<Name> refName;
+
+        int memberIndex = this.methodHandleMemberIndex(cpi);
+
+        Tag refTag = this.tagAt(memberIndex);
+        if (refTag == Tag.METHOD_REF || refTag == Tag.INTERFACE_METHOD_REF) {
+            InterpreterResolvedJavaMethod target = this.resolvedMethodAt(accessingClass, memberIndex);
+            Symbol<Type>[] parsed = target.getParsedSymbolicSignature(CremaRuntimeAccess.getInstance().getSymbolPool());
+
+            mtype = signatureToMethodType(parsed, accessingClass);
+            /*
+             * we should use the klass from the method ref here rather than the declaring klass of
+             * the target this is because the resolved target might come from a default method and
+             * have an interface as declaring klass however if the refKind is invokeVirtual, it
+             * would be illegal to use the interface type
+             */
+            int holderIndex = this.memberClassIndex(memberIndex);
+            mklass = this.resolvedTypeAt(accessingClass, holderIndex);
+            refName = target.getSymbolicName();
+        } else {
+            assert refTag == Tag.FIELD_REF;
+            InterpreterResolvedJavaField field = this.resolvedFieldAt(accessingClass, memberIndex);
+            JavaType fieldType = field.getType();
+            if (fieldType instanceof InterpreterResolvedJavaType resolvedJavaType) {
+                mtype = resolvedJavaType.getJavaClass();
+            } else {
+                mtype = resolveSymbolAndAccessCheck(field.getDeclaringClass(), (UnresolvedJavaType) fieldType);
+            }
+            mklass = field.getDeclaringClass();
+            refName = field.getSymbolicName();
+        }
+        String mname = refName.toString();
+        int refKind = this.methodHandleRefKind(cpi);
+        return Target_java_lang_invoke_MethodHandleNatives.linkMethodHandleConstant(
+                        accessingClass.getJavaClass(), refKind,
+                        mklass.getJavaClass(), mname, mtype);
+    }
+
     private Object resolveMethodType(int cpi, InterpreterResolvedObjectType accessingClass) {
         Symbol<Signature> sig = this.methodTypeSignature(cpi);
         Symbol<Type>[] parsed = SymbolsSupport.getSignatures().parsed(sig);
@@ -255,4 +298,10 @@ private static Class<?> resolveSymbolAndAccessCheck(InterpreterResolvedObjectTyp
         // GR-62339 check access
         return clazz;
     }
+
+    private static Class<?> resolveSymbolAndAccessCheck(InterpreterResolvedObjectType accessingClass, UnresolvedJavaType type) {
+        Class<?> clazz = CremaSupport.singleton().resolveOrThrow(type, accessingClass);
+        // GR-62339 check access
+        return clazz;
+    }
 }