Add dynamic access detection phase

Author: jormundur00

substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/results/StrengthenGraphs.java

@@ -252,6 +252,8 @@ public final void applyResults(AnalysisMethod method) {
             return;
         }
 
+        preStrengthenGraphs(graph, method);
+
         graph.resetDebug(debug);
         if (beforeCounters != null) {
             beforeCounters.collect(graph);
@@ -279,6 +281,8 @@ public final void applyResults(AnalysisMethod method) {
         }
     }
 
+    protected abstract void preStrengthenGraphs(StructuredGraph graph, AnalysisMethod method);
+
     protected abstract void postStrengthenGraphs(StructuredGraph graph, AnalysisMethod method);
 
     protected abstract void persistStrengthenGraph(AnalysisMethod method);

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/NeverInlineTrivial.java

@@ -45,4 +45,10 @@
      * Documents the reason why the annotated code must not be inlined.
      */
     String value();
+
+    /**
+     * Specifies the condition under which the annotated code is not inlined.
+     * If left at the default, the code is never inlined.
+     */
+    String onlyWith() default "";
 }

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/hub/DynamicHub.java

@@ -89,6 +89,7 @@
 import com.oracle.svm.core.BuildPhaseProvider.AfterHostedUniverse;
 import com.oracle.svm.core.BuildPhaseProvider.CompileQueueFinished;
 import com.oracle.svm.core.NeverInline;
+import com.oracle.svm.core.NeverInlineTrivial;
 import com.oracle.svm.core.RuntimeAssertionsSupport;
 import com.oracle.svm.core.SubstrateUtil;
 import com.oracle.svm.core.Uninterruptible;
