[NFC] Cleanup: Remove Function::getBasicBlockList() when not required.

[vporpo]

Summary

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

clang/lib/CodeGen/CGVTables.cpp

static void resolveTopLevelMetadata(llvm::Function *Fn,
   auto *DIS = Fn->getSubprogram();
   if (!DIS)
     return;
   auto *NewDIS = DIS->replaceWithDistinct(DIS->clone());
   VMap.MD()[DIS].reset(NewDIS);
 
   // Find all llvm.dbg.declare intrinsics and resolve the DILocalVariable nodes
   // they are referencing.
-  for (auto &BB : Fn->getBasicBlockList()) {
+  for (auto &BB : *Fn) {
     for (auto &I : BB) {
       if (auto *DII = dyn_cast<llvm::DbgVariableIntrinsic>(&I)) {
         auto *DILocal = DII->getVariable();
         if (!DILocal->isResolved())
           DILocal->resolve();
       }
     }
   }

lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptx86ABIFixups.cpp

 }
 
 static bool
 findRSCallSites(llvm::Module &module, std::set<llvm::CallInst *> &rs_callsites,
                 bool (*predicate)(llvm::CallInst *)) {
   bool found = false;
 
   for (auto &func : module.getFunctionList())
-    for (auto &block : func.getBasicBlockList())
+    for (auto &block : func)
       for (auto &inst : block) {
         llvm::CallInst *call_inst =
             llvm::dyn_cast_or_null<llvm::CallInst>(&inst);
         if (!call_inst || !call_inst->getCalledFunction())
           // This is not the call-site you are looking for...
           continue;
         if (isRSAPICall(call_inst) && predicate(call_inst)) {
           rs_callsites.insert(call_inst);

llvm/lib/ExecutionEngine/Orc/SpeculateAnalyses.cpp

std::size_t SequenceBBQuery::getHottestBlocks(std::size_t TotalBlocks) {
   return TotalBlocks / 2;
 }
 
 // FIXME : find good implementation.
 SequenceBBQuery::BlockListTy
 SequenceBBQuery::rearrangeBB(const Function &F, const BlockListTy &BBList) {
   BlockListTy RearrangedBBSet;
 
-  for (auto &Block : F.getBasicBlockList())
+  for (auto &Block : F)
     if (llvm::is_contained(BBList, &Block))
       RearrangedBBSet.push_back(&Block);
 
   assert(RearrangedBBSet.size() == BBList.size() &&
          "BasicBlock missing while rearranging?");
   return RearrangedBBSet;
 }
 

llvm/lib/Target/AArch64/SMEABIPass.cpp

bool SMEABI::updateNewZAFunctions(Module *M, Function *F,
 
   // Enable pstate.za at the start of the function.
   Builder.SetInsertPoint(&OrigBB->front());
   Function *EnableZAIntr =
       Intrinsic::getDeclaration(M, Intrinsic::aarch64_sme_za_enable);
   Builder.CreateCall(EnableZAIntr->getFunctionType(), EnableZAIntr);
 
   // Before returning, disable pstate.za
-  for (BasicBlock &BB : F->getBasicBlockList()) {
+  for (BasicBlock &BB : *F) {
     Instruction *T = BB.getTerminator();
     if (!T || !isa<ReturnInst>(T))
       continue;
     Builder.SetInsertPoint(T);
     Function *DisableZAIntr =
         Intrinsic::getDeclaration(M, Intrinsic::aarch64_sme_za_disable);
     Builder.CreateCall(DisableZAIntr->getFunctionType(), DisableZAIntr);
   }

llvm/lib/Transforms/CFGuard/CFGuard.cpp

if (cfguard_module_flag != 2)
     return false;
 
   SmallVector<CallBase *, 8> IndirectCalls;
 
   // Iterate over the instructions to find all indirect call/invoke/callbr
   // instructions. Make a separate list of pointers to indirect
   // call/invoke/callbr instructions because the original instructions will be
   // deleted as the checks are added.
-  for (BasicBlock &BB : F.getBasicBlockList()) {
+  for (BasicBlock &BB : F) {
     for (Instruction &I : BB) {
       auto *CB = dyn_cast<CallBase>(&I);
       if (CB && CB->isIndirectCall() && !CB->hasFnAttr("guard_nocf")) {
         IndirectCalls.push_back(CB);
         CFGuardCounter++;
       }
     }
   }

llvm/lib/Transforms/IPO/InlineSimple.cpp

public:
 
   static char ID; // Pass identification, replacement for typeid
 
   InlineCost getInlineCost(CallBase &CB) override {
     Function *Callee = CB.getCalledFunction();
     TargetTransformInfo &TTI = TTIWP->getTTI(*Callee);
 
     bool RemarksEnabled = false;
-    const auto &BBs = CB.getCaller()->getBasicBlockList();
+    const auto &BBs = *CB.getCaller();
     if (!BBs.empty()) {
       auto DI = OptimizationRemark(DEBUG_TYPE, "", DebugLoc(), &BBs.front());
       if (DI.isEnabled())
         RemarksEnabled = true;
     }
     OptimizationRemarkEmitter ORE(CB.getCaller());
 
     std::function<AssumptionCache &(Function &)> GetAssumptionCache =

llvm/lib/Transforms/IPO/WholeProgramDevirt.cpp

void DevirtModule::rebuildGlobal(VTableBits &B) {
 
   B.GV->replaceAllUsesWith(Alias);
   B.GV->eraseFromParent();
 }
 
 bool DevirtModule::areRemarksEnabled() {
   const auto &FL = M.getFunctionList();
   for (const Function &Fn : FL) {
-    const auto &BBL = Fn.getBasicBlockList();
-    if (BBL.empty())
+    if (Fn.empty())
       continue;
-    auto DI = OptimizationRemark(DEBUG_TYPE, "", DebugLoc(), &BBL.front());
+    auto DI = OptimizationRemark(DEBUG_TYPE, "", DebugLoc(), &Fn.front());
     return DI.isEnabled();
   }
   return false;
 }
 
 void DevirtModule::scanTypeTestUsers(
     Function *TypeTestFunc,
     DenseMap<Metadata *, std::set<TypeMemberInfo>> &TypeIdMap) {

llvm/lib/Transforms/Instrumentation/AddressSanitizer.cpp

void ModuleAddressSanitizer::poisonOneInitializer(Function &GlobalInit,
   IRBuilder<> IRB(&GlobalInit.front(),
                   GlobalInit.front().getFirstInsertionPt());
 
   // Add a call to poison all external globals before the given function starts.
   Value *ModuleNameAddr = ConstantExpr::getPointerCast(ModuleName, IntptrTy);
   IRB.CreateCall(AsanPoisonGlobals, ModuleNameAddr);
 
   // Add calls to unpoison all globals before each return instruction.
-  for (auto &BB : GlobalInit.getBasicBlockList())
+  for (auto &BB : GlobalInit)
     if (ReturnInst *RI = dyn_cast<ReturnInst>(BB.getTerminator()))
       CallInst::Create(AsanUnpoisonGlobals, "", RI);
 }
 
 void ModuleAddressSanitizer::createInitializerPoisonCalls(
     Module &M, GlobalValue *ModuleName) {
   GlobalVariable *GV = M.getGlobalVariable("llvm.global_ctors");
   if (!GV)

llvm/lib/Transforms/Utils/FunctionComparator.cpp

case Value::BlockAddressVal: {
     if (LBA->getFunction() == RBA->getFunction()) {
       // They are BBs in the same function. Order by which comes first in the
       // BB order of the function. This order is deterministic.
       Function *F = LBA->getFunction();
       BasicBlock *LBB = LBA->getBasicBlock();
       BasicBlock *RBB = RBA->getBasicBlock();
       if (LBB == RBB)
         return 0;
-      for (BasicBlock &BB : F->getBasicBlockList()) {
+      for (BasicBlock &BB : *F) {
         if (&BB == LBB) {
           assert(&BB != RBB);
           return -1;
         }
         if (&BB == RBB)
           return 1;
       }
       llvm_unreachable("Basic Block Address does not point to a basic block in "

llvm/lib/Transforms/Utils/InlineFunction.cpp

llvm::InlineResult llvm::InlineFunction(CallBase &CB, InlineFunctionInfo &IFI,
   // If we cloned in _exactly one_ basic block, and if that block ends in a
   // return instruction, we splice the body of the inlined callee directly into
   // the calling basic block.
   if (Returns.size() == 1 && std::distance(FirstNewBlock, Caller->end()) == 1) {
     // Move all of the instructions right before the call.
     OrigBB->splice(CB.getIterator(), &*FirstNewBlock, FirstNewBlock->begin(),
                    FirstNewBlock->end());
     // Remove the cloned basic block.
-    Caller->getBasicBlockList().pop_back();
+    Caller->back().eraseFromParent();
 
     // If the call site was an invoke instruction, add a branch to the normal
     // destination.
     if (InvokeInst *II = dyn_cast<InvokeInst>(&CB)) {
       BranchInst *NewBr = BranchInst::Create(II->getNormalDest(), &CB);
       NewBr->setDebugLoc(Returns[0]->getDebugLoc());
     }
 
llvm::InlineResult llvm::InlineFunction(CallBase &CB, InlineFunctionInfo &IFI,
   // unconditional branch.
   CalleeEntry->replaceAllUsesWith(OrigBB);  // Update PHI nodes
   OrigBB->splice(Br->getIterator(), CalleeEntry);
 
   // Remove the unconditional branch.
   Br->eraseFromParent();
 
   // Now we can remove the CalleeEntry block, which is now empty.
-  Caller->getBasicBlockList().erase(CalleeEntry);
+  CalleeEntry->eraseFromParent();
 
   // If we inserted a phi node, check to see if it has a single value (e.g. all
   // the entries are the same or undef).  If so, remove the PHI so it doesn't
   // block other optimizations.
   if (PHI) {
     AssumptionCache *AC =
         IFI.GetAssumptionCache ? &IFI.GetAssumptionCache(*Caller) : nullptr;
     auto &DL = Caller->getParent()->getDataLayout();

llvm/unittests/FuzzMutate/StrategiesTest.cpp

 static void VerifyBlockShuffle(StringRef Source) {
   LLVMContext Ctx;
   auto Mutator = createMutator<ShuffleBlockStrategy>();
   ASSERT_TRUE(Mutator);
 
   std::unique_ptr<Module> M = parseAssembly(Source.data(), Ctx);
   Function *F = &*M->begin();
   DenseMap<BasicBlock *, int> PreShuffleInstCnt;
-  for (BasicBlock &BB : F->getBasicBlockList()) {
+  for (BasicBlock &BB : *F) {
     PreShuffleInstCnt.insert({&BB, BB.size()});
   }
   std::mt19937 mt(Seed);
   std::uniform_int_distribution<int> RandInt(INT_MIN, INT_MAX);
   for (int i = 0; i < 100; i++) {
     Mutator->mutateModule(*M, RandInt(mt), Source.size(), Source.size() + 1024);
-    for (BasicBlock &BB : F->getBasicBlockList()) {
+    for (BasicBlock &BB : *F) {
       int PostShuffleIntCnt = BB.size();
       EXPECT_EQ(PostShuffleIntCnt, PreShuffleInstCnt[&BB]);
     }
     EXPECT_FALSE(verifyModule(*M, &errs()));
   }
 }
 
 TEST(ShuffleBlockStrategy, ShuffleBlocks) {

llvm/unittests/IR/InstructionsTest.cpp

 if.then:
   ret void
 
 if.end:
   ret void
 }
 )");
   Function *Foo = M->getFunction("foo");
-  auto BBs = Foo->getBasicBlockList().begin();
+  auto BBs = Foo->begin();
   CallBrInst &CBI = cast<CallBrInst>(BBs->front());
   ++BBs;
   ++BBs;
   BasicBlock &BranchTestExit = *BBs;
   ++BBs;
   BasicBlock &IfThen = *BBs;
 
   // Test that setting the first indirect destination of callbr updates the dest

mlir/lib/Target/LLVMIR/ConvertFromLLVMIR.cpp

 getTopologicallySortedBlocks(llvm::Function *func) {
   SetVector<llvm::BasicBlock *> blocks;
   for (llvm::BasicBlock &bb : *func) {
     if (blocks.count(&bb) == 0) {
       llvm::ReversePostOrderTraversal<llvm::BasicBlock *> traversal(&bb);
       blocks.insert(traversal.begin(), traversal.end());
     }
   }
-  assert(blocks.size() == func->getBasicBlockList().size() &&
-         "some blocks are not sorted");
+  assert(blocks.size() == func->size() && "some blocks are not sorted");
 
   return blocks;
 }
 
 // Handles importing globals and functions from an LLVM module.
 namespace {
 class Importer {
 public: