lcb: Add annotation to overwrite operands (#493)

* ast: Defined new annotation for overwriting operands

* viam: Add overwritten nodes to graph

* chore: Fix build

* viam: Fixed broken layers

* ast: Support multiple fields in annotation

* lcb: Moved node to LCB

* chore: Fixed build

* ast: Addressed feedback and use fields directly

* ast: Renamed "overwrite operand" to "add operands"

Author: kper

sys/aarch64/aarch64.vadl

@@ -1764,13 +1764,15 @@ instruction set architecture AArch64Base = {
     }
 
   model ExceptionCallInstr (i: InstrWithFunct): IsaDefs = {
+    [add operands : imm16]
     instruction $i.id: SuperVisorCallFormat = {
       raise GeneralException (ExceptionClass::$i.funct, 0, PC.next, 0)
       }
     $ExceptionCallEncAsm ($i)
     }
 
   model HaltInstr (i: InstrWithFunct): IsaDefs = {
+    [add operands : imm16]
     instruction $i.id: SuperVisorCallFormat = {}
     $ExceptionCallEncAsm ($i)
     }
@@ -1797,6 +1799,7 @@ instruction set architecture AArch64Base = {
     }
 
   model BTIInstr (i: InstrNoFunct): IsaDefs = {
+    [add operands : bti]
     instruction $i.id: BTIFormat = {}
     encoding $i.id = {op = 0b1101'0101'0000'0011, opc = $i.opcode}
     assembly $i.id = ($i.mnemo, btiOp2(bti))

vadl/main/vadl/ast/AnnotationTable.java

@@ -20,6 +20,7 @@
 import static java.util.Objects.requireNonNull;
 import static vadl.error.Diagnostic.ensure;
 import static vadl.error.Diagnostic.error;
+import static vadl.viam.ViamError.ensurePresent;
 
 import com.google.errorprone.annotations.concurrent.LazyInit;
 import java.math.BigInteger;
@@ -35,6 +36,7 @@
 import java.util.function.Supplier;
 import java.util.stream.Collectors;
 import javax.annotation.Nullable;
+import vadl.error.Diagnostic;
 import vadl.gcb.annotations.OnlyNegativeNumbersAnnotation;
 import vadl.gcb.annotations.SkipPruningAnnotation;
 import vadl.gcb.annotations.StatusRegisterAnnotation;
@@ -46,12 +48,14 @@
 import vadl.viam.AssemblyDescription;
 import vadl.viam.Constant;
 import vadl.viam.Encoding;
+import vadl.viam.Format;
 import vadl.viam.Instruction;
 import vadl.viam.MemoryRegion;
 import vadl.viam.RegisterTensor;
 import vadl.viam.Relocation;
 import vadl.viam.annotations.AsmParserCaseSensitive;
 import vadl.viam.annotations.AsmParserCommentString;
+import vadl.viam.annotations.DefineOperandAnnotation;
 import vadl.viam.annotations.EnableHtifAnno;
 import vadl.viam.annotations.InstructionUndefinedAnno;
 
@@ -240,6 +244,17 @@ public class AnnotationTable {
             def.addAnnotation(new OnlyNegativeNumbersAnnotation());
           }
         }).build();
+
+    annotationOn(InstructionDefinition.class, "add operands", DefinitionRefAnnotation::new)
+        .applyViam((def, annotation, lowering) -> {
+          var fields =
+              annotation.def.stream()
+                  .map(x -> (Format.Field) ensurePresent(lowering.fetch((RangeFormatField) x),
+                      () -> Diagnostic.error("Cannot find field", x.location()))).toList();
+
+          def.addAnnotation(new DefineOperandAnnotation(fields));
+        }).build();
+
   }
 
   /**
@@ -1266,30 +1281,31 @@ void resolveName(AnnotationDefinition definition, SymbolTable.SymbolResolver res
 }
 
 class DefinitionRefAnnotation extends Annotation {
-  @LazyInit
-  Definition def;
+  List<Definition> def = new ArrayList<>();
 
   private Expr firstVal() {
     return definition.values.getFirst();
   }
 
   @Override
   void resolveName(AnnotationDefinition definition, SymbolTable.SymbolResolver resolver) {
-    verifyValuesCnt(definition, 1);
     // resolve the symbol of the value
-    firstVal().accept(resolver);
+    for (var v : definition.values) {
+      v.accept(resolver);
+    }
   }
 
   @Override
   void typeCheck(AnnotationDefinition definition, TypeChecker typeChecker) {
-    var v = firstVal();
-    ensure(v instanceof Identifier, () -> error("Invalid annotation value", v)
-        .description("A single identifier was expected.")
-    );
-    var target = ((Identifier) v).target();
-    ensure(target instanceof Definition, () -> error("Invalid annotation value", v)
-        .description("The identifier must reference a definition."));
-    def = (Definition) target;
+    for (var v : definition.values) {
+      ensure(v instanceof Identifier, () -> error("Invalid annotation value", v)
+          .description("A single identifier was expected.")
+      );
+      var target = ((Identifier) v).target();
+      ensure(target instanceof Definition, () -> error("Invalid annotation value", v)
+          .description("The identifier must reference a definition."));
+      def.add((Definition) target);
+    }
   }
 
   @Override

vadl/main/vadl/cppCodeGen/mixins/CInvalidMixins.java

@@ -45,7 +45,6 @@ public interface CInvalidMixins {
   interface SideEffect
       extends WriteRegTensor, WriteMem, WriteArtificialRes, ProcCall,
       WriteStageOutput {
-
   }
 
   @SuppressWarnings("MissingJavadocType")

vadl/main/vadl/gcb/passes/IdentifyFieldUsagePass.java

@@ -207,10 +207,7 @@ public Map<Field, List<FieldUsage>> getFieldUsages(Instruction instruction) {
      * {@link Format} then return an empty list.
      */
     public List<FieldUsage> getFieldUsages(Instruction instruction, Field field) {
-      var obj = ensureNonNull(fieldUsage.get(instruction),
-          () -> Diagnostic.error("Cannot find field's usages for instruction",
-              instruction.location()));
-
+      var obj = fieldUsage.getOrDefault(instruction, new IdentityHashMap<>());
       return Optional.ofNullable(obj.get(field)).orElse(Collections.emptyList());
     }
 

