Merge pull request #494 from OpenVADL/bugfix/immediate-bitwidth-branches

lcb: Used predicate method for "isBranchOffsetInRange"

Author: kper

vadl/main/resources/templates/lcb/llvm/lib/Target/InstrInfo.cpp

@@ -356,9 +356,13 @@ bool [(${namespace})]InstrInfo::isBranchOffsetInRange(unsigned BranchOp, int64_t
     default:
       std::cerr << "Op " << BranchOp << std::endl;
       llvm_unreachable("Unexpected opcode!");
-    [# th:each="branch : ${branchInstructions}" ]
+    [# th:each="branch : ${machineBranchInstructions}" ]
     case [(${namespace})]::[(${branch.name})]:
-      return isIntN([(${branch.bitWidth})], BrOffset);
+      return [(${branch.predicateMethod})](BrOffset);
+    [/]
+    [# th:each="branch : ${pseudoBranchInstructions}" ]
+    case [(${namespace})]::[(${branch.name})]:
+       return isIntN([(${branch.bitWidth})], BrOffset);
     [/]
   }
 }

vadl/main/vadl/lcb/template/lib/Target/EmitInstrInfoCppFilePass.java

@@ -46,6 +46,7 @@
 import vadl.lcb.passes.isaMatching.database.Query;
 import vadl.lcb.template.CommonVarNames;
 import vadl.lcb.template.LcbTemplateRenderingPass;
+import vadl.lcb.template.utils.ImmediatePredicateFunctionProvider;
 import vadl.pass.PassResults;
 import vadl.template.Renderable;
 import vadl.types.BuiltInTable;
@@ -283,7 +284,23 @@ private Optional<String> getJumpFromMachineInstructions(
         .map(Definition::simpleName);
   }
 
-  record BranchInstruction(String name, /* size of the immediate */ int bitWidth) implements
+  record BranchInstruction(String name,
+                           int bitWidth, /* size of the immediate */
+                           String predicateMethod) implements
+      Renderable {
+
+    @Override
+    public Map<String, Object> renderObj() {
+      return Map.of(
+          "name", name,
+          "bitWidth", bitWidth,
+          "predicateMethod", predicateMethod
+      );
+    }
+  }
+
+  record PseudoBranchInstruction(String name,
+                                 int bitWidth /* size of the immediate */) implements
       Renderable {
 
     @Override
@@ -370,7 +387,9 @@ protected Map<String, Object> createVariables(final PassResults passResults,
     map.put("additionImm", additionRI.simpleName());
     map.put("addition", additionRR.simpleName());
     map.put("additionRegisterFile", additionRegisterFile.simpleName());
-    map.put("branchInstructions", getBranchInstructions(specification, passResults, fieldUsages));
+    map.put("machineBranchInstructions", machineBranchInstructions(specification, passResults));
+    map.put("pseudoBranchInstructions",
+        pseudoBranchInstructions(specification, passResults, fieldUsages));
     map.put("instructionSizes", instructionSizes(specification));
     map.put("jumpInstruction", jumpInstructionName);
     map.put("beq",
@@ -415,14 +434,24 @@ private List<InstructionSize> instructionSizes(Specification specification) {
         .toList();
   }
 
-  private List<BranchInstruction> getBranchInstructions(
+  private List<BranchInstruction> machineBranchInstructions(
+      Specification specification,
+      PassResults passResults) {
+    var branchInstructions = new ArrayList<BranchInstruction>();
+    var database = new Database(passResults, specification);
+
+    machineInstructions(passResults, database, branchInstructions);
+
+    return branchInstructions;
+  }
+
+  private List<PseudoBranchInstruction> pseudoBranchInstructions(
       Specification specification,
       PassResults passResults,
       IdentifyFieldUsagePass.ImmediateDetectionContainer fieldUsages) {
-    var branchInstructions = new ArrayList<BranchInstruction>();
+    var branchInstructions = new ArrayList<PseudoBranchInstruction>();
     var database = new Database(passResults, specification);
 
-    machineInstructions(database, branchInstructions);
     pseudoInstructions(fieldUsages, database, branchInstructions);
 
     return branchInstructions;
@@ -431,7 +460,7 @@ private List<BranchInstruction> getBranchInstructions(
   private static void pseudoInstructions(
       IdentifyFieldUsagePass.ImmediateDetectionContainer fieldUsages,
       Database database,
-      List<BranchInstruction> branchInstructions) {
+      List<PseudoBranchInstruction> branchInstructions) {
     var result = database.run(
         new Query.Builder().pseudoInstructionLabel(PseudoInstructionLabel.J).build());
 
@@ -447,14 +476,17 @@ private static void pseudoInstructions(
         var immediate = unwrap(immediates.stream().findFirst());
         int bitWidth = immediate.size();
         branchInstructions.add(
-            new BranchInstruction(pseudoInstruction.identifier.simpleName(), bitWidth));
+            new PseudoBranchInstruction(pseudoInstruction.identifier.simpleName(), bitWidth));
       }
     }
   }
 
   private static void machineInstructions(
+      PassResults passResults,
       Database database,
       List<BranchInstruction> branchInstructions) {
+    var lookup =
+        ImmediatePredicateFunctionProvider.predicateFunctionsByFieldAccess(passResults);
     var result = database.run(new Query.Builder().machineInstructionLabels(List.of(
         MachineInstructionLabel.J,
         MachineInstructionLabel.BEQ,
@@ -490,9 +522,14 @@ private static void machineInstructions(
           () -> Diagnostic.error("We only support branch instructions with one label.",
               machineInstruction.location()));
       var immediate = unwrap(immediates.stream().findFirst());
+      var function = ensureNonNull(lookup.get(immediate.fieldAccess()),
+          () -> Diagnostic.error("Cannot find field access' predicate", immediate.location()));
+      var functionName = function.header().functionName().lower();
       int bitWidth = immediate.fieldAccess().type().asDataType().bitWidth();
       branchInstructions.add(
-          new BranchInstruction(machineInstruction.identifier.simpleName(), bitWidth));
+          new BranchInstruction(machineInstruction.identifier.simpleName(),
+              bitWidth,
+              functionName));
     }
   }
 

vadl/main/vadl/lcb/template/utils/ImmediatePredicateFunctionProvider.java

@@ -16,11 +16,13 @@
 
 package vadl.lcb.template.utils;
 
+import java.util.IdentityHashMap;
 import java.util.Map;
 import vadl.cppCodeGen.model.GcbCppFunctionWithBody;
 import vadl.lcb.passes.llvmLowering.CreateFunctionsFromImmediatesPass;
 import vadl.lcb.passes.llvmLowering.tablegen.model.TableGenImmediateRecord;
 import vadl.pass.PassResults;
+import vadl.viam.Format;
 
 /**
  * Utility class for predicates.
@@ -34,4 +36,19 @@ public static Map<TableGenImmediateRecord, GcbCppFunctionWithBody> generatePredi
     return ((CreateFunctionsFromImmediatesPass.Output)
         passResults.lastResultOf(CreateFunctionsFromImmediatesPass.class)).predicates();
   }
+
+  /**
+   * Get the predicate functions by field access.
+   */
+  public static Map<Format.FieldAccess, GcbCppFunctionWithBody> predicateFunctionsByFieldAccess(
+      PassResults passResults) {
+    var result = new IdentityHashMap<Format.FieldAccess, GcbCppFunctionWithBody>();
+    var map = generatePredicateFunctions(passResults);
+
+    for (var entry : map.entrySet()) {
+      result.put(entry.getKey().fieldAccessRef(), entry.getValue());
+    }
+
+    return result;
+  }
 }