[GR-67368] Registering function descriptors for runtime foreign access via API during Feature#afterRegistration

PullRequest: graal/21545

Author: kimeta

substratevm/src/com.oracle.svm.hosted.foreign/src/com/oracle/svm/hosted/foreign/ForeignFunctionsFeature.java

@@ -59,6 +59,7 @@
 import org.graalvm.nativeimage.hosted.RuntimeReflection;
 import org.graalvm.nativeimage.impl.ConfigurationCondition;
 import org.graalvm.nativeimage.impl.RuntimeForeignAccessSupport;
+import org.graalvm.nativeimage.impl.RuntimeReflectionSupport;
 import org.graalvm.word.Pointer;
 import org.graalvm.word.UnsignedWord;
 
@@ -206,12 +207,14 @@ private final class RuntimeForeignAccessSupportImpl extends ConditionalConfigura
 
         private final Lookup implLookup = ReflectionUtil.readStaticField(MethodHandles.Lookup.class, "IMPL_LOOKUP");
 
-        private final AnalysisMetaAccess analysisMetaAccess;
-        private final AnalysisUniverse universe;
+        private AnalysisMetaAccess analysisMetaAccess;
 
-        RuntimeForeignAccessSupportImpl(AnalysisMetaAccess analysisMetaAccess, AnalysisUniverse analysisUniverse) {
-            this.analysisMetaAccess = analysisMetaAccess;
-            this.universe = analysisUniverse;
+        RuntimeForeignAccessSupportImpl() {
+        }
+
+        void duringSetup(AnalysisMetaAccess metaAccess, AnalysisUniverse analysisUniverse) {
+            this.analysisMetaAccess = metaAccess;
+            setUniverse(analysisUniverse);
         }
 
         @Override
@@ -220,7 +223,7 @@ public void registerForDowncall(ConfigurationCondition condition, FunctionDescri
             try {
                 LinkerOptions linkerOptions = LinkerOptions.forDowncall(desc, options);
                 SharedDesc sharedDesc = new SharedDesc(desc, linkerOptions);
-                registerConditionalConfiguration(condition, _ -> universe.getBigbang().postTask(_ -> createStub(DowncallStubFactory.INSTANCE, sharedDesc)));
+                runConditionalTask(condition, _ -> createStub(DowncallStubFactory.INSTANCE, sharedDesc));
             } catch (IllegalArgumentException e) {
                 throw UserError.abort(e, "Could not register downcall");
             }
@@ -232,7 +235,7 @@ public void registerForUpcall(ConfigurationCondition condition, FunctionDescript
             try {
                 LinkerOptions linkerOptions = LinkerOptions.forUpcall(desc, options);
                 SharedDesc sharedDesc = new SharedDesc(desc, linkerOptions);
-                registerConditionalConfiguration(condition, _ -> universe.getBigbang().postTask(_ -> createStub(UpcallStubFactory.INSTANCE, sharedDesc)));
+                runConditionalTask(condition, _ -> createStub(UpcallStubFactory.INSTANCE, sharedDesc));
             } catch (IllegalArgumentException e) {
                 throw UserError.abort(e, "Could not register upcall");
             }
@@ -256,11 +259,11 @@ public void registerForDirectUpcall(ConfigurationCondition condition, MethodHand
             try {
                 LinkerOptions linkerOptions = LinkerOptions.forUpcall(desc, options);
                 DirectUpcallDesc directUpcallDesc = new DirectUpcallDesc(target, directMethodHandleDesc, desc, linkerOptions);
-                registerConditionalConfiguration(condition, _ -> universe.getBigbang().postTask(_ -> {
-                    RuntimeReflection.register(method);
+                runConditionalTask(condition, _ -> {
+                    ImageSingletons.lookup(RuntimeReflectionSupport.class).register(ConfigurationCondition.alwaysTrue(), false, method);
                     createStub(UpcallStubFactory.INSTANCE, directUpcallDesc.toSharedDesc());
                     createStub(DirectUpcallStubFactory.INSTANCE, directUpcallDesc);
-                }));
+                });
             } catch (IllegalArgumentException e) {
                 throw UserError.abort(e, "Could not register direct upcall");
             }
@@ -383,7 +386,8 @@ public boolean isInConfiguration(IsInConfigurationAccess access) {
     public void afterRegistration(AfterRegistrationAccess access) {
         abiUtils = AbiUtils.create();
         foreignFunctionsRuntime = new ForeignFunctionsRuntime(abiUtils);
-
+        accessSupport = new RuntimeForeignAccessSupportImpl();
+        ImageSingletons.add(RuntimeForeignAccessSupport.class, accessSupport);
         ImageSingletons.add(AbiUtils.class, abiUtils);
         ImageSingletons.add(ForeignSupport.class, foreignFunctionsRuntime);
         ImageSingletons.add(ForeignFunctionsRuntime.class, foreignFunctionsRuntime);
@@ -392,8 +396,7 @@ public void afterRegistration(AfterRegistrationAccess access) {
     @Override
     public void duringSetup(DuringSetupAccess a) {
         var access = (FeatureImpl.DuringSetupAccessImpl) a;
-        accessSupport = new RuntimeForeignAccessSupportImpl(access.getMetaAccess(), access.getUniverse());
-        ImageSingletons.add(RuntimeForeignAccessSupport.class, accessSupport);
+        accessSupport.duringSetup(access.getMetaAccess(), access.getUniverse());
         if (SubstrateOptions.isSharedArenaSupportEnabled()) {
             ImageSingletons.add(SharedArenaSupport.class, new SharedArenaSupportImpl());
         }

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

@@ -27,10 +27,12 @@
 import java.util.Collection;
 import java.util.Map;
 import java.util.Objects;
+import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentLinkedQueue;
 import java.util.function.Consumer;
 
+import com.oracle.graal.pointsto.meta.AnalysisUniverse;
 import org.graalvm.nativeimage.hosted.Feature;
 import org.graalvm.nativeimage.impl.ConfigurationCondition;
 
@@ -40,7 +42,29 @@
 public abstract class ConditionalConfigurationRegistry {
     private Feature.BeforeAnalysisAccess beforeAnalysisAccess;
     private SVMHost hostVM;
+    protected AnalysisUniverse universe;
     private final Map<Class<?>, Collection<Runnable>> pendingReachabilityHandlers = new ConcurrentHashMap<>();
+    private final Set<ConditionalTask> pendingConditionalTasks = ConcurrentHashMap.newKeySet();
+
+    record ConditionalTask(ConfigurationCondition condition, Consumer<ConfigurationCondition> task) {
+    }
+
+    protected void runConditionalTask(ConfigurationCondition condition, Consumer<ConfigurationCondition> task) {
+        if (universe != null) {
+            registerConditionalConfiguration(condition, (cnd) -> universe.getBigbang().postTask(debugContext -> task.accept(cnd)));
+        } else {
+            pendingConditionalTasks.add(new ConditionalTask(condition, task));
+            VMError.guarantee(universe == null, "There shouldn't be a race condition on Feature.duringSetup.");
+        }
+    }
+
+    protected void setUniverse(AnalysisUniverse analysisUniverse) {
+        this.universe = analysisUniverse;
+        for (var conditionalTask : pendingConditionalTasks) {
+            registerConditionalConfiguration(conditionalTask.condition, (cnd) -> universe.getBigbang().postTask(debug -> conditionalTask.task.accept(cnd)));
+        }
+        pendingConditionalTasks.clear();
+    }
 
     protected void registerConditionalConfiguration(ConfigurationCondition condition, Consumer<ConfigurationCondition> consumer) {
         Objects.requireNonNull(condition, "Cannot use null value as condition for conditional configuration. Please ensure that you register a non-null condition.");

substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/reflect/ReflectionDataBuilder.java

@@ -119,7 +119,6 @@
 
 public class ReflectionDataBuilder extends ConditionalConfigurationRegistry implements RuntimeReflectionSupport, ReflectionHostedSupport {
     private AnalysisMetaAccess metaAccess;
-    private AnalysisUniverse universe;
     private final SubstrateAnnotationExtractor annotationExtractor;
     private BeforeAnalysisAccessImpl analysisAccess;
     private final ClassForNameSupport classForNameSupport;
@@ -163,11 +162,6 @@ public class ReflectionDataBuilder extends ConditionalConfigurationRegistry impl
     private Map<Type, Set<Integer>> processedTypes = new ConcurrentHashMap<>();
     private Map<Class<?>, Set<Method>> pendingRecordClasses;
 
-    record ConditionalTask(ConfigurationCondition condition, Consumer<ConfigurationCondition> task) {
-    }
-
-    private final Set<ConditionalTask> pendingConditionalTasks = ConcurrentHashMap.newKeySet();
-
     // Annotations handling
     private final Map<AnnotatedElement, AnnotationValue[]> filteredAnnotations = new ConcurrentHashMap<>();
     private final Map<AnalysisMethod, AnnotationValue[][]> filteredParameterAnnotations = new ConcurrentHashMap<>();
@@ -181,11 +175,7 @@ record ConditionalTask(ConfigurationCondition condition, Consumer<ConfigurationC
 
     public void duringSetup(AnalysisMetaAccess analysisMetaAccess, AnalysisUniverse analysisUniverse) {
         this.metaAccess = analysisMetaAccess;
-        this.universe = analysisUniverse;
-        for (var conditionalTask : pendingConditionalTasks) {
-            registerConditionalConfiguration(conditionalTask.condition, (cnd) -> universe.getBigbang().postTask(debug -> conditionalTask.task.accept(cnd)));
-        }
-        pendingConditionalTasks.clear();
+        setUniverse(analysisUniverse);
         if (ImageLayerBuildingSupport.buildingImageLayer()) {
             layeredReflectionDataBuilder = LayeredReflectionDataBuilder.singleton();
         }
@@ -199,13 +189,7 @@ private void runConditionalInAnalysisTask(ConfigurationCondition condition, Cons
         if (sealed) {
             throw new UnsupportedFeatureException("Too late to add classes, methods, and fields for reflective access. Registration must happen in a Feature before the analysis has finished.");
         }
-
-        if (universe != null) {
-            registerConditionalConfiguration(condition, (cnd) -> universe.getBigbang().postTask(debug -> task.accept(cnd)));
-        } else {
-            pendingConditionalTasks.add(new ConditionalTask(condition, task));
-            VMError.guarantee(universe == null, "There shouldn't be a race condition on Feature.duringSetup.");
-        }
+        runConditionalTask(condition, task);
     }
 
     private void setQueryFlag(Class<?> clazz, int flag) {