[GR-48365] Be more conservative when merging PiNodes and ValueAnchorNodes

tkrodriguez · tkrodriguez · commit de9f8d540519 · 2023-12-02T06:30:37.000Z
PullRequest: graal/15653
diff --git a/compiler/src/jdk.graal.compiler.test/src/jdk/graal/compiler/core/test/ea/EscapeAnalysisTest.java b/compiler/src/jdk.graal.compiler.test/src/jdk/graal/compiler/core/test/ea/EscapeAnalysisTest.java
@@ -408,7 +408,7 @@ public boolean testInstanceOfSnippet() {
 
     @SuppressWarnings("unused")
     public static void testNewNodeSnippet() {
-        new ValueAnchorNode(null);
+        new ValueAnchorNode();
     }
 
     /**
diff --git a/compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/nodes/ConditionAnchorNode.java b/compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/nodes/ConditionAnchorNode.java
@@ -86,7 +86,7 @@ public Node canonical(CanonicalizerTool tool, Node forValue) {
             // An anchor that still has usages must still exist since it's possible the condition is
             // true for control flow reasons so the Pi stamp is also only valid for those reason.
             if (c.getValue() == negated || hasUsages()) {
-                return new ValueAnchorNode(null);
+                return new ValueAnchorNode();
             } else {
                 return null;
             }
@@ -100,7 +100,7 @@ public Node canonical(CanonicalizerTool tool, Node forValue) {
     @Override
     public void lower(LoweringTool tool) {
         if (graph().getGuardsStage() == GraphState.GuardsStage.FIXED_DEOPTS) {
-            ValueAnchorNode newAnchor = graph().add(new ValueAnchorNode(null));
+            ValueAnchorNode newAnchor = graph().add(new ValueAnchorNode());
             graph().replaceFixedWithFixed(this, newAnchor);
         }
     }
diff --git a/compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/nodes/FixedGuardNode.java b/compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/nodes/FixedGuardNode.java
@@ -103,7 +103,7 @@ public void simplify(SimplifierTool tool) {
                  * are required to be anchored. After guard lowering it might be possible to replace
                  * the ValueAnchorNode with the Begin of the current block.
                  */
-                graph().replaceFixedWithFixed(this, graph().add(new ValueAnchorNode(null)));
+                graph().replaceFixedWithFixed(this, graph().add(new ValueAnchorNode()));
             } else {
                 graph().removeFixed(this);
             }
diff --git a/compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/nodes/PiNode.java b/compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/nodes/PiNode.java
@@ -227,7 +227,7 @@ public void virtualize(VirtualizerTool tool) {
         }
     }
 
