[GR-66389] Add InterceptJSInvokeNodes in WasmGC backend

PullRequest: graal/21209

Author: patrick96

web-image/src/com.oracle.svm.hosted.webimage.test/src/com/oracle/svm/hosted/webimage/test/spec/JS_JTT_JSAnnotation.java

@@ -51,20 +51,13 @@
 public class JS_JTT_JSAnnotation extends JTTTestSuite {
 
     // @formatter:off
-    // TODO GR-62854 Remove Runnable#run once JSBodyFeature is enabled for WasmGC and InterceptJSInvokeTypeFlow is used
     private static final String REFLECT_CONFIG = """
 [
   {
     "name" : "java.lang.String",
     "methods": [
         {"name" : "indexOf"}
     ]
-  },
-  {
-    "name" : "java.lang.Runnable",
-    "methods": [
-        {"name" : "run"}
-    ]
   }
 ]""";
 

web-image/src/com.oracle.svm.hosted.webimage/src/com/oracle/svm/hosted/webimage/codegen/JSBodyFeature.java

@@ -24,11 +24,7 @@
  */
 package com.oracle.svm.hosted.webimage.codegen;
 
-import java.lang.reflect.Executable;
-import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
-import java.util.List;
-import java.util.Set;
 
 import org.graalvm.nativeimage.AnnotationAccess;
 import org.graalvm.nativeimage.Platforms;
@@ -46,11 +42,8 @@
 import com.oracle.svm.core.feature.InternalFeature;
 import com.oracle.svm.core.nodes.SubstrateMethodCallTargetNode;
 import com.oracle.svm.hosted.FeatureImpl;
-import com.oracle.svm.hosted.ImageClassLoader;
-import com.oracle.svm.hosted.webimage.codegen.node.InterceptJSInvokeNode;
 import com.oracle.svm.hosted.webimage.codegen.oop.ClassWithMirrorLowerer;
 import com.oracle.svm.hosted.webimage.js.JSObjectAccessMethodSupport;
-import com.oracle.svm.hosted.webimage.util.ReflectUtil;
 import com.oracle.svm.util.ReflectionUtil;
 import com.oracle.svm.webimage.api.Nothing;
 import com.oracle.svm.webimage.platform.WebImageJSPlatform;
@@ -79,17 +72,6 @@
 @AutomaticallyRegisteredFeature
 @Platforms(WebImageJSPlatform.class)
 public final class JSBodyFeature implements InternalFeature {
-    // The set of methods that are potentially overridden by a JS-annotated method.
-    private Set<Method> jsOverridden;
-
-    @Override
-    public void afterRegistration(AfterRegistrationAccess access) {
-        FeatureImpl.AfterRegistrationAccessImpl accessImpl = (FeatureImpl.AfterRegistrationAccessImpl) access;
-        ImageClassLoader imageClassLoader = accessImpl.getImageClassLoader();
-        List<Class<?>> allClasses = imageClassLoader.findSubclasses(Object.class, true);
-        jsOverridden = ReflectUtil.findBaseMethodsOfJSAnnotated(allClasses);
-    }
-
     @Override
     public void registerGraphBuilderPlugins(Providers providers, GraphBuilderConfiguration.Plugins plugins, ParsingReason reason) {
         plugins.appendNodePlugin(new NodePlugin() {
@@ -98,28 +80,6 @@ public boolean handleInvoke(GraphBuilderContext b, ResolvedJavaMethod method, Va
                 if (AnnotationAccess.isAnnotationPresent(method.getDeclaringClass(), JS.Import.class)) {
                     ((AnalysisType) method.getDeclaringClass()).registerAsInstantiated("JS.Import classes might be allocated in JavaScript. We need to tell the static analysis about that");
                 }
-                if (canBeJavaScriptCall((AnalysisMethod) method)) {
-                    InterceptJSInvokeNode intercept = b.append(new InterceptJSInvokeNode(method, b.bci()));
-                    for (final ValueNode arg : args) {
-                        intercept.arguments().add(arg);
-                    }
-                }
-                return false;
-            }
-
-            private boolean canBeJavaScriptCall(AnalysisMethod method) {
-                Executable executable;
-                try {
-                    executable = method.getJavaMethod();
-                } catch (Throwable e) {
-                    // Either a substituted method, or a method with a malformed bytecode signature.
-                    // This is most likely not a JS-annotated method.
-                    return false;
-                }
-                if (executable instanceof Method) {
-                    return jsOverridden.contains(executable);
-                }
-                // Not a normal method (constructor).
                 return false;
             }
 
@@ -314,9 +274,4 @@ private static void findJSObjectSubtypes(FeatureImpl.DuringAnalysisAccessImpl ac
             access.requireAnalysisIteration();
         }
     }
-
-    @Override
-    public void afterAnalysis(AfterAnalysisAccess access) {
-        jsOverridden = null;
-    }
 }

web-image/src/com.oracle.svm.hosted.webimage/src/com/oracle/svm/hosted/webimage/codegen/JSBodyTypeFlowFeature.java

@@ -0,0 +1,112 @@
+/*
+ * 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.hosted.webimage.codegen;
+
+import java.lang.reflect.Executable;
+import java.lang.reflect.Method;
+import java.util.Set;
+
+import org.graalvm.nativeimage.Platforms;
+
+import com.oracle.graal.pointsto.meta.AnalysisMethod;
+import com.oracle.svm.core.ParsingReason;
+import com.oracle.svm.core.feature.AutomaticallyRegisteredFeature;
+import com.oracle.svm.core.feature.InternalFeature;
+import com.oracle.svm.hosted.FeatureImpl;
+import com.oracle.svm.hosted.ImageClassLoader;
+import com.oracle.svm.hosted.webimage.codegen.node.InterceptJSInvokeNode;
+import com.oracle.svm.hosted.webimage.util.ReflectUtil;
+import com.oracle.svm.webimage.platform.WebImagePlatform;
+
+import jdk.graal.compiler.nodes.ValueNode;
+import jdk.graal.compiler.nodes.graphbuilderconf.GraphBuilderConfiguration;
+import jdk.graal.compiler.nodes.graphbuilderconf.GraphBuilderContext;
+import jdk.graal.compiler.nodes.graphbuilderconf.NodePlugin;
+import jdk.graal.compiler.phases.util.Providers;
+import jdk.vm.ci.meta.ResolvedJavaMethod;
+
+/**
+ * Inserts {@link InterceptJSInvokeNode} into the IR at any invoke that may target a
+ * {@link org.graalvm.webimage.api.JS} annotated method to deal with types that may leak to
+ * JavaScript.
+ * <p>
+ * TODO GR-62854 Merge into JSBodyFeature once it is enabled by default
+ */
+@AutomaticallyRegisteredFeature
+@Platforms(WebImagePlatform.class)
+public class JSBodyTypeFlowFeature implements InternalFeature {
+    /**
+     * The set of methods that are potentially overridden by a JS-annotated method.
+     * <p>
+     * Any call to such a method needs to have a {@link InterceptJSInvokeNode} attached to it.
+     */
+    private Set<Method> jsOverridden;
+
+    @Override
+    public void afterRegistration(AfterRegistrationAccess access) {
+        FeatureImpl.AfterRegistrationAccessImpl accessImpl = (FeatureImpl.AfterRegistrationAccessImpl) access;
+        ImageClassLoader imageClassLoader = accessImpl.getImageClassLoader();
+        jsOverridden = ReflectUtil.findBaseMethodsOfJSAnnotated(imageClassLoader);
+    }
+
+    @Override
+    public void registerGraphBuilderPlugins(Providers providers, GraphBuilderConfiguration.Plugins plugins, ParsingReason reason) {
+        plugins.appendNodePlugin(new NodePlugin() {
+            @Override
+            public boolean handleInvoke(GraphBuilderContext b, ResolvedJavaMethod method, ValueNode[] args) {
+                if (canBeJavaScriptCall((AnalysisMethod) method)) {
+                    InterceptJSInvokeNode intercept = b.append(new InterceptJSInvokeNode(method, b.bci()));
+                    for (final ValueNode arg : args) {
+                        intercept.arguments().add(arg);
+                    }
+                }
+                return false;
+            }
+
+            private boolean canBeJavaScriptCall(AnalysisMethod method) {
+                Executable executable;
+                try {
+                    executable = method.getJavaMethod();
+                } catch (Throwable e) {
+                    // Either a substituted method, or a method with a malformed bytecode signature.
+                    // This is most likely not a JS-annotated method.
+                    return false;
+                }
+                if (executable instanceof Method) {
+                    return jsOverridden.contains(executable);
+                }
+                // Not a normal method (constructor).
+                return false;
+            }
+
+        });
+    }
+
+    @Override
+    public void afterAnalysis(AfterAnalysisAccess access) {
+        jsOverridden = null;
+    }
+}

web-image/src/com.oracle.svm.hosted.webimage/src/com/oracle/svm/hosted/webimage/util/ReflectUtil.java

@@ -25,10 +25,7 @@
 
 package com.oracle.svm.hosted.webimage.util;
 
-import java.lang.annotation.Annotation;
-import java.lang.reflect.GenericSignatureFormatError;
 import java.lang.reflect.Method;
-import java.lang.reflect.Modifier;
 import java.util.Arrays;
 import java.util.HashSet;
 import java.util.LinkedHashSet;
@@ -42,6 +39,8 @@
 
 import com.oracle.graal.pointsto.infrastructure.OriginalClassProvider;
 import com.oracle.graal.pointsto.infrastructure.OriginalMethodProvider;
+import com.oracle.svm.hosted.ImageClassLoader;
+import com.oracle.svm.util.ReflectionUtil;
 
 import jdk.vm.ci.meta.MetaAccessProvider;
 import jdk.vm.ci.meta.ResolvedJavaMethod;
@@ -169,92 +168,42 @@ private static void findAllInterfaces(Class<?> type, LinkedHashSet<Class<?>> int
         }
     }
 
-    public static Set<Method> findBaseMethodsOfJSAnnotated(List<Class<?>> allClasses) {
-        HashSet<Method> set = new HashSet<>();
-        for (Class<?> cls : allClasses) {
-            Method[] declaredMethods;
-            try {
-                declaredMethods = cls.getDeclaredMethods();
-            } catch (NoClassDefFoundError e) {
-                // Some classes may be missing on the class path, but these will not be used by the
-                // image.
-                continue;
-            } catch (VerifyError | ClassFormatError | ClassCircularityError | IllegalAccessError e) {
-                // Skip the corrupted class encountered during the analysis.
-                System.err.printf(
-                                "Skipped JS annotated base methods lookup for class %s.%nError: %s, Message: %s.%n",
-                                cls.getName(),
-                                e.getClass().getName(),
-                                e.getMessage());
-                continue;
-            }
-            for (Method method : declaredMethods) {
-                Annotation jsAnnotation;
-                try {
-                    jsAnnotation = method.getAnnotation(JS.class);
-                } catch (GenericSignatureFormatError e) {
-                    // Skip the corrupted method encountered during the analysis.
-                    System.err.printf(
-                                    "Skipped JS annotated base methods lookup for method %s::%s.%nError: %s, Message: %s.%n",
-                                    method.getDeclaringClass().getName(),
-                                    method.getName(),
-                                    e.getClass().getName(),
-                                    e.getMessage());
-                    continue;
-                }
-                if (jsAnnotation != null) {
-                    markBaseMethods(method, cls, set, new HashSet<>());
-                }
-            }
-        }
-        return set;
-    }
+    /**
+     * Finds all methods annotated with {@link JS} as well as all the methods it overrides.
+     */
+    public static Set<Method> findBaseMethodsOfJSAnnotated(ImageClassLoader imageClassLoader) {
+        Set<Method> methods = new HashSet<>();
 
-    private static void markBaseMethods(Method method, Class<?> type, HashSet<Method> set, HashSet<Class<?>> seen) {
-        if (seen.contains(type)) {
-            // We already saw this type -- we skip it to avoid traversing an interface type twice.
-            return;
-        }
-        seen.add(type);
-        if (!set.contains(method)) {
-            set.add(method);
-        }
-        if (Modifier.isPrivate(method.getModifiers()) || Modifier.isStatic(method.getModifiers())) {
-            // Private and static methods cannot override anything.
-            return;
-        }
-        resolveAndMarkBaseMethods(method, type.getSuperclass(), set, seen);
-        for (Class<?> i : type.getInterfaces()) {
-            resolveAndMarkBaseMethods(method, i, set, seen);
+        List<Method> annotatedMethods = imageClassLoader.findAnnotatedMethods(JS.class);
+
+        for (Method annotatedMethod : annotatedMethods) {
+            findBaseMethods(annotatedMethod, annotatedMethod.getDeclaringClass(), methods);
         }
+
+        return methods;
     }
 
-    private static void resolveAndMarkBaseMethods(Method method, Class<?> type, HashSet<Method> set, HashSet<Class<?>> seen) {
-        if (type == null) {
-            // We reached Object's superclass.
+    /**
+     * Finds all methods the given {@code originalMethod} overrides (including itself) from the
+     * given class upwards and adds them to the given set.
+     */
+    private static void findBaseMethods(Method originalMethod, Class<?> clazz, Set<Method> jsOverridenMethodSet) {
+        if (clazz == null) {
             return;
         }
-        for (Method declaredMethod : type.getDeclaredMethods()) {
-            if (isOverriding(method, declaredMethod)) {
-                markBaseMethods(declaredMethod, type, set, seen);
-                return;
-            }
-        }
-        // There is no override in the current class, continue using the subtype's method.
-        markBaseMethods(method, type, set, seen);
-    }
 
-    private static boolean isOverriding(Method method, Method baseMethod) {
-        if (method.getParameterCount() != baseMethod.getParameterCount() || !method.getName().equals(baseMethod.getName())) {
-            return false;
+        // This is either the same method as originalMethod or a method it overrides.
+        Method baseMethod = ReflectionUtil.lookupMethod(true, clazz, originalMethod.getName(), originalMethod.getParameterTypes());
+
+        if (baseMethod != null) {
+            jsOverridenMethodSet.add(baseMethod);
         }
-        Class<?>[] parameters = method.getParameterTypes();
-        Class<?>[] baseParameters = baseMethod.getParameterTypes();
-        for (int i = 0; i < parameters.length; i++) {
-            if (!parameters[i].equals(baseParameters[i])) {
-                return false;
-            }
+
+        for (Class<?> clazzInterface : clazz.getInterfaces()) {
+            findBaseMethods(originalMethod, clazzInterface, jsOverridenMethodSet);
         }
-        return true;
+
+        findBaseMethods(originalMethod, clazz.getSuperclass(), jsOverridenMethodSet);
     }
+
 }