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/MethodHandleUtils.java

@@ -29,6 +29,7 @@
 import java.lang.invoke.MethodHandle;
 
 import com.oracle.svm.core.AlwaysInline;
+import com.oracle.svm.core.hub.RuntimeClassLoading;
 
 import sun.invoke.util.Wrapper;
 
@@ -127,4 +128,15 @@ public static short shortUnbox(Object retVal, Class<?> returnType) {
                 throw shouldNotReachHere("Unexpected type for unbox function");
         }
     }
+
+    /**
+     * Returns the resolved member if runtime class loading is enabled. Otherwise, always returns
+     * {@code null}.
+     */
+    public static ResolvedMember getResolvedMember(Target_java_lang_invoke_MemberName memberName) {
+        if (RuntimeClassLoading.isSupported()) {
+            return memberName.resolved;
+        }
+        return null;
+    }
 }

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

@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2025, 2025, 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.invoke;
+
+/**
+ * This interface should be implemented by the possible resolution results of member names.
+ * 
+ * @see Target_java_lang_invoke_MemberName#resolved
+ */
+public interface ResolvedMember {
+}

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.WithRuntimeClassLoading;
 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 = WithRuntimeClassLoading.class)//
+    public ResolvedMember 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.NoRuntimeClassLoading;
 
 /**
  * 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 = 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 = 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.NoRuntimeClassLoading;
 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 = 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 = 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,11 @@
 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.RuntimeClassLoading.NoRuntimeClassLoading;
+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 +87,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 +140,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 +180,7 @@ static Object linkToNative(Object... args) throws Throwable {
     }
 
     @Substitute
+    @TargetElement(onlyWith = NoRuntimeClassLoading.class)
     void maybeCustomize() {
         /*
          * JDK 8 update 60 added an additional customization possibility for method handles. For all
@@ -161,6 +189,7 @@ void maybeCustomize() {
     }
 
     @Delete
+    @TargetElement(onlyWith = NoRuntimeClassLoading.class)
     native void customize();
 }
 
@@ -173,6 +202,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