[BasicBlockUtils] Factor MergeBlockIntoPredecessor args into a struct, NFC

[vsk]

Summary

Factor the arguments to MergeBlockIntoPredecessor into a struct to
make usage of the API more readable.

This is in preparation for a change which adds another knob to
MergeBlockIntoPredecessor.

[asbirlea]

lgtm with some nits.

llvm/lib/Transforms/Scalar/GVN.cpp

2230

s/removedBlock/RemovedBlock (see clang-tidy or llvm doc)

2230

Perhaps directly passing: {&DTU, LI, nullptr, MD}?

llvm/include/llvm/Transforms/Utils/BasicBlockUtils.h

 
 /// Attempts to merge a block into its predecessor, if possible. The return
 /// value indicates success or failure.
 /// By default do not merge blocks if BB's predecessor has multiple successors.
 /// If PredecessorWithTwoSuccessors = true, the blocks can only be merged
 /// if BB's Pred has a branch to BB and to AnotherBB, and BB has a single
 /// successor Sing. In this case the branch will be updated with Sing instead of
 /// BB, and BB will still be merged into its predecessor and removed.
-bool MergeBlockIntoPredecessor(BasicBlock *BB, DomTreeUpdater *DTU = nullptr,
-                               LoopInfo *LI = nullptr,
-                               MemorySSAUpdater *MSSAU = nullptr,
-                               MemoryDependenceResults *MemDep = nullptr,
-                               bool PredecessorWithTwoSuccessors = false);
+struct MergeBlockIntoPredecessorOpts {
+  DomTreeUpdater *DTU = nullptr;
+  LoopInfo *LI = nullptr;
+  MemorySSAUpdater *MSSAU = nullptr;
+  MemoryDependenceResults *MemDep = nullptr;
+  bool PredecessorWithTwoSuccessors = false;
+};
+bool MergeBlockIntoPredecessor(BasicBlock *BB,
+                               MergeBlockIntoPredecessorOpts Opts = {});
 
 /// Merge block(s) sucessors, if possible. Return true if at least two
 /// of the blocks were merged together.
 /// In order to merge, each block must be terminated by an unconditional
 /// branch. If L is provided, then the blocks merged into their predecessors
 /// must be in L. In addition, This utility calls on another utility:
 /// MergeBlockIntoPredecessor. Blocks are successfully merged when the call to
 /// MergeBlockIntoPredecessor returns true.

llvm/lib/Transforms/Scalar/GVN.cpp

bool GVN::runImpl(Function &F, AssumptionCache &RunAC, DominatorTree &RunDT,
   bool ShouldContinue = true;
 
   DomTreeUpdater DTU(DT, DomTreeUpdater::UpdateStrategy::Eager);
   // Merge unconditional branches, allowing PRE to catch more
   // optimization opportunities.
   for (Function::iterator FI = F.begin(), FE = F.end(); FI != FE; ) {
     BasicBlock *BB = &*FI++;
 
-    bool removedBlock = MergeBlockIntoPredecessor(BB, &DTU, LI, nullptr, MD);
+    MergeBlockIntoPredecessorOpts MergeOpts;
+    MergeOpts.DTU = &DTU;
+    MergeOpts.LI = LI;
+    MergeOpts.MemDep = MD;
+    bool removedBlock = MergeBlockIntoPredecessor(BB, MergeOpts);
     if (removedBlock)
       ++NumGVNBlocks;
 
     Changed |= removedBlock;
   }
 
   unsigned Iteration = 0;
   while (ShouldContinue) {

llvm/lib/Transforms/Scalar/LoopFuse.cpp

void simplifyLatchBranch(const FusionCandidate &FC) const {
     }
   }
 
   /// Move instructions from FC0.Latch to FC1.Latch. If FC0.Latch has an unique
   /// successor, then merge FC0.Latch with its unique successor.
   void mergeLatch(const FusionCandidate &FC0, const FusionCandidate &FC1) {
     moveInstructionsToTheBeginning(*FC0.Latch, *FC1.Latch, DT, PDT, DI);
     if (BasicBlock *Succ = FC0.Latch->getUniqueSuccessor()) {
-      MergeBlockIntoPredecessor(Succ, &DTU, &LI);
+      MergeBlockIntoPredecessor(Succ, {&DTU, &LI});
       DTU.flush();
     }
   }
 
   /// Fuse two fusion candidates, creating a new fused loop.
   ///
   /// This method contains the mechanics of fusing two loops, represented by \p
   /// FC0 and \p FC1. It is assumed that \p FC0 dominates \p FC1 and \p FC1

llvm/lib/Transforms/Scalar/LoopSimplifyCFG.cpp

for (auto &Block : Blocks) {
     if (!Succ)
       continue;
 
     BasicBlock *Pred = Succ->getSinglePredecessor();
     if (!Pred || !Pred->getSingleSuccessor() || LI.getLoopFor(Pred) != &L)
       continue;
 
     // Merge Succ into Pred and delete it.
-    MergeBlockIntoPredecessor(Succ, &DTU, &LI, MSSAU);
+    MergeBlockIntoPredecessor(Succ, {&DTU, &LI, MSSAU});
 
     if (MSSAU && VerifyMemorySSA)
       MSSAU->getMemorySSA()->verifyMemorySSA();
 
     Changed = true;
   }
 
   return Changed;

llvm/lib/Transforms/Scalar/LoopUnswitch.cpp

if (BranchInst *BI = dyn_cast<BranchInst>(I)) {
               Worklist.push_back(Use);
           for (User *U : PN->users())
             Worklist.push_back(cast<Instruction>(U));
           removeFromWorklist(PN, Worklist);
           ++NumSimplify;
         }
         // Merge the block and make the remaining analyses updates.
         DomTreeUpdater DTU(DT, DomTreeUpdater::UpdateStrategy::Eager);
-        MergeBlockIntoPredecessor(Succ, &DTU, LI, MSSAU.get());
+        MergeBlockIntoPredecessor(Succ, {&DTU, LI, MSSAU.get()});
         ++NumSimplify;
         continue;
       }
 
       continue;
     }
   }
 }