@@ -1566,24 +1567,28 @@ private static Constructor<?>[] copyConstructors(Constructor<?>[] original) {
     private native Constructor<?> getEnclosingConstructor();
 
     @Substitute
+    @NeverInlineTrivial(value = "Used in dynamic access call usage analysis: DynamicAccessDetectionPhase", onlyWith = "TrackDynamicAccess")
     @CallerSensitive
     private static Class<?> forName(String className) throws Throwable {
         return forName(className, Reflection.getCallerClass());
     }
 
     @Substitute
+    @NeverInlineTrivial(value = "Used in dynamic access call usage analysis: DynamicAccessDetectionPhase", onlyWith = "TrackDynamicAccess")
     @CallerSensitiveAdapter
     private static Class<?> forName(String className, Class<?> caller) throws Throwable {
         return forName(className, true, caller == null ? ClassLoader.getSystemClassLoader() : caller.getClassLoader(), caller);
     }
 
     @Substitute
+    @NeverInlineTrivial(value = "Used in dynamic access call usage analysis: DynamicAccessDetectionPhase", onlyWith = "TrackDynamicAccess")
     @CallerSensitive
     private static Class<?> forName(Module module, String className) throws Throwable {
         return forName(module, className, Reflection.getCallerClass());
     }
 
     @Substitute
+    @NeverInlineTrivial(value = "Used in dynamic access call usage analysis: DynamicAccessDetectionPhase", onlyWith = "TrackDynamicAccess")
     @CallerSensitiveAdapter
     @TargetElement(onlyWith = JDK21OrEarlier.class)
     private static Class<?> forName(@SuppressWarnings("unused") Module module, String className, Class<?> caller) throws Throwable {
@@ -1599,12 +1604,14 @@ private static Class<?> forName(@SuppressWarnings("unused") Module module, Strin
     }
 
     @Substitute
+    @NeverInlineTrivial(value = "Used in dynamic access call usage analysis: DynamicAccessDetectionPhase", onlyWith = "TrackDynamicAccess")
     @CallerSensitive
     private static Class<?> forName(String name, boolean initialize, ClassLoader loader) throws Throwable {
         return forName(name, initialize, loader, Reflection.getCallerClass());
     }
 
     @Substitute
+    @NeverInlineTrivial(value = "Used in dynamic access call usage analysis: DynamicAccessDetectionPhase", onlyWith = "TrackDynamicAccess")
     @CallerSensitiveAdapter
     @TargetElement(onlyWith = JDK21OrEarlier.class)
     private static Class<?> forName(String name, boolean initialize, ClassLoader loader, @SuppressWarnings("unused") Class<?> caller) throws Throwable {

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

@@ -0,0 +1,298 @@
+/*
+ * 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;
+
+import com.oracle.svm.core.BuildArtifacts;
+import com.oracle.svm.core.feature.AutomaticallyRegisteredFeature;
+import com.oracle.svm.core.feature.InternalFeature;
+import com.oracle.svm.core.option.AccumulatingLocatableMultiOptionValue;
+import com.oracle.svm.core.option.HostedOptionKey;
+import com.oracle.svm.core.option.HostedOptionValues;
+import com.oracle.svm.core.option.LocatableMultiOptionValue;
+import com.oracle.svm.core.option.SubstrateOptionsParser;
+import com.oracle.svm.core.util.UserError;
+import com.oracle.svm.hosted.driver.IncludeOptionsSupport;
+import com.oracle.svm.hosted.phases.DynamicAccessDetectionPhase;
+import jdk.graal.compiler.options.Option;
+import jdk.graal.compiler.options.OptionKey;
+import jdk.graal.compiler.options.OptionValues;
+import jdk.graal.compiler.util.json.JsonBuilder;
+import jdk.graal.compiler.util.json.JsonPrettyWriter;
+import jdk.vm.ci.meta.ResolvedJavaMethod;
+import org.graalvm.collections.EconomicMap;
+import org.graalvm.nativeimage.ImageSingletons;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.NoSuchFileException;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Objects;
+import java.util.Set;
+import java.util.TreeMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentSkipListMap;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import static com.oracle.svm.hosted.driver.IncludeOptionsSupport.parseIncludeSelector;
+
+/**
+ * This is a support class that keeps track of dynamic access calls requiring metadata usage
+ * detected during {@link DynamicAccessDetectionPhase} and outputs them to the image-build output.
+ */
+@AutomaticallyRegisteredFeature
+public final class DynamicAccessDetectionFeature implements InternalFeature {
+
+    public static class Options {
+        @Option(help = "Serialize all method calls requiring metadata for dynamic access in the reached parts of the project, limited to the provided comma-separated list of class path entries and module or package names.")//
+        public static final HostedOptionKey<AccumulatingLocatableMultiOptionValue.Strings> TrackDynamicAccess = new HostedOptionKey<>(
+                        AccumulatingLocatableMultiOptionValue.Strings.buildWithCommaDelimiter());
+
+        @Option(help = "Output all method calls requiring metadata for dynamic access found by -H:TrackDynamicAccess to the console.")
+        public static final HostedOptionKey<Boolean> ReportDynamicAccessToConsole = new HostedOptionKey<>(false);
+    }
+
+    private record MethodsByAccessKind(Map<DynamicAccessDetectionPhase.DynamicAccessKind, CallLocationsByMethod> methodsByAccessKind) {
+        MethodsByAccessKind() {
+            this(new TreeMap<>());
+        }
+
+        public Set<DynamicAccessDetectionPhase.DynamicAccessKind> getAccessKinds() {
+            return methodsByAccessKind.keySet();
+        }
+
+        public CallLocationsByMethod getCallLocationsByMethod(DynamicAccessDetectionPhase.DynamicAccessKind accessKind) {
+            return methodsByAccessKind.getOrDefault(accessKind, new CallLocationsByMethod());
+        }
+    }
+
+    private record CallLocationsByMethod(Map<String, List<String>> callLocationsByMethod) {
+        CallLocationsByMethod() {
+            this(new TreeMap<>());
+        }
+
+        public Set<String> getMethods() {
+            return callLocationsByMethod.keySet();
+        }
+
+        public List<String> getMethodCallLocations(String methodName) {
+            return callLocationsByMethod.getOrDefault(methodName, new ArrayList<>());
+        }
+    }
+
+    private static final String OUTPUT_DIR_NAME = "dynamic-access";
+
+    private Set<String> sourceEntries; // Class path entries and module or package names
+    private final Map<String, MethodsByAccessKind> callsBySourceEntry;
+    private final Set<FoldEntry> foldEntries = ConcurrentHashMap.newKeySet();
+    private final boolean printToConsole;
+
+    public DynamicAccessDetectionFeature() {
+        callsBySourceEntry = new ConcurrentSkipListMap<>();
+        printToConsole = Options.ReportDynamicAccessToConsole.getValue();
+    }
+
+    public static DynamicAccessDetectionFeature instance() {
+        return ImageSingletons.lookup(DynamicAccessDetectionFeature.class);
+    }
+
+    public void addCall(String entry, DynamicAccessDetectionPhase.DynamicAccessKind accessKind, String call, String callLocation) {
+        MethodsByAccessKind entryContent = callsBySourceEntry.computeIfAbsent(entry, k -> new MethodsByAccessKind());
+        CallLocationsByMethod methodCallLocations = entryContent.methodsByAccessKind().computeIfAbsent(accessKind, k -> new CallLocationsByMethod());
+        List<String> callLocations = methodCallLocations.callLocationsByMethod().computeIfAbsent(call, k -> new ArrayList<>());
+        callLocations.add(callLocation);
+    }
+
+    public MethodsByAccessKind getMethodsByAccessKind(String entry) {
+        return callsBySourceEntry.getOrDefault(entry, new MethodsByAccessKind());
+    }
+
+    public Set<String> getSourceEntries() {
+        return sourceEntries;
+    }
+
+    public static String getEntryName(String path) {
+        String fileName = path.substring(path.lastIndexOf("/") + 1);
+        if (fileName.endsWith(".jar")) {
+            fileName = fileName.substring(0, fileName.lastIndexOf('.'));
+        }
+        return fileName;
+    }
+
+    private void printReportForEntry(String entry) {
+        System.out.println("Dynamic method usage detected in " + entry + ":");
+        MethodsByAccessKind methodsByAccessKind = getMethodsByAccessKind(entry);
+        for (DynamicAccessDetectionPhase.DynamicAccessKind accessKind : methodsByAccessKind.getAccessKinds()) {
+            System.out.println("    " + accessKind + " calls detected:");
+            CallLocationsByMethod methodCallLocations = methodsByAccessKind.getCallLocationsByMethod(accessKind);
+            for (String call : methodCallLocations.getMethods()) {
+                System.out.println("        " + call + ":");
+                for (String callLocation : methodCallLocations.getMethodCallLocations(call)) {
+                    System.out.println("            at " + callLocation);
+                }
+            }
+        }
+    }
+
+    public static Path getOrCreateDirectory(Path directory) throws IOException {
+        if (Files.exists(directory)) {
+            if (!Files.isDirectory(directory)) {
+                throw new NoSuchFileException(directory.toString(), null,
+                                "Failed to retrieve directory: The path exists but is not a directory.");
+            }
+        } else {
+            try {
+                Files.createDirectory(directory);
+            } catch (IOException e) {
+                throw new IOException("Failed to create directory: " + directory, e);
+            }
+        }
+        return directory;
+    }
+
+    private void dumpReportForEntry(String entry) {
+        try {
+            Path reportDirectory = getOrCreateDirectory(NativeImageGenerator.generatedFiles(HostedOptionValues.singleton()).resolve(OUTPUT_DIR_NAME));
+            MethodsByAccessKind methodsByAccessKind = getMethodsByAccessKind(entry);
+            for (DynamicAccessDetectionPhase.DynamicAccessKind accessKind : methodsByAccessKind.getAccessKinds()) {
+                Path entryDirectory = getOrCreateDirectory(reportDirectory.resolve(getEntryName(entry)));
+                Path targetPath = entryDirectory.resolve(accessKind.fileName);
+                try (var writer = new JsonPrettyWriter(targetPath)) {
+                    try (JsonBuilder.ObjectBuilder dynamicAccessBuilder = writer.objectBuilder()) {
+                        for (String methodName : methodsByAccessKind.getCallLocationsByMethod(accessKind).getMethods()) {
+                            try (JsonBuilder.ArrayBuilder methodCallLocationBuilder = dynamicAccessBuilder.append(methodName).array()) {
+                                for (String methodLocation : methodsByAccessKind.getCallLocationsByMethod(accessKind).getMethodCallLocations(methodName)) {
+                                    methodCallLocationBuilder.append(methodLocation);
+                                }
+                            }
+                        }
+                    }
+                    BuildArtifacts.singleton().add(BuildArtifacts.ArtifactType.BUILD_INFO, targetPath);
+                }
+            }
+        } catch (IOException e) {
+            UserError.abort("Failed to dump report for entry %s:", entry);
+        }
+    }
+
+    public void reportDynamicAccess() {
+        for (String entry : sourceEntries) {
+            if (callsBySourceEntry.containsKey(entry)) {
+                dumpReportForEntry(entry);
+                if (printToConsole) {
+                    printReportForEntry(entry);
+                }
+            }
+        }
+    }
+
+    /*
+     * Support data structure used to keep track of calls which don't require metadata, but can't be
+     * folded.
+     */
+    public static class FoldEntry {
+        private final int bci;
+        private final ResolvedJavaMethod method;
+
+        public FoldEntry(int bci, ResolvedJavaMethod method) {
+            this.bci = bci;
+            this.method = method;
+        }
+
+        @Override
+        public boolean equals(Object obj) {
+            if (this == obj) {
+                return true;
+            }
+            if (obj == null || getClass() != obj.getClass()) {
+                return false;
+            }
+            FoldEntry other = (FoldEntry) obj;
+            return bci == other.bci && Objects.equals(method, other.method);
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hash(bci, method);
+        }
+    }
+
+    public void addFoldEntry(int bci, ResolvedJavaMethod method) {
+        foldEntries.add(new FoldEntry(bci, method));
+    }
+
+    /*
+     * If a fold entry exists for the given method, the method should be ignored by the analysis
+     * phase.
+     */
+    public boolean containsFoldEntry(int bci, ResolvedJavaMethod method) {
+        return foldEntries.contains(new FoldEntry(bci, method));
+    }
+
+    @Override
+    public void afterRegistration(AfterRegistrationAccess access) {
+        ImageClassLoader imageClassLoader = ((FeatureImpl.AfterRegistrationAccessImpl) access).getImageClassLoader();
+        NativeImageClassLoaderSupport support = imageClassLoader.classLoaderSupport;
+        NativeImageClassLoaderSupport.IncludeSelectors dynamicAccessSelectors = support.getDynamicAccessSelectors();
+
+        Set<String> tmpSet = new HashSet<>();
+        tmpSet.addAll(dynamicAccessSelectors.classpathEntries().stream()
+                .map(path -> path.toAbsolutePath().toString())
+                .collect(Collectors.toSet()));
+        tmpSet.addAll(dynamicAccessSelectors.moduleNames());
+        tmpSet.addAll(dynamicAccessSelectors.packages().stream()
+                .map(Object::toString)
+                .collect(Collectors.toSet()));
+        sourceEntries = Set.copyOf(tmpSet);
+    }
+
+    @Override
+    public void beforeCompilation(BeforeCompilationAccess access) {
+        DynamicAccessDetectionFeature.instance().reportDynamicAccess();
+    }
+
+    private static String dynamicAccessPossibleOptions() {
+        return "[" + IncludeOptionsSupport.possibleExtendedOptions() + "]";
+    }
+
+    public static void parseDynamicAccessOptions(EconomicMap<OptionKey<?>, Object> hostedValues, NativeImageClassLoaderSupport classLoaderSupport) {
+        AccumulatingLocatableMultiOptionValue.Strings trackDynamicAccess = Options.TrackDynamicAccess.getValue(new OptionValues(hostedValues));
+        Stream<LocatableMultiOptionValue.ValueWithOrigin<String>> valuesWithOrigins = trackDynamicAccess.getValuesWithOrigins();
+        valuesWithOrigins.forEach(valueWithOrigin -> {
+            String optionArgument = SubstrateOptionsParser.commandArgument(Options.TrackDynamicAccess, valueWithOrigin.value(), true, false);
+            var options = Arrays.stream(valueWithOrigin.value().split(",")).toList();
+            for (String option : options) {
+                UserError.guarantee(!option.isEmpty(), "Option %s from %s cannot be passed an empty string",
+                        optionArgument, valueWithOrigin.origin());
+                parseIncludeSelector(optionArgument, valueWithOrigin, classLoaderSupport.getDynamicAccessSelectors(), IncludeOptionsSupport.ExtendedOption.parse(option), dynamicAccessPossibleOptions());
+            }
+        });
+    }
+}