vadl/main/vadl/iss/passes/tcgLowering/TcgCtx.java

@@ -180,7 +180,6 @@ List<TcgVRefNode> handle(ProcCallNode toHandle) {
       throw new IllegalStateException("ProcCallNode should not exist here.");
     }
 
-
     private TcgVRefNode toNode(TcgV tcgV) {
       return toNode(tcgV, new NodeList<>());
     }

vadl/main/vadl/lcb/codegen/assembly/AbstractAssemblyInstructionPrinterHandler.java

@@ -17,16 +17,22 @@
 package vadl.lcb.codegen.assembly;
 
 import com.google.errorprone.annotations.concurrent.LazyInit;
+import vadl.cppCodeGen.context.CGenContext;
 import vadl.cppCodeGen.context.CNodeContext;
 import vadl.cppCodeGen.mixins.CDefaultMixins;
+import vadl.cppCodeGen.mixins.CInvalidMixins;
+import vadl.error.Diagnostic;
+import vadl.javaannotations.Handler;
+import vadl.lcb.graph.DefinedImmediateSideEffectNode;
 import vadl.lcb.passes.llvmLowering.tablegen.model.TableGenInstruction;
 import vadl.viam.PrintableInstruction;
+import vadl.viam.graph.Node;
 
 /**
  * Abstract class for assembly printing functionality.
  */
 public abstract class AbstractAssemblyInstructionPrinterHandler
