Adjustment of materialization of LocalVarIncNode, ForNode, and SwitchNode.

Author: jchalou

graal-js/src/com.oracle.truffle.js/src/com/oracle/truffle/js/nodes/access/LocalVarIncNode.java

@@ -56,12 +56,10 @@
 import com.oracle.truffle.api.profiles.ConditionProfile;
 import com.oracle.truffle.js.nodes.JavaScriptNode;
 import com.oracle.truffle.js.nodes.binary.JSAddNode;
-import com.oracle.truffle.js.nodes.binary.JSBinaryNode;
 import com.oracle.truffle.js.nodes.binary.JSSubtractNode;
 import com.oracle.truffle.js.nodes.cast.JSToNumericNode;
 import com.oracle.truffle.js.nodes.instrumentation.JSTags.ReadVariableTag;
 import com.oracle.truffle.js.nodes.instrumentation.JSTags.WriteVariableTag;
-import com.oracle.truffle.js.nodes.unary.JSUnaryNode;
 import com.oracle.truffle.js.runtime.BigInt;
 import com.oracle.truffle.js.runtime.JSRuntime;
 import com.oracle.truffle.js.runtime.SafeInteger;
@@ -203,18 +201,8 @@ abstract class LocalVarOpMaterializedNode extends LocalVarIncNode {
         super(from.op, from.frameSlot, from.hasTemporalDeadZone, from.scopeFrameNode);
 
         JavaScriptNode readOld = JSReadFrameSlotNode.create(frameSlot, scopeFrameNode, hasTemporalDeadZone);
-        JavaScriptNode convert = JSToNumericNode.create(readOld);
-        if (materializedTags != null) {
-            // need to force materialization, because the convert node might not have source section
-            // at this point
-            JavaScriptNode materializedConvertNode = (JavaScriptNode) convert.materializeInstrumentableNodes(materializedTags);
-            if (convert == materializedConvertNode) {
-                convert = cloneUninitialized(convert, materializedTags);
-            } else {
-                convert = materializedConvertNode;
-            }
-        }
-        convertOld = JSWriteFrameSlotNode.create(frameSlot, scopeFrameNode, convert, hasTemporalDeadZone);
+        JavaScriptNode convert = (JavaScriptNode) JSToNumericNode.create(readOld).materializeInstrumentableNodes(materializedTags);
+        convertOld = cloneUninitialized(JSWriteFrameSlotNode.create(frameSlot, scopeFrameNode, convert, hasTemporalDeadZone), materializedTags);
 
         JavaScriptNode readTmp = JSReadFrameSlotNode.create(frameSlot, scopeFrameNode, hasTemporalDeadZone);
         JavaScriptNode one = JSConstantNode.createInt(1);
@@ -224,26 +212,15 @@ abstract class LocalVarOpMaterializedNode extends LocalVarIncNode {
         } else {
             opNode = JSAddNode.create(readTmp, one);
         }
-        if (materializedTags != null) {
-            // need to force materialization, because the convert node might not have source section
-            // at this point
-            JavaScriptNode materializedOpNode = (JavaScriptNode) opNode.materializeInstrumentableNodes(materializedTags);
-            if (opNode == materializedOpNode) {
-                opNode = cloneUninitialized(opNode, materializedTags);
-            } else {
-                opNode = materializedOpNode;
-            }
-        }
-        this.writeNew = JSWriteFrameSlotNode.create(frameSlot, scopeFrameNode, opNode, hasTemporalDeadZone);
-        // The readTmp and one nodes are no longer valid, they have been cloned
-        if (opNode instanceof JSBinaryNode) {
-            transferSourceSectionAddExpressionTag(from, ((JSBinaryNode) opNode).getLeft());
-            transferSourceSectionAddExpressionTag(from, ((JSBinaryNode) opNode).getRight());
-        } else if (opNode instanceof JSUnaryNode) {
-            transferSourceSectionAddExpressionTag(from, ((JSUnaryNode) opNode).getOperand());
-        }
-        transferSourceSectionAddExpressionTag(from, writeNew);
+        /*
+         * Have to transfer source sections before cloning and materialization. Some nodes might
+         * become instrumentable by this operation.
+         */
+        transferSourceSectionAddExpressionTag(from, readTmp);
+        transferSourceSectionAddExpressionTag(from, one);
         transferSourceSectionAddExpressionTag(from, opNode);
+        this.writeNew = cloneUninitialized(JSWriteFrameSlotNode.create(frameSlot, scopeFrameNode, opNode, hasTemporalDeadZone), materializedTags);
+        transferSourceSectionAddExpressionTag(from, writeNew);
         transferSourceSectionAndTags(from, this);
     }
 

