When enabled, let crema handle MethodHandle, MemberName, & LambdaForm

In that mode re-enable a number of JDK code path that are usually
substituted.

Author: gilles-duboscq

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/hub/crema/CremaSupport.java

@@ -32,13 +32,15 @@
 
 import com.oracle.svm.core.hub.DynamicHub;
 import com.oracle.svm.core.hub.registry.SymbolsSupport;
+import com.oracle.svm.core.invoke.Target_java_lang_invoke_MemberName;
 import com.oracle.svm.espresso.classfile.ParserKlass;
 import com.oracle.svm.espresso.classfile.descriptors.ByteSequence;
 import com.oracle.svm.espresso.classfile.descriptors.Signature;
 import com.oracle.svm.espresso.classfile.descriptors.Symbol;
 import com.oracle.svm.espresso.classfile.descriptors.Type;
 
 import jdk.vm.ci.meta.JavaType;
+import jdk.vm.ci.meta.ResolvedJavaField;
 import jdk.vm.ci.meta.ResolvedJavaMethod;
 import jdk.vm.ci.meta.ResolvedJavaType;
 
@@ -48,6 +50,20 @@ public interface CremaSupport {
 
     int getAfterFieldsOffset(DynamicHub hub);
 
+    Target_java_lang_invoke_MemberName resolveMemberName(Target_java_lang_invoke_MemberName mn, Class<?> caller);
+
+    Object invokeBasic(Target_java_lang_invoke_MemberName memberName, Object methodHandle, Object[] args);
+
+    Object linkToVirtual(Object[] args);
+
+    Object linkToStatic(Object[] args);
+
+    Object linkToSpecial(Object[] args);
+
+    Object linkToInterface(Object[] args);
+
+    Object getStaticStorage(ResolvedJavaField resolved);
+
     interface CremaDispatchTable {
         int vtableLength();
 

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

@@ -34,6 +34,8 @@
 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.RuntimeClassLoading;
 import com.oracle.svm.core.methodhandles.Target_java_lang_invoke_MethodHandleNatives;
 import com.oracle.svm.core.util.BasedOnJDKFile;
 import com.oracle.svm.core.util.VMError;
@@ -46,7 +48,16 @@ public final class Target_java_lang_invoke_MemberName {
     @Inject @RecomputeFieldValue(kind = RecomputeFieldValue.Kind.Reset)//
     public MethodHandleIntrinsic intrinsic;
 
+    /**
+     * This is used by crema to store metadata for the resolved field or method.
+     */
+    @Inject @RecomputeFieldValue(kind = RecomputeFieldValue.Kind.Reset)//
+    @TargetElement(onlyWith = RuntimeClassLoading.WithRuntimeClassLoading.class)//
+    public Object resolved;
+
+    @Alias public Class<?> clazz;
     @Alias public String name;
+    @Alias public Object type;
     @Alias public int flags;
     @Alias public Object resolution;
 

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

@@ -38,6 +38,7 @@
 import com.oracle.svm.core.annotate.TargetClass;
 import com.oracle.svm.core.annotate.TargetElement;
 import com.oracle.svm.core.fieldvaluetransformer.NewEmptyArrayFieldValueTransformer;
+import com.oracle.svm.core.hub.RuntimeClassLoading;
 
 /**
  * In the JDK implementation of method handles, each bound method handle is an instance of a
@@ -73,7 +74,7 @@ final class Target_java_lang_invoke_BoundMethodHandle {
  * We hijack the species with no bound parameters for our implementation since it already inherits
  * from BoundMethodHandle and doesn't contain any superfluous members.
  */
-@TargetClass(className = "java.lang.invoke.SimpleMethodHandle")
+@TargetClass(className = "java.lang.invoke.SimpleMethodHandle", onlyWith = RuntimeClassLoading.NoRuntimeClassLoading.class)
 final class Target_java_lang_invoke_SimpleMethodHandle {
     /*
      * Since we represent all the bound method handle species with the basic one, the species data
@@ -130,7 +131,7 @@ Target_java_lang_invoke_BoundMethodHandle copyWith(MethodType type, Target_java_
 }
 
 /* Hardcoded species, needs a special case to avoid initialization */
-@TargetClass(className = "java.lang.invoke.BoundMethodHandle", innerClass = "Species_L")
+@TargetClass(className = "java.lang.invoke.BoundMethodHandle", innerClass = "Species_L", onlyWith = RuntimeClassLoading.NoRuntimeClassLoading.class)
 final class Target_java_lang_invoke_BoundMethodHandle_Species_L {
     @Substitute
     static Target_java_lang_invoke_BoundMethodHandle make(MethodType mt, Target_java_lang_invoke_LambdaForm lf, Object argL0) {

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

@@ -30,6 +30,8 @@
 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.RuntimeClassLoading;
 import com.oracle.svm.core.invoke.Target_java_lang_invoke_MemberName;
 import com.oracle.svm.util.ReflectionUtil;
 
@@ -42,10 +44,18 @@ public final class Target_java_lang_invoke_LambdaForm {
     @Alias @RecomputeFieldValue(kind = RecomputeFieldValue.Kind.Custom, declClass = LambdaFormCacheTransformer.class)//
     volatile Object transformCache;
 
+    // isCompiled needs to be reset if vmentry is reset
+    @Alias @RecomputeFieldValue(kind = RecomputeFieldValue.Kind.Reset)//
+    boolean isCompiled;
+
     @Alias
     native String lambdaName();
 
+    @Alias
+    native void prepare();
+
     @Substitute
+    @TargetElement(onlyWith = RuntimeClassLoading.NoRuntimeClassLoading.class)
     void compileToBytecode() {
         /*
          * Those lambda form types are required to be precompiled to bytecode during method handles
@@ -62,6 +72,7 @@ void compileToBytecode() {
      */
     @Substitute
     @SuppressWarnings("static-method")
+    @TargetElement(onlyWith = RuntimeClassLoading.NoRuntimeClassLoading.class)
     private boolean forceInterpretation() {
         return true;
     }

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

@@ -44,7 +44,10 @@
 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.classinitialization.EnsureClassInitializedNode;
+import com.oracle.svm.core.hub.RuntimeClassLoading;
+import com.oracle.svm.core.hub.crema.CremaSupport;
 import com.oracle.svm.core.invoke.MethodHandleUtils;
 import com.oracle.svm.core.invoke.Target_java_lang_invoke_MemberName;
 import com.oracle.svm.core.reflect.SubstrateAccessor;
@@ -83,6 +86,17 @@ final class Target_java_lang_invoke_MethodHandle {
     /* All MethodHandle.invoke* methods funnel through here. */
     @Substitute(polymorphicSignature = true)
     Object invokeBasic(Object... args) throws Throwable {
+        if (RuntimeClassLoading.isSupported()) {
+            Target_java_lang_invoke_LambdaForm form = internalForm();
+            Target_java_lang_invoke_MemberName vmentry = form.vmentry;
+            if (vmentry == null) {
+                // if the form comes from the image, its entry might have been reset
+                form.prepare();
+                vmentry = form.vmentry;
+                assert vmentry != null;
+            }
+            return CremaSupport.singleton().invokeBasic(vmentry, this, args);
+        }
         Target_java_lang_invoke_MemberName memberName = internalMemberName();
         Object ret;
         if (memberName != null) {
@@ -125,21 +139,33 @@ Object invokeExact(Object... args) throws Throwable {
 
     @Substitute(polymorphicSignature = true)
     static Object linkToVirtual(Object... args) throws Throwable {
+        if (RuntimeClassLoading.isSupported()) {
+            return CremaSupport.singleton().linkToVirtual(args);
+        }
         return Util_java_lang_invoke_MethodHandle.linkTo(args);
     }
 
     @Substitute(polymorphicSignature = true)
     static Object linkToStatic(Object... args) throws Throwable {
+        if (RuntimeClassLoading.isSupported()) {
+            return CremaSupport.singleton().linkToStatic(args);
+        }
         return Util_java_lang_invoke_MethodHandle.linkTo(args);
     }
 
     @Substitute(polymorphicSignature = true)
     static Object linkToInterface(Object... args) throws Throwable {
+        if (RuntimeClassLoading.isSupported()) {
+            return CremaSupport.singleton().linkToInterface(args);
+        }
         return Util_java_lang_invoke_MethodHandle.linkTo(args);
     }
 
     @Substitute(polymorphicSignature = true)
     static Object linkToSpecial(Object... args) throws Throwable {
+        if (RuntimeClassLoading.isSupported()) {
+            return CremaSupport.singleton().linkToSpecial(args);
+        }
         return Util_java_lang_invoke_MethodHandle.linkTo(args);
     }
 
@@ -153,6 +179,7 @@ static Object linkToNative(Object... args) throws Throwable {
     }
 
     @Substitute
+    @TargetElement(onlyWith = RuntimeClassLoading.NoRuntimeClassLoading.class)
     void maybeCustomize() {
         /*
          * JDK 8 update 60 added an additional customization possibility for method handles. For all
@@ -161,6 +188,7 @@ void maybeCustomize() {
     }
 
     @Delete
+    @TargetElement(onlyWith = RuntimeClassLoading.NoRuntimeClassLoading.class)
     native void customize();
 }
 
@@ -173,6 +201,11 @@ static Object linkTo(Object... args) throws Throwable {
     }
 
     static Object invokeInternal(Target_java_lang_invoke_MemberName memberName, MethodType methodType, Object... args) throws Throwable {
+        /*
+         * This is never reached in the "crema" case since invokeBasic & linkTo* are instead
+         * redirected to CremaSupport.
+         */
+        assert !RuntimeClassLoading.isSupported();
         /*
          * The method handle may have been resolved at build time. If that is the case, the
          * SVM-specific information needed to perform the invoke is not stored in the handle yet, so

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

@@ -45,13 +45,12 @@
 import com.oracle.svm.core.annotate.Alias;
 import com.oracle.svm.core.annotate.AnnotateOriginal;
 import com.oracle.svm.core.annotate.Delete;
-import com.oracle.svm.core.annotate.RecomputeFieldValue;
-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.hub.crema.CremaSupport;
 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;
@@ -61,6 +60,7 @@
 import com.oracle.svm.util.ReflectionUtil;
 
 import jdk.graal.compiler.debug.GraalError;
+import jdk.vm.ci.meta.ResolvedJavaField;
 import sun.invoke.util.VerifyAccess;
 
 /**
@@ -127,7 +127,7 @@ private static void expand(Target_java_lang_invoke_MemberName self) {
 
     @Substitute
     private static long objectFieldOffset(Target_java_lang_invoke_MemberName self) {
-        if (self.reflectAccess == null && self.intrinsic == null) {
+        if (self.reflectAccess == null && self.intrinsic == null && self.resolved == null) {
             throw new InternalError("Unresolved field");
         }
         if (!self.isField() || self.isStatic()) {
@@ -138,12 +138,15 @@ private static long objectFieldOffset(Target_java_lang_invoke_MemberName self) {
         if (self.intrinsic != null) {
             return -1L;
         }
+        if (RuntimeClassLoading.isSupported() && self.resolved != null) {
+            return ((ResolvedJavaField) self.resolved).getOffset();
+        }
         return UnsafeFieldUtil.getFieldOffset(SubstrateUtil.cast(self.reflectAccess, Target_java_lang_reflect_Field.class));
     }
 
     @Substitute
     private static long staticFieldOffset(Target_java_lang_invoke_MemberName self) {
-        if (self.reflectAccess == null && self.intrinsic == null) {
+        if (self.reflectAccess == null && self.intrinsic == null && self.resolved == null) {
             throw new InternalError("Unresolved field");
         }
         if (!self.isField() || !self.isStatic()) {
@@ -153,17 +156,23 @@ private static long staticFieldOffset(Target_java_lang_invoke_MemberName self) {
         if (self.intrinsic != null) {
             return -1L;
         }
+        if (RuntimeClassLoading.isSupported() && self.resolved != null) {
+            return ((ResolvedJavaField) self.resolved).getOffset();
+        }
         return UnsafeFieldUtil.getFieldOffset(SubstrateUtil.cast(self.reflectAccess, Target_java_lang_reflect_Field.class));
     }
 
     @Substitute
     private static Object staticFieldBase(Target_java_lang_invoke_MemberName self) {
-        if (self.reflectAccess == null) {
+        if (self.reflectAccess == null && self.resolved == null) {
             throw new InternalError("Unresolved field");
         }
         if (!self.isField() || !self.isStatic()) {
             throw new InternalError("Static field required");
         }
+        if (RuntimeClassLoading.isSupported() && self.resolved != null) {
+            return CremaSupport.singleton().getStaticStorage((ResolvedJavaField) self.resolved);
+        }
         Field field = (Field) self.reflectAccess;
         int layerNumber;
         if (ImageLayerBuildingSupport.buildingImageLayer()) {
@@ -209,7 +218,7 @@ public static Target_java_lang_invoke_MemberName resolve(Target_java_lang_invoke
                     throws LinkageError, ClassNotFoundException {
         Class<?> declaringClass = self.getDeclaringClass();
         Target_java_lang_invoke_MemberName resolved = Util_java_lang_invoke_MethodHandleNatives.resolve(self, caller, speculativeResolve);
-        assert resolved == null || resolved.reflectAccess != null || resolved.intrinsic != null;
+        assert resolved == null || resolved.reflectAccess != null || resolved.intrinsic != null || resolved.resolved != null;
         if (resolved != null && resolved.reflectAccess != null && caller != null &&
                         !Util_java_lang_invoke_MethodHandleNatives.verifyAccess(declaringClass, resolved.reflectAccess.getDeclaringClass(), resolved.reflectAccess.getModifiers(), caller,
                                         lookupMode)) {
@@ -317,14 +326,24 @@ private static void forceAccess(AccessibleObject target) {
 
     @SuppressWarnings("unused")
     public static Target_java_lang_invoke_MemberName resolve(Target_java_lang_invoke_MemberName self, Class<?> caller, boolean speculativeResolve)
-                    throws LinkageError, ClassNotFoundException {
-        if (self.reflectAccess != null || self.intrinsic != null) {
-            return self;
-        }
+                    throws LinkageError {
         Class<?> declaringClass = self.getDeclaringClass();
         if (declaringClass == null) {
             return null;
         }
+        if (RuntimeClassLoading.isSupported()) {
+            try {
+                return CremaSupport.singleton().resolveMemberName(self, caller);
+            } catch (Throwable t) {
+                if (speculativeResolve) {
+                    return null;
+                }
+                throw t;
+            }
+        }
+        if (self.reflectAccess != null || self.intrinsic != null) {
+            return self;
+        }
 
         /* Intrinsic methods */
         self.intrinsic = MethodHandleIntrinsicImpl.resolve(self);
@@ -397,30 +416,3 @@ static boolean verifyAccess(Class<?> refc, Class<?> defc, int mods, Class<?> loo
         }
     }
 }
-
-@TargetClass(className = "java.lang.invoke.MethodHandleNatives", innerClass = "Constants")
-final class Target_java_lang_invoke_MethodHandleNatives_Constants {
-    // Checkstyle: stop
-    @Alias @RecomputeFieldValue(isFinal = true, kind = Kind.None) static int MN_IS_METHOD;
-    @Alias @RecomputeFieldValue(isFinal = true, kind = Kind.None) static int MN_IS_CONSTRUCTOR;
-    @Alias @RecomputeFieldValue(isFinal = true, kind = Kind.None) static int MN_IS_FIELD;
-    @Alias @RecomputeFieldValue(isFinal = true, kind = Kind.None) static int MN_IS_TYPE;
-    @Alias @RecomputeFieldValue(isFinal = true, kind = Kind.None) static int MN_CALLER_SENSITIVE;
-    @Alias @RecomputeFieldValue(isFinal = true, kind = Kind.None) static int MN_REFERENCE_KIND_SHIFT;
-
-    /**
-     * Constant pool reference-kind codes, as used by CONSTANT_MethodHandle CP entries.
-     */
-    @Alias @RecomputeFieldValue(isFinal = true, kind = Kind.None) static byte REF_NONE;  // null
-    @Alias @RecomputeFieldValue(isFinal = true, kind = Kind.None) static byte REF_getField;
-    @Alias @RecomputeFieldValue(isFinal = true, kind = Kind.None) static byte REF_getStatic;
-    @Alias @RecomputeFieldValue(isFinal = true, kind = Kind.None) static byte REF_putField;
-    @Alias @RecomputeFieldValue(isFinal = true, kind = Kind.None) static byte REF_putStatic;
-    @Alias @RecomputeFieldValue(isFinal = true, kind = Kind.None) static byte REF_invokeVirtual;
-    @Alias @RecomputeFieldValue(isFinal = true, kind = Kind.None) static byte REF_invokeStatic;
-    @Alias @RecomputeFieldValue(isFinal = true, kind = Kind.None) static byte REF_invokeSpecial;
-    @Alias @RecomputeFieldValue(isFinal = true, kind = Kind.None) static byte REF_newInvokeSpecial;
-    @Alias @RecomputeFieldValue(isFinal = true, kind = Kind.None) static byte REF_invokeInterface;
-    @Alias @RecomputeFieldValue(isFinal = true, kind = Kind.None) static byte REF_LIMIT;
-    // Checkstyle: resume
-}