[NFC] Cleanup: Remove uses of BasicBlock::getInstList().

[vporpo]

Summary

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

[aeubanks]

I think this is obvious enough to go in without review given all the other cleanup you've done so far, but still lgtm

llvm/lib/Target/BPF/BPFAbstractMemberAccess.cpp

Instruction *BPFCoreSharedInfo::insertPassThrough(Module *M, BasicBlock *BB,
                                                   Instruction *Input,
                                                   Instruction *Before) {
   Function *Fn = Intrinsic::getDeclaration(
       M, Intrinsic::bpf_passthrough, {Input->getType(), Input->getType()});
   Constant *SeqNumVal = ConstantInt::get(Type::getInt32Ty(BB->getContext()),
                                          BPFCoreSharedInfo::SeqNum++);
 
   auto *NewInst = CallInst::Create(Fn, {SeqNumVal, Input});
-  BB->getInstList().insert(Before->getIterator(), NewInst);
+  NewInst->insertBefore(Before);
   return NewInst;
 }
 } // namespace llvm
 
 using namespace llvm;
 
 namespace {
 class BPFAbstractMemberAccess final {
bool BPFAbstractMemberAccess::transformGEPChain(CallInst *Call,
   //   using %9 instead of %4
   // The original Call inst is removed.
 
   // Load the global variable.
   auto *LDInst = new LoadInst(Type::getInt64Ty(BB->getContext()), GV, "", Call);
 
   // Generate a BitCast
   auto *BCInst = new BitCastInst(Base, Type::getInt8PtrTy(BB->getContext()));
-  BB->getInstList().insert(Call->getIterator(), BCInst);
+  BCInst->insertBefore(Call);
 
   // Generate a GetElementPtr
   auto *GEP = GetElementPtrInst::Create(Type::getInt8Ty(BB->getContext()),
                                         BCInst, LDInst);
-  BB->getInstList().insert(Call->getIterator(), GEP);
+  GEP->insertBefore(Call);
 
   // Generate a BitCast
   auto *BCInst2 = new BitCastInst(GEP, Call->getType());
-  BB->getInstList().insert(Call->getIterator(), BCInst2);
+  BCInst2->insertBefore(Call);
 
   // For the following code,
   //    Block0:
   //      ...
   //      if (...) goto Block1 else ...
   //    Block1:
   //      %6 = load llvm.sk_buff:0:50$0:0:0:2:0
   //      %7 = bitcast %struct.sk_buff* %2 to i8*

llvm/lib/Target/BPF/BPFAdjustOpt.cpp

for (auto &BB : F)
           continue;
         }
 
         Constant *Opcode =
             ConstantInt::get(Type::getInt32Ty(BB.getContext()), Op);
         Function *Fn = Intrinsic::getDeclaration(
             M, Intrinsic::bpf_compare, {Op0->getType(), ConstOp1->getType()});
         auto *NewInst = CallInst::Create(Fn, {Opcode, Op0, ConstOp1});
-        BB.getInstList().insert(I.getIterator(), NewInst);
+        NewInst->insertBefore(&I);
         Icmp->replaceAllUsesWith(NewInst);
         Changed = true;
         ToBeDeleted = Icmp;
       }
 
   return Changed;
 }
 

llvm/lib/Target/BPF/BPFCheckAndAdjustIR.cpp

for (auto &BB : F)
         Value *Arg0 = Call->getArgOperand(0);
         Value *Arg1 = Call->getArgOperand(1);
         Value *Arg2 = Call->getArgOperand(2);
 
         auto OpVal = cast<ConstantInt>(Arg0)->getValue().getZExtValue();
         CmpInst::Predicate Opcode = (CmpInst::Predicate)OpVal;
 
         auto *ICmp = new ICmpInst(Opcode, Arg1, Arg2);