graal-js/src/com.oracle.truffle.js/src/com/oracle/truffle/js/nodes/control/ForNode.java

@@ -99,9 +99,10 @@ public Object getNodeObject() {
     public InstrumentableNode materializeInstrumentableNodes(Set<Class<? extends Tag>> materializedTags) {
         if (hasMaterializationTag(materializedTags) && AbstractRepeatingNode.materializationNeeded(loop.getRepeatingNode())) {
             IterationScopeNode newCopy = cloneUninitialized(copy, materializedTags);
-            // The repeating node might not be instrumentable at this point, because source section
-            // is transferred later,
-            // so we need to force the materialization of repeating node.
+            /*
+             * The repeating node might not be instrumentable at this point, because source section
+             * is transferred later, so we need to force the materialization of repeating node.
+             */
             AbstractRepeatingNode materializedLoop = (AbstractRepeatingNode) ((AbstractRepeatingNode) loop.getRepeatingNode()).materializeInstrumentableNodes(materializedTags);
             if (materializedLoop == loop.getRepeatingNode()) {
                 materializedLoop = cloneUninitialized((AbstractRepeatingNode) loop.getRepeatingNode(), materializedTags);

graal-js/src/com.oracle.truffle.js/src/com/oracle/truffle/js/nodes/control/SwitchNode.java

@@ -109,25 +109,37 @@ public Object getNodeObject() {
     public InstrumentableNode materializeInstrumentableNodes(Set<Class<? extends Tag>> materializedTags) {
         if (materializedTags.contains(ControlFlowRootTag.class) && needsMaterialization()) {
             JavaScriptNode[] newCaseExpressions = new JavaScriptNode[caseExpressions.length];
-            boolean somethingChanged = false;
+            boolean wasChanged = false;
             for (int i = 0; i < caseExpressions.length; i++) {
                 InstrumentableNode materialized = caseExpressions[i].materializeInstrumentableNodes(materializedTags);
                 newCaseExpressions[i] = JSTaggedExecutionNode.createForInput((JavaScriptNode) materialized, ControlFlowBranchTag.class,
                                 JSTags.createNodeObjectDescriptor("type", ControlFlowBranchTag.Type.Condition.name()), materializedTags);
                 if (newCaseExpressions[i] != caseExpressions[i]) {
-                    somethingChanged = true;
+                    wasChanged = true;
                 }
             }
             JavaScriptNode[] newStatements = new JavaScriptNode[statements.length];
             for (int i = 0; i < statements.length; i++) {
                 InstrumentableNode materialized = statements[i].materializeInstrumentableNodes(materializedTags);
                 newStatements[i] = JSTaggedExecutionNode.createFor((JavaScriptNode) materialized, ControlFlowBlockTag.class, materializedTags);
                 if (newStatements[i] != statements[i]) {
-                    somethingChanged = true;
+                    wasChanged = true;
                 }
             }
-            if (!somethingChanged) {
+            if (!wasChanged) {
                 return this;
+            } else {
+                // clone expressions and statements that were not cloned by materialization
+                for (int i = 0; i < caseExpressions.length; i++) {
+                    if (newCaseExpressions[i] == caseExpressions[i]) {
+                        newCaseExpressions[i] = cloneUninitialized(caseExpressions[i], materializedTags);
+                    }
+                }
+                for (int i = 0; i < statements.length; i++) {
+                    if (newStatements[i] == statements[i]) {
+                        newStatements[i] = cloneUninitialized(statements[i], materializedTags);
+                    }
+                }
             }
             SwitchNode materialized = SwitchNode.create(newCaseExpressions, jumptable, newStatements);
             transferSourceSectionAndTags(this, materialized);