TailDuplicator: Fix tail duplicator to insert a branch when fallthrough is present.

[verena]

Summary

If a block with an implicit fallthrough is duplicated into another, we need to insert an explicit branch, since the target block could be anywhere in the function. Also remove a duplicated call to removeBranch.

Unfortunately, I work on a proprietary target, so cannot provide a test case.

[verena]

Ping?

[verena]

I noticed this fix is needed in another place in this method as well.

lib/CodeGen/TailDuplicator.cpp

bool TailDuplicator::canTailDuplicate(MachineBasicBlock *TailBB,
   SmallVector<MachineOperand, 4> PredCond;
   if (TII->analyzeBranch(*PredBB, PredTBB, PredFBB, PredCond))
     return false;
   if (!PredCond.empty())
     return false;
   return true;
 }
 
+/// If the block \p MBB contains an implicit fallthrough to another block add an
+/// explicit unconditional branch. If the block is unanalyzable do nothing.
+static void addBranchForFallthrough(const TargetInstrInfo *TII,
+                                    MachineBasicBlock &MBB) {
+  MachineBasicBlock *TBB, *FBB;
+  SmallVector<MachineOperand, 4> TailCond;
+  if (!TII->analyzeBranch(MBB, TBB, FBB, TailCond)) {
+    bool FallsThrough = !TBB || (!FBB && !TailCond.empty());
+    MachineBasicBlock *FallThroughTarget = MBB.getNextNode();
+    if (FallsThrough && FallThroughTarget)
+      if (MBB.isSuccessor(FallThroughTarget))
+        TII->insertUnconditionalBranch(MBB, FallThroughTarget, DebugLoc());
+  }
+}
+
 /// If it is profitable, duplicate TailBB's contents in each
 /// of its predecessors.
 /// \p IsSimple result of isSimpleBB
 /// \p TailBB   Block to be duplicated.
 /// \p ForcedLayoutPred  When non-null, use this block as the layout predecessor
 ///                      instead of the previous block in MF's order.
 /// \p TDBBs             A vector to keep track of all blocks tail-duplicated
 ///                      into.
for (MachineBasicBlock *PredBB : Preds) {
     if (IsLayoutSuccessor)
       continue;
 
     LLVM_DEBUG(dbgs() << "\nTail-duplicating into PredBB: " << *PredBB
                       << "From Succ: " << *TailBB);
 
     TDBBs.push_back(PredBB);
 
+    // If the BB to merge in has a fallthrough, insert an explicit branch,
+    // because these instructions will be moved into a different block now.
+    addBranchForFallthrough(TII, *TailBB);
+
     // Remove PredBB's unconditional branch.
     TII->removeBranch(*PredBB);
 
     // Clone the contents of TailBB into PredBB.
     DenseMap<unsigned, RegSubRegPair> LocalVRMap;
     SmallVector<std::pair<unsigned, RegSubRegPair>, 4> CopyInfos;
     for (MachineBasicBlock::iterator I = TailBB->begin(), E = TailBB->end();
          I != E; /* empty */) {
if (PrevBB->succ_size() == 1 &&
       *PrevBB->succ_begin() == TailBB &&
       !TII->analyzeBranch(*PrevBB, PriorTBB, PriorFBB, PriorCond) &&
       PriorCond.empty() &&
       (!PriorTBB || PriorTBB == TailBB) &&
       TailBB->pred_size() == 1 &&
       !TailBB->hasAddressTaken()) {
     LLVM_DEBUG(dbgs() << "\nMerging into block: " << *PrevBB
                       << "From MBB: " << *TailBB);
+    addBranchForFallthrough(TII, *TailBB);
     // There may be a branch to the layout successor. This is unlikely but it
     // happens. The correct thing to do is to remove the branch before
     // duplicating the instructions in all cases.
     TII->removeBranch(*PrevBB);
     if (PreRegAlloc) {
       DenseMap<unsigned, RegSubRegPair> LocalVRMap;
       SmallVector<std::pair<unsigned, RegSubRegPair>, 4> CopyInfos;
       MachineBasicBlock::iterator I = TailBB->begin();