New plugins for strict mode inference.

Author: Aca-S

substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/ResourcesFeature.java

@@ -55,6 +55,7 @@
 import java.util.regex.Pattern;
 import java.util.stream.Collectors;
 
+import com.oracle.svm.hosted.dynamicaccessinference.StrictDynamicAccessInferenceFeature;
 import org.graalvm.nativeimage.ImageSingletons;
 import org.graalvm.nativeimage.hosted.RuntimeResourceAccess;
 import org.graalvm.nativeimage.impl.ConfigurationCondition;
@@ -672,7 +673,7 @@ public void beforeCompilation(BeforeCompilationAccess access) {
 
     @Override
     public void registerInvocationPlugins(Providers providers, GraphBuilderConfiguration.Plugins plugins, ParsingReason reason) {
-        if (!reason.duringAnalysis() || reason == ParsingReason.JITCompilation) {
+        if (!reason.duringAnalysis() || reason == ParsingReason.JITCompilation || StrictDynamicAccessInferenceFeature.isEnforced()) {
             return;
         }
 

substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/dynamicaccessinference/StrictDynamicAccessInferenceFeature.java

@@ -24,13 +24,8 @@
  */
 package com.oracle.svm.hosted.dynamicaccessinference;
 
-import java.lang.invoke.MethodType;
 import java.lang.reflect.Field;
-import java.lang.reflect.InvocationHandler;
-import java.util.function.BooleanSupplier;
-import java.util.function.Predicate;
 
-import com.oracle.svm.core.ParsingReason;
 import org.graalvm.nativeimage.ImageSingletons;
 import org.graalvm.nativeimage.hosted.RuntimeReflection;
 
@@ -43,51 +38,7 @@
 
 import jdk.graal.compiler.options.Option;
 import jdk.graal.compiler.options.OptionStability;
-import jdk.vm.ci.meta.ResolvedJavaMethod;
-
-/**
- * Feature which enables a graph IR optimization independent analysis of compile-time inferrable
- * method invocations which require dynamic access and would otherwise require a manual reachability
- * registration.
- * <p>
- * The targeted methods are:
- * <ul>
- * <li>{@link java.lang.Class#forName(String)}</li>
- * <li>{@link java.lang.Class#forName(String, boolean, ClassLoader)}</li>
- * <li>{@link java.lang.Class#getField(String)}</li>
- * <li>{@link java.lang.Class#getDeclaredField(String)}</li>
- * <li>{@link java.lang.Class#getConstructor(Class[])}</li>
- * <li>{@link java.lang.Class#getDeclaredConstructor(Class[])}</li>
- * <li>{@link java.lang.Class#getMethod(String, Class[])}</li>
- * <li>{@link java.lang.Class#getDeclaredMethod(String, Class[])}</li>
- * <li>{@link java.lang.Class#getFields()}</li>
- * <li>{@link java.lang.Class#getDeclaredFields()}</li>
- * <li>{@link java.lang.Class#getConstructors()}</li>
- * <li>{@link java.lang.Class#getDeclaredConstructors()}</li>
- * <li>{@link java.lang.Class#getMethods()}</li>
- * <li>{@link java.lang.Class#getDeclaredMethods()}</li>
- * <li>{@link java.lang.Class#getClasses()}</li>
- * <li>{@link java.lang.Class#getDeclaredClasses()}</li>
- * <li>{@link java.lang.Class#getNestMembers()}</li>
- * <li>{@link java.lang.Class#getPermittedSubclasses()}</li>
- * <li>{@link java.lang.Class#getRecordComponents()}</li>
- * <li>{@link java.lang.Class#getSigners()}</li>
- * <li>{@link java.lang.invoke.MethodHandles.Lookup#findClass(String)}}</li>
- * <li>{@link java.lang.invoke.MethodHandles.Lookup#findVirtual(Class, String, MethodType)}}</li>
- * <li>{@link java.lang.invoke.MethodHandles.Lookup#findStatic(Class, String, MethodType)}}</li>
- * <li>{@link java.lang.invoke.MethodHandles.Lookup#findConstructor(Class, MethodType)}}</li>
- * <li>{@link java.lang.invoke.MethodHandles.Lookup#findGetter(Class, String, Class)}}</li>
- * <li>{@link java.lang.invoke.MethodHandles.Lookup#findStaticGetter(Class, String, Class)}}</li>
- * <li>{@link java.lang.invoke.MethodHandles.Lookup#findSetter(Class, String, Class)}}</li>
- * <li>{@link java.lang.invoke.MethodHandles.Lookup#findStaticSetter(Class, String, Class)}}</li>
- * <li>{@link java.lang.invoke.MethodHandles.Lookup#findVarHandle(Class, String, Class)}}</li>
- * <li>{@link java.lang.invoke.MethodHandles.Lookup#findStaticVarHandle(Class, String, Class)}}</li>
- * <li>{@link java.lang.Class#getResource(String)}</li>
- * <li>{@link java.lang.Class#getResourceAsStream(String)}</li>
- * <li>{@link java.io.ObjectInputFilter.Config#createFilter(String)}</li>
- * <li>{@link java.lang.reflect.Proxy#newProxyInstance(ClassLoader, Class[], InvocationHandler)}</li>
- * </ul>
- */
+
 @AutomaticallyRegisteredFeature
 public class StrictDynamicAccessInferenceFeature implements InternalFeature {
 
@@ -112,6 +63,10 @@ public static boolean isActive() {
         return Options.StrictDynamicAccessInference.getValue() != Options.Mode.Disable;
     }
 
+    public static boolean isEnforced() {
+        return Options.StrictDynamicAccessInference.getValue() == Options.Mode.Enforce;
+    }
+
     @Override
     public boolean isInConfiguration(IsInConfigurationAccess access) {
         return isActive();
@@ -127,9 +82,6 @@ public void afterRegistration(AfterRegistrationAccess access) {
 
         ImageSingletons.add(ConstantExpressionRegistry.class, registry);
         ImageSingletons.add(StrictDynamicAccessInferenceSupport.class, support);
-
-        cacheMode(Options.StrictDynamicAccessInference.getValue());
-        cacheRegistry(registry);
     }
 
     @Override
@@ -167,47 +119,4 @@ public void afterAnalysis(AfterAnalysisAccess access) {
          */
         ConstantExpressionRegistry.singleton().seal();
     }
-
-    private static void cacheMode(Options.Mode mode) {
-        cachedMode = mode;
-    }
-
-    private static void cacheRegistry(ConstantExpressionRegistry registry) {
-        cachedRegistry = registry;
-    }
-
-    private static Options.Mode cachedMode = Options.Mode.Disable;
-    private static ConstantExpressionRegistry cachedRegistry = null;
-
-    /**
-     * Utility method which attempts to infer {@code targetMethod} according to the {@code Disable},
-     * {@code Warn} and {@code Enforce} options of {@code StrictConstantAnalysis}.
-     */
-    public static boolean tryToInfer(ParsingReason reason, Predicate<ConstantExpressionRegistry> strictModeRoutine, BooleanSupplier graphModeRoutine, ResolvedJavaMethod targetMethod,
-                    Predicate<ResolvedJavaMethod> strictModeTarget) {
-        /*
-         * Do not restrict the folding of reflective calls if not building graphs for the analysis.
-         */
-        if (!reason.duringAnalysis() || reason == ParsingReason.JITCompilation) {
-            return graphModeRoutine.getAsBoolean();
-        }
-        boolean isTarget = strictModeTarget.test(targetMethod);
-        if (cachedMode != Options.Mode.Disable && isTarget) {
-            if (strictModeRoutine.test(cachedRegistry)) {
-                return true;
-            }
-        }
-        if (cachedMode != Options.Mode.Enforce || !isTarget) {
-            return graphModeRoutine.getAsBoolean();
-        }
-        return false;
-    }
-
-    /**
-     * Utility method which attempts to infer {@code targetMethod} according to the {@code Disable},
-     * {@code Warn} and {@code Enforce} options of {@code StrictConstantAnalysis}.
-     */
-    public static boolean tryToInfer(ParsingReason reason, Predicate<ConstantExpressionRegistry> strictModeRoutine, BooleanSupplier graphModeRoutine) {
-        return tryToInfer(reason, strictModeRoutine, graphModeRoutine, null, (method) -> true);
-    }
 }

substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/dynamicaccessinference/StrictProxyInferenceFeature.java

@@ -0,0 +1,105 @@
+/*
+ * 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.dynamicaccessinference;
+
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+import java.util.List;
+
+import org.graalvm.nativeimage.hosted.Feature;
+import org.graalvm.nativeimage.hosted.RuntimeProxyCreation;
+
+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.ReachabilityRegistrationNode;
+import com.oracle.svm.util.ReflectionUtil;
+
+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.InvocationPlugin;
+import jdk.graal.compiler.nodes.graphbuilderconf.InvocationPlugins;
+import jdk.graal.compiler.phases.util.Providers;
+import jdk.vm.ci.meta.ResolvedJavaMethod;
+
+@AutomaticallyRegisteredFeature
+public class StrictProxyInferenceFeature implements InternalFeature {
+
+    private ConstantExpressionRegistry registry;
+
+    @Override
+    public List<Class<? extends Feature>> getRequiredFeatures() {
+        return List.of(StrictDynamicAccessInferenceFeature.class);
+    }
+
+    @Override
+    public boolean isInConfiguration(IsInConfigurationAccess access) {
+        StrictDynamicAccessInferenceFeature.Options.Mode mode = StrictDynamicAccessInferenceFeature.Options.StrictDynamicAccessInference.getValue();
+        return mode == StrictDynamicAccessInferenceFeature.Options.Mode.Enforce;
+    }
+
+    @Override
+    public void duringSetup(DuringSetupAccess access) {
+        registry = ConstantExpressionRegistry.singleton();
+    }
+
+    @Override
+    public void registerInvocationPlugins(Providers providers, GraphBuilderConfiguration.Plugins plugins, ParsingReason reason) {
+        if (reason != ParsingReason.PointsToAnalysis) {
+            return;
+        }
+
+        InvocationPlugins invocationPlugins = plugins.getInvocationPlugins();
+
+        Method getProxyClass = ReflectionUtil.lookupMethod(Proxy.class, "getProxyClass", ClassLoader.class, Class[].class);
+        Method newProxyInstance = ReflectionUtil.lookupMethod(Proxy.class, "newProxyInstance", ClassLoader.class, Class[].class, InvocationHandler.class);
+
+        for (Method method : List.of(getProxyClass, newProxyInstance)) {
+            invocationPlugins.register(method.getDeclaringClass(), new InvocationPlugin.RequiredInvocationPlugin(method.getName(), method.getParameterTypes()) {
+                @Override
+                public boolean isDecorator() {
+                    return true;
+                }
+
+                @Override
+                public boolean defaultHandler(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver receiver, ValueNode... args) {
+                    Class<?>[] interfaces = registry.getArgument(b.getMethod(), b.bci(), targetMethod, 1, Class[].class);
+                    return registerProxy(b, reason, interfaces);
+                }
+            });
+        }
+    }
+
+    private boolean registerProxy(GraphBuilderContext b, ParsingReason reason, Class<?>[] interfaces) {
+        if (interfaces == null) {
+            return false;
+        }
+
+        b.add(ReachabilityRegistrationNode.create(() -> RuntimeProxyCreation.register(interfaces), reason));
+        return true;
+    }
+}