lowering: Add micro architecture lowering

Author: flofriday

.idea/misc.xml

@@ -4365,15 +4365,16 @@ enum ProcessKind {
 
 class MicroArchitectureDefinition extends Definition implements IdentifiableNode {
   Identifier id;
-  IsId processor;
+  @Child
+  IsId isa;
   @Child
   List<Definition> definitions;
   SourceLocation loc;
 
-  MicroArchitectureDefinition(Identifier id, IsId processor, List<Definition> definitions,
+  MicroArchitectureDefinition(Identifier id, IsId isa, List<Definition> definitions,
                               SourceLocation loc) {
     this.id = id;
-    this.processor = processor;
+    this.isa = isa;
     this.definitions = definitions;
     this.loc = loc;
   }
@@ -4404,7 +4405,7 @@ void prettyPrint(int indent, StringBuilder builder) {
     builder.append("micro architecture ");
     id.prettyPrint(0, builder);
     builder.append(" implements ");
-    processor.prettyPrint(0, builder);
+    isa.prettyPrint(0, builder);
     builder.append(" = {\n");
     prettyPrintDefinitions(indent + 1, builder, definitions);
     builder.append(prettyIndentString(indent)).append("}\n");
@@ -4420,13 +4421,13 @@ public boolean equals(Object o) {
     }
     MicroArchitectureDefinition that = (MicroArchitectureDefinition) o;
     return Objects.equals(id, that.id)
-        && Objects.equals(processor, that.processor)
+        && Objects.equals(isa, that.isa)
         && Objects.equals(definitions, that.definitions);
   }
 
   @Override
   public int hashCode() {
-    return Objects.hash(id, processor, definitions);
+    return Objects.hash(id, isa, definitions);
   }
 
 }

vadl/main/vadl/ast/Definition.java

@@ -895,7 +895,7 @@ public Definition visit(CpuProcessDefinition definition) {
 
   @Override
   public Definition visit(MicroArchitectureDefinition definition) {
-    return new MicroArchitectureDefinition(definition.id, definition.processor,
+    return new MicroArchitectureDefinition(definition.id, definition.isa,
         expandDefinitions(definition.definitions), copyLoc(definition.loc)
     ).withAnnotations(expandAnnotations(definition.annotations));
   }

vadl/main/vadl/ast/MacroExpander.java

@@ -2184,7 +2184,12 @@ public Void visit(CpuProcessDefinition definition) {
 
   @Override
   public Void visit(MicroArchitectureDefinition definition) {
-    throwUnimplemented(definition);
+    if (!(definition.isa.target() instanceof InstructionSetDefinition)) {
+      throw error("ISA required", definition.isa)
+          .locationDescription(definition.isa, "A MIA implements an ISA but this points to a %s",
+              requireNonNull(definition.isa.target()).getClass().getSimpleName()).build();
+    }
+    definition.definitions.forEach(this::check);
     return null;
   }
 

vadl/main/vadl/ast/TypeChecker.java

@@ -69,16 +69,20 @@
 import vadl.viam.Function;
 import vadl.viam.Instruction;
 import vadl.viam.InstructionSetArchitecture;
+import vadl.viam.Logic;
 import vadl.viam.Memory;
 import vadl.viam.MemoryRegion;
+import vadl.viam.MicroArchitecture;
 import vadl.viam.PrintableInstruction;
 import vadl.viam.Procedure;
 import vadl.viam.Processor;
 import vadl.viam.PseudoInstruction;
 import vadl.viam.RegisterResource;
 import vadl.viam.RegisterTensor;
 import vadl.viam.Relocation;
+import vadl.viam.Signal;
 import vadl.viam.Specification;
+import vadl.viam.Stage;
 import vadl.viam.annotations.AlignmentAnnotation;
 import vadl.viam.asm.AsmDirectiveMapping;
 import vadl.viam.asm.AsmModifier;
@@ -1464,8 +1468,30 @@ public Optional<vadl.viam.Definition> visit(MemoryDefinition definition) {
 
   @Override
   public Optional<vadl.viam.Definition> visit(MicroArchitectureDefinition definition) {
-    throw new RuntimeException("The ViamGenerator does not support `%s` yet".formatted(
-        definition.getClass().getSimpleName()));
+    var identifier = generateIdentifier(definition.viamId, definition.identifier());
+    var isa = visitIsa(
+        (InstructionSetDefinition) requireNonNull(definition.isa.target()));
+
+    var children = definition.definitions.stream().map(this::fetch).filter(Optional::isPresent)
+        .map(Optional::orElseThrow).toList();
+    var stages = filterAndCastToInstance(children, Stage.class);
+    var logic = filterAndCastToInstance(children, Logic.class);
+    var signals = filterAndCastToInstance(children, Signal.class);
+    var registers = filterAndCastToInstance(children, RegisterTensor.class);
+    var memories = filterAndCastToInstance(children, Memory.class);
+    var functions = filterAndCastToInstance(children, Function.class);
+
+    return Optional.of(new MicroArchitecture(
+            identifier,
+            isa,
+            stages,
+            logic,
+            signals,
+            registers,
+            memories,
+            functions
+        )
+    );
   }
 
   @Override

vadl/main/vadl/ast/ViamLowering.java

@@ -65,7 +65,7 @@ public class RtlEnricherCollection {
       forType(DefinitionEntity.class, (defEntity, passResults) -> {
         if (defEntity.origin() instanceof MicroArchitecture mia) {
           var mappingExt = mia.extension(MiaMapping.class);
-          var isaExt = mia.processor().isa().extension(InstructionProgressGraphExtension.class);
+          var isaExt = mia.isa().extension(InstructionProgressGraphExtension.class);
           if (mappingExt != null && isaExt != null) {
             var info = InfoUtils.createGraphModal(isaExt.ipg().name, isaExt.ipg().name,
                 viz(isaExt.ipg(), mappingExt));

vadl/main/vadl/dump/infoEnrichers/RtlEnricherCollection.java

@@ -26,7 +26,7 @@
  */
 public class MicroArchitecture extends Definition {
 
-  private final Processor processor;
+  private final InstructionSetArchitecture instructionSetArchitecture;
 
   // Stages and Logic elements
   private final List<Stage> stages;
@@ -42,34 +42,39 @@ public class MicroArchitecture extends Definition {
   /**
    * Create a micro architecture definition.
    *
-   * @param identifier identifier
-   * @param processor  processor definition
-   * @param stages     list of stages
-   * @param logic      list of logic elements
+   * @param identifier                 identifier
+   * @param instructionSetArchitecture processor definition
+   * @param stages                     list of stages
+   * @param logic                      list of logic elements
    */
-  public MicroArchitecture(Identifier identifier, Processor processor, List<Stage> stages,
+  public MicroArchitecture(Identifier identifier,
+                           InstructionSetArchitecture instructionSetArchitecture,
+                           List<Stage> stages,
                            List<Logic> logic) {
-    this(identifier, processor, stages, logic, new ArrayList<>(), new ArrayList<>(),
+    this(identifier, instructionSetArchitecture, stages, logic, new ArrayList<>(),
+        new ArrayList<>(),
         new ArrayList<>(), new ArrayList<>());
   }
 
   /**
    * Create a micro architecture definition.
    *
-   * @param identifier identifier
-   * @param processor  processor definition
-   * @param stages     list of stages
-   * @param logic      list of logic elements
-   * @param signals    list of signals
-   * @param registers  list of registers (tensors)
-   * @param memories   list of memories
-   * @param functions  list of functions
+   * @param identifier                 identifier
+   * @param instructionSetArchitecture processor definition
+   * @param stages                     list of stages
+   * @param logic                      list of logic elements
+   * @param signals                    list of signals
+   * @param registers                  list of registers (tensors)
+   * @param memories                   list of memories
+   * @param functions                  list of functions
    */
-  public MicroArchitecture(Identifier identifier, Processor processor, List<Stage> stages,
+  public MicroArchitecture(Identifier identifier,
+                           InstructionSetArchitecture instructionSetArchitecture,
+                           List<Stage> stages,
                            List<Logic> logic, List<Signal> signals, List<RegisterTensor> registers,
                            List<Memory> memories, List<Function> functions) {
     super(identifier);
-    this.processor = processor;
+    this.instructionSetArchitecture = instructionSetArchitecture;
     this.stages = stages;
     this.logic = logic;
     this.signals = signals;
@@ -85,8 +90,8 @@ public MicroArchitecture(Identifier identifier, Processor processor, List<Stage>
     }
   }
 
-  public Processor processor() {
-    return processor;
+  public InstructionSetArchitecture isa() {
+    return instructionSetArchitecture;
   }
 
   public List<Stage> stages() {

vadl/main/vadl/viam/MicroArchitecture.java

@@ -51,9 +51,9 @@ public PassName getName() {
       return null;
     }
 
-    var mip = viam.processor().orElse(null);
+    var isa = viam.isa().orElse(null);
 
-    if (mip == null) {
+    if (isa == null) {
       // if there is no mip, we just do nothing
       return null;
     }
@@ -65,9 +65,9 @@ public PassName getName() {
 
     viam.add(
         switch (dummyMia) {
-          case single -> SingleStageDummyMia.mia(mip);
-          case three -> ThreeStageDummyMia.mia(viam, mip);
-          case five -> FiveStageDummyMia.mia(viam, mip);
+          case single -> SingleStageDummyMia.mia(isa);
+          case three -> ThreeStageDummyMia.mia(viam, isa);
+          case five -> FiveStageDummyMia.mia(viam, isa);
         }
     );
 

vadl/main/vadl/viam/passes/dummyPasses/DummyMiaPass.java

@@ -24,10 +24,10 @@
 import vadl.types.MicroArchitectureType;
 import vadl.types.Type;
 import vadl.viam.Identifier;
+import vadl.viam.InstructionSetArchitecture;
 import vadl.viam.Logic;
 import vadl.viam.Memory;
 import vadl.viam.MicroArchitecture;
-import vadl.viam.Processor;
 import vadl.viam.RegisterTensor;
 import vadl.viam.Resource;
 import vadl.viam.Specification;
@@ -47,12 +47,12 @@
  */
 class FiveStageDummyMia {
 
-  public static MicroArchitecture mia(Specification viam, Processor mip) {
+  public static MicroArchitecture mia(Specification viam, InstructionSetArchitecture isa) {
     var regFile = viam.isa().orElseThrow().registerTensors()
         .stream().filter(RegisterTensor::isRegisterFile).findFirst().get();
     var mem = viam.isa().orElseThrow().ownMemories().get(0);
-    var pc = Objects.requireNonNull(mip.isa().pc()).registerTensor();
-    var csr = mip.isa().registerTensors().stream()
+    var pc = Objects.requireNonNull(isa.pc()).registerTensor();
+    var csr = isa.registerTensors().stream()
         .filter(reg -> reg.simpleName().equals("CSR")).findAny().orElse(null);
 
     var ident = Identifier.noLocation("MiA");
@@ -68,7 +68,7 @@ public static MicroArchitecture mia(Specification viam, Processor mip) {
 
     return new MicroArchitecture(
         ident,
-        mip,
+        isa,
         new ArrayList<>(List.of(fetch, decode, execute, memory, writeBack)),
         new ArrayList<>(List.of(bypass, predict))
     );

vadl/main/vadl/viam/passes/dummyPasses/FiveStageDummyMia.java

@@ -22,9 +22,8 @@
 import vadl.types.MicroArchitectureType;
 import vadl.types.Type;
 import vadl.viam.Identifier;
+import vadl.viam.InstructionSetArchitecture;
 import vadl.viam.MicroArchitecture;
-import vadl.viam.Processor;
-import vadl.viam.Specification;
 import vadl.viam.Stage;
 import vadl.viam.StageOutput;
 import vadl.viam.graph.Graph;
@@ -41,14 +40,14 @@
  */
 class SingleStageDummyMia {
 
-  public static MicroArchitecture mia(Processor mip) {
+  public static MicroArchitecture mia(InstructionSetArchitecture isa) {
     var ident = Identifier.noLocation("MiA");
 
     var issStage = iss(ident.append("ISS"));
 
     return new MicroArchitecture(
         ident,
-        mip,
+        isa,
         new ArrayList<>(List.of(issStage)),
         new ArrayList<>()
     );