Use image heap scanner to find method handle objects that are actually reachable.

Author: peter-hofer

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/jdk/VarHandleFeature.java

@@ -25,6 +25,7 @@
 package com.oracle.svm.core.jdk;
 
 import java.lang.invoke.MethodHandle;
+import java.lang.invoke.VarHandle;
 import java.lang.reflect.Field;
 import java.lang.reflect.Modifier;
 import java.util.HashMap;
@@ -76,11 +77,10 @@
  * unsafe accessed so that our static analysis is correct, and 2) recompute the field offsets from
  * the hosted offsets to the runtime offsets. Luckily, we have all information to reconstruct the
  * original {@link Field} (see {@link #findVarHandleField}). The registration for unsafe access
- * happens in an object replacer: the method {@link #processVarHandle} is called for every object
- * (and therefore every VarHandle) that is reachable in the image heap. The field offset
- * recomputations are registered for all classes manually (a bit of code duplication on our side),
- * but all recomputations use the same custom field value recomputation handler:
- * {@link VarHandleFieldOffsetComputer}.
+ * happens in {@link #processReachableHandle} which is called for every relevant object once it
+ * becomes reachable and so part of the image heap. The field offset recomputations are registered
+ * for all classes manually (a bit of code duplication on our side), but all recomputations use the
+ * same custom field value recomputation handler: {@link VarHandleFieldOffsetComputer}.
  *
  * For static fields, also the base of the Unsafe access needs to be changed to the static field
  * holder arrays defined in {@link StaticFieldsSupport}. We cannot do a recomputation to the actual
@@ -187,11 +187,6 @@ Field findVarHandleField(Object varHandle) {
         throw VMError.shouldNotReachHere("Could not find field referenced in VarHandle: " + type + ", offset = " + originalFieldOffset + ", isStatic = " + info.isStatic);
     }
 
-    @Override
-    public void duringSetup(DuringSetupAccess access) {
-        access.registerObjectReplacer(this::processVarHandle);
-    }
-
     @Override
     public void beforeAnalysis(BeforeAnalysisAccess access) {
         markAsUnsafeAccessed = access::registerAsUnsafeAccessed;
@@ -202,13 +197,21 @@ public void afterAnalysis(AfterAnalysisAccess access) {
         markAsUnsafeAccessed = null;
     }
 
+    public void registerHeapVarHandle(VarHandle varHandle) {
+        processReachableHandle(varHandle);
+    }
+
+    public void registerHeapMethodHandle(MethodHandle directMethodHandle) {
+        processReachableHandle(directMethodHandle);
+    }
+
     /**
      * Register all fields accessed by a VarHandle for an instance field or a static field as unsafe
      * accessed, which is necessary for correctness of the static analysis. We want to process every
-     * VarHandle only once, therefore we mark all VarHandle that were already processed in in
+     * VarHandle only once, therefore we mark all VarHandle that were already processed in
      * {@link #processedVarHandles}.
      */
-    private Object processVarHandle(Object obj) {
+    private Object processReachableHandle(Object obj) {
         VarHandleInfo info = infos.get(obj.getClass());
         if (info != null && processedVarHandles.putIfAbsent(obj, true) == null) {
             VMError.guarantee(markAsUnsafeAccessed != null, "New VarHandle found after static analysis");

substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/heap/SVMImageHeapScanner.java

@@ -24,8 +24,12 @@
  */
 package com.oracle.svm.hosted.heap;
 
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodType;
+import java.lang.invoke.VarHandle;
 import java.lang.reflect.Executable;
 import java.lang.reflect.Field;
+import java.lang.reflect.Member;
 import java.util.function.Consumer;
 
 import org.graalvm.collections.EconomicMap;
@@ -44,11 +48,13 @@
 import com.oracle.graal.pointsto.meta.AnalysisMetaAccess;
 import com.oracle.svm.core.BuildPhaseProvider;
 import com.oracle.svm.core.hub.DynamicHub;
+import com.oracle.svm.core.jdk.VarHandleFeature;
 import com.oracle.svm.core.util.VMError;
 import com.oracle.svm.hosted.ImageClassLoader;
 import com.oracle.svm.hosted.ameta.AnalysisConstantReflectionProvider;
 import com.oracle.svm.hosted.ameta.ReadableJavaField;
 import com.oracle.svm.hosted.meta.HostedMetaAccess;
+import com.oracle.svm.hosted.methodhandles.MethodHandleFeature;
 import com.oracle.svm.hosted.reflect.ReflectionHostedSupport;
 import com.oracle.svm.util.ReflectionUtil;
 
@@ -63,6 +69,10 @@ public class SVMImageHeapScanner extends ImageHeapScanner {
     private final Field economicMapImplEntriesField;
     private final Field economicMapImplHashArrayField;
     private final ReflectionHostedSupport reflectionSupport;
+    private final Class<?> memberNameClass;
+    private final MethodHandleFeature methodHandleSupport;
+    private final Class<?> directMethodHandleClass;
+    private final VarHandleFeature varHandleSupport;
 
     @SuppressWarnings("this-escape")
     public SVMImageHeapScanner(BigBang bb, ImageHeap imageHeap, ImageClassLoader loader, AnalysisMetaAccess metaAccess,
@@ -74,6 +84,10 @@ public SVMImageHeapScanner(BigBang bb, ImageHeap imageHeap, ImageClassLoader loa
         economicMapImplHashArrayField = ReflectionUtil.lookupField(economicMapImpl, "hashArray");
         ImageSingletons.add(ImageHeapScanner.class, this);
         reflectionSupport = ImageSingletons.lookup(ReflectionHostedSupport.class);
+        memberNameClass = getClass("java.lang.invoke.MemberName");
+        methodHandleSupport = ImageSingletons.lookup(MethodHandleFeature.class);
+        directMethodHandleClass = getClass("java.lang.invoke.DirectMethodHandle");
+        varHandleSupport = ImageSingletons.lookup(VarHandleFeature.class);
     }
 
     public static ImageHeapScanner instance() {
@@ -149,6 +163,14 @@ protected void onObjectReachable(ImageHeapConstant imageHeapConstant, ScanReason
                 reflectionSupport.registerHeapReflectionExecutable(executable, reason);
             } else if (object instanceof DynamicHub hub) {
                 reflectionSupport.registerHeapDynamicHub(hub, reason);
+            } else if (object instanceof VarHandle varHandle) {
+                varHandleSupport.registerHeapVarHandle(varHandle);
+            } else if (directMethodHandleClass.isInstance(object)) {
+                varHandleSupport.registerHeapMethodHandle((MethodHandle) object);
+            } else if (object instanceof MethodType methodType) {
+                methodHandleSupport.registerHeapMethodType(methodType);
+            } else if (memberNameClass.isInstance(object)) {
+                methodHandleSupport.registerHeapMemberName((Member) object);
             }
         }
     }

substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/methodhandles/MethodHandleFeature.java

@@ -30,6 +30,7 @@
 import java.lang.reflect.Array;
 import java.lang.reflect.Field;
 import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Member;
 import java.lang.reflect.Method;
 import java.util.Iterator;
 import java.util.Optional;
@@ -39,7 +40,6 @@
 
 import com.oracle.graal.pointsto.meta.AnalysisMetaAccess;
 import com.oracle.graal.pointsto.meta.AnalysisType;
-import com.oracle.svm.core.BuildPhaseProvider;
 import com.oracle.svm.core.feature.AutomaticallyRegisteredFeature;
 import com.oracle.svm.core.feature.InternalFeature;
 import com.oracle.svm.core.fieldvaluetransformer.FieldValueTransformerWithAvailability;
@@ -81,9 +81,6 @@
 @SuppressWarnings("unused")
 public class MethodHandleFeature implements InternalFeature {
 
-    private Class<?> memberNameClass;
-    private Method memberNameGetDeclaringClass;
-    private Method memberNameGetName;
     private Method memberNameIsMethod;
     private Method memberNameIsConstructor;
     private Method memberNameIsField;
@@ -106,9 +103,7 @@ public class MethodHandleFeature implements InternalFeature {
 
     @Override
     public void duringSetup(DuringSetupAccess access) {
-        memberNameClass = access.findClassByName("java.lang.invoke.MemberName");
-        memberNameGetDeclaringClass = ReflectionUtil.lookupMethod(memberNameClass, "getDeclaringClass");
-        memberNameGetName = ReflectionUtil.lookupMethod(memberNameClass, "getName");
+        Class<?> memberNameClass = access.findClassByName("java.lang.invoke.MemberName");
         memberNameIsMethod = ReflectionUtil.lookupMethod(memberNameClass, "isMethod");
         memberNameIsConstructor = ReflectionUtil.lookupMethod(memberNameClass, "isConstructor");
         memberNameIsField = ReflectionUtil.lookupMethod(memberNameClass, "isField");
@@ -126,8 +121,6 @@ public void duringSetup(DuringSetupAccess access) {
         Class<?> concurrentWeakInternSetClass = access.findClassByName("java.lang.invoke.MethodType$ConcurrentWeakInternSet");
         runtimeMethodTypeInternTable = ReflectionUtil.newInstance(concurrentWeakInternSetClass);
         concurrentWeakInternSetAdd = ReflectionUtil.lookupMethod(concurrentWeakInternSetClass, "add", Object.class);
-
-        access.registerObjectReplacer(this::registerSeenObject);
     }
 
     @Override
@@ -313,39 +306,28 @@ private static void registerVarHandleMethodsForReflection(FeatureAccess access,
         }
     }
 
-    private Object registerSeenObject(Object obj) {
-        if (!BuildPhaseProvider.isAnalysisFinished()) {
-            if (obj instanceof MethodType mt) {
-                registerMethodType(mt);
-            } else if (memberNameClass.isInstance(obj)) {
-                /*
-                 * We used to register only MemberName instances which are reachable from a
-                 * MethodHandle, but optimizations can eliminate a MethodHandle object in code which
-                 * we might never see otherwise and leave a MemberName object behind which is still
-                 * used for a call. Therefore, we register all MemberName instances in the image
-                 * heap, which should only be reachable via MethodHandle objects, in any case.
-                 */
-                registerMemberName(obj);
-            }
-        }
-        return obj;
-    }
-
-    private void registerMethodType(MethodType methodType) {
+    public void registerHeapMethodType(MethodType methodType) {
         try {
             concurrentWeakInternSetAdd.invoke(runtimeMethodTypeInternTable, methodType);
         } catch (ReflectiveOperationException e) {
             throw VMError.shouldNotReachHere(e);
         }
     }
 
-    private void registerMemberName(Object memberName) {
+    public void registerHeapMemberName(Member memberName) {
+        /*
+         * We used to register only MemberName instances which are reachable from MethodHandle
+         * objects, but code optimizations can eliminate a MethodHandle object which might never
+         * become reachable otherwise and leave a MemberName object behind which is still used for a
+         * call or field access. Therefore, we register all MemberName instances in the image heap,
+         * which should only come into existence via MethodHandle objects, in any case.
+         */
         try {
-            Class<?> declaringClass = (Class<?>) memberNameGetDeclaringClass.invoke(memberName);
+            Class<?> declaringClass = memberName.getDeclaringClass();
             boolean isMethod = (boolean) memberNameIsMethod.invoke(memberName);
             boolean isConstructor = (boolean) memberNameIsConstructor.invoke(memberName);
             boolean isField = (boolean) memberNameIsField.invoke(memberName);
-            String name = (isMethod || isField) ? (String) memberNameGetName.invoke(memberName) : null;
+            String name = (isMethod || isField) ? memberName.getName() : null;
             Class<?>[] paramTypes = null;
             if (isMethod || isConstructor) {
                 MethodType methodType = (MethodType) memberNameGetMethodType.invoke(memberName);