Merge pull request #65 from OpenVADL/bugfix/56-instalias-order

lcb: Fixed #56 - Use TableGen operand order

Author: Jozott00

vadl/main/vadl/gcb/passes/assembly/AssemblyConcatBuiltinMergingPass.java

@@ -26,6 +26,7 @@
 import vadl.pass.PassResults;
 import vadl.types.BuiltInTable;
 import vadl.viam.Specification;
+import vadl.viam.graph.control.ReturnNode;
 import vadl.viam.graph.dependency.BuiltInCall;
 import vadl.viam.graph.dependency.ExpressionNode;
 
@@ -56,7 +57,14 @@ public Object execute(PassResults passResults, Specification viam) throws IOExce
         .map(isa -> isa.ownInstructions().stream())
         .orElseGet(Stream::empty)
         .flatMap(
-            instruction -> instruction.assembly().function().behavior().getNodes(BuiltInCall.class))
+            instruction -> {
+              var nodes = new ArrayList<BuiltInCall>();
+              var returnNode =
+                  instruction.assembly().function().behavior().getNodes(ReturnNode.class)
+                      .findFirst().orElseThrow();
+              returnNode.collectInputsWithChildren(nodes, BuiltInCall.class);
+              return nodes.stream();
+            })
         .filter(builtin -> builtin.builtIn() == BuiltInTable.CONCATENATE_STRINGS)
         // only find concat strings that are not used by other concat strings.
         // we will recursively resolve them, so we want only the root objects.

vadl/main/vadl/lcb/codegen/expansion/PseudoExpansionCodeGenerator.java

@@ -84,7 +84,7 @@ public class PseudoExpansionCodeGenerator extends FunctionCodeGenerator {
   private final PseudoInstruction pseudoInstruction;
   private final SymbolTable symbolTable;
   private final GenerateLinkerComponentsPass.VariantKindStore variantKindStore;
-  private final IdentityHashMap<Instruction, LlvmLoweringRecord> machineInstructionRecords;
+  private final IdentityHashMap<Instruction, LlvmLoweringRecord.Machine> machineInstructionRecords;
 
 
   /**
@@ -100,7 +100,7 @@ public PseudoExpansionCodeGenerator(TargetName targetName,
                                           variantKindStore,
                                       PseudoInstruction pseudoInstruction,
                                       Function function,
-                                      IdentityHashMap<Instruction, LlvmLoweringRecord>
+                                      IdentityHashMap<Instruction, LlvmLoweringRecord.Machine>
                                           machineInstructionRecords) {
     super(function);
     this.targetName = targetName;

vadl/main/vadl/lcb/passes/llvmLowering/LlvmLoweringPass.java

@@ -37,7 +37,6 @@
 import vadl.lcb.codegen.model.llvm.ValueType;
 import vadl.lcb.passes.TableGenInstructionCtx;
 import vadl.lcb.passes.isaMatching.IsaPseudoInstructionMatchingPass;
-import vadl.lcb.passes.llvmLowering.domain.LlvmLoweringPseudoRecord;
 import vadl.lcb.passes.llvmLowering.domain.LlvmLoweringRecord;
 import vadl.lcb.passes.llvmLowering.domain.RegisterRef;
 import vadl.lcb.passes.llvmLowering.domain.machineDag.LcbMachineInstructionNode;
@@ -241,8 +240,8 @@ public static Flags withIsAsCheapAsMove(Flags flags) {
    * tablegen records for machine instructions and pseudo instructions.
    */
   public record LlvmLoweringPassResult(
-      IdentityHashMap<Instruction, LlvmLoweringRecord> machineInstructionRecords,
-      IdentityHashMap<PseudoInstruction, LlvmLoweringPseudoRecord> pseudoInstructionRecords) {
+      IdentityHashMap<Instruction, LlvmLoweringRecord.Machine> machineInstructionRecords,
+      IdentityHashMap<PseudoInstruction, LlvmLoweringRecord.Pseudo> pseudoInstructionRecords) {
 
   }
 
@@ -264,7 +263,7 @@ public Object execute(PassResults passResults, Specification viam) throws IOExce
         () -> Diagnostic.error("Cannot find semantics of the instructions", viam.sourceLocation()));
     var fieldUsages = (IdentifyFieldUsagePass.ImmediateDetectionContainer) passResults.lastResultOf(
         IdentifyFieldUsagePass.class);
