[NFC] Cleanup: Replace Function::getBasicBlockList().splice() with Function::splice()

[vporpo]

Summary

This is part of a series of patches that aim at making Function::getBasicBlockList() private.

[vporpo]

Rebased.

[foad]

AMDGPU part looks obviously fine, thanks.

llvm/lib/AsmParser/LLParser.cpp

if (Name.empty()) {
     if (!BB) {
       P.error(Loc, "unable to create block named '" + Name + "'");
       return nullptr;
     }
   }
 
   // Move the block to the end of the function.  Forward ref'd blocks are
   // inserted wherever they happen to be referenced.
-  F.getBasicBlockList().splice(F.end(), F.getBasicBlockList(), BB);
+  F.splice(F.end(), &F, BB->getIterator());
 
   // Remove the block from forward ref sets.
   if (Name.empty()) {
     ForwardRefValIDs.erase(NumberedVals.size());
     NumberedVals.push_back(BB);
   } else {
     // BB forward references are already in the function symbol table.
     ForwardRefVals.erase(Name);

llvm/lib/IR/BasicBlock.cpp

void BasicBlock::removeFromParent() {
   getParent()->getBasicBlockList().remove(getIterator());
 }
 
 iplist<BasicBlock>::iterator BasicBlock::eraseFromParent() {
   return getParent()->getBasicBlockList().erase(getIterator());
 }
 
 void BasicBlock::moveBefore(BasicBlock *MovePos) {
-  MovePos->getParent()->getBasicBlockList().splice(
-      MovePos->getIterator(), getParent()->getBasicBlockList(), getIterator());
+  MovePos->getParent()->splice(MovePos->getIterator(), getParent(),
+                               getIterator());
 }
 
 void BasicBlock::moveAfter(BasicBlock *MovePos) {
-  MovePos->getParent()->getBasicBlockList().splice(
-      ++MovePos->getIterator(), getParent()->getBasicBlockList(),
+  MovePos->getParent()->splice(++MovePos->getIterator(), getParent(),
                                getIterator());
 }
 
 const Module *BasicBlock::getModule() const {
   return getParent()->getParent();
 }
 
 const CallInst *BasicBlock::getTerminatingMustTailCall() const {
   if (InstList.empty())

llvm/lib/Linker/IRMover.cpp

Error IRLinker::linkFunctionBody(Function &Dst, Function &Src) {
   if (Src.hasPersonalityFn())
     Dst.setPersonalityFn(Src.getPersonalityFn());
 
   // Copy over the metadata attachments without remapping.
   Dst.copyMetadata(&Src, 0);
 
   // Steal arguments and splice the body of Src into Dst.
   Dst.stealArgumentListFrom(Src);
-  Dst.getBasicBlockList().splice(Dst.end(), Src.getBasicBlockList());
+  Dst.splice(Dst.end(), &Src);
 
   // Everything has been moved over.  Remap it.
   Mapper.scheduleRemapFunction(Dst);
   return Error::success();
 }
 
 void IRLinker::linkAliasAliasee(GlobalAlias &Dst, GlobalAlias &Src) {
   Mapper.scheduleMapGlobalAlias(Dst, *Src.getAliasee(), IndirectSymbolMCID);

llvm/lib/Target/AMDGPU/AMDGPURewriteOutArguments.cpp

bool AMDGPURewriteOutArguments::runOnFunction(Function &F) {
   RetAttrs.addAttribute(Attribute::SExt);
   RetAttrs.addAttribute(Attribute::ZExt);
   RetAttrs.addAttribute(Attribute::NoAlias);
   NewFunc->removeRetAttrs(RetAttrs);
   // TODO: How to preserve metadata?
 
   // Move the body of the function into the new rewritten function, and replace
   // this function with a stub.
-  NewFunc->getBasicBlockList().splice(NewFunc->begin(), F.getBasicBlockList());
+  NewFunc->splice(NewFunc->begin(), &F);
 
   for (std::pair<ReturnInst *, ReplacementVec> &Replacement : Replacements) {
     ReturnInst *RI = Replacement.first;
     IRBuilder<> B(RI);
     B.SetCurrentDebugLocation(RI->getDebugLoc());
 
     int RetIdx = 0;
     Value *NewRetVal = PoisonValue::get(NewRetTy);

llvm/lib/Transforms/IPO/ArgumentPromotion.cpp

while (!F->use_empty()) {
     // Finally, remove the old call from the program, reducing the use-count of
     // F.
     CB.eraseFromParent();
   }
 
   // Since we have now created the new function, splice the body of the old
   // function right into the new function, leaving the old rotting hulk of the
   // function empty.
-  NF->getBasicBlockList().splice(NF->begin(), F->getBasicBlockList());
+  NF->splice(NF->begin(), F);
 
   // We will collect all the new created allocas to promote them into registers
   // after the following loop
   SmallVector<AllocaInst *, 4> Allocas;
 
   // Loop over the argument list, transferring uses of the old arguments over to
   // the new arguments, also transferring over the names as well.
   Function::arg_iterator I2 = NF->arg_begin();

llvm/lib/Transforms/IPO/Attributor.cpp

for (auto &It : ArgumentReplacementMap) {
     NewFn->setAttributes(AttributeList::get(
         Ctx, OldFnAttributeList.getFnAttrs(), OldFnAttributeList.getRetAttrs(),
         NewArgumentAttributes));
     AttributeFuncs::updateMinLegalVectorWidthAttr(*NewFn, LargestVectorWidth);
 
     // Since we have now created the new function, splice the body of the old
     // function right into the new function, leaving the old rotting hulk of the
     // function empty.
-    NewFn->getBasicBlockList().splice(NewFn->begin(),
-                                      OldFn->getBasicBlockList());
+    NewFn->splice(NewFn->begin(), OldFn);
 
     // Fixup block addresses to reference new function.
     SmallVector<BlockAddress *, 8u> BlockAddresses;
     for (User *U : OldFn->users())
       if (auto *BA = dyn_cast<BlockAddress>(U))
         BlockAddresses.push_back(BA);
     for (auto *BA : BlockAddresses)
       BA->replaceAllUsesWith(BlockAddress::get(NewFn, BA->getBasicBlock()));

llvm/lib/Transforms/IPO/DeadArgumentElimination.cpp

for (User *U : llvm::make_early_inc_range(F.users())) {
     // Finally, remove the old call from the program, reducing the use-count of
     // F.
     CB->eraseFromParent();
   }
 
   // Since we have now created the new function, splice the body of the old
   // function right into the new function, leaving the old rotting hulk of the
   // function empty.
-  NF->getBasicBlockList().splice(NF->begin(), F.getBasicBlockList());
+  NF->splice(NF->begin(), &F);
 
   // Loop over the argument list, transferring uses of the old arguments over to
   // the new arguments, also transferring over the names as well.  While we're
   // at it, remove the dead arguments from the DeadArguments list.
   for (Function::arg_iterator I = F.arg_begin(), E = F.arg_end(),
                               I2 = NF->arg_begin();
        I != E; ++I, ++I2) {
     // Move the name and users over to the new version.
while (!F->use_empty()) {
     // Finally, remove the old call from the program, reducing the use-count of
     // F.
     CB.eraseFromParent();
   }
 
   // Since we have now created the new function, splice the body of the old
   // function right into the new function, leaving the old rotting hulk of the
   // function empty.
-  NF->getBasicBlockList().splice(NF->begin(), F->getBasicBlockList());
+  NF->splice(NF->begin(), F);
 
   // Loop over the argument list, transferring uses of the old arguments over to
   // the new arguments, also transferring over the names as well.
   ArgI = 0;
   for (Function::arg_iterator I = F->arg_begin(), E = F->arg_end(),
                               I2 = NF->arg_begin();
        I != E; ++I, ++ArgI)
     if (ArgAlive[ArgI]) {

llvm/lib/Transforms/Instrumentation/ControlHeightReduction.cpp

for (BasicBlock *BB : RI.R->blocks()) { // This includes the blocks in the
       BasicBlock *NewBB = CloneBasicBlock(BB, VMap, ".nonchr", &F);
       NewBlocks.push_back(NewBB);
       VMap[BB] = NewBB;
     }
 
   // Place the cloned blocks right after the original blocks (right before the
   // exit block of.)
   if (ExitBlock)
-    F.getBasicBlockList().splice(ExitBlock->getIterator(),
-                                 F.getBasicBlockList(),
-                                 NewBlocks[0]->getIterator(), F.end());
+    F.splice(ExitBlock->getIterator(), &F, NewBlocks[0]->getIterator(),
+             F.end());
 
   // Update the cloned blocks/instructions to refer to themselves.
   for (BasicBlock *NewBB : NewBlocks)
     for (Instruction &I : *NewBB)
       RemapInstruction(&I, VMap,
                        RF_NoModuleLevelChanges | RF_IgnoreMissingLocals);
 
   // Add the cloned blocks to the PHIs of the exit blocks. ExitBlock is null for

llvm/lib/Transforms/Utils/CloneFunction.cpp

for (BasicBlock *BB : OrigLoop->getBlocks()) {
 
     // Update DominatorTree.
     BasicBlock *IDomBB = DT->getNode(BB)->getIDom()->getBlock();
     DT->changeImmediateDominator(cast<BasicBlock>(VMap[BB]),
                                  cast<BasicBlock>(VMap[IDomBB]));
   }
 
   // Move them physically from the end of the block list.
-  F->getBasicBlockList().splice(Before->getIterator(), F->getBasicBlockList(),
-                                NewPH);
-  F->getBasicBlockList().splice(Before->getIterator(), F->getBasicBlockList(),
-                                NewLoop->getHeader()->getIterator(), F->end());
+  F->splice(Before->getIterator(), F, NewPH->getIterator());
+  F->splice(Before->getIterator(), F, NewLoop->getHeader()->getIterator(),
+            F->end());
 
   return NewLoop;
 }
 
 /// Duplicate non-Phi instructions from the beginning of block up to
 /// StopAt instruction into a split block between BB and its predecessor.
 BasicBlock *llvm::DuplicateInstructionsInSplitBetween(
     BasicBlock *BB, BasicBlock *PredBB, Instruction *StopAt,

llvm/lib/Transforms/Utils/InlineFunction.cpp

llvm::InlineResult llvm::InlineFunction(CallBase &CB, InlineFunctionInfo &IFI,
   Instruction *Br = OrigBB->getTerminator();
   assert(Br && Br->getOpcode() == Instruction::Br &&
          "splitBasicBlock broken!");
   Br->setOperand(0, &*FirstNewBlock);
 
   // Now that the function is correct, make it a little bit nicer.  In
   // particular, move the basic blocks inserted from the end of the function
   // into the space made by splitting the source basic block.
-  Caller->getBasicBlockList().splice(AfterCallBB->getIterator(),
-                                     Caller->getBasicBlockList(), FirstNewBlock,
-                                     Caller->end());
+  Caller->splice(AfterCallBB->getIterator(), Caller, FirstNewBlock,
 
   // Handle all of the return instructions that we just cloned in, and eliminate
   // any users of the original call/invoke instruction.
   Type *RTy = CalledFunc->getReturnType();
 
   PHINode *PHI = nullptr;
   if (Returns.size() > 1) {
     // The PHI node should go at the front of the new basic block to merge all

llvm/lib/Transforms/Utils/LoopPeel.cpp

#endif
     // because it is not the Loop's latch branch anymore.
     auto *LatchTermCopy = cast<Instruction>(VMap[LatchTerm]);
     LatchTermCopy->setMetadata(LLVMContext::MD_loop, nullptr);
 
     InsertTop = InsertBot;
     InsertBot = SplitBlock(InsertBot, InsertBot->getTerminator(), &DT, LI);
     InsertBot->setName(Header->getName() + ".peel.next");
 
-    F->getBasicBlockList().splice(InsertTop->getIterator(),
-                                  F->getBasicBlockList(),
-                                  NewBlocks[0]->getIterator(), F->end());
+    F->splice(InsertTop->getIterator(), F, NewBlocks[0]->getIterator(),
+              F->end());
   }
 
   // Now adjust the phi nodes in the loop header to get their initial values
   // from the last peeled-off iteration instead of the preheader.
   for (BasicBlock::iterator I = Header->begin(); isa<PHINode>(I); ++I) {
     PHINode *PHI = cast<PHINode>(I);
     Value *NewVal = PHI->getIncomingValueForBlock(Latch);
     Instruction *LatchInst = dyn_cast<Instruction>(NewVal);

llvm/lib/Transforms/Utils/LoopSimplify.cpp

static BasicBlock *insertUniqueBackedgeBlock(Loop *L, BasicBlock *Preheader,
   BranchInst *BETerminator = BranchInst::Create(Header, BEBlock);
   BETerminator->setDebugLoc(Header->getFirstNonPHI()->getDebugLoc());
 
   LLVM_DEBUG(dbgs() << "LoopSimplify: Inserting unique backedge block "
                     << BEBlock->getName() << "\n");
 
   // Move the new backedge block to right after the last backedge block.
   Function::iterator InsertPos = ++BackedgeBlocks.back()->getIterator();
-  F->getBasicBlockList().splice(InsertPos, F->getBasicBlockList(), BEBlock);
+  F->splice(InsertPos, F, BEBlock->getIterator());
 
   // Now that the block has been inserted into the function, create PHI nodes in
   // the backedge block which correspond to any PHI nodes in the header block.
   for (BasicBlock::iterator I = Header->begin(); isa<PHINode>(I); ++I) {
     PHINode *PN = cast<PHINode>(I);
     PHINode *NewPN = PHINode::Create(PN->getType(), BackedgeBlocks.size(),
                                      PN->getName()+".be", BETerminator);
 

llvm/lib/Transforms/Utils/LoopUnrollRuntime.cpp

Loop *remainderLoop = CloneLoopBlocks(
       NewPreHeader, NewBlocks, LoopBlocks, VMap, DT, LI);
 
   // Assign the maximum possible trip count as the back edge weight for the
   // remainder loop if the original loop comes with a branch weight.
   if (remainderLoop && !UnrollRemainder)
     updateLatchBranchWeightsForRemainderLoop(L, remainderLoop, Count);
 
   // Insert the cloned blocks into the function.
-  F->getBasicBlockList().splice(InsertBot->getIterator(),
-                                F->getBasicBlockList(),
-                                NewBlocks[0]->getIterator(),
-                                F->end());
+  F->splice(InsertBot->getIterator(), F, NewBlocks[0]->getIterator(), F->end());
 
   // Now the loop blocks are cloned and the other exiting blocks from the
   // remainder are connected to the original Loop's exit blocks. The remaining
   // work is to update the phi nodes in the original loop, and take in the
   // values from the cloned region.
   for (auto *BB : OtherExits) {
     // Given we preserve LCSSA form, we know that the values used outside the
     // loop will be used through these phi nodes at the exit blocks that are

llvm/unittests/Analysis/LazyCallGraphTest.cpp

TEST(LazyCallGraphTest, ReplaceNodeFunction) {
   Function &E = *Function::Create(D.getFunctionType(), D.getLinkage(), "e");
   D.getParent()->getFunctionList().insert(D.getIterator(), &E);
 
   // Change each use of 'd' to use 'e'. This is particularly easy as they have
   // the same type.
   D.replaceAllUsesWith(&E);
 
   // Splice the body of the old function into the new one.
-  E.getBasicBlockList().splice(E.begin(), D.getBasicBlockList());
+  E.splice(E.begin(), &D);
   // And fix up the one argument.
   D.arg_begin()->replaceAllUsesWith(&*E.arg_begin());
   E.arg_begin()->takeName(&*D.arg_begin());
 
   // Now replace the function in the graph.
   RC1.replaceNodeFunction(DN, E);
 
   EXPECT_EQ(&E, &DN.getFunction());