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

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, 2017, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2015, 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
@@ -31,6 +31,7 @@
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
+import java.util.function.BooleanSupplier;
 
 /**
  * Every thus annotated method is never trivially inlined by the compiler. Specific inlining to
@@ -45,4 +46,24 @@
      * Documents the reason why the annotated code must not be inlined.
      */
     String value();
+
+    /**
+     * Avoid inlining only if any of the provided predicates are true (default: class that is never inlined).
+     *
+     * The classes must implement {@link BooleanSupplier}.
+     */
+    Class<?>[] onlyWith() default NeverInlined.class;
+
+    /**
+     * The default value for the {@link NeverInlineTrivial#onlyWith()} attribute.*
+     */
+    class NeverInlined implements BooleanSupplier {
+        NeverInlined() {
+        }
+
+        @Override
+        public boolean getAsBoolean() {
+            return true;
+        }
+    }
 }

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

@@ -37,6 +37,7 @@
 import java.nio.file.Paths;
 import java.util.List;
 import java.util.UUID;
+import java.util.function.BooleanSupplier;
 import java.util.function.Predicate;
 
 import org.graalvm.collections.EconomicMap;
@@ -1413,4 +1414,12 @@ public static class TruffleStableOptions {
                      2. All @CEntryPoint definitions in classes loaded by the custom loader are processed.
                      3. All @TargetClass substitutions in classes loaded by the custom loader are processed.""")//
     public static final HostedOptionKey<String> LibGraalClassLoader = new HostedOptionKey<>("");
+
+    @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);
 }

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

@@ -0,0 +1,11 @@
+package com.oracle.svm.core;
+
+import java.util.function.BooleanSupplier;
+
+public class TrackDynamicAccess implements BooleanSupplier {
+
+    @Override
+    public boolean getAsBoolean() {
+        return SubstrateOptions.TrackDynamicAccess.hasBeenSet();
+    }
+}

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

@@ -80,6 +80,8 @@
 import java.util.Optional;
 import java.util.StringJoiner;
 
+import com.oracle.svm.core.SubstrateOptions;
+import com.oracle.svm.core.TrackDynamicAccess;
 import org.graalvm.nativeimage.AnnotationAccess;
 import org.graalvm.nativeimage.ImageSingletons;
 import org.graalvm.nativeimage.Platform;
@@ -89,6 +91,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 +1569,28 @@ private static Constructor<?>[] copyConstructors(Constructor<?>[] original) {
     private native Constructor<?> getEnclosingConstructor();
 
     @Substitute
+    @NeverInlineTrivial(value = "Used in dynamic access call usage analysis: DynamicAccessDetectionPhase", onlyWith = TrackDynamicAccess.class)
     @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.class)
     @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.class)
     @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.class)
     @CallerSensitiveAdapter
     @TargetElement(onlyWith = JDK21OrEarlier.class)
     private static Class<?> forName(@SuppressWarnings("unused") Module module, String className, Class<?> caller) throws Throwable {
@@ -1599,12 +1606,14 @@ private static Class<?> forName(@SuppressWarnings("unused") Module module, Strin
     }
 
     @Substitute
+    @NeverInlineTrivial(value = "Used in dynamic access call usage analysis: DynamicAccessDetectionPhase", onlyWith = TrackDynamicAccess.class)
     @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.class)
     @CallerSensitiveAdapter
     @TargetElement(onlyWith = JDK21OrEarlier.class)
     private static Class<?> forName(String name, boolean initialize, ClassLoader loader, @SuppressWarnings("unused") Class<?> caller) throws Throwable {