-    var abi = (Abi) viam.definitions().filter(x -> x instanceof Abi).findFirst().get();
+    var abi = (Abi) viam.definitions().filter(x -> x instanceof Abi).findFirst().orElseThrow();
 
     var architectureType =
         ensurePresent(ValueType.from(abi.stackPointer().registerFile().resultType()),
@@ -288,7 +287,7 @@ public Object execute(PassResults passResults, Specification viam) throws IOExce
         List.of(new LlvmPseudoInstructionLoweringUnconditionalJumpsStrategyImpl(machineStrategies),
             new LlvmPseudoInstructionLoweringDefaultStrategyImpl(machineStrategies));
 
-    var machineRecords = generateRecordsForMachineInstructions(viam, abi, machineStrategies,
+    var machineRecords = machineInstructions(viam, abi, machineStrategies,
         labelingResult);
     var pseudoRecords = pseudoInstructions(machineRecords, viam, fieldUsages, abi,
         pseudoStrategies, labelingResult, labelingResultPseudo);
@@ -297,11 +296,11 @@ public Object execute(PassResults passResults, Specification viam) throws IOExce
   }
 
 
-  private IdentityHashMap<Instruction, LlvmLoweringRecord> generateRecordsForMachineInstructions(
+  private IdentityHashMap<Instruction, LlvmLoweringRecord.Machine> machineInstructions(
       Specification viam, Abi abi,
       List<LlvmInstructionLoweringStrategy> strategies,
       IsaMachineInstructionMatchingPass.Result labelledMachineInstructions) {
-    var tableGenRecords = new IdentityHashMap<Instruction, LlvmLoweringRecord>();
+    var tableGenRecords = new IdentityHashMap<Instruction, LlvmLoweringRecord.Machine>();
 
     viam.isa().map(isa -> isa.ownInstructions().stream()).orElseGet(Stream::empty)
         .forEach(instruction -> {
@@ -337,16 +336,16 @@ var record =
     return tableGenRecords;
   }
 
-  private IdentityHashMap<PseudoInstruction, LlvmLoweringPseudoRecord> pseudoInstructions(
-      IdentityHashMap<Instruction, LlvmLoweringRecord> machineRecords,
+  private IdentityHashMap<PseudoInstruction, LlvmLoweringRecord.Pseudo> pseudoInstructions(
+      IdentityHashMap<Instruction, LlvmLoweringRecord.Machine> machineRecords,
       Specification viam,
       IdentifyFieldUsagePass.ImmediateDetectionContainer fieldUsages,
       Abi abi,
       List<LlvmPseudoInstructionLowerStrategy> pseudoStrategies,
       IsaMachineInstructionMatchingPass.Result labelledMachineInstructions,
       IsaPseudoInstructionMatchingPass.Result labelledPseudoInstructions
   ) {
-    var tableGenRecords = new IdentityHashMap<PseudoInstruction, LlvmLoweringPseudoRecord>();
+    var tableGenRecords = new IdentityHashMap<PseudoInstruction, LlvmLoweringRecord.Pseudo>();
 
     viam.isa().map(isa -> isa.ownPseudoInstructions().stream()).orElseGet(Stream::empty)
         .forEach(pseudo -> {
@@ -372,7 +371,7 @@ var record =
   }
 
   private @Nonnull List<TableGenInstAlias> instAliases(
-      IdentityHashMap<Instruction, LlvmLoweringRecord> machineRecords,
+      IdentityHashMap<Instruction, LlvmLoweringRecord.Machine> machineRecords,
       IdentifyFieldUsagePass.ImmediateDetectionContainer fieldUsages,
       PseudoInstruction pseudo) {
     if (pseudo.behavior().getNodes(InstrCallNode.class).toList().size() != 1) {
@@ -388,14 +387,13 @@ var record =
     graph.addWithInputs(
         new LcbMachineInstructionNode(new NodeList<>(args), instruction.target()));
 
-    var instAliases = List.of(
+    return List.of(
         new TableGenInstAlias(
             pseudo,
             pseudo.assembly(),
             graph
         )
     );
-    return instAliases;
   }
 
   private List<ExpressionNode> getArgsForInstAlias(
@@ -404,8 +402,8 @@ private List<ExpressionNode> getArgsForInstAlias(
       InstrCallNode instruction) {
     var args = new ArrayList<ExpressionNode>();
 
-    for (int i = 0; i < instruction.arguments().size(); i++) {
-      var field = instruction.getParamFields().get(i);
+    for (int i = 0; i < machineRecord.info().outputInputOperandsFormatFields().size(); i++) {
+      var field = machineRecord.info().outputInputOperandsFormatFields().get(i);
       var argument = instruction.getArgument(field);
       var fieldUsageMap = fieldUsages.getFieldUsages(instruction.target());
 

vadl/main/vadl/lcb/passes/llvmLowering/domain/LlvmLoweringPseudoRecord.java

@@ -19,20 +19,24 @@
 
 import java.util.List;
 import vadl.lcb.passes.llvmLowering.LlvmLoweringPass;
+import vadl.lcb.passes.llvmLowering.tablegen.model.TableGenInstAlias;
 import vadl.lcb.passes.llvmLowering.tablegen.model.TableGenPattern;
+import vadl.viam.Instruction;
+import vadl.viam.PseudoInstruction;
 
 /**
  * Contains information for the lowering of instructions.
  */
-public class LlvmLoweringRecord {
+public abstract class LlvmLoweringRecord {
   private final LlvmLoweringPass.BaseInstructionInfo info;
   private final List<TableGenPattern> patterns;
 
   /**
    * Constructor.
    */
-  public LlvmLoweringRecord(LlvmLoweringPass.BaseInstructionInfo info,
-                            List<TableGenPattern> patterns) {
+  public LlvmLoweringRecord(
+      LlvmLoweringPass.BaseInstructionInfo info,
+      List<TableGenPattern> patterns) {
     this.info = info;
     this.patterns = patterns;
   }
@@ -44,4 +48,48 @@ public List<TableGenPattern> patterns() {
   public LlvmLoweringPass.BaseInstructionInfo info() {
     return info;
   }
+
+  /**
+   * Represents a {@link LlvmLoweringRecord} for {@link Instruction}.
+   */
+  public static class Machine extends LlvmLoweringRecord {
+    private final Instruction instructionRef;
+
+    /**
+     * Constructor.
+     */
+    public Machine(Instruction instructionRef, LlvmLoweringPass.BaseInstructionInfo info,
+                   List<TableGenPattern> patterns) {
+      super(info, patterns);
+      this.instructionRef = instructionRef;
+    }
+
+
+    public Instruction instruction() {
+      return instructionRef;
+    }
+  }
+
+  /**
+   * Represents a {@link LlvmLoweringRecord} for {@link PseudoInstruction}.
+   */
+  public static class Pseudo extends LlvmLoweringRecord {
+    private final List<TableGenInstAlias> instAliases;
+
+    /**
+     * Constructor.
+     */
+    public Pseudo(LlvmLoweringPass.BaseInstructionInfo info,
+                  List<TableGenPattern> patterns,
+                  List<TableGenInstAlias> instAliases
+    ) {
+      super(info, patterns);
+      this.instAliases = instAliases;
+    }
+
+    public List<TableGenInstAlias> instAliases() {
+      return instAliases;
+    }
+
+  }
 }

vadl/main/vadl/lcb/passes/llvmLowering/domain/LlvmLoweringRecord.java

@@ -285,7 +285,7 @@ public LlvmLoweringPass.BaseInstructionInfo lowerBaseInfo(Graph behavior) {
    * Generate a lowering result for the given {@link Graph} for pseudo instructions.
    * If it is not lowerable then return {@link Optional#empty()}.
    */
-  public Optional<LlvmLoweringRecord> lowerInstruction(
+  public Optional<LlvmLoweringRecord.Machine> lowerInstruction(
       IsaMachineInstructionMatchingPass.Result labelledMachineInstructions,
       Instruction instruction,
       Graph unmodifiedBehavior,
@@ -340,12 +340,14 @@ public Optional<LlvmLoweringRecord> lowerInstruction(
               info.outputs(),
               patterns,
               abi);
-      return Optional.of(new LlvmLoweringRecord(
+      return Optional.of(new LlvmLoweringRecord.Machine(
+          instruction,
           info,
           Stream.concat(patterns.stream(), alternativePatterns.stream()).toList()
       ));
     } else {
-      return Optional.of(new LlvmLoweringRecord(
+      return Optional.of(new LlvmLoweringRecord.Machine(
+          instruction,
           info,
           Collections.emptyList()
       ));

vadl/main/vadl/lcb/passes/llvmLowering/strategies/LlvmInstructionLoweringStrategy.java

@@ -32,7 +32,6 @@
 import vadl.gcb.passes.PseudoInstructionLabel;
 import vadl.gcb.passes.pseudo.PseudoFuncParamNode;
 import vadl.lcb.passes.llvmLowering.LlvmLoweringPass;
-import vadl.lcb.passes.llvmLowering.domain.LlvmLoweringPseudoRecord;
 import vadl.lcb.passes.llvmLowering.domain.LlvmLoweringRecord;
 import vadl.lcb.passes.llvmLowering.domain.RegisterRef;
 import vadl.lcb.passes.llvmLowering.domain.machineDag.LcbMachineInstructionNode;
@@ -90,9 +89,9 @@ public boolean isApplicable(@Nullable PseudoInstructionLabel pseudoInstructionLa
   }
 
   /**
-   * Lower a {@link PseudoInstruction} into a {@link LlvmLoweringPseudoRecord}.
+   * Lower a {@link PseudoInstruction} into a {@link LlvmLoweringRecord.Pseudo}.
    */
-  public Optional<LlvmLoweringPseudoRecord> lowerInstruction(
+  public Optional<LlvmLoweringRecord.Pseudo> lowerInstruction(
       Abi abi,
       List<TableGenInstAlias> instAliases,
       PseudoInstruction pseudo,
@@ -257,7 +256,7 @@ pseudo instruction MOV( rd : Index, rs1 : Index ) =
         dedup(defs)
     );
 
-    return Optional.of(new LlvmLoweringPseudoRecord(
+    return Optional.of(new LlvmLoweringRecord.Pseudo(
         info,
         patterns,
         instAliases

vadl/main/vadl/lcb/passes/llvmLowering/strategies/LlvmPseudoInstructionLowerStrategy.java

@@ -84,7 +84,7 @@ protected Set<MachineInstructionLabel> getSupportedInstructionLabels() {
   }
 
   @Override
-  public Optional<LlvmLoweringRecord> lowerInstruction(
+  public Optional<LlvmLoweringRecord.Machine> lowerInstruction(
       IsaMachineInstructionMatchingPass.Result labelledMachineInstructions,
       Instruction instruction,
       Graph uninlinedBehavior,
@@ -101,7 +101,7 @@ public Optional<LlvmLoweringRecord> lowerInstruction(
         createIntermediateResult(labelledMachineInstructions, instruction, copy, abi));
   }
 
-  private LlvmLoweringRecord createIntermediateResult(
+  private LlvmLoweringRecord.Machine createIntermediateResult(
       IsaMachineInstructionMatchingPass.Result supportedInstructions,
       Instruction instruction,
       Graph visitedGraph,
@@ -123,7 +123,8 @@ private LlvmLoweringRecord createIntermediateResult(
         .map(LoweringStrategyUtils::replaceBasicBlockByLabelImmediateInMachineInstruction)
         .toList();
 
-    return new LlvmLoweringRecord(
+    return new LlvmLoweringRecord.Machine(
+        instruction,
         info,
         allPatterns
     );

vadl/main/vadl/lcb/passes/llvmLowering/strategies/instruction/LlvmInstructionLoweringConditionalBranchesStrategyImpl.java

@@ -74,7 +74,7 @@ protected Set<MachineInstructionLabel> getSupportedInstructionLabels() {
   }
 
   @Override
-  public Optional<LlvmLoweringRecord> lowerInstruction(
+  public Optional<LlvmLoweringRecord.Machine> lowerInstruction(
       IsaMachineInstructionMatchingPass.Result labelledMachineInstructions,
       Instruction instruction,
       Graph unmodifiedBehavior,
@@ -94,7 +94,8 @@ public Optional<LlvmLoweringRecord> lowerInstruction(
     var patterns = generatePatterns(instruction,
         inputOperands,
         copy.getNodes(WriteResourceNode.class).toList());
-    return Optional.of(new LlvmLoweringRecord(
+    return Optional.of(new LlvmLoweringRecord.Machine(
+        instruction,
         new LlvmLoweringPass.BaseInstructionInfo(inputOperands,
             info.outputs(),
             info.flags(),