llvm/lib/Transforms/Utils/BasicBlockUtils.cpp

bool llvm::DeleteDeadPHIs(BasicBlock *BB, const TargetLibraryInfo *TLI,
   bool Changed = false;
   for (unsigned i = 0, e = PHIs.size(); i != e; ++i)
     if (PHINode *PN = dyn_cast_or_null<PHINode>(PHIs[i].operator Value*()))
       Changed |= RecursivelyDeleteDeadPHINode(PN, TLI, MSSAU);
 
   return Changed;
 }
 
-bool llvm::MergeBlockIntoPredecessor(BasicBlock *BB, DomTreeUpdater *DTU,
-                                     LoopInfo *LI, MemorySSAUpdater *MSSAU,
-                                     MemoryDependenceResults *MemDep,
-                                     bool PredecessorWithTwoSuccessors) {
+bool llvm::MergeBlockIntoPredecessor(BasicBlock *BB,
+                                     MergeBlockIntoPredecessorOpts Opts) {
+  DomTreeUpdater *DTU = Opts.DTU;
+  LoopInfo *LI = Opts.LI;
+  MemorySSAUpdater *MSSAU = Opts.MSSAU;
+  MemoryDependenceResults *MemDep = Opts.MemDep;
+  bool PredecessorWithTwoSuccessors = Opts.PredecessorWithTwoSuccessors;
+
   if (BB->hasAddressTaken())
     return false;
 
   // Can't merge if there are multiple predecessors, or no predecessors.
   BasicBlock *PredBB = BB->getUniquePredecessor();
   if (!PredBB) return false;
 
   // Don't break self-loops.
bool llvm::MergeBlockSuccessorsIntoGivenBlocks(
 
   bool BlocksHaveBeenMerged = false;
   while (!MergeBlocks.empty()) {
     BasicBlock *BB = *MergeBlocks.begin();
     BasicBlock *Dest = BB->getSingleSuccessor();
     if (Dest && (!L || L->contains(Dest))) {
       BasicBlock *Fold = Dest->getUniquePredecessor();
       (void)Fold;
-      if (MergeBlockIntoPredecessor(Dest, DTU, LI)) {
+      if (MergeBlockIntoPredecessor(Dest, {DTU, LI})) {
         assert(Fold == BB &&
                "Expecting BB to be unique predecessor of the Dest block");
         MergeBlocks.erase(Dest);
         BlocksHaveBeenMerged = true;
       } else
         MergeBlocks.erase(BB);
     } else
       MergeBlocks.erase(BB);

llvm/lib/Transforms/Utils/LoopRotationUtils.cpp

do {
     if (MSSAU && VerifyMemorySSA)
       MSSAU->getMemorySSA()->verifyMemorySSA();
 
     // Now that the CFG and DomTree are in a consistent state again, try to merge
     // the OrigHeader block into OrigLatch.  This will succeed if they are
     // connected by an unconditional branch.  This is just a cleanup so the
     // emitted code isn't too gross in this common case.
     DomTreeUpdater DTU(DT, DomTreeUpdater::UpdateStrategy::Eager);
-    MergeBlockIntoPredecessor(OrigHeader, &DTU, LI, MSSAU);
+    MergeBlockIntoPredecessor(OrigHeader, {&DTU, LI, MSSAU});
 
     if (MSSAU && VerifyMemorySSA)
       MSSAU->getMemorySSA()->verifyMemorySSA();
 
     LLVM_DEBUG(dbgs() << "LoopRotation: into "; L->dump());
 
     ++NumRotated;
 
bool LoopRotate::simplifyLoopLatch(Loop *L) {
 
   if (!shouldSpeculateInstrs(Latch->begin(), Jmp->getIterator(), L))
     return false;
 
   LLVM_DEBUG(dbgs() << "Folding loop latch " << Latch->getName() << " into "
                     << LastExit->getName() << "\n");
 
   DomTreeUpdater DTU(DT, DomTreeUpdater::UpdateStrategy::Eager);
-  MergeBlockIntoPredecessor(Latch, &DTU, LI, MSSAU, nullptr,
-                            /*PredecessorWithTwoSuccessors=*/true);
-
+  MergeBlockIntoPredecessorOpts MergeOpts = {&DTU, LI, MSSAU};
+  MergeOpts.PredecessorWithTwoSuccessors = true;
+  MergeBlockIntoPredecessor(Latch, MergeOpts);
   if (MSSAU && VerifyMemorySSA)
     MSSAU->getMemorySSA()->verifyMemorySSA();
 
   return true;
 }
 
 /// Rotate \c L, and return true if any modification was made.
 bool LoopRotate::processLoop(Loop *L) {

llvm/lib/Transforms/Utils/LoopUnroll.cpp

for (BasicBlock *Latch : Latches) {
     BranchInst *Term = dyn_cast<BranchInst>(Latch->getTerminator());
     assert((Term ||
             (CompletelyUnroll && !LatchIsExiting && Latch == Latches.back())) &&
            "Need a branch as terminator, except when fully unrolling with "
            "unconditional latch");
     if (Term && Term->isUnconditional()) {
       BasicBlock *Dest = Term->getSuccessor(0);
       BasicBlock *Fold = Dest->getUniquePredecessor();
-      if (MergeBlockIntoPredecessor(Dest, &DTU, LI)) {
+      if (MergeBlockIntoPredecessor(Dest, {&DTU, LI})) {
         // Dest has been folded into Fold. Update our worklists accordingly.
         std::replace(Latches.begin(), Latches.end(), Dest, Fold);
         UnrolledLoopBlocks.erase(std::remove(UnrolledLoopBlocks.begin(),
                                              UnrolledLoopBlocks.end(), Dest),
                                  UnrolledLoopBlocks.end());
       }
     }
   }

llvm/lib/Transforms/Vectorize/VPlan.cpp

assert((EnableVPlanNativePath ||
           isa<UnreachableInst>(LastBB->getTerminator())) &&
          "Expected InnerLoop VPlan CFG to terminate with unreachable");
   assert((!EnableVPlanNativePath || isa<BranchInst>(LastBB->getTerminator())) &&
          "Expected VPlan CFG to terminate with branch in NativePath");
   LastBB->getTerminator()->eraseFromParent();
   BranchInst::Create(VectorLatchBB, LastBB);
 
   // Merge LastBB with Latch.
-  bool Merged = MergeBlockIntoPredecessor(VectorLatchBB, nullptr, State->LI);
+  MergeBlockIntoPredecessorOpts MergeOpts;
+  MergeOpts.LI = State->LI;
+  bool Merged = MergeBlockIntoPredecessor(VectorLatchBB, MergeOpts);
   (void)Merged;
   assert(Merged && "Could not merge last basic block with latch.");
   VectorLatchBB = LastBB;
 
   // We do not attempt to preserve DT for outer loop vectorization currently.
   if (!EnableVPlanNativePath)
     updateDominatorTree(State->DT, VectorPreHeaderBB, VectorLatchBB,
                         L->getExitBlock());