[NFC] Removed call to getInstList() from range loops on BBs.

llvm/lib/Analysis/CFLGraph.h

template <typename CFLAA> class CFLGraphBuilder {
   }
 
   // Builds the graph needed for constructing the StratifiedSets for the given
   // function
   void buildGraphFrom(Function &Fn) {
     GetEdgesVisitor Visitor(*this, Fn.getParent()->getDataLayout());
 
     for (auto &Bb : Fn.getBasicBlockList())
-      for (auto &Inst : Bb.getInstList())
+      for (auto &Inst : Bb)
         addInstructionToGraph(Visitor, Inst);
 
     for (auto &Arg : Fn.args())
       addArgumentToGraph(Arg);
   }
 
 public:
   CFLGraphBuilder(CFLAA &Analysis, const TargetLibraryInfo &TLI, Function &Fn)

llvm/lib/Transforms/CFGuard/CFGuard.cpp

bool CFGuard::runOnFunction(Function &F) {
 
   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 (Instruction &I : BB.getInstList()) {
+    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/SampleProfile.cpp

bool SampleProfileLoader::inlineHotFunctions(
   bool LocalChanged = true;
   while (LocalChanged) {
     LocalChanged = false;
     SmallVector<CallBase *, 10> CIS;
     for (auto &BB : F) {
       bool Hot = false;
       SmallVector<CallBase *, 10> AllCandidates;
       SmallVector<CallBase *, 10> ColdCandidates;
-      for (auto &I : BB.getInstList()) {
+      for (auto &I : BB) {
         const FunctionSamples *FS = nullptr;
         if (auto *CB = dyn_cast<CallBase>(&I)) {
           if (!isa<IntrinsicInst>(I)) {
             if ((FS = findCalleeFunctionSamples(*CB))) {
               assert((!FunctionSamples::UseMD5 || FS->GUIDToFuncNameMap) &&
                      "GUIDToFuncNameMap has to be populated");
               AllCandidates.push_back(CB);
               if (FS->getHeadSamplesEstimate() > 0 ||
assert((!ProfAccForSymsInList ||
          "ProfAccForSymsInList should be false when profile-sample-accurate "
          "is enabled");
 
   // Populating worklist with initial call sites from root inliner, along
   // with call site weights.
   CandidateQueue CQueue;
   InlineCandidate NewCandidate;
   for (auto &BB : F) {
-    for (auto &I : BB.getInstList()) {
+    for (auto &I : BB) {
       auto *CB = dyn_cast<CallBase>(&I);
       if (!CB)
         continue;
       if (getInlineCandidate(&NewCandidate, CB))
         CQueue.push(NewCandidate);
     }
   }
 
void SampleProfileLoader::generateMDProfMetadata(Function &F) {
   // edge weights computed during propagation.
   LLVM_DEBUG(dbgs() << "\nPropagation complete. Setting branch weights\n");
   LLVMContext &Ctx = F.getContext();
   MDBuilder MDB(Ctx);
   for (auto &BI : F) {
     BasicBlock *BB = &BI;
 
     if (BlockWeights[BB]) {
-      for (auto &I : BB->getInstList()) {
+      for (auto &I : *BB) {
         if (!isa<CallInst>(I) && !isa<InvokeInst>(I))
           continue;
         if (!cast<CallBase>(I).getCalledFunction()) {
           const DebugLoc &DLoc = I.getDebugLoc();
           if (!DLoc)
             continue;
           const DILocation *DIL = DLoc;
           const FunctionSamples *FS = findFunctionSamples(I);
if (BlockWeights[BB]) {
           I.setMetadata(LLVMContext::MD_prof,
                         MDB.createBranchWeights(
                             {static_cast<uint32_t>(BlockWeights[BB])}));
         }
       }
     } else if (OverwriteExistingWeights || ProfileSampleBlockAccurate) {
       // Set profile metadata (possibly annotated by LTO prelink) to zero or
       // clear it for cold code.
-      for (auto &I : BB->getInstList()) {
+      for (auto &I : *BB) {
         if (isa<CallInst>(I) || isa<InvokeInst>(I)) {
           if (cast<CallBase>(I).isIndirectCall())
             I.setMetadata(LLVMContext::MD_prof, nullptr);
           else
             I.setMetadata(LLVMContext::MD_prof, MDB.createBranchWeights(0));
         }
       }
     }
if (FunctionSamples::ProfileIsProbeBased) {
     }
   }
 
   std::unordered_set<LineLocation, LineLocationHash> MatchedCallsiteLocs;
 
   // Go through all the callsites on the IR and flag the callsite if the target
   // name is the same as the one in the profile.
   for (auto &BB : F) {
-    for (auto &I : BB.getInstList()) {
+    for (auto &I : BB) {
       if (!isa<CallBase>(&I) || isa<IntrinsicInst>(&I))
         continue;
 
       const auto *CB = dyn_cast<CallBase>(&I);
       if (auto &DLoc = I.getDebugLoc()) {
         LineLocation IRCallsite = FunctionSamples::getCallSiteIdentifier(DLoc);
 
         StringRef CalleeName;

llvm/lib/Transforms/Scalar/EarlyCSE.cpp

bool EarlyCSE::processNode(DomTreeNode *Node) {
   /// LastStore - Keep track of the last non-volatile store that we saw... for
   /// as long as there in no instruction that reads memory.  If we see a store
   /// to the same location, we delete the dead store.  This zaps trivial dead
   /// stores which can occur in bitfield code among other things.
   Instruction *LastStore = nullptr;
 
   // See if any instructions in the block can be eliminated.  If so, do it.  If
   // not, add them to AvailableValues.
-  for (Instruction &Inst : make_early_inc_range(BB->getInstList())) {
+  for (Instruction &Inst : make_early_inc_range(*BB)) {
     // Dead instructions should just be removed.
     if (isInstructionTriviallyDead(&Inst, &TLI)) {
       LLVM_DEBUG(dbgs() << "EarlyCSE DCE: " << Inst << '\n');
       if (!DebugCounter::shouldExecute(CSECounter)) {
         LLVM_DEBUG(dbgs() << "Skipping due to debug counter\n");
         continue;
       }
 

llvm/lib/Transforms/Utils/AddDiscriminators.cpp

static bool addDiscriminators(Function &F) {
 
   LocationBBMap LBM;
   LocationDiscriminatorMap LDM;
 
   // Traverse all instructions in the function. If the source line location
   // of the instruction appears in other basic block, assign a new
   // discriminator for this instruction.
   for (BasicBlock &B : F) {
-    for (auto &I : B.getInstList()) {
+    for (auto &I : B) {
       // Not all intrinsic calls should have a discriminator.
       // We want to avoid a non-deterministic assignment of discriminators at
       // different debug levels. We still allow discriminators on memory
       // intrinsic calls because those can be early expanded by SROA into
       // pairs of loads and stores, and the expanded load/store instructions
       // should have a valid discriminator.
       if (!shouldHaveDiscriminator(&I))
         continue;
static bool addDiscriminators(Function &F) {
   }
 
   // Traverse all instructions and assign new discriminators to call
   // instructions with the same lineno that are in the same basic block.
   // Sample base profile needs to distinguish different function calls within
   // a same source line for correct profile annotation.
   for (BasicBlock &B : F) {
     LocationSet CallLocations;
-    for (auto &I : B.getInstList()) {
+    for (auto &I : B) {
       // We bypass intrinsic calls for the following two reasons:
       //  1) We want to avoid a non-deterministic assignment of
       //     discriminators.
       //  2) We want to minimize the number of base discriminators used.
       if (!isa<InvokeInst>(I) && (!isa<CallInst>(I) || isa<IntrinsicInst>(I)))  
         continue;
 
       DILocation *CurrentDIL = I.getDebugLoc();