-    implements CDefaultMixins.AllExpressions {
+    implements CDefaultMixins.AllExpressions, CInvalidMixins {
 
   protected final PrintableInstruction instruction;
   protected final TableGenInstruction tableGenInstruction;
@@ -43,4 +49,12 @@ public AbstractAssemblyInstructionPrinterHandler(PrintableInstruction instructio
     this.instruction = instruction;
     this.tableGenInstruction = tableGenInstruction;
   }
+
+  @Handler
+  @SuppressWarnings("MissingJavadocMethod")
+  public void handle(CGenContext<Node> ctx, DefinedImmediateSideEffectNode node) {
+    throw Diagnostic.error(
+        "not supported",
+        node.location()).build();
+  }
 }

vadl/main/vadl/lcb/codegen/assembly/AssemblyInstructionPrinterImmediateHandler.java

@@ -27,6 +27,7 @@
 import java.util.stream.Stream;
 import vadl.cppCodeGen.context.CGenContext;
 import vadl.cppCodeGen.context.CNodeContext;
+import vadl.cppCodeGen.mixins.CInvalidMixins;
 import vadl.error.Diagnostic;
 import vadl.gcb.passes.IdentifyFieldUsagePass;
 import vadl.gcb.passes.operands.ReferencesFormatField;
@@ -95,7 +96,7 @@
 @DispatchFor(
     value = Node.class,
     context = CNodeContext.class,
-    include = {"vadl.viam"}
+    include = {"vadl.viam", "vadl.lcb.graph"}
 )
 public class AssemblyInstructionPrinterImmediateHandler
     extends AbstractAssemblyInstructionPrinterHandler {

vadl/main/vadl/lcb/codegen/assembly/AssemblyInstructionPrinterLabelHandler.java

@@ -21,6 +21,7 @@
 import java.util.ArrayList;
 import vadl.cppCodeGen.context.CGenContext;
 import vadl.cppCodeGen.context.CNodeContext;
+import vadl.cppCodeGen.mixins.CInvalidMixins;
 import vadl.error.Diagnostic;
 import vadl.javaannotations.DispatchFor;
 import vadl.lcb.passes.llvmLowering.tablegen.model.TableGenInstruction;
@@ -41,7 +42,7 @@
 @DispatchFor(
     value = Node.class,
     context = CNodeContext.class,
-    include = {"vadl.viam"}
+    include = {"vadl.viam", "vadl.lcb.graph"}
 )
 public class AssemblyInstructionPrinterLabelHandler
     extends AssemblyInstructionPrinterImmediateHandler {

vadl/main/vadl/lcb/graph/DefinedImmediateSideEffectNode.java

@@ -0,0 +1,69 @@
+// SPDX-FileCopyrightText : © 2025 TU Wien <vadl@tuwien.ac.at>
+// SPDX-License-Identifier: GPL-3.0-or-later
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+package vadl.lcb.graph;
+
+import java.util.List;
+import javax.annotation.Nullable;
+import vadl.javaannotations.viam.Input;
+import vadl.viam.graph.GraphNodeVisitor;
+import vadl.viam.graph.Node;
+import vadl.viam.graph.dependency.ExpressionNode;
+import vadl.viam.graph.dependency.SideEffectNode;
+
+/**
+ * Node which indicates that a field or field access function is used. This is required for the LCB
+ * since not all operands of an instruction must be part of a behavior.
+ */
+public class DefinedImmediateSideEffectNode extends SideEffectNode {
+  @Input
+  private ExpressionNode value;
+
+  public DefinedImmediateSideEffectNode(@Nullable ExpressionNode condition, ExpressionNode value) {
+    super(condition);
+    this.value = value;
+  }
+
+  @Override
+  public Node copy() {
+    return new DefinedImmediateSideEffectNode(condition != null
+        ? condition.copy() : null,
+        value.copy());
+  }
+
+  @Override
+  public Node shallowCopy() {
+    return new DefinedImmediateSideEffectNode(condition, value);
+  }
+
+  @Override
+  public <T extends GraphNodeVisitor> void accept(T visitor) {
+    visitor.visit(this);
+  }
+
+  @Override
+  protected void collectInputs(List<Node> collection) {
+    super.collectInputs(collection);
+    collection.add(value);
+  }
+
+  @Override
+  public void applyOnInputsUnsafe(
+      vadl.viam.graph.GraphVisitor.Applier<vadl.viam.graph.Node> visitor) {
+    super.applyOnInputsUnsafe(visitor);
+    value = visitor.apply(this, value, ExpressionNode.class);
+  }
+}

vadl/main/vadl/lcb/passes/OverwriteInputOperandsPass.java

@@ -0,0 +1,62 @@
+// SPDX-FileCopyrightText : © 2025 TU Wien <vadl@tuwien.ac.at>
+// SPDX-License-Identifier: GPL-3.0-or-later
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+package vadl.lcb.passes;
+
+import java.io.IOException;
+import javax.annotation.Nullable;
+import vadl.configuration.GeneralConfiguration;
+import vadl.lcb.graph.DefinedImmediateSideEffectNode;
+import vadl.pass.Pass;
+import vadl.pass.PassName;
+import vadl.pass.PassResults;
+import vadl.viam.Specification;
+import vadl.viam.annotations.DefineOperandAnnotation;
+import vadl.viam.graph.dependency.FieldRefNode;
+
+/**
+ * Reads all the {@link DefineOperandAnnotation} and adds them as
+ * {@link DefinedImmediateSideEffectNode}.
+ */
+public class OverwriteInputOperandsPass extends Pass {
+  public OverwriteInputOperandsPass(GeneralConfiguration configuration) {
+    super(configuration);
+  }
+
+  @Override
+  public PassName getName() {
+    return new PassName("OverwriteInputOperandsPass");
+  }
+
+  @Nullable
+  @Override
+  public Object execute(PassResults passResults, Specification viam) throws IOException {
+    var machineInstructions = viam.isa().stream()
+        .flatMap(isa -> isa.ownInstructions().stream())
+        .filter(x -> x.hasAnnotation(DefineOperandAnnotation.class));
+
+    machineInstructions.forEach(machineInstruction -> {
+      var annotation = machineInstruction.expectAnnotation(DefineOperandAnnotation.class);
+
+      for (var field : annotation.inputs()) {
+        machineInstruction.behavior().addWithInputs(
+            new DefinedImmediateSideEffectNode(null, new FieldRefNode(field, field.type())));
+      }
+    });
+
+    return null;
+  }
+}