Allow to delay methods to the application layer

Author: Zeavee

substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/PointsToAnalysis.java

@@ -346,7 +346,7 @@ public AnalysisMethod addRootMethod(Executable method, boolean invokeSpecial, Ob
 
     @Override
     public AnalysisMethod forcedAddRootMethod(AnalysisMethod method, boolean invokeSpecial, Object reason, MultiMethod.MultiMethodKey... otherRoots) {
-        AnalysisError.guarantee(isBaseLayerAnalysisEnabled());
+        AnalysisError.guarantee(isBaseLayerAnalysisEnabled() || hostVM.buildingImageLayer());
         registerDefaultMethod(method, reason);
         PointsToAnalysisMethod analysisMethod = assertPointsToAnalysisMethod(method);
         postTask(ignore -> {

substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/api/HostVM.java

@@ -284,6 +284,16 @@ public boolean hasNeverInlineDirective(ResolvedJavaMethod method) {
         return true;
     }
 
+    /**
+     * Check if the method has to be inlined.
+     *
+     * @param method the target method
+     */
+    public boolean hasAlwaysInlineDirective(ResolvedJavaMethod method) {
+        /* No force inlining by the static analysis unless explicitly overwritten by the VM. */
+        return false;
+    }
+
     public InlineBeforeAnalysisGraphDecoder createInlineBeforeAnalysisGraphDecoder(BigBang bb, AnalysisMethod method, StructuredGraph resultGraph) {
         /* No inlining by the static analysis unless explicitly overwritten by the VM. */
         return new InlineBeforeAnalysisGraphDecoder(bb, InlineBeforeAnalysisPolicy.NO_INLINING, resultGraph, bb.getProviders(method), null);

substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/flow/InvokeTypeFlow.java

@@ -278,6 +278,10 @@ protected void linkCallee(PointsToAnalysis bb, boolean isStatic, MethodFlowsGrap
         if (!calleeFlows.isStub()) {
             bb.analysisPolicy().registerAsImplementationInvoked(this, calleeFlows.getMethod());
         }
+
+        if (calleeFlows.getMethod().isDelayed()) {
+            saturateForOpenTypeWorld(bb);
+        }
     }
 
     /*
@@ -426,4 +430,15 @@ public boolean canBeStaticallyBound() {
     public MultiMethodKey getCallerMultiMethodKey() {
         return callerMultiMethodKey;
     }
+
+    /**
+     * Saturates the actual return of the invoke type flow to ensure that the type state represents
+     * all the types that could exist in the open world.
+     */
+    public void saturateForOpenTypeWorld(PointsToAnalysis bb) {
+        if (actualReturn != null) {
+            actualReturn.enableFlow(bb);
+            actualReturn.onSaturated(bb);
+        }
+    }
 }

substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/flow/MethodFlowsGraph.java

@@ -490,10 +490,7 @@ void saturateForOpenTypeWorld(PointsToAnalysis bb) {
          */
         for (InvokeTypeFlow invokeTypeFlow : getInvokes()) {
             if (!invokeTypeFlow.isDirectInvoke() && !bb.isClosed(invokeTypeFlow.getReceiverType())) {
-                if (invokeTypeFlow.actualReturn != null) {
-                    invokeTypeFlow.actualReturn.enableFlow(bb);
-                    invokeTypeFlow.actualReturn.onSaturated(bb);
-                }
+                invokeTypeFlow.saturateForOpenTypeWorld(bb);
             }
         }
     }

substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/flow/MethodTypeFlowBuilder.java

@@ -706,6 +706,11 @@ protected void apply(boolean forceReparse, Object reason) {
 
         method.setReachableInCurrentLayer();
 
+        if (method.isDelayed()) {
+            /* The method will be analyzed in the application layer */
+            return;
+        }
+
         if (method.analyzedInPriorLayer()) {
             /*
              * We don't need to analyze this method. We already know its return type state from the

substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/meta/AnalysisMethod.java

@@ -51,6 +51,7 @@
 
 import com.oracle.graal.pointsto.BigBang;
 import com.oracle.graal.pointsto.PointsToAnalysis;
+import com.oracle.graal.pointsto.api.HostVM;
 import com.oracle.graal.pointsto.api.ImageLayerLoader;
 import com.oracle.graal.pointsto.api.ImageLayerWriter;
 import com.oracle.graal.pointsto.constraints.UnsupportedFeatureException;
@@ -126,6 +127,7 @@ public record Signature(String name, AnalysisType[] parameterTypes) {
     public final ResolvedJavaMethod wrapped;
 
     private final int id;
+    private final boolean buildingSharedLayer;
     /** Marks a method loaded from a base layer. */
     private final boolean isInBaseLayer;
     private final boolean analyzedInPriorLayer;
@@ -196,9 +198,12 @@ public record Signature(String name, AnalysisType[] parameterTypes) {
      */
     private boolean hasOpaqueReturn;
 
+    private CompilationBehavior compilationBehavior = CompilationBehavior.DEFAULT;
+
     @SuppressWarnings({"this-escape", "unchecked"})
     protected AnalysisMethod(AnalysisUniverse universe, ResolvedJavaMethod wrapped, MultiMethodKey multiMethodKey, Map<MultiMethodKey, MultiMethod> multiMethodMap) {
         super(universe.hostVM.enableTrackAcrossLayers());
+        HostVM hostVM = universe.hostVM();
         this.wrapped = wrapped;
 
         declaringClass = universe.lookup(wrapped.getDeclaringClass());
@@ -213,13 +218,14 @@ protected AnalysisMethod(AnalysisUniverse universe, ResolvedJavaMethod wrapped,
         } else {
             signature = getUniverse().lookup(wrappedSignature, wrapped.getDeclaringClass());
         }
-        hasNeverInlineDirective = universe.hostVM().hasNeverInlineDirective(wrapped);
+        hasNeverInlineDirective = hostVM.hasNeverInlineDirective(wrapped);
 
         name = createName(wrapped, multiMethodKey);
         qualifiedName = format("%H.%n(%P)");
         modifiers = wrapped.getModifiers();
 
-        if (universe.hostVM().buildingExtensionLayer() && declaringClass.isInBaseLayer()) {
+        buildingSharedLayer = hostVM.buildingSharedLayer();
+        if (hostVM.buildingExtensionLayer() && declaringClass.isInBaseLayer()) {
             int mid = universe.getImageLayerLoader().lookupHostedMethodInBaseLayer(this);
             if (mid != -1) {
                 /*
@@ -236,7 +242,7 @@ protected AnalysisMethod(AnalysisUniverse universe, ResolvedJavaMethod wrapped,
             id = universe.computeNextMethodId();
             isInBaseLayer = false;
         }
-        analyzedInPriorLayer = isInBaseLayer && universe.hostVM().analyzedInPriorLayer(this);
+        analyzedInPriorLayer = isInBaseLayer && hostVM.analyzedInPriorLayer(this);
 
         ExceptionHandler[] original = wrapped.getExceptionHandlers();
         exceptionHandlers = new ExceptionHandler[original.length];
@@ -281,6 +287,7 @@ protected AnalysisMethod(AnalysisMethod original, MultiMethodKey multiMethodKey)
         super(original.enableTrackAcrossLayers);
         wrapped = original.wrapped;
         id = original.id;
+        buildingSharedLayer = original.buildingSharedLayer;
         isInBaseLayer = original.isInBaseLayer;
         analyzedInPriorLayer = original.analyzedInPriorLayer;
         declaringClass = original.declaringClass;
@@ -306,6 +313,35 @@ protected AnalysisMethod(AnalysisMethod original, MultiMethodKey multiMethodKey)
         this.enableReachableInCurrentLayer = original.enableReachableInCurrentLayer;
     }
 
+    public void setCompilationBehavior(CompilationBehavior compilationBehavior) {
+        this.compilationBehavior = compilationBehavior;
+    }
+
+    public CompilationBehavior getCompilationBehavior() {
+        return compilationBehavior;
+    }
+
+    /**
+     * Delays this method to the application layer. This should not be called after the method was
+     * already parsed to avoid analyzing all the method's callees.
+     */
+    public void setFullyDelayedToApplicationLayer() {
+        HostVM hostVM = getUniverse().getBigbang().getHostVM();
+        AnalysisError.guarantee(hostVM.buildingImageLayer(), "Methods can only be delayed in layered images");
+        AnalysisError.guarantee(parsedGraphCacheState.get() == GraphCacheEntry.UNPARSED, "The method %s was marked as delayed to the application layer but was already parsed", this);
+        AnalysisError.guarantee(!hostVM.hasAlwaysInlineDirective(this), "Method %s with an always inline directive cannot be delayed to the application layer as such methods cannot be inlined", this);
+        AnalysisError.guarantee(isConcrete(), "Method %s is not concrete and cannot be delayed to the application layer", this);
+        this.compilationBehavior = CompilationBehavior.FULLY_DELAYED_TO_APPLICATION_LAYER;
+    }
+
+    /**
+     * Returns true if this method is marked as delayed to the application layer and the current
+     * layer is a shared layer.
+     */
+    public boolean isDelayed() {
+        return compilationBehavior == CompilationBehavior.FULLY_DELAYED_TO_APPLICATION_LAYER && buildingSharedLayer;
+    }
+
     private static String createName(ResolvedJavaMethod wrapped, MultiMethodKey multiMethodKey) {
         String aName = wrapped.getName();
         if (multiMethodKey != ORIGINAL_METHOD) {
@@ -847,7 +883,8 @@ public Type[] getGenericParameterTypes() {
 
     @Override
     public boolean canBeInlined() {
-        return !hasNeverInlineDirective();
+        /* Delayed methods should not be inlined in the current layer */
+        return !hasNeverInlineDirective() && !isDelayed();
     }
 
     @Override
@@ -1202,6 +1239,7 @@ private AnalysisParsedGraph setGraph(BigBang bb, Stage stage, GraphCacheEntry ex
                 /* We lost the race, another thread is doing the parsing. */
                 return null;
             }
+            AnalysisError.guarantee(!isDelayed(), "The method %s was parsed even though it was marked as delayed to the application layer", this);
 
             GraphCacheEntry newEntry = graphSupplier.get(bb, this, expectedValue);
 
@@ -1360,4 +1398,40 @@ public boolean hasOpaqueReturn() {
     }
 
     protected abstract AnalysisMethod createMultiMethod(AnalysisMethod analysisMethod, MultiMethodKey newMultiMethodKey);
+
+    /**
+     * This state represents how a method should be compiled in layered images. The state of a
+     * method can only be decided in the first layer if it is marked as tracked across layers. The
+     * state has to stay the same across all the extension layers. If not specified, the state of a
+     * method will be {@link CompilationBehavior#DEFAULT}.
+     */
+    public enum CompilationBehavior {
+
+        /**
+         * Method remains unanalyzed until the application layer and any inlining in a shared layer
+         * is prevented. A call to the method in a shared layer will be replaced by an indirect
+         * call. The compilation of those methods is then forced in the application layer and the
+         * corresponding symbol is declared as global.
+         *
+         * A delayed method that is not referenced in any shared layer is treated as a
+         * {@link CompilationBehavior#DEFAULT} method in the application layer and does not have to
+         * be compiled. If it is only referenced in the application layer, it might be inlined and
+         * not compiled at all.
+         */
+        FULLY_DELAYED_TO_APPLICATION_LAYER,
+
+        /**
+         * Method can be inlined into other methods, both before analysis and during compilation,
+         * and will be compiled as a distinct compilation unit as stipulated by the normal native
+         * image generation process (i.e., the method is installed as a root and/or a reference to
+         * the method exists via a call and/or an explicit MethodReference).
+         */
+        DEFAULT,
+
+        /**
+         * Method is pinned to a specific shared layer, meaning it has to be analyzed and compiled
+         * in this specific layer. A method can only be pinned to a shared layer.
+         */
+        PINNED_TO_SHARED_LAYER,
+    }
 }

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

@@ -40,6 +40,7 @@
 
 import com.oracle.graal.pointsto.BigBang;
 import com.oracle.graal.pointsto.PointsToAnalysis;
+import com.oracle.graal.pointsto.api.HostVM;
 import com.oracle.graal.pointsto.api.PointstoOptions;
 import com.oracle.graal.pointsto.flow.AnalysisParsedGraph;
 import com.oracle.graal.pointsto.flow.InvokeTypeFlow;
@@ -193,6 +194,8 @@ public boolean equals(Object obj) {
     /** Used to avoid aggressive optimizations for open type world analysis. */
     protected final boolean isClosedTypeWorld;
 
+    protected final boolean buildingSharedLayer;
+
     public StrengthenGraphs(BigBang bb, Universe converter) {
         this.bb = bb;
         this.converter = converter;
@@ -208,7 +211,9 @@ public StrengthenGraphs(BigBang bb, Universe converter) {
             beforeCounters = null;
             afterCounters = null;
         }
-        this.isClosedTypeWorld = converter.hostVM().isClosedTypeWorld();
+        HostVM hostVM = converter.hostVM();
+        this.isClosedTypeWorld = hostVM.isClosedTypeWorld();
+        this.buildingSharedLayer = hostVM.buildingSharedLayer();
     }
 
     private static void reportNeverNullInstanceFields(BigBang bb) {

substratevm/src/com.oracle.svm.core.graal.amd64/src/com/oracle/svm/core/graal/amd64/SubstrateAMD64Backend.java

@@ -687,15 +687,22 @@ protected Value emitIndirectForeignCallAddress(ForeignCallLinkage linkage) {
             SubstrateForeignCallLinkage callTarget = (SubstrateForeignCallLinkage) linkage;
             SharedMethod targetMethod = (SharedMethod) callTarget.getMethod();
             if (SubstrateUtil.HOSTED && targetMethod.forceIndirectCall()) {
-                /*
-                 * Load the address for the start of the text section and then add in the offset for
-                 * this specific method.
-                 */
-                var methodLocation = DynamicImageLayerInfo.singleton().getPriorLayerMethodLocation(targetMethod);
-                AllocatableValue basePointerAddress = newVariable(getLIRKindTool().getWordKind());
-                append(new AMD64CGlobalDataLoadAddressOp(methodLocation.base(), basePointerAddress));
-                Value codeOffsetInSection = emitConstant(getLIRKindTool().getWordKind(), JavaConstant.forLong(methodLocation.offset()));
-                return getArithmetic().emitAdd(basePointerAddress, codeOffsetInSection, false);
+                DynamicImageLayerInfo dynamicImageLayerInfo = DynamicImageLayerInfo.singleton();
+                if (dynamicImageLayerInfo.isMethodCompilationDelayed(targetMethod)) {
+                    AllocatableValue methodAddress = newVariable(getLIRKindTool().getWordKind());
+                    append(new AMD64CGlobalDataLoadAddressOp(dynamicImageLayerInfo.getSymbolForDelayedMethod(targetMethod), methodAddress));
+                    return methodAddress;
+                } else {
+                    /*
+                     * Load the address for the start of the text section and then add in the offset
+                     * for this specific method.
+                     */
+                    var methodLocation = dynamicImageLayerInfo.getPriorLayerMethodLocation(targetMethod);
+                    AllocatableValue basePointerAddress = newVariable(getLIRKindTool().getWordKind());
+                    append(new AMD64CGlobalDataLoadAddressOp(methodLocation.base(), basePointerAddress));
+                    Value codeOffsetInSection = emitConstant(getLIRKindTool().getWordKind(), JavaConstant.forLong(methodLocation.offset()));
+                    return getArithmetic().emitAdd(basePointerAddress, codeOffsetInSection, false);
+                }
             }
             if (!shouldEmitOnlyIndirectCalls()) {
                 return null;
@@ -1497,13 +1504,18 @@ private static JavaConstant getZeroConstant(AllocatableValue dst) {
         public AMD64LIRInstruction createLoadMethodPointerConstant(AllocatableValue dst, SubstrateMethodPointerConstant constant) {
             if (ImageLayerBuildingSupport.buildingExtensionLayer()) {
                 if (constant.pointer().getMethod() instanceof SharedMethod sharedMethod && sharedMethod.forceIndirectCall()) {
-                    /*
-                     * AMD64LoadMethodPointerConstantOp retrieves the address via a PC-relative
-                     * load. This is not possible to do in extension layers when referring to
-                     * methods defined in prior layers.
-                     */
-                    var methodLocation = DynamicImageLayerInfo.singleton().getPriorLayerMethodLocation(sharedMethod);
-                    return new AMD64CGlobalDataLoadAddressOp(methodLocation.base(), dst, methodLocation.offset());
+                    DynamicImageLayerInfo dynamicImageLayerInfo = DynamicImageLayerInfo.singleton();
+                    if (dynamicImageLayerInfo.isMethodCompilationDelayed(sharedMethod)) {
+                        return new AMD64CGlobalDataLoadAddressOp(dynamicImageLayerInfo.getSymbolForDelayedMethod(sharedMethod), dst);
+                    } else {
+                        /*
+                         * AMD64LoadMethodPointerConstantOp retrieves the address via a PC-relative
+                         * load. This is not possible to do in extension layers when referring to
+                         * methods defined in prior layers.
+                         */
+                        var methodLocation = dynamicImageLayerInfo.getPriorLayerMethodLocation(sharedMethod);
+                        return new AMD64CGlobalDataLoadAddressOp(methodLocation.base(), dst, methodLocation.offset());
+                    }
                 }
             }
 

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/graal/snippets/NonSnippetLowerings.java

@@ -402,11 +402,17 @@ public void lower(FixedNode node, LoweringTool tool) {
                          * address offset of the text section start and then add in the offset for
                          * this specific method.
                          */
-                        var methodLocation = DynamicImageLayerInfo.singleton().getPriorLayerMethodLocation(targetMethod);
-                        AddressNode methodPointerAddress = graph.addOrUniqueWithInputs(
-                                        new OffsetAddressNode(new CGlobalDataLoadAddressNode(methodLocation.base()),
-                                                        ConstantNode.forIntegerKind(ConfigurationValues.getWordKind(), methodLocation.offset())));
-                        loweredCallTarget = createIndirectCall(graph, callTarget, parameters, method, signature, callType, invokeKind, methodPointerAddress);
+                        DynamicImageLayerInfo dynamicImageLayerInfo = DynamicImageLayerInfo.singleton();
+                        if (dynamicImageLayerInfo.isMethodCompilationDelayed(targetMethod)) {
+                            loweredCallTarget = createIndirectCall(graph, callTarget, parameters, method, signature, callType, invokeKind,
+                                            graph.addOrUniqueWithInputs(new CGlobalDataLoadAddressNode(dynamicImageLayerInfo.getSymbolForDelayedMethod(targetMethod))));
+                        } else {
+                            var methodLocation = dynamicImageLayerInfo.getPriorLayerMethodLocation(targetMethod);
+                            AddressNode methodPointerAddress = graph.addOrUniqueWithInputs(
+                                            new OffsetAddressNode(new CGlobalDataLoadAddressNode(methodLocation.base()),
+                                                            ConstantNode.forIntegerKind(ConfigurationValues.getWordKind(), methodLocation.offset())));
+                            loweredCallTarget = createIndirectCall(graph, callTarget, parameters, method, signature, callType, invokeKind, methodPointerAddress);
+                        }
                     } else if (!SubstrateBackend.shouldEmitOnlyIndirectCalls()) {
                         loweredCallTarget = createDirectCall(graph, callTarget, parameters, signature, callType, invokeKind, targetMethod, node);
                     } else if (!targetMethod.hasImageCodeOffset()) {

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/imagelayer/DynamicImageLayerInfo.java

@@ -50,6 +50,10 @@ public static DynamicImageLayerInfo singleton() {
         return ImageSingletons.lookup(DynamicImageLayerInfo.class);
     }
 
+    public abstract boolean isMethodCompilationDelayed(SharedMethod method);
+
+    public abstract CGlobalDataInfo getSymbolForDelayedMethod(SharedMethod targetMethod);
+
     public record PriorLayerMethodLocation(CGlobalDataInfo base, int offset) {
     }