[AIE] Use ConflictBits in bundle conflict test

Author: Martien de Jong

llvm/lib/Target/AIE/AIEBundle.h

@@ -91,10 +91,15 @@ template <class I> class Bundle {
     // Verify there is a format that can accommodate the new slots
     MCSlotKind Slot = FormatInterface->getSlotKind(InstOpCode);
     assert(Slot != MCSlotKind());
-    SlotBits NewSlots = FormatInterface->getSlotInfo(Slot)->getSlotSet();
-    return (OccupiedSlots & NewSlots) == 0 &&
-           FormatInterface->getPacketFormats().getFormat(OccupiedSlots |
-                                                         NewSlots);
+
+    auto *SlotInfo = FormatInterface->getSlotInfo(Slot);
+    // ConflictBits is a fast predictor of missing formats
+    SlotBits ConflictBits = SlotInfo->getConflictSet();
+    if (OccupiedSlots & ConflictBits) {
+      return false;
+    }
+    SlotBits NewSlots = OccupiedSlots | SlotInfo->getSlotSet();
+    return FormatInterface->getPacketFormats().getFormat(NewSlots);
   }
 
   /// Add an instruction to the bundle

llvm/test/TableGen/CodeGenFormat/SlotLogicTests/slot_conflicts.td

@@ -12,22 +12,23 @@
 // We have the slots A. X, M and XM, which interfere like the
 // corresponding slots on typical AIE architectures.
 // We compute conflicts from the totality of formats, and we should find
-//  conflicts
-//  X -> {XM},
-//  M -> {XM},
+// conflicts
+//  X -> {X, XM},
+//  M -> {M, XM},
 //  XM -> {X, M, XM}
-// and nothing more. In particular, ConflictBits of A should be equal to its SlotBits
+//  A -> {A}
+// and nothing more.
 
 // CHECK-LABEL:   "X",
-// CHECK-NEXT:  10,
+// CHECK-NEXT:  8,
 // CHECK-NEXT:  1,
 // CHECK-NEXT:  5,
 // CHECK-LABEL:  "A",
 // CHECK-NEXT:  10,
 // CHECK-NEXT:  2,
 // CHECK-NEXT:  2,
 // CHECK-LABEL:  "XM",
-// CHECK-NEXT:  20,
+// CHECK-NEXT:  18,
 // CHECK-NEXT:  4,
 // CHECK-NEXT:  13,
 // CHECK-LABEL:  "M",
@@ -45,9 +46,9 @@ include "llvm/Target/CodeGenFormat.td"
 let Namespace = "TEST" in {
 def nop_slot 	 : InstSlot<"nop", 14> { let Artificial = true; }
 def lda_slot     : InstSlot<"A", 10>;
-def alu_slot     : InstSlot<"X", 10>;
+def alu_slot     : InstSlot<"X", 8>;
 def mov_slot     : InstSlot<"M", 10>;
-def lng_slot     : InstSlot<"XM", 20>;
+def lng_slot     : InstSlot<"XM", 18>;
 }
 
 
@@ -64,14 +65,14 @@ def TESTCodeGenFormat : CodeGenFormat {
 let Namespace = "TEST" in
 def default_slot : InstSlot<"default", 0, true>;
 
-class TESTInst<dag outs, dag ins, string opcodestr, string argstr, list<dag> pattern>
+class TESTInst<dag outs, dag ins, string opc, string arg, list<dag> pattern>
     : Instruction, InstFormat
 {
   let Namespace = "TEST";
 
   dag OutOperandList = outs;
   dag InOperandList = ins;
-  let AsmString = opcodestr # "\t" # argstr;
+  let AsmString = opc # "\t" # arg;
   let Pattern = pattern;
 
   let Slot = default_slot;
@@ -83,29 +84,40 @@ class TESTSubInst<dag outs, dag ins>
   let isComposite = false;
 }
 
-class TESTPacketFormat<dag outs, dag ins> : TESTInst<outs, ins,"", "", []> {
+class TESTFormat<dag outs, dag ins> : TESTInst<outs, ins, "", "", []> {
   let isComposite = true;
 }
 
 
-class TEST_instr32<dag outs, dag ins> : TESTPacketFormat<outs, ins> {
+class TEST_I32<dag outs, dag ins> : TESTFormat<outs, ins> {
   field bits<32> Inst;
   field bits<32> instr32;
   let Inst = {instr32};
 }
 
-def I64_A_XM : TEST_instr32<(outs), (ins lda_slot:$lda, lng_slot:$lng)> {
+def I32_A_XM : TEST_I32<(outs), (ins lda_slot:$lda, lng_slot:$lng)> {
   bits<10> lda;
-  bits<20> lng;
-  let instr32 = {lda, lng, 0b00};
-
+  bits<18> lng;
+  let instr32 = {lda, lng, 0b1001};
 }
 
-def I64_A_X_M : TEST_instr32<(outs), (ins lda_slot:$lda, alu_slot:$alu, mov_slot:$mov)> {
+def I32_A_X : TEST_I32<(outs), (ins lda_slot:$lda, alu_slot:$alu)> {
   bits<10> lda;
-  bits<10> alu;
+  bits<8> alu;
+  let instr32 = {lda, alu, 0b0000000000, 0b1001};
+}
+
+def I32 : TEST_I32<(outs), (ins alu_slot:$alu, mov_slot:$mov)> {
+  bits<8> alu;
   bits<10> mov;
-  let instr32 = {lda, alu, mov, 0b01};
+  let instr32 = {0b0000000000, alu, mov, 0b0110};
 }
 
+def I32 : TEST_I32<(outs), 
+        (ins lda_slot:$lda, alu_slot:$alu, mov_slot:$mov)> {
+  bits<10> lda;
+  bits<8> alu;
+  bits<10> mov;
+  let instr32 = {lda, alu, mov, 0b1110};
+}