Validation: use appropriate root node for locals, fix local offset upper bound

Author: DSouzaM

truffle/src/com.oracle.truffle.api.bytecode.test/src/com/oracle/truffle/api/bytecode/test/basic_interpreter/BasicInterpreterTest.java

@@ -1215,6 +1215,55 @@ public void testLocalsNonlocalWrite() {
         assertEquals(2L, root.call());
     }
 
+    @Test
+    public void testLocalsNonlocalDifferentFrameSizes() {
+        /*
+         * When validating/executing a materialized local access, the frame/root of the materialized
+         * local should be used, not the frame/root of the instruction.
+         */
+        BytecodeRootNodes<BasicInterpreter> nodes = createNodes(BytecodeConfig.DEFAULT, b -> {
+            // x = 1
+            // (lambda: x = x + 41)()
+            // return x
+            b.beginRoot(LANGUAGE);
+
+            for (int i = 0; i < 100; i++) {
+                b.createLocal();
+            }
+            BytecodeLocal xLoc = b.createLocal();
+
+            b.beginStoreLocal(xLoc);
+            b.emitLoadConstant(1L);
+            b.endStoreLocal();
+
+            b.beginRoot(LANGUAGE);
+            b.beginStoreLocalMaterialized(xLoc);
+            b.emitLoadArgument(0);
+            b.beginAddConstantOperation(41L);
+            b.beginLoadLocalMaterialized(xLoc);
+            b.emitLoadArgument(0);
+            b.endLoadLocalMaterialized();
+            b.endAddConstantOperation();
+            b.endStoreLocalMaterialized();
+            BasicInterpreter inner = b.endRoot();
+
+            b.beginInvoke();
+            b.beginCreateClosure();
+            b.emitLoadConstant(inner);
+            b.endCreateClosure();
+            b.endInvoke();
+
+            b.beginReturn();
+            b.emitLoadLocal(xLoc);
+            b.endReturn();
+
+            b.endRoot();
+        });
+        BasicInterpreter outer = nodes.getNode(0);
+
+        assertEquals(42L, outer.getCallTarget().call());
+    }
+
     @Test
     public void testVariadicZeroVarargs() {
         // return veryComplex(7);

truffle/src/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/bytecode/generator/BytecodeDSLNodeFactory.java

@@ -9665,8 +9665,7 @@ private CodeExecutableElement createValidateBytecodes() {
             for (InstructionModel instr : model.getInstructions()) {
                 b.startCase().tree(createInstructionConstant(instr)).end().startBlock();
 
-                // instruction data array
-
+                boolean rootNodeAvailable = false;
                 for (InstructionImmediate immediate : instr.getImmediates()) {
                     // argument data array
                     String readImmediate = "bc[bci + " + immediate.offset() + "]";
@@ -9696,26 +9695,27 @@ private CodeExecutableElement createValidateBytecodes() {
                             b.end();
                             break;
                         case LOCAL_OFFSET: {
-                            InstructionImmediate root = instr.getImmediate(ImmediateKind.LOCAL_ROOT);
-                            if (root == null) {
-                                b.startAssign("root").string("this.getRoot()").end();
-                            } else {
-                                b.startAssign("root").string("this.getRoot().getBytecodeRootNodeImpl(", readBc("bci + " + root.offset()), ")").end();
+                            if (!rootNodeAvailable) {
+                                rootNodeAvailable = tryEmitRootNodeForLocalInstruction(b, instr);
+                            }
+                            b.startIf().string(localName).string(" < USER_LOCALS_START_IDX");
+                            if (rootNodeAvailable) {
+                                b.string(" || ").string(localName).string(" >= root.maxLocals");
                             }
-                            b.startIf().string(localName).string(" - USER_LOCALS_START_IDX").string(" < 0 || ").string(localName).string(" - USER_LOCALS_START_IDX").string(
-                                            " >= root.maxLocals").end().startBlock();
+                            b.end().startBlock();
                             b.tree(createValidationErrorWithBci("local offset is out of bounds"));
                             b.end();
                             break;
                         }
                         case LOCAL_INDEX: {
-                            InstructionImmediate root = instr.getImmediate(ImmediateKind.LOCAL_ROOT);
-                            if (root == null) {
-                                b.startAssign("root").string("this.getRoot()").end();
-                            } else {
-                                b.startAssign("root").string("this.getRoot().getBytecodeRootNodeImpl(", readBc("bci + " + root.offset()), ")").end();
+                            if (!rootNodeAvailable) {
+                                rootNodeAvailable = tryEmitRootNodeForLocalInstruction(b, instr);
+                            }
+                            b.startIf().string(localName).string(" < 0");
+                            if (rootNodeAvailable) {
+                                b.string(" || ").string(localName).string(" >= root.numLocals");
                             }
-                            b.startIf().string(localName).string(" < 0 || ").string(localName).string(" >= root.numLocals").end().startBlock();
+                            b.end().startBlock();
                             b.tree(createValidationErrorWithBci("local index is out of bounds"));
                             b.end();
                             break;
@@ -9868,6 +9868,26 @@ private CodeExecutableElement createValidateBytecodes() {
             return validate;
         }
 
+        private boolean tryEmitRootNodeForLocalInstruction(CodeTreeBuilder b, InstructionModel instr) {
+            switch (instr.kind) {
+                case LOAD_LOCAL, STORE_LOCAL, CLEAR_LOCAL: {
+                    b.startAssign("root").string("this.getRoot()").end();
+                    return true;
+                }
+                case LOAD_LOCAL_MATERIALIZED, STORE_LOCAL_MATERIALIZED: {
+                    InstructionImmediate rootImmediate = instr.getImmediate(ImmediateKind.LOCAL_ROOT);
+                    if (rootImmediate != null) {
+                        b.startAssign("root").startCall("this.getRoot().getBytecodeRootNodeImpl").tree(readImmediate("bc", "bci", rootImmediate)).end(2);
+                        return true;
+                    }
+                    break;
+                }
+                default:
+                    throw new AssertionError("Unexpected instruction: " + instr);
+            }
+            return false;
+        }
+
         /**
          * Returns true if the instruction can take -1 as a child bci.
          */