-        BB.getInstList().insert(Call->getIterator(), ICmp);
+        ICmp->insertBefore(Call);
 
         Call->replaceAllUsesWith(ICmp);
         ToBeDeleted = Call;
       }
   return Changed;
 }
 
 bool BPFCheckAndAdjustIR::adjustIR(Module &M) {

llvm/lib/Target/Hexagon/HexagonLoopIdiomRecognition.cpp

void Simplifier::Context::link(Instruction *I, BasicBlock *B,
   if (I->getParent())
     return;
 
   for (Value *Op : I->operands()) {
     if (Instruction *OpI = dyn_cast<Instruction>(Op))
       link(OpI, B, At);
   }
 
-  B->getInstList().insert(At, I);
+  I->insertAt(B, At);
 }
 
 Value *Simplifier::Context::materialize(BasicBlock *B,
       BasicBlock::iterator At) {
   if (Instruction *RootI = dyn_cast<Instruction>(Root))
     link(RootI, B, At);
   return Root;
 }

llvm/lib/Target/WebAssembly/WebAssemblyFixFunctionBitcasts.cpp

for (; AI != AE && PI != PE; ++AI, ++PI) {
     Type *ParamType = *PI;
 
     if (ArgType == ParamType) {
       Args.push_back(&*AI);
     } else {
       if (CastInst::isBitOrNoopPointerCastable(ArgType, ParamType, DL)) {
         Instruction *PtrCast =
             CastInst::CreateBitOrPointerCast(AI, ParamType, "cast");
-        BB->getInstList().push_back(PtrCast);
+        PtrCast->insertAt(BB, BB->end());
         Args.push_back(PtrCast);
       } else if (ArgType->isStructTy() || ParamType->isStructTy()) {
         LLVM_DEBUG(dbgs() << "createWrapper: struct param type in bitcast: "
                           << F->getName() << "\n");
         WrapperNeeded = false;
       } else {
         LLVM_DEBUG(dbgs() << "createWrapper: arg type mismatch calling: "
                           << F->getName() << "\n");
if (RtnType->isVoidTy()) {
       LLVM_DEBUG(dbgs() << "Creating dummy return: " << *RtnType << "\n");
       ReturnInst::Create(M->getContext(), UndefValue::get(RtnType), BB);
     } else if (RtnType == ExpectedRtnType) {
       ReturnInst::Create(M->getContext(), Call, BB);
     } else if (CastInst::isBitOrNoopPointerCastable(ExpectedRtnType, RtnType,
                                                     DL)) {
       Instruction *Cast =
           CastInst::CreateBitOrPointerCast(Call, RtnType, "cast");
-      BB->getInstList().push_back(Cast);
+      Cast->insertAt(BB, BB->end());
       ReturnInst::Create(M->getContext(), Cast, BB);
     } else if (RtnType->isStructTy() || ExpectedRtnType->isStructTy()) {
       LLVM_DEBUG(dbgs() << "createWrapper: struct return type in bitcast: "
                         << F->getName() << "\n");
       WrapperNeeded = false;
     } else {
       LLVM_DEBUG(dbgs() << "createWrapper: return type mismatch calling: "
                         << F->getName() << "\n");

llvm/lib/Target/WebAssembly/WebAssemblyLowerEmscriptenEHSjLj.cpp

for (Instruction &I : *BB) {
       wrapTestSetjmp(BB, CI->getDebugLoc(), Threw, SetjmpTable, SetjmpTableSize,
                      Label, LongjmpResult, CallEmLongjmpBB,
                      CallEmLongjmpBBThrewPHI, CallEmLongjmpBBThrewValuePHI,
                      EndBB);
       assert(Label && LongjmpResult && EndBB);
 
       // Create switch instruction
       IRB.SetInsertPoint(EndBB);
-      IRB.SetCurrentDebugLocation(EndBB->getInstList().back().getDebugLoc());
+      IRB.SetCurrentDebugLocation(EndBB->back().getDebugLoc());
       SwitchInst *SI = IRB.CreateSwitch(Label, Tail, SetjmpRetPHIs.size());
       // -1 means no longjmp happened, continue normally (will hit the default
       // switch case). 0 means a longjmp that is not ours to handle, needs a
       // rethrow. Otherwise the index is the same as the index in P+1 (to avoid
       // 0).
       for (unsigned I = 0; I < SetjmpRetPHIs.size(); I++) {
         SI->addCase(IRB.getInt32(I + 1), SetjmpRetPHIs[I]->getParent());
         SetjmpRetPHIs[I]->addIncoming(LongjmpResult, EndBB);