decoder: RTL decoder improvements

- improve structure of the hdl decision tree
  by moving default assignments to the top
- for now use big-endian byte order to be compatible
  with the existing RTL description
- Always decode/match all ISA instructions, even if
  no output signal depends on them (as we don't want
  to fall back to 'invalid' in this case)
- Fix/run the test suite (locally) with all 3 decoder
  versions and the rv43im spec.
- Use wildcards in the rtl-table output patterns

Author: rascmatt

vadl/main/resources/templates/rtl/CoreTest.scala

@@ -150,7 +150,7 @@ class CoreTest extends AnyFunSpec with ChiselSim {
                     if (value.testBit(0)) {
                       val result = value >> 1
                       if (result == 0) {
-                        println("RVTEST_PASS")
+                        println(f"RVTEST_PASS: ${file.getName}")
                         passed += file.getName
                       } else {
                         println(f"RVTEST_FAIL $result")
@@ -186,6 +186,9 @@ class CoreTest extends AnyFunSpec with ChiselSim {
     val result = f"passed ${passed.mkString(" ")}\nfailed ${failed.mkString(" ")}\ntimeout ${timeout.mkString(" ")}\n"
     if (failed.nonEmpty || timeout.nonEmpty) {
       fail(result)
+    } else {
+      println(f"All Passed!")
+      println(f"Tests run: ${passed.mkString(" ")}")
     }
   }
 }

vadl/main/vadl/rtl/template/HdlBehavior.java

@@ -328,6 +328,13 @@ String handle(RtlDecodeTreeNode decodeTreeNode) {
         cacheExprOrSig.put(usage, signal.simpleName());
       }
 
+      final var isa = module.context().viam().isa().orElse(null);
+      ViamError.ensureNonNull(isa, "The ISA must not be null.");
+
+      // Include ISA instructions without signals so they're not decoded as 'invalid' insns.
+      isa.ownInstructions()
+          .forEach(i -> decisionMap.computeIfAbsent(i, x -> new HashMap<>()));
+
       ViamError.ensureNonNull(decodeTreeNode.instructionWord(),
           "The instruction word of the RtlDecodeTreeNode must not be null.");
 

vadl/main/vadl/vdt/passes/VdtInputPreparationPass.java

@@ -23,9 +23,7 @@
 import java.io.IOException;
 import java.nio.ByteOrder;
 import java.util.ArrayList;
-import java.util.Collection;
 import java.util.HashSet;
-import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Set;
 import java.util.function.Predicate;
@@ -35,7 +33,6 @@
 import vadl.pass.Pass;
 import vadl.pass.PassName;
 import vadl.pass.PassResults;
-import vadl.rtl.ipg.nodes.RtlDecodeTreeNode;
 import vadl.rtl.passes.InstructionProgressGraphExtension;
 import vadl.types.BuiltInTable;
 import vadl.vdt.impl.irregular.model.DecodeEntry;
@@ -91,21 +88,17 @@ public Object execute(PassResults passResults, Specification viam) throws IOExce
       return null;
     }
 
-    final Collection<Instruction> relevantInstructions;
+    // TODO: get the byte order from the VADL specification -> Implement memory annotations
+    final ByteOrder bo;
     if (isa.hasExtension(InstructionProgressGraphExtension.class)) {
-      // For RTL lowering, we might only want to consider a subset of instructions for the VDT.
-      final var ipg = isa.expectExtension(InstructionProgressGraphExtension.class).ipg();
-      relevantInstructions = ipg.getNodes(RtlDecodeTreeNode.class).findAny()
-          .map(d -> ipg.getContext(d).instructions())
-          .orElse(new LinkedHashSet<>(isa.ownInstructions()));
+      // For now, the HDL assumes big-endian representation of the instruction word
+      bo = ByteOrder.BIG_ENDIAN;
     } else {
-      relevantInstructions = isa.ownInstructions();
+      bo = ByteOrder.LITTLE_ENDIAN;
     }
 
-    // TODO: get the byte order from the VADL specification -> Implement memory annotations
-    final ByteOrder bo = ByteOrder.LITTLE_ENDIAN;
-
-    return relevantInstructions.stream()
+    return isa.ownInstructions()
+        .stream()
         .map(i -> {
 
           final var pattern = toFixedBitPattern(i, bo);

vadl/main/vadl/vdt/target/rtl/RtlTableDecoderGenerator.java

@@ -88,7 +88,9 @@ public String generate() {
     for (Map.Entry<Instruction, Map<Signal, ConstantNode>> decision : decisionMap.entrySet()) {
 
       var insn = decision.getKey();
-      var pattern = toFixedBitPattern(insn, ByteOrder.LITTLE_ENDIAN);
+
+      // TODO: get the byte order from the VADL specification -> Implement memory annotations
+      var pattern = toFixedBitPattern(insn, ByteOrder.BIG_ENDIAN);
 
       appendable
           .append("BitPat(\"").append(toChiselPattern(pattern, true)).append("\")")
@@ -102,6 +104,8 @@ public String generate() {
         var value = decision.getValue().get(signal);
         if (value != null) {
           appendable.append(value.constant().asVal().asString("", 2, true));
+        } else if (isInvalid(signal)) {
+          appendable.append("0");
         } else {
           appendable.append(getDefaultValue(signal));
         }
@@ -173,6 +177,6 @@ private static CharSequence getDefaultValue(Signal signal) {
       throw new ViamError("Signal type not supported: %s", signal.type());
     }
 
-    return "0".repeat(signal.type().asDataType().bitWidth());
+    return "?".repeat(signal.type().asDataType().bitWidth());
   }
 }

vadl/main/vadl/vdt/target/rtl/RtlVdtDecoderGenerator.java

@@ -82,6 +82,18 @@ public String generate(Node tree) {
     // The template engine only indents the first line, so to format everything nicely, add an extra
     // indent level, and remove the initial indent at the end.
     appendable.indent();
+
+    // Initialize signals with default values
+    for (Signal signal : signals) {
+
+      appendable
+          .append(signal.simpleName())
+          .append(" := ")
+          .appendLn(getDefaultValue(signal));
+    }
+
+    appendable.newLine();
+
     tree.accept(this);
     appendable.unindent();
     return appendable.toString().stripLeading();
@@ -131,18 +143,9 @@ public Void handle(InnerNodeImpl node) {
 
       appendable.appendLn("// Invalid");
 
-      for (Signal signal : signals) {
-
-        appendable
-            .append(signal.simpleName())
-            .append(" := ");
-
-        if (isInvalid(signal)) {
-          appendable.appendLn("true.B");
-        } else {
-          appendable.appendLn(getDefaultValue(signal));
-        }
-      }
+      appendable
+          .append(invalidInsn.simpleName())
+          .appendLn(" := true.B");
 
     }
 
@@ -189,18 +192,9 @@ public Void handle(MultiDecisionNode node) {
         .indent()
         .appendLn("// Invalid");
 
-    for (Signal signal : signals) {
-
-      appendable
-          .append(signal.simpleName())
-          .append(" := ");
-
-      if (isInvalid(signal)) {
-        appendable.appendLn("true.B");
-      } else {
-        appendable.appendLn(getDefaultValue(signal));
-      }
-    }
+    appendable
+        .append(invalidInsn.simpleName())
+        .appendLn(" := true.B");
 
     appendable.unindent()
         .appendLn("}");
@@ -241,17 +235,10 @@ public Void handle(SingleDecisionNode node) {
       node.getOtherChild().accept(this);
     } else {
       // If we don't have an 'other' option, fall back to 'invalid'
-      appendable.appendLn("// Invalid");
-      for (Signal signal : signals) {
-        appendable
-            .append(signal.simpleName())
-            .append(" := ");
-        if (isInvalid(signal)) {
-          appendable.appendLn("true.B");
-        } else {
-          appendable.appendLn(getDefaultValue(signal));
-        }
-      }
+      appendable
+          .appendLn("// Invalid")
+          .append(invalidInsn.simpleName())
+          .appendLn(" := true.B");
     }
 
     appendable.unindent()
@@ -292,27 +279,21 @@ public Void visit(LeafNode node) {
 
     for (Signal signal : signals) {
 
-      appendable
-          .append(signal.simpleName())
-          .append(" := ");
-
       var value = decision == null ? null : decision.get(signal);
 
       if (value == null) {
-        appendable.appendLn(getDefaultValue(signal));
         continue;
       }
 
-      appendable.appendLn(toChiselValue(value.constant()));
+      appendable
+          .append(signal.simpleName())
+          .append(" := ")
+          .appendLn(toChiselValue(value.constant()));
     }
 
     return null;
   }
 
-  private boolean isInvalid(Signal signal) {
-    return signal.identifier.equals(invalidInsn.identifier);
-  }
-
   private static CharSequence toChiselValue(Constant constant) {
 
     if (constant.type().isTrivialCastTo(Type.bool())) {