[GR-32229] Allow to fixup the stamp of FallbackInvokeWithExceptionNode.

PullRequest: graal/9499

Author: zapster

compiler/src/org.graalvm.compiler.graph/src/org/graalvm/compiler/graph/Graph.java

@@ -1241,7 +1241,7 @@ public int nodeIdCount() {
      * @param replacementsMap the replacement map (can be null if no replacement is to be performed)
      * @return a map which associates the original nodes from {@code nodes} to their duplicates
      */
-    public UnmodifiableEconomicMap<Node, Node> addDuplicates(Iterable<? extends Node> newNodes, final Graph oldGraph, int estimatedNodeCount, EconomicMap<Node, Node> replacementsMap) {
+    public EconomicMap<Node, Node> addDuplicates(Iterable<? extends Node> newNodes, final Graph oldGraph, int estimatedNodeCount, EconomicMap<Node, Node> replacementsMap) {
         DuplicationReplacement replacements;
         if (replacementsMap == null) {
             replacements = null;

compiler/src/org.graalvm.compiler.replacements/src/org/graalvm/compiler/replacements/SnippetTemplate.java

@@ -1608,7 +1608,7 @@ public UnmodifiableEconomicMap<Node, Node> instantiate(MetaAccessProvider metaAc
             StructuredGraph replaceeGraph = replacee.graph();
             EconomicMap<Node, Node> replacements = bind(replaceeGraph, metaAccess, args);
             replacements.put(entryPointNode, AbstractBeginNode.prevBegin(replacee));
-            UnmodifiableEconomicMap<Node, Node> duplicates = inlineSnippet(replacee, debug, replaceeGraph, replacements);
+            EconomicMap<Node, Node> duplicates = inlineSnippet(replacee, debug, replaceeGraph, replacements);
 
             // Re-wire the control flow graph around the replacee
             FixedNode firstCFGNodeDuplicate = (FixedNode) duplicates.get(firstCFGNode);
@@ -1712,6 +1712,8 @@ public UnmodifiableEconomicMap<Node, Node> instantiate(MetaAccessProvider metaAc
                 InvokeWithExceptionNode invoke = macroNode.createInvoke(returnValue);
                 // replace placeholder
                 replaceeGraph.replaceWithExceptionSplit(fallbackInvokeNode, invoke);
+                // register the invoke as the replacement for the fallback invoke
+                duplicates.put(fallbackInvoke, invoke);
             }
 
             if (killReplacee) {
@@ -1724,15 +1726,15 @@ public UnmodifiableEconomicMap<Node, Node> instantiate(MetaAccessProvider metaAc
         }
     }
 
-    private UnmodifiableEconomicMap<Node, Node> inlineSnippet(Node replacee, DebugContext debug, StructuredGraph replaceeGraph, EconomicMap<Node, Node> replacements) {
+    private EconomicMap<Node, Node> inlineSnippet(Node replacee, DebugContext debug, StructuredGraph replaceeGraph, EconomicMap<Node, Node> replacements) {
         Mark mark = replaceeGraph.getMark();
         try (InliningLog.UpdateScope scope = replaceeGraph.getInliningLog().openUpdateScope((oldNode, newNode) -> {
             InliningLog log = replaceeGraph.getInliningLog();
             if (oldNode == null) {
                 log.trackNewCallsite(newNode);
             }
         })) {
-            UnmodifiableEconomicMap<Node, Node> duplicates = replaceeGraph.addDuplicates(nodes, snippet, snippet.getNodeCount(), replacements);
+            EconomicMap<Node, Node> duplicates = replaceeGraph.addDuplicates(nodes, snippet, snippet.getNodeCount(), replacements);
             if (scope != null) {
                 replaceeGraph.getInliningLog().addLog(duplicates, snippet.getInliningLog());
             }

compiler/src/org.graalvm.compiler.replacements/src/org/graalvm/compiler/replacements/nodes/FallbackInvokeWithExceptionNode.java

@@ -31,20 +31,17 @@
 import static org.graalvm.compiler.nodes.Invoke.CYCLES_UNKNOWN_RATIONALE;
 import static org.graalvm.compiler.nodes.Invoke.SIZE_UNKNOWN_RATIONALE;
 
-import org.graalvm.compiler.core.common.type.StampFactory;
-import org.graalvm.compiler.core.common.type.TypeReference;
+import org.graalvm.compiler.core.common.type.Stamp;
 import org.graalvm.compiler.graph.NodeClass;
 import org.graalvm.compiler.nodeinfo.NodeInfo;
 import org.graalvm.compiler.nodes.WithExceptionNode;
 import org.graalvm.compiler.nodes.memory.SingleMemoryKill;
 import org.graalvm.word.LocationIdentity;
 
-import jdk.vm.ci.meta.MetaAccessProvider;
-
 /**
  * Placeholder for a fallback call from a {@link MacroStateSplitWithExceptionNode}.
  *
- * The {@link #fallbackFunctionCallThrowing()} intrinsic can be used in snippets that lower a
+ * The {@link #fallbackFunctionCall()} intrinsic can be used in snippets that lower a
  * {@link MacroStateSplitWithExceptionNode}. The {@link FallbackInvokeWithExceptionNode} will be
  * replaced with the {@linkplain MacroStateSplitWithExceptionNode#createInvoke original call} of the
  * macro node. This can be useful for handling exceptional and/or slow path cases.
@@ -60,18 +57,27 @@ public final class FallbackInvokeWithExceptionNode extends WithExceptionNode imp
 
     public static final NodeClass<FallbackInvokeWithExceptionNode> TYPE = NodeClass.create(FallbackInvokeWithExceptionNode.class);
 
-    public FallbackInvokeWithExceptionNode(@InjectedNodeParameter MetaAccessProvider metaAccess) {
-        super(TYPE, StampFactory.objectNonNull(TypeReference.createExactTrusted(metaAccess.lookupJavaType(Object.class))));
+    public FallbackInvokeWithExceptionNode(@InjectedNodeParameter Stamp stamp) {
+        super(TYPE, stamp);
     }
 
     @Override
     public LocationIdentity getKilledLocationIdentity() {
         return LocationIdentity.any();
     }
 
+    /**
+     * At the time when this node was created (i.e. when creating the snippet template), we did not
+     * have actual parameters so the precise stamp was not known. To fix that, we allow updating it
+     * after the snippet was instantiated.
+     */
+    public boolean updateInitialStamp(Stamp newStamp) {
+        return updateStamp(newStamp);
+    }
+
     /**
      * @see FallbackInvokeWithExceptionNode
      */
     @NodeIntrinsic
-    public static native void fallbackFunctionCallThrowing();
+    public static native Object fallbackFunctionCall();
 }