Crema: Resolve METHODTYPE constant pool entries

Author: gilles-duboscq

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

@@ -29,6 +29,7 @@
 
 import java.lang.invoke.CallSite;
 import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodType;
 import java.lang.reflect.AccessibleObject;
 import java.lang.reflect.Constructor;
 import java.lang.reflect.Field;
@@ -48,7 +49,9 @@
 import com.oracle.svm.core.annotate.RecomputeFieldValue.Kind;
 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.imagelayer.ImageLayerBuildingSupport;
 import com.oracle.svm.core.invoke.Target_java_lang_invoke_MemberName;
 import com.oracle.svm.core.layeredimagesingleton.MultiLayeredImageSingleton;
@@ -215,6 +218,10 @@ public static Target_java_lang_invoke_MemberName resolve(Target_java_lang_invoke
         return resolved;
     }
 
+    @Alias
+    @TargetElement(onlyWith = RuntimeClassLoading.WithRuntimeClassLoading.class)
+    public static native MethodType findMethodHandleType(Class<?> rtype, Class<?>[] ptypes);
+
     @Delete
     static native MethodHandle linkMethodHandleConstant(Class<?> callerClass, int refKind, Class<?> defc, String name, Object type);
 }

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.MethodType;
 import java.util.List;
 
 import org.graalvm.nativeimage.Platform;
@@ -270,6 +271,12 @@ public String resolveStringAt(int cpi) {
         return (String) resolvedEntry;
     }
 
+    public MethodType resolvedMethodTypeAt(char cpi, InterpreterResolvedObjectType accessingClass) {
+        Object resolvedEntry = resolvedAt(cpi, accessingClass);
+        assert resolvedEntry != null;
+        return (MethodType) resolvedEntry;
+    }
+
     @Override
     public int intAt(int index) {
         checkTag(index, CONSTANT_Integer);

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

@@ -264,6 +264,8 @@
 import static com.oracle.svm.interpreter.metadata.Bytecodes.TABLESWITCH;
 import static com.oracle.svm.interpreter.metadata.Bytecodes.WIDE;
 
+import java.lang.invoke.MethodType;
+
 import com.oracle.svm.core.jdk.InternalVMMethod;
 import com.oracle.svm.core.util.VMError;
 import com.oracle.svm.espresso.classfile.ConstantPool;
@@ -1207,6 +1209,9 @@ private static void loadConstant(InterpreterFrame frame, InterpreterResolvedJava
                 String string = pool.resolveStringAt(cpi);
                 putObject(frame, top, string);
             }
+            case METHODTYPE -> {
+                putObject(frame, top, resolveMethodType(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
@@ -1281,6 +1286,15 @@ private static int invoke(InterpreterFrame callerFrame, InterpreterResolvedJavaM
         return retStackEffect - Bytecodes.stackEffectOf(opcode);
     }
 
+    private static MethodType resolveMethodType(InterpreterConstantPool pool, InterpreterResolvedJavaMethod method, int opcode, char cpi) {
+        assert opcode == LDC || opcode == LDC_W;
+        try {
+            return pool.resolvedMethodTypeAt(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

@@ -24,11 +24,16 @@
  */
 package com.oracle.svm.interpreter;
 
+import java.lang.invoke.MethodType;
+
+import com.oracle.svm.core.hub.crema.CremaSupport;
 import com.oracle.svm.core.hub.registry.SymbolsSupport;
+import com.oracle.svm.core.methodhandles.Target_java_lang_invoke_MethodHandleNatives;
 import com.oracle.svm.core.util.VMError;
 import com.oracle.svm.espresso.classfile.ParserConstantPool;
 import com.oracle.svm.espresso.classfile.descriptors.Name;
 import com.oracle.svm.espresso.classfile.descriptors.Signature;
+import com.oracle.svm.espresso.classfile.descriptors.SignatureSymbols;
 import com.oracle.svm.espresso.classfile.descriptors.Symbol;
 import com.oracle.svm.espresso.classfile.descriptors.Type;
 import com.oracle.svm.espresso.classfile.descriptors.TypeSymbols;
@@ -62,10 +67,17 @@ protected Object resolve(int cpi, InterpreterResolvedObjectType accessingClass)
             case INTERFACE_METHOD_REF -> resolveInterfaceMethodRefConstant(cpi, accessingClass);
             case METHOD_REF -> resolveClassMethodRefConstant(cpi, accessingClass);
             case CLASS -> resolveClassConstant(cpi, accessingClass);
+            case METHODTYPE -> resolveMethodType(cpi, accessingClass);
             default -> throw VMError.unimplemented("Unimplemented CP resolution for " + tag);
         };
     }
 
+    private Object resolveMethodType(int cpi, InterpreterResolvedObjectType accessingClass) {
+        Symbol<Signature> sig = this.methodTypeSignature(cpi);
+        Symbol<Type>[] parsed = SymbolsSupport.getSignatures().parsed(sig);
+        return signatureToMethodType(parsed, accessingClass);
+    }
+
     private String resolveStringConstant(int stringIndex, @SuppressWarnings("unused") InterpreterResolvedObjectType accessingKlass) {
         int utf8Index = this.stringUtf8Index(stringIndex);
         String string = this.utf8At(utf8Index).toString().intern(); // intern?
@@ -223,4 +235,24 @@ private InterpreterResolvedJavaMethod resolveInterfaceMethodRefConstant(int inte
 
         return interfaceMethod;
     }
+
+    public static MethodType signatureToMethodType(Symbol<Type>[] signature, InterpreterResolvedObjectType accessingClass) {
+        Symbol<Type> rt = SignatureSymbols.returnType(signature);
+        int pcount = SignatureSymbols.parameterCount(signature);
+        Class<?>[] ptypes = new Class<?>[pcount];
+        Class<?> rtype;
+        for (int i = 0; i < pcount; i++) {
+            Symbol<Type> paramType = SignatureSymbols.parameterType(signature, i);
+            ptypes[i] = resolveSymbolAndAccessCheck(accessingClass, paramType);
+        }
+        rtype = resolveSymbolAndAccessCheck(accessingClass, rt);
+
+        return Target_java_lang_invoke_MethodHandleNatives.findMethodHandleType(rtype, ptypes);
+    }
+
+    private static Class<?> resolveSymbolAndAccessCheck(InterpreterResolvedObjectType accessingClass, Symbol<Type> type) {
+        Class<?> clazz = CremaSupport.singleton().resolveOrThrow(type, accessingClass);
+        // GR-62339 check access
+        return clazz;
+    }
 }