[mips] Compact branch hazard detection

[abeserminji]

Summary

Follow up to D27209 fix, this patch now also covers cases such as when unsafe instruction appears in forbidden slot of branch instruction.

[sdardis]

LGTM.

lib/Target/Mips/MipsHazardSchedule.cpp

static Iter getNextMachineInstrInBB(Iter Position) {
   I = std::find_if_not(I, E,
                        [](const Iter &Insn) { return Insn->isTransient(); });
 
   return I;
 }
 
 // Find the next real instruction from the current position, looking through
 // basic block boundaries.
-static Iter getNextMachineInstr(Iter Position) {
-  if (std::next(Position) == Position->getParent()->end()) {
-    const MachineBasicBlock * MBB = (&*Position)->getParent();
-    for (auto *Succ : MBB->successors()) {
-      if (MBB->isLayoutSuccessor(Succ)) {
-        Iter I = Succ->begin();
-        Iter Next = getNextMachineInstrInBB(I);
-        if (Next == Succ->end()) {
-          return getNextMachineInstr(I);
-        } else {
-          return I;
-        }
-      }
+static Iter getNextMachineInstr(Iter Position, MachineBasicBlock *Parent) {
+  if (Position == Parent->end()) {
+    MachineBasicBlock *Succ = Parent->getNextNode();
+    if (Succ != nullptr && Parent->isSuccessor(Succ)) {
+      Position = Succ->begin();
+      Parent = Succ;
+      llvm_unreachable(
+          "Should have identified the end of the function earlier!");
     }
-    llvm_unreachable("Should have identified the end of the function earlier!");
   }
 
-  return getNextMachineInstrInBB(Position);
+  Iter Instr = getNextMachineInstrInBB(Position);
+  if (Instr == Parent->end()) {
+    return getNextMachineInstr(Instr, Parent);
+  }
+  return Instr;
 }
 
 bool MipsHazardSchedule::runOnMachineFunction(MachineFunction &MF) {
 
   const MipsSubtarget *STI =
       &static_cast<const MipsSubtarget &>(MF.getSubtarget());
 
   // Forbidden slot hazards are only defined for MIPSR6 but not microMIPSR6.
for (Iter I = FI->begin(); I != FI->end(); ++I) {
       // Forbidden slot hazard handling. Use lookahead over state.
       if (!TII->HasForbiddenSlot(*I))
         continue;
 
       Iter Inst;
       bool LastInstInFunction =
           std::next(I) == FI->end() && std::next(FI) == MF.end();
       if (!LastInstInFunction) {
-        if (std::next(I) != FI->end()) {
-          // Start looking from the next instruction in the basic block.
-          Inst = getNextMachineInstr(std::next(I));
-        } else {
-          // Next instruction in the physical successor basic block.
-          Inst = getNextMachineInstr(I);
-        }
+        Inst = getNextMachineInstr(std::next(I), &*FI);
       }
 
       if (LastInstInFunction || !TII->SafeInForbiddenSlot(*Inst)) {
         Changed = true;
         MIBundleBuilder(&*I)
             .append(BuildMI(MF, I->getDebugLoc(), TII->get(Mips::NOP)));
         NumInsertedNops++;
       }
     }
   }
   return Changed;
 }

test/CodeGen/Mips/compactbranches/unsafe-in-forbidden-slot.ll

+; RUN: llc -march=mips64el -O0 -mcpu=mips64r6 < %s | FileCheck %s
+; RUN: llc -march=mips64 -O0 -mcpu=mips64r6 < %s | FileCheck %s
+
+@boo = global i32 0, align 4
+
+; Function Attrs: nounwind
+define void @_Z3foov() #0 {
+entry:
+  %0 = load volatile i32, i32* @boo, align 4
+  switch i32 %0, label %sw.epilog [
+    i32 0, label %sw.bb
+    i32 1, label %sw.bb1
+    i32 2, label %sw.bb1
+  ]
+
+sw.bb:                                            ; preds = %entry
+  store volatile i32 1, i32* @boo, align 4
+  br label %sw.epilog
+; CHECK: beqzc
+; CHECK-NEXT: nop
+; CHECK-NEXT: .LBB
+; CHECK-NEXT: j
+
+sw.bb1:                                           ; preds = %entry, %entry
+  store volatile i32 2, i32* @boo, align 4
+  br label %sw.epilog
+; CHECK: bnezc
+; CHECK-NEXT: nop
+; CHECK-NEXT: .LBB
+; CHECK-NEXT: j
+
+sw.epilog:                                        ; preds = %entry, %sw.bb1, %sw.bb
+  ret void
+}