[MachineBasicBlock] Explicit FT branching param

Introduce a parameter in getFallThrough() to optionally
allow returning the fall through basic block in spite of
an explicit branch instruction to it. This parameter is
set to false by default.

Introduce getLogicalFallThrough() which calls
getFallThrough(false) to obtain the block while avoiding
insertion of a jump instruction to its immediate successor.

This patch also reverts the changes made by D134557 and
solves the case where a jump is inserted after another jump
(branch-relax-no-terminators.mir).

Reviewed By: arsenm

Differential Revision: https://reviews.llvm.org/D140790

Author: gandhi56

llvm/include/llvm/CodeGen/MachineBasicBlock.h

@@ -793,10 +793,15 @@ class MachineBasicBlock
 
   /// Return the fallthrough block if the block can implicitly
   /// transfer control to the block after it by falling off the end of
-  /// it.  This should return null if it can reach the block after
-  /// it, but it uses an explicit branch to do so (e.g., a table
-  /// jump).  Non-null return  is a conservative answer.
-  MachineBasicBlock *getFallThrough();
+  /// it. If an explicit branch to the fallthrough block is not allowed,
+  /// set JumpToFallThrough to be false. Non-null return is a conservative
+  /// answer.
+  MachineBasicBlock *getFallThrough(bool JumpToFallThrough = false);
+
+  /// Return the fallthrough block if the block can implicitly
+  /// transfer control to it's successor, whether by a branch or
+  /// a fallthrough. Non-null return is a conservative answer.
+  MachineBasicBlock *getLogicalFallThrough() { return getFallThrough(true); }
 
   /// Return true if the block can implicitly transfer control to the
   /// block after it by falling off the end of it.  This should return

llvm/lib/CodeGen/BranchRelaxation.cpp

@@ -442,7 +442,6 @@ bool BranchRelaxation::fixupConditionalBranch(MachineInstr &MI) {
 
 bool BranchRelaxation::fixupUnconditionalBranch(MachineInstr &MI) {
   MachineBasicBlock *MBB = MI.getParent();
-  MachineBasicBlock *TBB = nullptr, *FBB = nullptr;
   SmallVector<MachineOperand, 4> Cond;
   unsigned OldBrSize = TII->getInstSizeInBytes(MI);
   MachineBasicBlock *DestBB = TII->getBranchDestBlock(MI);
@@ -456,20 +455,6 @@ bool BranchRelaxation::fixupUnconditionalBranch(MachineInstr &MI) {
 
   MachineBasicBlock *BranchBB = MBB;
 
-  auto RemoveBranch = [&](MachineBasicBlock *MBB) {
-    unsigned &BBSize = BlockInfo[MBB->getNumber()].Size;
-    int RemovedSize = 0;
-    TII->removeBranch(*MBB, &RemovedSize);
-    BBSize -= RemovedSize;
-  };
-
-  auto InsertUncondBranch = [&](MachineBasicBlock *MBB,
-                                MachineBasicBlock *Dst) {
-    TII->insertUnconditionalBranch(*MBB, Dst, DebugLoc());
-    // Recalculate the block size.
-    BlockInfo[MBB->getNumber()].Size = computeBlockSize(*MBB);
-  };
-
   // If this was an expanded conditional branch, there is already a single
   // unconditional branch in a block.
   if (!MBB->empty()) {
@@ -511,13 +496,10 @@ bool BranchRelaxation::fixupUnconditionalBranch(MachineInstr &MI) {
     MachineBasicBlock *PrevBB = &*std::prev(DestBB->getIterator());
     // Fall through only if PrevBB has no unconditional branch as one of its
     // terminators.
-    if (TII->analyzeBranch(*PrevBB, TBB, FBB, Cond))
-      report_fatal_error("Could not analyze terminators.");
-    if (!FBB) {
-      if (!Cond.empty() && TBB && TBB == DestBB)
-        RemoveBranch(PrevBB);
-      if (!TBB || (TBB && !Cond.empty()))
-        InsertUncondBranch(PrevBB, DestBB);
+    if (auto *FT = PrevBB->getLogicalFallThrough()) {
+      assert(FT == DestBB);
+      TII->insertUnconditionalBranch(*PrevBB, FT, DebugLoc());
+      BlockInfo[PrevBB->getNumber()].Size = computeBlockSize(*PrevBB);
     }
     // Now, RestoreBB could be placed directly before DestBB.
     MF->splice(DestBB->getIterator(), RestoreBB->getIterator());

llvm/lib/CodeGen/MachineBasicBlock.cpp

@@ -944,7 +944,7 @@ const MachineBasicBlock *MachineBasicBlock::getSingleSuccessor() const {
   return Successors.size() == 1 ? Successors[0] : nullptr;
 }
 
-MachineBasicBlock *MachineBasicBlock::getFallThrough() {
+MachineBasicBlock *MachineBasicBlock::getFallThrough(bool JumpToFallThrough) {
   MachineFunction::iterator Fallthrough = getIterator();
   ++Fallthrough;
   // If FallthroughBlock is off the end of the function, it can't fall through.
@@ -975,8 +975,8 @@ MachineBasicBlock *MachineBasicBlock::getFallThrough() {
 
   // If there is some explicit branch to the fallthrough block, it can obviously
   // reach, even though the branch should get folded to fall through implicitly.
-  if (MachineFunction::iterator(TBB) == Fallthrough ||
-      MachineFunction::iterator(FBB) == Fallthrough)
+  if (!JumpToFallThrough && (MachineFunction::iterator(TBB) == Fallthrough ||
+                           MachineFunction::iterator(FBB) == Fallthrough))
     return &*Fallthrough;
 
   // If it's an unconditional branch to some block not the fall through, it