-    public static ValueNode canonical(ValueNode object, Stamp piStamp, GuardingNode guard, PiNode self) {
+    public static ValueNode canonical(ValueNode object, Stamp piStamp, GuardingNode guard, ValueNode self) {
         // Use most up to date stamp.
         Stamp computedStamp = piStamp.improveWith(object.stamp(NodeView.DEFAULT));
 
@@ -257,15 +257,16 @@ public static ValueNode canonical(ValueNode object, Stamp piStamp, GuardingNode
                     }
                     if (otherPi.object() == self || otherPi.object() == object) {
                         // Check if other pi's stamp is more precise
-                        Stamp joinedStamp = piStamp.improveWith(otherPi.piStamp());
-                        if (joinedStamp.equals(piStamp)) {
+                        Stamp joinedPiStamp = piStamp.improveWith(otherPi.piStamp());
+                        if (joinedPiStamp.equals(piStamp)) {
                             // Stamp did not get better, nothing to do.
-                        } else if (otherPi.object() == object && joinedStamp.equals(otherPi.piStamp())) {
+                        } else if (otherPi.object() == object && joinedPiStamp.equals(otherPi.piStamp())) {
                             // We can be replaced with the other pi.
                             return otherPi;
-                        } else {
-                            // Create a new pi node with the more precise joined stamp.
-                            return new PiNode(object, joinedStamp, guard.asNode());
+                        } else if (self != null && self.hasExactlyOneUsage() && otherPi.object == self) {
+                            if (joinedPiStamp.equals(otherPi.piStamp)) {
+                                return object;
+                            }
                         }
                     }
                 }
diff --git a/compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/nodes/extended/ValueAnchorNode.java b/compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/nodes/extended/ValueAnchorNode.java
@@ -30,106 +30,45 @@
 import static jdk.graal.compiler.nodeinfo.NodeSize.SIZE_0;
 
 import jdk.graal.compiler.core.common.type.StampFactory;
+import jdk.graal.compiler.graph.Node;
 import jdk.graal.compiler.graph.NodeClass;
 import jdk.graal.compiler.graph.spi.NodeWithIdentity;
 import jdk.graal.compiler.nodeinfo.NodeInfo;
-import jdk.graal.compiler.nodes.virtual.VirtualObjectNode;
-import jdk.graal.compiler.nodes.AbstractBeginNode;
-import jdk.graal.compiler.nodes.FixedNode;
 import jdk.graal.compiler.nodes.FixedWithNextNode;
-import jdk.graal.compiler.nodes.ValueNode;
 import jdk.graal.compiler.nodes.debug.ControlFlowAnchored;
-import jdk.graal.compiler.nodes.memory.FixedAccessNode;
+import jdk.graal.compiler.nodes.spi.Canonicalizable;
+import jdk.graal.compiler.nodes.spi.CanonicalizerTool;
 import jdk.graal.compiler.nodes.spi.LIRLowerable;
 import jdk.graal.compiler.nodes.spi.NodeLIRBuilderTool;
-import jdk.graal.compiler.nodes.spi.Simplifiable;
-import jdk.graal.compiler.nodes.spi.SimplifierTool;
-import jdk.graal.compiler.nodes.spi.Virtualizable;
-import jdk.graal.compiler.nodes.spi.VirtualizerTool;
-import jdk.graal.compiler.nodes.util.GraphUtil;
 
 /**
- * This node can be used for two different kinds of anchoring for non-CFG (floating) nodes: It can
- * 1) keep one node above a certain point in the graph by specifying that node as the
- * {@link #anchored} node; or 2) it can keep nodes below a certain point in the graph by using this
- * node as an Anchor or Guard input.
+ * This node can be used to keep nodes below a certain point in the graph by using this node as an
+ * Anchor or Guard input.
  *
  * This node must not move in the CFG, because that would change the anchor point. So optimizations
  * like de-duplication are not allowed and this node implements {@link NodeWithIdentity}. However,
  * duplication is allowed, i.e., it is on purpose that this node does not implement
  * {@link ControlFlowAnchored}.
  */
 @NodeInfo(allowedUsageTypes = {Anchor, Guard}, cycles = CYCLES_0, size = SIZE_0)
-public final class ValueAnchorNode extends FixedWithNextNode implements LIRLowerable, Simplifiable, Virtualizable, AnchoringNode, GuardingNode, NodeWithIdentity {
+public final class ValueAnchorNode extends FixedWithNextNode implements LIRLowerable, Canonicalizable, AnchoringNode, GuardingNode, NodeWithIdentity {
 
     public static final NodeClass<ValueAnchorNode> TYPE = NodeClass.create(ValueAnchorNode.class);
-    @OptionalInput(Guard) ValueNode anchored;
 
-    public ValueAnchorNode(ValueNode value) {
+    public ValueAnchorNode() {
         super(TYPE, StampFactory.forVoid());
-        this.anchored = value;
     }
 
     @Override
     public void generate(NodeLIRBuilderTool gen) {
         // Nothing to emit, since this node is used for structural purposes only.
     }
 
-    public ValueNode getAnchoredNode() {
-        return anchored;
-    }
-
     @Override
-    public void simplify(SimplifierTool tool) {
-        while (next() instanceof ValueAnchorNode) {
-            ValueAnchorNode nextAnchor = (ValueAnchorNode) next();
-            if (nextAnchor.anchored == anchored || nextAnchor.anchored == null) {
-                // two anchors for the same anchored -> coalesce
-                // nothing anchored on the next anchor -> coalesce
-                nextAnchor.replaceAtUsages(this);
-                GraphUtil.removeFixedWithUnusedInputs(nextAnchor);
-                /*
-                 * Combining two anchors can allow the combining of two PiNode that are now anchored
-                 * at the same place.
-                 */
-                tool.addToWorkList(usages());
-            } else {
-                break;
-            }
-        }
-        if (tool.allUsagesAvailable() && hasNoUsages() && next() instanceof FixedAccessNode) {
-            FixedAccessNode currentNext = (FixedAccessNode) next();
-            if (currentNext.getGuard() == anchored) {
-                GraphUtil.removeFixedWithUnusedInputs(this);
-                return;
-            }
-        }
-
-        if (anchored != null && (anchored.isConstant() || anchored instanceof FixedNode)) {
-            // anchoring fixed nodes and constants is useless
-            removeAnchoredNode();
-        }
-
-        if (anchored == null && hasNoUsages()) {
-            // anchor is not necessary any more => remove.
-            GraphUtil.removeFixedWithUnusedInputs(this);
+    public Node canonical(CanonicalizerTool tool) {
+        if (tool.allUsagesAvailable() && hasNoUsages()) {
+            return null;
         }
-    }
-
-    @Override
-    public void virtualize(VirtualizerTool tool) {
-        if (anchored == null || anchored instanceof AbstractBeginNode) {
-            tool.delete();
-        } else {
-            ValueNode alias = tool.getAlias(anchored);
-            if (alias instanceof VirtualObjectNode) {
-                tool.delete();
-            }
-        }
-    }
-
-    public void removeAnchoredNode() {
-        this.updateUsages(anchored, null);
-        this.anchored = null;
+        return this;
     }
 }
diff --git a/compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/nodes/loop/LoopFragmentInside.java b/compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/nodes/loop/LoopFragmentInside.java
@@ -320,7 +320,7 @@ protected CompareNode placeNewSegmentAndCleanup(LoopEx loop, EconomicMap<Node, N
                      * anchor point here ensuring nothing can flow above the original iteration.
                      */
                     if (!(lastCodeNode instanceof GuardingNode) || !(lastCodeNode instanceof AnchoringNode)) {
-                        ValueAnchorNode newAnchoringPointAfterPrevIteration = graph.add(new ValueAnchorNode(null));
+                        ValueAnchorNode newAnchoringPointAfterPrevIteration = graph.add(new ValueAnchorNode());
                         graph.addAfterFixed(lastCodeNode, newAnchoringPointAfterPrevIteration);
                         lastCodeNode = newAnchoringPointAfterPrevIteration;
                     }
diff --git a/compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/phases/common/ConditionalEliminationPhase.java b/compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/phases/common/ConditionalEliminationPhase.java
@@ -425,7 +425,7 @@ protected void processConditionAnchor(ConditionAnchorNode node) {
                     GraphUtil.unlinkFixedNode(node);
                     GraphUtil.killWithUnusedFloatingInputs(node);
                 } else {
-                    ValueAnchorNode valueAnchor = node.graph().add(new ValueAnchorNode(null));
+                    ValueAnchorNode valueAnchor = node.graph().add(new ValueAnchorNode());
                     node.replaceAtUsages(valueAnchor);
                     node.graph().replaceFixedWithFixed(node, valueAnchor);
                 }
@@ -437,7 +437,11 @@ protected void processConditionAnchor(ConditionAnchorNode node) {
         protected void processGuard(GuardNode node) {
             if (!tryProveGuardCondition(node, node.getCondition(), (guard, result, guardedValueStamp, newInput) -> {
                 if (result != node.isNegated()) {
+                    ValueNode condition = node.getCondition();
                     node.replaceAndDelete(guard.asNode());
+                    if (condition.hasNoUsages()) {
+                        GraphUtil.killWithUnusedFloatingInputs(condition);
+                    }
                     if (guard instanceof DeoptimizingGuard && !((DeoptimizingGuard) guard).isNegated()) {
                         rebuildPiNodes((DeoptimizingGuard) guard);
                     }
diff --git a/compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/phases/common/inlining/InliningUtil.java b/compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/phases/common/inlining/InliningUtil.java
@@ -697,7 +697,7 @@ private static Pair<ValueNode, FixedNode> replaceInvokeAtUsages(ValueNode invoke
                 StructuredGraph graph = origReturn.graph();
                 if (!(anchorCandidate instanceof AbstractBeginNode)) {
                     // Add anchor for pi after the original candidate
-                    ValueAnchorNode anchor = graph.add(new ValueAnchorNode(null));
+                    ValueAnchorNode anchor = graph.add(new ValueAnchorNode());
                     if (anchorCandidate.predecessor() == null) {
                         anchor.setNext(anchorCandidate);
                     } else {
diff --git a/compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/replacements/nodes/MethodHandleNode.java b/compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/replacements/nodes/MethodHandleNode.java
@@ -35,25 +35,21 @@
 import jdk.graal.compiler.core.common.type.StampPair;
 import jdk.graal.compiler.core.common.type.TypeReference;
 import jdk.graal.compiler.debug.GraalError;
-import jdk.graal.compiler.graph.Node;
 import jdk.graal.compiler.graph.NodeClass;
 import jdk.graal.compiler.nodeinfo.NodeInfo;
 import jdk.graal.compiler.nodes.CallTargetNode;
 import jdk.graal.compiler.nodes.CallTargetNode.InvokeKind;
 import jdk.graal.compiler.nodes.FixedGuardNode;
 import jdk.graal.compiler.nodes.FixedNode;
 import jdk.graal.compiler.nodes.FixedWithNextNode;
-import jdk.graal.compiler.nodes.GuardNode;
 import jdk.graal.compiler.nodes.Invoke;
 import jdk.graal.compiler.nodes.InvokeNode;
 import jdk.graal.compiler.nodes.LogicNode;
 import jdk.graal.compiler.nodes.NodeView;
 import jdk.graal.compiler.nodes.PiNode;
 import jdk.graal.compiler.nodes.StructuredGraph;
 import jdk.graal.compiler.nodes.ValueNode;
-import jdk.graal.compiler.nodes.extended.AnchoringNode;
 import jdk.graal.compiler.nodes.extended.GuardingNode;
-import jdk.graal.compiler.nodes.extended.ValueAnchorNode;
 import jdk.graal.compiler.nodes.java.InstanceOfNode;
 import jdk.graal.compiler.nodes.java.MethodCallTargetNode;
 import jdk.graal.compiler.nodes.spi.Simplifiable;
@@ -138,14 +134,6 @@ public GraphAdder(StructuredGraph graph) {
          */
         public abstract <T extends ValueNode> T add(T node);
 
-        /**
-         * @return an {@link AnchoringNode} if floating guards should be created, otherwise
-         *         {@link FixedGuardNode}s will be used.
-         */
-        public AnchoringNode getGuardAnchor() {
-            return null;
-        }
-
         public Assumptions getAssumptions() {
             return graph.getAssumptions();
         }
@@ -331,19 +319,10 @@ private static void maybeCastArgument(GraphAdder adder, ValueNode[] arguments, i
                     assert !inst.isAlive();
                     if (!inst.isTautology()) {
                         inst = adder.add(inst);
-                        AnchoringNode guardAnchor = adder.getGuardAnchor();
                         DeoptimizationReason reason = DeoptimizationReason.ClassCastException;
                         DeoptimizationAction action = DeoptimizationAction.InvalidateRecompile;
                         Speculation speculation = SpeculationLog.NO_SPECULATION;
-                        GuardingNode guard;
-                        if (guardAnchor == null) {
-                            FixedGuardNode fixedGuard = adder.add(new FixedGuardNode(inst, reason, action, speculation, false));
-                            guard = fixedGuard;
-                        } else {
-                            GuardNode newGuard = adder.add(new GuardNode(inst, guardAnchor, reason, action, false, speculation, null));
-                            adder.add(new ValueAnchorNode(newGuard));
-                            guard = newGuard;
-                        }
+                        GuardingNode guard = adder.add(new FixedGuardNode(inst, reason, action, speculation, false));
                         ValueNode valueNode = adder.add(PiNode.create(argument, StampFactory.object(targetType), guard.asNode()));
                         arguments[index] = valueNode;
                     }
diff --git a/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/results/StrengthenGraphs.java b/substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/results/StrengthenGraphs.java
@@ -402,7 +402,7 @@ public void simplify(Node n, SimplifierTool tool) {
                          * anchor the PiNode at the BeginNode of the preceding block, because at
                          * that point the condition is not proven yet.
                          */
-                        ValueAnchorNode anchor = graph.add(new ValueAnchorNode(null));
+                        ValueAnchorNode anchor = graph.add(new ValueAnchorNode());
                         graph.addAfterFixed(survivingBegin, anchor);
                         survivingBegin.replaceAtUsages(anchor, InputType.Guard, InputType.Anchor);
                     }
@@ -726,7 +726,7 @@ private ValueNode insertPi(ValueNode input, Object newStampOrConstant, FixedWith
                 return null;
             }
 
-            ValueAnchorNode anchor = graph.add(new ValueAnchorNode(null));
+            ValueAnchorNode anchor = graph.add(new ValueAnchorNode());
             graph.addAfterFixed(anchorPoint, anchor);
             return graph.unique(new PiNode(input, piStamp, anchor));
         }

Original file line number	Diff line number	Diff line change
`@@ -408,7 +408,7 @@ public boolean testInstanceOfSnippet() {`
`408`	`408`
`409`	`409`	`@SuppressWarnings("unused")`
`410`	`410`	`public static void testNewNodeSnippet() {`
`411`		`- new ValueAnchorNode(null);`
	`411`	`+ new ValueAnchorNode();`
`412`	`412`	`}`
`413`	`413`
`414`	`414`	`/**`
Original file line number	Diff line number	Diff line change
`@@ -86,7 +86,7 @@ public Node canonical(CanonicalizerTool tool, Node forValue) {`
`86`	`86`	`// An anchor that still has usages must still exist since it's possible the condition is`
`87`	`87`	`// true for control flow reasons so the Pi stamp is also only valid for those reason.`
`88`	`88`	`if (c.getValue() == negated \|\| hasUsages()) {`
`89`		`- return new ValueAnchorNode(null);`
	`89`	`+ return new ValueAnchorNode();`
`90`	`90`	`} else {`
`91`	`91`	`return null;`
`92`	`92`	`}`
`@@ -100,7 +100,7 @@ public Node canonical(CanonicalizerTool tool, Node forValue) {`
`100`	`100`	`@Override`
`101`	`101`	`public void lower(LoweringTool tool) {`
`102`	`102`	`if (graph().getGuardsStage() == GraphState.GuardsStage.FIXED_DEOPTS) {`
`103`		`- ValueAnchorNode newAnchor = graph().add(new ValueAnchorNode(null));`
	`103`	`+ ValueAnchorNode newAnchor = graph().add(new ValueAnchorNode());`
`104`	`104`	`graph().replaceFixedWithFixed(this, newAnchor);`
`105`	`105`	`}`
`106`	`106`	`}`
Original file line number	Diff line number	Diff line change
`@@ -103,7 +103,7 @@ public void simplify(SimplifierTool tool) {`
`103`	`103`	`* are required to be anchored. After guard lowering it might be possible to replace`
`104`	`104`	`* the ValueAnchorNode with the Begin of the current block.`
`105`	`105`	`*/`
`106`		`- graph().replaceFixedWithFixed(this, graph().add(new ValueAnchorNode(null)));`
	`106`	`+ graph().replaceFixedWithFixed(this, graph().add(new ValueAnchorNode()));`
`107`	`107`	`} else {`
`108`	`108`	`graph().removeFixed(this);`
`109`	`109`	`}`
Original file line number	Diff line number	Diff line change
`@@ -227,7 +227,7 @@ public void virtualize(VirtualizerTool tool) {`
`227`	`227`	`}`
`228`	`228`	`}`
`229`	`229`
`230`		`- public static ValueNode canonical(ValueNode object, Stamp piStamp, GuardingNode guard, PiNode self) {`
	`230`	`+ public static ValueNode canonical(ValueNode object, Stamp piStamp, GuardingNode guard, ValueNode self) {`
`231`	`231`	`// Use most up to date stamp.`
`232`	`232`	`Stamp computedStamp = piStamp.improveWith(object.stamp(NodeView.DEFAULT));`
`233`	`233`
`@@ -257,15 +257,16 @@ public static ValueNode canonical(ValueNode object, Stamp piStamp, GuardingNode`
`257`	`257`	`}`
`258`	`258`	`if (otherPi.object() == self \|\| otherPi.object() == object) {`
`259`	`259`	`// Check if other pi's stamp is more precise`
`260`		`- Stamp joinedStamp = piStamp.improveWith(otherPi.piStamp());`
`261`		`- if (joinedStamp.equals(piStamp)) {`
	`260`	`+ Stamp joinedPiStamp = piStamp.improveWith(otherPi.piStamp());`
	`261`	`+ if (joinedPiStamp.equals(piStamp)) {`
`262`	`262`	`// Stamp did not get better, nothing to do.`
`263`		`- } else if (otherPi.object() == object && joinedStamp.equals(otherPi.piStamp())) {`
	`263`	`+ } else if (otherPi.object() == object && joinedPiStamp.equals(otherPi.piStamp())) {`
`264`	`264`	`// We can be replaced with the other pi.`
`265`	`265`	`return otherPi;`
`266`		`- } else {`
`267`		`- // Create a new pi node with the more precise joined stamp.`
`268`		`- return new PiNode(object, joinedStamp, guard.asNode());`
	`266`	`+ } else if (self != null && self.hasExactlyOneUsage() && otherPi.object == self) {`
	`267`	`+ if (joinedPiStamp.equals(otherPi.piStamp)) {`
	`268`	`+ return object;`
	`269`	`+ }`
`269`	`270`	`}`
`270`	`271`	`}`
`271`	`272`	`}`
Original file line number	Diff line number	Diff line change
`@@ -320,7 +320,7 @@ protected CompareNode placeNewSegmentAndCleanup(LoopEx loop, EconomicMap<Node, N`
`320`	`320`	`* anchor point here ensuring nothing can flow above the original iteration.`
`321`	`321`	`*/`
`322`	`322`	`if (!(lastCodeNode instanceof GuardingNode) \|\| !(lastCodeNode instanceof AnchoringNode)) {`
`323`		`- ValueAnchorNode newAnchoringPointAfterPrevIteration = graph.add(new ValueAnchorNode(null));`
	`323`	`+ ValueAnchorNode newAnchoringPointAfterPrevIteration = graph.add(new ValueAnchorNode());`
`324`	`324`	`graph.addAfterFixed(lastCodeNode, newAnchoringPointAfterPrevIteration);`
`325`	`325`	`lastCodeNode = newAnchoringPointAfterPrevIteration;`
`326`	`326`	`}`
Original file line number	Diff line number	Diff line change
`@@ -402,7 +402,7 @@ public void simplify(Node n, SimplifierTool tool) {`
`402`	`402`	`* anchor the PiNode at the BeginNode of the preceding block, because at`
`403`	`403`	`* that point the condition is not proven yet.`
`404`	`404`	`*/`
`405`		`- ValueAnchorNode anchor = graph.add(new ValueAnchorNode(null));`
	`405`	`+ ValueAnchorNode anchor = graph.add(new ValueAnchorNode());`
`406`	`406`	`graph.addAfterFixed(survivingBegin, anchor);`
`407`	`407`	`survivingBegin.replaceAtUsages(anchor, InputType.Guard, InputType.Anchor);`
`408`	`408`	`}`
`@@ -726,7 +726,7 @@ private ValueNode insertPi(ValueNode input, Object newStampOrConstant, FixedWith`
`726`	`726`	`return null;`
`727`	`727`	`}`
`728`	`728`
`729`		`- ValueAnchorNode anchor = graph.add(new ValueAnchorNode(null));`
	`729`	`+ ValueAnchorNode anchor = graph.add(new ValueAnchorNode());`
`730`	`730`	`graph.addAfterFixed(anchorPoint, anchor);`
`731`	`731`	`return graph.unique(new PiNode(input, piStamp, anchor));`
`732`	`732`	`}`