[GR-80723] Fix publishOldBytecodes emission.

PullRequest: graal/25835

Author: DSouzaM

truffle/src/com.oracle.truffle.api.bytecode.test/src/com/oracle/truffle/api/bytecode/test/NotUpdatableBytecodeTest.java

@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) 2026, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * The Universal Permissive License (UPL), Version 1.0
+ *
+ * Subject to the condition set forth below, permission is hereby granted to any
+ * person obtaining a copy of this software, associated documentation and/or
+ * data (collectively the "Software"), free of charge and under any and all
+ * copyright rights in the Software, and any and all patent rights owned or
+ * freely licensable by each licensor hereunder covering either (i) the
+ * unmodified Software as contributed to or provided by such licensor, or (ii)
+ * the Larger Works (as defined below), to deal in both
+ *
+ * (a) the Software, and
+ *
+ * (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if
+ * one is included with the Software each a "Larger Work" to which the Software
+ * is contributed by such licensors),
+ *
+ * without restriction, including without limitation the rights to copy, create
+ * derivative works of, display, perform, and distribute the Software and make,
+ * use, sell, offer for sale, import, export, have made, and have sold the
+ * Software and the Larger Work(s), and to sublicense the foregoing rights on
+ * either these or other terms.
+ *
+ * This license is subject to the following condition:
+ *
+ * The above copyright notice and either this complete permission notice or at a
+ * minimum a reference to the UPL must be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+package com.oracle.truffle.api.bytecode.test;
+
+import com.oracle.truffle.api.bytecode.BytecodeRootNode;
+import com.oracle.truffle.api.bytecode.GenerateBytecode;
+import com.oracle.truffle.api.bytecode.Operation;
+import com.oracle.truffle.api.dsl.Specialization;
+import com.oracle.truffle.api.frame.FrameDescriptor;
+import com.oracle.truffle.api.nodes.RootNode;
+
+/**
+ * Compile-time regression for a bytecode root that is not updatable.
+ * <p>
+ * Instruction tracing counts as an instrumentation, so a root with tracing left at its default
+ * stays updatable even when it declares no {@code @Instrumentation} and no tags. Disabling tracing
+ * removes that instrumentation. With no other instrumentations or tags, {@code publishOldBytecodes()}
+ * is not generated, and {@code updateBytecode} must not call it. This root fails to compile if the
+ * generated interpreter still emits that call.
+ *
+ * @see <a href="https://github.com/oracle/graal/issues/14682">oracle/graal#14682</a>
+ */
+public class NotUpdatableBytecodeTest {
+
+    @GenerateBytecode(languageClass = BytecodeDSLTestLanguage.class, enableInstructionTracing = false)
+    public abstract static class TracingDisabledRootNode extends RootNode implements BytecodeRootNode {
+
+        protected TracingDisabledRootNode(BytecodeDSLTestLanguage language, FrameDescriptor frameDescriptor) {
+            super(language, frameDescriptor);
+        }
+
+        @Operation
+        public static final class Add {
+            @Specialization
+            public static int doInts(int a, int b) {
+                return a + b;
+            }
+        }
+    }
+
+}

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

@@ -1343,21 +1343,21 @@ private CodeExecutableElement createTransition() {
 
         String transitionBciExpr;
         if (parent.model.isBytecodeUpdatable()) {
-            transitionBciExpr = "newBci";
+            transitionBciExpr = parent.castBytecodeIndexToInt("newBci");
         } else {
             transitionBciExpr = BytecodeRootNodeElement.decodeBci("state");
         }
         if (parent.model.needsCachedTagsTransition()) {
             b.newLine();
             // When transitioning from uncached to cached we need to update local tags.
             if (!parent.model.isBytecodeUpdatable()) {
-                b.declaration(parent.getBytecodeIndexType(), "currentBci", BytecodeRootNodeElement.decodeBci("state"));
+                b.declaration(type(int.class), "currentBci", BytecodeRootNodeElement.decodeBci("state"));
                 transitionBciExpr = "currentBci";
             }
             b.startIf().string(transitionBciExpr).string(" > 0 && this.getTier().ordinal() < bc.getTier().ordinal()").end().startBlock();
             b.lineComment("Populate cached tags for any locals already stored in the frame.");
 
-            b.startDeclaration(type(int.class), "localCount").startCall("bc.getLocalCount").string(parent.castBytecodeIndexToInt(transitionBciExpr)).end(2);
+            b.startDeclaration(type(int.class), "localCount").startCall("bc.getLocalCount").string(transitionBciExpr).end(2);
             b.startFor().string("int localOffset = 0; localOffset < localCount; localOffset++").end().startBlock();
             b.startIf().startCall("FRAMES.getTag").string("frame").string(BytecodeRootNodeElement.USER_LOCALS_START_INDEX + " + localOffset").end().string(" == ").staticReference(
                             parent.frameTagsElement.getIllegal()).end().startBlock();
@@ -1366,10 +1366,10 @@ private CodeExecutableElement createTransition() {
             b.end();
 
             b.startStatement().startCall("bc.setLocalValue");
-            b.string(parent.castBytecodeIndexToInt(transitionBciExpr));
+            b.string(transitionBciExpr);
             b.string("frame");
             b.string("localOffset");
-            b.startCall("bc.getLocalValue").string(parent.castBytecodeIndexToInt(transitionBciExpr)).string("frame").string("localOffset").end();
+            b.startCall("bc.getLocalValue").string(transitionBciExpr).string("frame").string("localOffset").end();
             b.end(2);
             b.end();
             b.end();
@@ -1384,7 +1384,7 @@ private CodeExecutableElement createTransition() {
         b.string("this");
         b.string(BytecodeRootNodeElement.decodeBci("state"));
         b.string("bc");
-        b.string(parent.castBytecodeIndexToInt(transitionBciExpr));
+        b.string(transitionBciExpr);
         b.string("wasCompiled");
         b.end(2); // createTransition + declaration
 

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

@@ -1532,13 +1532,20 @@ private CodeExecutableElement createUpdateBytecode() {
         b.end().end(); // call, call
         b.end(); // statement
 
-        b.startIf().string("bytecodes_ != null").end().startBlock();
-        b.lineComment("Ensure old bytecodes are published before the new bytecode node.");
-        b.statement("oldBytecode.publishOldBytecodes()");
-        b.end().startElseBlock();
-        b.lineComment("When bytecode doesn't change, nodes are reused and should be re-adopted.");
-        b.statement("newBytecode.adoptNodesAfterUpdate()");
-        b.end();
+        if (model.isBytecodeUpdatable()) {
+            b.startIf().string("bytecodes_ != null").end().startBlock();
+            b.lineComment("Ensure old bytecodes are published before the new bytecode node.");
+            b.statement("oldBytecode.publishOldBytecodes()");
+            b.end().startElseBlock();
+            b.lineComment("When bytecode doesn't change, nodes are reused and should be re-adopted.");
+            b.statement("newBytecode.adoptNodesAfterUpdate()");
+            b.end();
+        } else {
+            b.startIf().string("bytecodes_ == null").end().startBlock();
+            b.lineComment("When bytecode doesn't change, nodes are reused and should be re-adopted.");
+            b.statement("newBytecode.adoptNodesAfterUpdate()");
+            b.end();
+        }
         emitFence(b);
         b.end().startDoWhile().startCall("!BYTECODE_UPDATER", "compareAndSet").string("this").string("oldBytecode").string("newBytecode").end().end();
         b.newLine();