[NFC] Use BB->size() instead of BB->getInstList().size().

[tmsriram]

LGTM

llvm/lib/Analysis/DomTreeUpdater.cpp

bool DomTreeUpdater::forceFlushDeletedBB() {
   if (DeletedBBs.empty())
     return false;
 
   for (auto *BB : DeletedBBs) {
     // After calling deleteBB or callbackDeleteBB under Lazy UpdateStrategy,
     // validateDeleteBB() removes all instructions of DelBB and adds an
     // UnreachableInst as its terminator. So we check whether the BasicBlock to
     // delete only has an UnreachableInst inside.
-    assert(BB->getInstList().size() == 1 &&
-           isa<UnreachableInst>(BB->getTerminator()) &&
+    assert(BB->size() == 1 && isa<UnreachableInst>(BB->getTerminator()) &&
            "DelBB has been modified while awaiting deletion.");
     BB->removeFromParent();
     eraseDelBBNode(BB);
     delete BB;
   }
   DeletedBBs.clear();
   Callbacks.clear();
   return true;

llvm/lib/Analysis/LoopNestAnalysis.cpp

const BasicBlock &LoopNest::skipEmptyBlockUntil(const BasicBlock *From,
                                                 bool CheckUniquePred) {
   assert(From && "Expecting valid From");
   assert(End && "Expecting valid End");
 
   if (From == End || !From->getUniqueSuccessor())
     return *From;
 
   auto IsEmpty = [](const BasicBlock *BB) {
-    return (BB->getInstList().size() == 1);
+    return (BB->size() == 1);
   };
 
   // Visited is used to avoid running into an infinite loop.
   SmallPtrSet<const BasicBlock *, 4> Visited;
   const BasicBlock *BB = From->getUniqueSuccessor();
   const BasicBlock *PredBB = From;
   while (BB && BB != End && IsEmpty(BB) && !Visited.count(BB) &&
          (!CheckUniquePred || BB->getUniquePredecessor())) {
if (&SingleSucc != InnerLoopPreHeader) {
       // The successors of the inner loop guard should be the inner loop
       // preheader or the outer loop latch possibly through empty blocks.
       for (const BasicBlock *Succ : BI->successors()) {
         const BasicBlock *PotentialInnerPreHeader = Succ;
         const BasicBlock *PotentialOuterLatch = Succ;
 
         // Ensure the inner loop guard successor is empty before skipping
         // blocks.
-        if (Succ->getInstList().size() == 1) {
+        if (Succ->size() == 1) {
           PotentialInnerPreHeader =
               &LoopNest::skipEmptyBlockUntil(Succ, InnerLoopPreHeader);
           PotentialOuterLatch =
               &LoopNest::skipEmptyBlockUntil(Succ, OuterLoopLatch);
         }
 
         if (PotentialInnerPreHeader == InnerLoopPreHeader)
           continue;

llvm/lib/Transforms/Utils/BasicBlockUtils.cpp

while (!BB->empty()) {
       // value with.  Note that since this block is unreachable, and all values
       // contained within it must dominate their uses, that all uses will
       // eventually be removed (they are themselves dead).
       if (!I.use_empty())
         I.replaceAllUsesWith(PoisonValue::get(I.getType()));
       BB->getInstList().pop_back();
     }
     new UnreachableInst(BB->getContext(), BB);
-    assert(BB->getInstList().size() == 1 &&
+    assert(BB->size() == 1 &&
            isa<UnreachableInst>(BB->getTerminator()) &&
            "The successor list of BB isn't empty before "
            "applying corresponding DTU updates.");
   }
 }
 
 void llvm::DeleteDeadBlock(BasicBlock *BB, DomTreeUpdater *DTU,
                            bool KeepOneInputPHIs) {