[llvm] Construct SmallVector with iterator ranges (NFC) (#136460)

Author: kazutakahirata

llvm/lib/Analysis/CGSCCPassManager.cpp

@@ -515,9 +515,7 @@ PreservedAnalyses CGSCCToFunctionPassAdaptor::run(LazyCallGraph::SCC &C,
   FunctionAnalysisManager &FAM =
       AM.getResult<FunctionAnalysisManagerCGSCCProxy>(C, CG).getManager();
 
-  SmallVector<LazyCallGraph::Node *, 4> Nodes;
-  for (LazyCallGraph::Node &N : C)
-    Nodes.push_back(&N);
+  SmallVector<LazyCallGraph::Node *, 4> Nodes(llvm::make_pointer_range(C));
 
   // The SCC may get split while we are optimizing functions due to deleting
   // edges. If this happens, the current SCC can shift, so keep track of

llvm/lib/CodeGen/AsmPrinter/DwarfStringPool.cpp

@@ -81,11 +81,8 @@ void DwarfStringPool::emit(AsmPrinter &Asm, MCSection *StrSection,
   Asm.OutStreamer->switchSection(StrSection);
 
   // Get all of the string pool entries and sort them by their offset.
-  SmallVector<const StringMapEntry<EntryTy> *, 64> Entries;
-  Entries.reserve(Pool.size());
-
-  for (const auto &E : Pool)
-    Entries.push_back(&E);
+  SmallVector<const StringMapEntry<EntryTy> *, 64> Entries(
+      llvm::make_pointer_range(Pool));
 
   llvm::sort(Entries, [](const StringMapEntry<EntryTy> *A,
                          const StringMapEntry<EntryTy> *B) {

llvm/lib/ExecutionEngine/JITLink/EHFrameSupport.cpp

@@ -643,9 +643,7 @@ EHFrameCFIBlockInspector EHFrameCFIBlockInspector::FromEdgeScan(Block &B) {
     return EHFrameCFIBlockInspector(nullptr);
   if (B.edges_size() == 1)
     return EHFrameCFIBlockInspector(&*B.edges().begin());
-  SmallVector<Edge *, 3> Es;
-  for (auto &E : B.edges())
-    Es.push_back(&E);
+  SmallVector<Edge *, 3> Es(llvm::make_pointer_range(B.edges()));
   assert(Es.size() >= 2 && Es.size() <= 3 && "Unexpected number of edges");
   llvm::sort(Es, [](const Edge *LHS, const Edge *RHS) {
     return LHS->getOffset() < RHS->getOffset();

llvm/lib/FuzzMutate/IRMutator.cpp

@@ -122,9 +122,8 @@ getInsertionRange(BasicBlock &BB) {
 }
 
 void InjectorIRStrategy::mutate(BasicBlock &BB, RandomIRBuilder &IB) {
-  SmallVector<Instruction *, 32> Insts;
-  for (Instruction &I : getInsertionRange(BB))
-    Insts.push_back(&I);
+  SmallVector<Instruction *, 32> Insts(
+      llvm::make_pointer_range(getInsertionRange(BB)));
   if (Insts.size() < 1)
     return;
 
@@ -395,9 +394,8 @@ void InsertFunctionStrategy::mutate(BasicBlock &BB, RandomIRBuilder &IB) {
     return isRetVoid ? nullptr : Call;
   };
 
-  SmallVector<Instruction *, 32> Insts;
-  for (Instruction &I : getInsertionRange(BB))
-    Insts.push_back(&I);
+  SmallVector<Instruction *, 32> Insts(
+      llvm::make_pointer_range(getInsertionRange(BB)));
   if (Insts.size() < 1)
     return;
 
@@ -421,9 +419,8 @@ void InsertFunctionStrategy::mutate(BasicBlock &BB, RandomIRBuilder &IB) {
 }
 
 void InsertCFGStrategy::mutate(BasicBlock &BB, RandomIRBuilder &IB) {
-  SmallVector<Instruction *, 32> Insts;
-  for (Instruction &I : getInsertionRange(BB))
-    Insts.push_back(&I);
+  SmallVector<Instruction *, 32> Insts(
+      llvm::make_pointer_range(getInsertionRange(BB)));
   if (Insts.size() < 1)
     return;
 
@@ -561,9 +558,8 @@ void InsertPHIStrategy::mutate(BasicBlock &BB, RandomIRBuilder &IB) {
     }
     PHI->addIncoming(Src, Pred);
   }
-  SmallVector<Instruction *, 32> InstsAfter;
-  for (Instruction &I : getInsertionRange(BB))
-    InstsAfter.push_back(&I);
+  SmallVector<Instruction *, 32> InstsAfter(
+      llvm::make_pointer_range(getInsertionRange(BB)));
   IB.connectToSink(BB, InstsAfter, PHI);
 }
 
@@ -573,9 +569,8 @@ void SinkInstructionStrategy::mutate(Function &F, RandomIRBuilder &IB) {
   }
 }
 void SinkInstructionStrategy::mutate(BasicBlock &BB, RandomIRBuilder &IB) {
-  SmallVector<Instruction *, 32> Insts;
-  for (Instruction &I : getInsertionRange(BB))
-    Insts.push_back(&I);
+  SmallVector<Instruction *, 32> Insts(
+      llvm::make_pointer_range(getInsertionRange(BB)));
   if (Insts.size() < 1)
     return;
   // Choose an Instruction to mutate.

llvm/lib/FuzzMutate/RandomIRBuilder.cpp

@@ -84,10 +84,8 @@ RandomIRBuilder::findOrCreateGlobalVariable(Module *M, ArrayRef<Value *> Srcs,
     return Pred.matches(Srcs, PoisonValue::get(GV->getValueType()));
   };
   bool DidCreate = false;
-  SmallVector<GlobalVariable *, 4> GlobalVars;
-  for (GlobalVariable &GV : M->globals()) {
-    GlobalVars.push_back(&GV);
-  }
+  SmallVector<GlobalVariable *, 4> GlobalVars(
+      llvm::make_pointer_range(M->globals()));
   auto RS = makeSampler(Rand, make_filter_range(GlobalVars, MatchesPred));
   RS.sample(nullptr, 1);
   GlobalVariable *GV = RS.getSelection();
@@ -146,10 +144,8 @@ Value *RandomIRBuilder::findOrCreateSource(BasicBlock &BB,
       auto Dominators = getDominators(&BB);
       std::shuffle(Dominators.begin(), Dominators.end(), Rand);
       for (BasicBlock *Dom : Dominators) {
-        SmallVector<Instruction *, 16> Instructions;
-        for (Instruction &I : *Dom) {
-          Instructions.push_back(&I);
-        }
+        SmallVector<Instruction *, 16> Instructions(
+            llvm::make_pointer_range(*Dom));
         auto RS =
             makeSampler(Rand, make_filter_range(Instructions, MatchesPred));
         // Also consider choosing no source, meaning we want a new one.

llvm/lib/Target/AArch64/AArch64Arm64ECCallLowering.cpp

@@ -656,9 +656,7 @@ Function *AArch64Arm64ECCallLowering::buildGuestExitThunk(Function *F) {
   GuardCheck->setCallingConv(CallingConv::CFGuard_Check);
 
   Value *GuardRetVal = B.CreateBitCast(GuardCheck, PtrTy);
-  SmallVector<Value *> Args;
-  for (Argument &Arg : GuestExit->args())
-    Args.push_back(&Arg);
+  SmallVector<Value *> Args(llvm::make_pointer_range(GuestExit->args()));
   CallInst *Call = B.CreateCall(Arm64Ty, GuardRetVal, Args);
   Call->setTailCallKind(llvm::CallInst::TCK_MustTail);
 
@@ -715,9 +713,7 @@ AArch64Arm64ECCallLowering::buildPatchableThunk(GlobalAlias *UnmangledAlias,
   Dispatch->setCallingConv(CallingConv::CFGuard_Check);
 
   Value *DispatchRetVal = B.CreateBitCast(Dispatch, PtrTy);
-  SmallVector<Value *> Args;
-  for (Argument &Arg : GuestExit->args())
-    Args.push_back(&Arg);
+  SmallVector<Value *> Args(llvm::make_pointer_range(GuestExit->args()));
   CallInst *Call = B.CreateCall(Arm64Ty, DispatchRetVal, Args);
   Call->setTailCallKind(llvm::CallInst::TCK_MustTail);
 

llvm/lib/Target/ARM/A15SDOptimizer.cpp

@@ -617,10 +617,9 @@ bool A15SDOptimizer::runOnInstruction(MachineInstr *MI) {
         continue;
 
       // Collect all the uses of this MI's DPR def for updating later.
-      SmallVector<MachineOperand*, 8> Uses;
       Register DPRDefReg = MI->getOperand(0).getReg();
-      for (MachineOperand &MO : MRI->use_operands(DPRDefReg))
-        Uses.push_back(&MO);
+      SmallVector<MachineOperand *, 8> Uses(
+          llvm::make_pointer_range(MRI->use_operands(DPRDefReg)));
 
       // We can optimize this.
       unsigned NewReg = optimizeSDPattern(MI);

llvm/lib/Target/NVPTX/NVPTXLowerArgs.cpp

@@ -554,9 +554,7 @@ static void handleByValParam(const NVPTXTargetMachine &TM, Argument *Arg) {
   if (ArgUseIsReadOnly && AUC.Conditionals.empty()) {
     // Convert all loads and intermediate operations to use parameter AS and
     // skip creation of a local copy of the argument.
-    SmallVector<Use *, 16> UsesToUpdate;
-    for (Use &U : Arg->uses())
-      UsesToUpdate.push_back(&U);
+    SmallVector<Use *, 16> UsesToUpdate(llvm::make_pointer_range(Arg->uses()));
 
     Value *ArgInParamAS = new AddrSpaceCastInst(
         Arg, PointerType::get(StructType->getContext(), ADDRESS_SPACE_PARAM),

llvm/lib/Target/SPIRV/SPIRVEmitIntrinsics.cpp

@@ -2399,9 +2399,8 @@ bool SPIRVEmitIntrinsics::runOnFunction(Function &Func) {
 
   preprocessUndefs(B);
   preprocessCompositeConstants(B);
-  SmallVector<Instruction *> Worklist;
-  for (auto &I : instructions(Func))
-    Worklist.push_back(&I);
+  SmallVector<Instruction *> Worklist(
+      llvm::make_pointer_range(instructions(Func)));
 
   applyDemangledPtrArgTypes(B);
 

llvm/lib/Target/SPIRV/SPIRVPreLegalizerCombiner.cpp

@@ -99,9 +99,8 @@ void applySPIRVDistance(MachineInstr &MI, MachineRegisterInfo &MRI,
   SPIRVGlobalRegistry *GR =
       MI.getMF()->getSubtarget<SPIRVSubtarget>().getSPIRVGlobalRegistry();
   auto RemoveAllUses = [&](Register Reg) {
-    SmallVector<MachineInstr *, 4> UsesToErase;
-    for (auto &UseMI : MRI.use_instructions(Reg))
-      UsesToErase.push_back(&UseMI);
+    SmallVector<MachineInstr *, 4> UsesToErase(
+        llvm::make_pointer_range(MRI.use_instructions(Reg)));
 
     // calling eraseFromParent to early invalidates the iterator.
     for (auto *MIToErase : UsesToErase) {

llvm/lib/Target/X86/X86CmovConversion.cpp

@@ -190,9 +190,7 @@ bool X86CmovConverterPass::runOnMachineFunction(MachineFunction &MF) {
   // execution behind a branch is better suited to handle on modern x86 chips.
   if (ForceMemOperand || ForceAll) {
     CmovGroups AllCmovGroups;
-    SmallVector<MachineBasicBlock *, 4> Blocks;
-    for (auto &MBB : MF)
-      Blocks.push_back(&MBB);
+    SmallVector<MachineBasicBlock *, 4> Blocks(llvm::make_pointer_range(MF));
     if (collectCmovCandidates(Blocks, AllCmovGroups, /*IncludeLoads*/ true)) {
       for (auto &Group : AllCmovGroups) {
         // Skip any group that doesn't do at least one memory operand cmov.

llvm/lib/Transforms/Scalar/IndVarSimplify.cpp

@@ -406,9 +406,7 @@ bool IndVarSimplify::rewriteNonIntegerIVs(Loop *L) {
   // the SCEV routines.
   BasicBlock *Header = L->getHeader();
 
-  SmallVector<WeakTrackingVH, 8> PHIs;
-  for (PHINode &PN : Header->phis())
-    PHIs.push_back(&PN);
+  SmallVector<WeakTrackingVH, 8> PHIs(llvm::make_pointer_range(Header->phis()));
 
   bool Changed = false;
   for (WeakTrackingVH &PHI : PHIs)

llvm/unittests/ExecutionEngine/MCJIT/MCJITTestBase.h

@@ -63,10 +63,7 @@ class TrivialModuleBuilder {
   Function *insertSimpleCallFunction(Module *M, Function *Callee) {
     Function *Result = startFunction(M, Callee->getFunctionType(), "caller");
 
-    SmallVector<Value*, 1> CallArgs;
-
-    for (Argument &A : Result->args())
-      CallArgs.push_back(&A);
+    SmallVector<Value *, 1> CallArgs(llvm::make_pointer_range(Result->args()));
 
     Value *ReturnCode = Builder.CreateCall(Callee, CallArgs);
     Builder.CreateRet(ReturnCode);

llvm/unittests/FuzzMutate/RandomIRBuilderTest.cpp

@@ -597,10 +597,7 @@ TEST(RandomIRBuilderTest, SrcAndSinkWOrphanBlock) {
     std::unique_ptr<Module> M = parseAssembly(Source, Ctx);
     Function &F = *M->getFunction("test");
     for (BasicBlock &BB : F) {
-      SmallVector<Instruction *, 4> Insts;
-      for (Instruction &I : BB) {
-        Insts.push_back(&I);
-      }
+      SmallVector<Instruction *, 4> Insts(llvm::make_pointer_range(BB));
       for (int j = 0; j < 10; j++) {
         IB.findOrCreateSource(BB, Insts);
       }

llvm/unittests/IR/BasicBlockDbgInfoTest.cpp

@@ -224,9 +224,8 @@ TEST(BasicBlockDbgInfoTest, MarkerOperations) {
   EXPECT_EQ(BB.size(), 1u);
   EXPECT_EQ(Marker2->StoredDbgRecords.size(), 2u);
   // They should also be in the correct order.
-  SmallVector<DbgRecord *, 2> DVRs;
-  for (DbgRecord &DVR : Marker2->getDbgRecordRange())
-    DVRs.push_back(&DVR);
+  SmallVector<DbgRecord *, 2> DVRs(
+      llvm::make_pointer_range(Marker2->getDbgRecordRange()));
   EXPECT_EQ(DVRs[0], DVR1);
   EXPECT_EQ(DVRs[1], DVR2);
 
@@ -577,9 +576,8 @@ class DbgSpliceTest : public ::testing::Test {
 
   bool CheckDVROrder(Instruction *I,
                      SmallVector<DbgVariableRecord *> CheckVals) {
-    SmallVector<DbgRecord *> Vals;
-    for (DbgRecord &D : I->getDbgRecordRange())
-      Vals.push_back(&D);
+    SmallVector<DbgRecord *> Vals(
+        llvm::make_pointer_range(I->getDbgRecordRange()));
 
     EXPECT_EQ(Vals.size(), CheckVals.size());
     if (Vals.size() != CheckVals.size())

llvm/unittests/IR/FunctionTest.cpp

@@ -83,9 +83,7 @@ TEST(FunctionTest, stealArgumentListFrom) {
 
   // Save arguments from F1 for later assertions.  F1 won't have lazy arguments
   // anymore.
-  SmallVector<Argument *, 4> Args;
-  for (Argument &A : F1->args())
-    Args.push_back(&A);
+  SmallVector<Argument *, 4> Args(llvm::make_pointer_range(F1->args()));
   EXPECT_EQ(2u, Args.size());
   EXPECT_FALSE(F1->hasLazyArguments());
 

llvm/unittests/Transforms/Vectorize/SandboxVectorizer/IntervalTest.cpp

@@ -157,9 +157,7 @@ define void @foo(i8 %v0) {
 // of references.
 template <typename RangeT>
 static SmallVector<sandboxir::Instruction *> getPtrVec(RangeT Range) {
-  SmallVector<sandboxir::Instruction *> PtrVec;
-  for (sandboxir::Instruction &I : Range)
-    PtrVec.push_back(&I);
+  SmallVector<sandboxir::Instruction *> PtrVec(llvm::make_pointer_range(Range));
   return PtrVec;
 }