[WIP] Drop SmallVector constructor taking iterator_range in favor of llvm::to_vector/llvm::to_vector_of

[yurai007]

Summary

Dropping SmallVector(const iterator_range<RangeTy>&) requires lot of adjustment to make change well-formed since iterator_range constructor is used in hundred of files.
That's because iterator_range is returned by commonly used functions like predecessors/successors, args, operands and other one.
I'm pushing to Phabricator just small part of change as WIP since I'm not sure if this is right direction you really want.

Depends on: https://reviews.llvm.org/D129781 and address comment: https://reviews.llvm.org/D129781#3655571

[dexonsmith]

Since the change has such a broad impact, this might deserve a discussion on a discourse topic. It’d be less work and introduce way less churn to add an ArrayRef overload to SmallVector’s list of constructors, and maybe that would accomplish enough?

If this change does go ahead (I have a weak opinion that it should but would be fine with adding ArrayRef instead), then it should be broken up somehow into more incremental patches, converting small groups of uses in chunks small enough to be reviewed/reverted, and with the removal of the constructor in a final patch on its own (which out of tree users could easily temporarily revert to give them time to convert their out of tree code).

Also, I have a couple of inline comments, pointing out two hazards where as written the SmallVector size gets redundantly used. I worry this is one more thing to update. It seems better to skip the type name, or for type aliases, to add a separate call to append.

llvm/include/llvm/IR/PredIteratorCache.h

47

Would it be better to use auto in places like this?

llvm/include/llvm/Support/CFGDiff.h

139

When there’s a type alias like this then it’s hard to know if the small size is in sync. Maybe instead:

VectRet Res;
Res.append(…);

[yurai007]

In D129988#3659583, @dexonsmith wrote:

Since the change has such a broad impact, this might deserve a discussion on a discourse topic. It’d be less work and introduce way less churn to add an ArrayRef overload to SmallVector’s list of constructors, and maybe that would accomplish enough?

I agree that adding ArrayRef overload would be much easier and less intrusive to code base. Maybe we should start with that.

If this change does go ahead (I have a weak opinion that it should but would be fine with adding ArrayRef instead), then it should be broken up somehow into more incremental patches, converting small groups of uses in chunks small enough to be reviewed/reverted, and with the removal of the constructor in a final patch on its own (which out of tree users could easily temporarily revert to give them time to convert their out of tree code).

Well, I don't have strong opinion either. However the more I think about idea of dropping iterator_range constructor the less I like it.
Both SmallVector and Iterator_range are heavily used in LLVM sources and removing constructor has big impact on whole tree (as this change proves).
Although to_vector/to_vector_of are great utilities and using them in many cases simplify (or at least reduce verbosity) still there are cases when using plain constructor seem to be better idea, like for mentioned type alias case:

VectRet Res = VectRet(detail::reverse_if<!InverseEdge>(R));

In general it would be great to give user full freedom to decide which to_vector* or constructor approach is right way for particular usage. Using constructor still looks for me like most idiomatic way for object creation in C++.
One of motivation for dropping SmallVector(const iterator_range<RangeTy>&) was referring to std::vector as one which doesn't have similar range constructor.
However in contrast to LLVM iterator_range, C++ Ranges is pretty new C++20 feature that starts gaining popularity.
Interestingly there is proposal for adding range constructor to many stdlib containers: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2022/p1206r7.pdf already approved for inclusion to C++23.
Also I checked last git history and I couldn't find any similar "iterator_range removal" patches which makes me wonder... that after all maybe what we need is just adding ArrayRef constructor :)

[yurai007]

Superseded by https://reviews.llvm.org/D130268

llvm/include/llvm/ADT/SmallVector.h

 #include <limits>
 #include <memory>
 #include <new>
 #include <type_traits>
 #include <utility>
 
 namespace llvm {
 
-template <typename IteratorT> class iterator_range;
-
 /// This is all the stuff common to all SmallVectors.
 ///
 /// The template parameter specifies the type which should be used to hold the
 /// Size and Capacity of the SmallVector, so it can be adjusted.
 /// Using 32 bit size is desirable to shrink the size of the SmallVector.
 /// Using 64 bit size is desirable for cases like SmallVector<char>, where a
 /// 32 bit size would limit the vector to ~4GB. SmallVectors are used for
 /// buffering bitcode output - which can exceed 4GB.
public:
   template <typename ItTy,
             typename = std::enable_if_t<std::is_convertible<
                 typename std::iterator_traits<ItTy>::iterator_category,
                 std::input_iterator_tag>::value>>
   SmallVector(ItTy S, ItTy E) : SmallVectorImpl<T>(N) {
     this->append(S, E);
   }
 
-  template <typename RangeTy>
-  explicit SmallVector(const iterator_range<RangeTy> &R)
-      : SmallVectorImpl<T>(N) {
-    this->append(R.begin(), R.end());
-  }
-
   SmallVector(std::initializer_list<T> IL) : SmallVectorImpl<T>(N) {
     this->assign(IL);
   }
 
   SmallVector(const SmallVector &RHS) : SmallVectorImpl<T>(N) {
     if (!RHS.empty())
       SmallVectorImpl<T>::operator=(RHS);
   }

llvm/include/llvm/Analysis/TargetTransformInfo.h

public:
   /// The returned cost is defined in terms of \c TargetCostConstants, see its
   /// comments for a detailed explanation of the cost values.
   InstructionCost getUserCost(const User *U, ArrayRef<const Value *> Operands,
                               TargetCostKind CostKind) const;
 
   /// This is a helper function which calls the two-argument getUserCost
   /// with \p Operands which are the current operands U has.
   InstructionCost getUserCost(const User *U, TargetCostKind CostKind) const {
-    SmallVector<const Value *, 4> Operands(U->operand_values());
-    return getUserCost(U, Operands, CostKind);
+    return getUserCost(U, to_vector<4>(U->operand_values()), CostKind);
   }
 
   /// If a branch or a select condition is skewed in one direction by more than
   /// this factor, it is very likely to be predicted correctly.
   BranchProbability getPredictableBranchThreshold() const;
 
   /// Return true if branch divergence exists.
   ///

llvm/include/llvm/Analysis/TargetTransformInfoImpl.h

InstructionCost getUserCost(const User *U, ArrayRef<const Value *> Operands,
     case Instruction::And:
     case Instruction::Or:
     case Instruction::Xor:
     case Instruction::FNeg: {
       TTI::OperandValueProperties Op1VP = TTI::OP_None;
       TTI::OperandValueProperties Op2VP = TTI::OP_None;
       TTI::OperandValueKind Op1VK =
         TTI::getOperandInfo(U->getOperand(0), Op1VP);
-      TTI::OperandValueKind Op2VK = Opcode != Instruction::FNeg ?
-        TTI::getOperandInfo(U->getOperand(1), Op2VP) : TTI::OK_AnyValue;
-      SmallVector<const Value *, 2> Operands(U->operand_values());
-      return TargetTTI->getArithmeticInstrCost(Opcode, Ty, CostKind,
-                                               Op1VK, Op2VK,
-                                               Op1VP, Op2VP, Operands, I);
+      TTI::OperandValueKind Op2VK =
+          Opcode != Instruction::FNeg
+              ? TTI::getOperandInfo(U->getOperand(1), Op2VP)
+              : TTI::OK_AnyValue;
+      return TargetTTI->getArithmeticInstrCost(
+          Opcode, Ty, CostKind, Op1VK, Op2VK, Op1VP, Op2VP,
+          to_vector<2>(U->operand_values()), I);
     }
     case Instruction::IntToPtr:
     case Instruction::PtrToInt:
     case Instruction::SIToFP:
     case Instruction::UIToFP:
     case Instruction::FPToUI:
     case Instruction::FPToSI:
     case Instruction::Trunc:
case Instruction::ExtractElement: {
       return TargetTTI->getVectorInstrCost(Opcode, DstTy, Idx);
     }
     }
     // By default, just classify everything as 'basic'.
     return TTI::TCC_Basic;
   }
 
   InstructionCost getInstructionLatency(const Instruction *I) {
-    SmallVector<const Value *, 4> Operands(I->operand_values());
-    if (getUserCost(I, Operands, TTI::TCK_Latency) == TTI::TCC_Free)
+    if (getUserCost(I, to_vector<4>(I->operand_values()), TTI::TCK_Latency) ==
+        TTI::TCC_Free)
       return 0;
 
     if (isa<LoadInst>(I))
       return 4;
 
     Type *DstTy = I->getType();
 
     // Usually an intrinsic is a simple instruction.

llvm/include/llvm/IR/DebugInfoMetadata.h

class GenericDINode : public DINode {
   }
 
   static GenericDINode *getImpl(LLVMContext &Context, unsigned Tag,
                                 MDString *Header, ArrayRef<Metadata *> DwarfOps,
                                 StorageType Storage, bool ShouldCreate = true);
 
   TempGenericDINode cloneImpl() const {
     return getTemporary(getContext(), getTag(), getHeader(),
-                        SmallVector<Metadata *, 4>(dwarf_operands()));
+                        to_vector_of<Metadata *, 4>(dwarf_operands()));
   }
 
 public:
   unsigned getHash() const { return SubclassData32; }
 
   DEFINE_MDNODE_GET(GenericDINode,
                     (unsigned Tag, StringRef Header,
                      ArrayRef<Metadata *> DwarfOps),

llvm/include/llvm/IR/PredIteratorCache.h

private:
   ///      use(*PI);
   /// instead of:
   /// for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI != E; ++PI)
   BasicBlock **GetPreds(BasicBlock *BB) {
     BasicBlock **&Entry = BlockToPredsMap[BB];
     if (Entry)
       return Entry;
 
-    SmallVector<BasicBlock *, 32> PredCache(predecessors(BB));
+    SmallVector<BasicBlock *, 32> PredCache = to_vector<32>(predecessors(BB));
     PredCache.push_back(nullptr); // null terminator.
 
     BlockToPredCountMap[BB] = PredCache.size() - 1;
 
     Entry = Memory.Allocate<BasicBlock *>(PredCache.size());
     std::copy(PredCache.begin(), PredCache.end(), Entry);
     return Entry;
   }

llvm/include/llvm/Support/CFGDiff.h

cfg::Update<NodePtr> popUpdateForIncrementalUpdates() {
     return U;
   }
 
   using VectRet = SmallVector<NodePtr, 8>;
   template <bool InverseEdge> VectRet getChildren(NodePtr N) const {
     using DirectedNodeT =
         std::conditional_t<InverseEdge, Inverse<NodePtr>, NodePtr>;
     auto R = children<DirectedNodeT>(N);
-    VectRet Res = VectRet(detail::reverse_if<!InverseEdge>(R));
+    VectRet Res = to_vector<8>(detail::reverse_if<!InverseEdge>(R));
 
     // Remove nullptr children for clang.
     llvm::erase_value(Res, nullptr);
 
     auto &Children = (InverseEdge != InverseGraph) ? Pred : Succ;
     auto It = Children.find(N);
     if (It == Children.end())
       return Res;

llvm/include/llvm/Support/GenericDomTree.h

protected:
   void Split(typename GraphTraits<N>::NodeRef NewBB) {
     using GraphT = GraphTraits<N>;
     using NodeRef = typename GraphT::NodeRef;
     assert(std::distance(GraphT::child_begin(NewBB),
                          GraphT::child_end(NewBB)) == 1 &&
            "NewBB should have a single successor!");
     NodeRef NewBBSucc = *GraphT::child_begin(NewBB);
 
-    SmallVector<NodeRef, 4> PredBlocks(children<Inverse<N>>(NewBB));
+    auto PredBlocks = to_vector_of<NodeRef, 4>(children<Inverse<N>>(NewBB));
 
     assert(!PredBlocks.empty() && "No predblocks?");
 
     bool NewBBDominatesNewBBSucc = true;
     for (auto Pred : children<Inverse<N>>(NewBBSucc)) {
       if (Pred != NewBB && !dominates(NewBBSucc, Pred) &&
           isReachableFromEntry(Pred)) {
         NewBBDominatesNewBBSucc = false;

llvm/include/llvm/Support/GenericDomTreeConstruction.h

static SmallVector<NodePtr, 8> getChildren(NodePtr N, BatchUpdatePtr BUI) {
     return getChildren<Inversed>(N);
   }
 
   template <bool Inversed>
   static SmallVector<NodePtr, 8> getChildren(NodePtr N) {
     using DirectedNodeT =
         std::conditional_t<Inversed, Inverse<NodePtr>, NodePtr>;
     auto R = children<DirectedNodeT>(N);
-    SmallVector<NodePtr, 8> Res(detail::reverse_if<!Inversed>(R));
+    auto Res = to_vector<8>(detail::reverse_if<!Inversed>(R));
 
     // Remove nullptr children for clang.
     llvm::erase_value(Res, nullptr);
     return Res;
   }
 
   NodePtr getIDom(NodePtr BB) const {
     auto InfoIt = NodeToInfo.find(BB);

llvm/lib/CodeGen/Analysis.cpp

if (CallEmpty) {
       Type *SlotType =
           ExtractValueInst::getIndexedType(RetSubTypes.back(), RetPath.back());
       CallVal = UndefValue::get(SlotType);
     }
 
     // The manipulations performed when we're looking through an insertvalue or
     // an extractvalue would happen at the front of the RetPath list, so since
     // we have to copy it anyway it's more efficient to create a reversed copy.
-    SmallVector<unsigned, 4> TmpRetPath(llvm::reverse(RetPath));
-    SmallVector<unsigned, 4> TmpCallPath(llvm::reverse(CallPath));
+    auto TmpRetPath = to_vector<4>(llvm::reverse(RetPath));
+    auto TmpCallPath = to_vector<4>(llvm::reverse(CallPath));
 
     // Finally, we can check whether the value produced by the tail call at this
     // index is compatible with the value we return.
     if (!slotOnlyDiscardsData(RetVal, CallVal, TmpRetPath, TmpCallPath,
                               AllowDifferingSizes, TLI,
                               F->getParent()->getDataLayout()))
       return false;
 

llvm/lib/CodeGen/AsmPrinter/PseudoProbePrinter.cpp

while (InlinedAt) {
     if (!CallerGuid)
       CallerGuid = Function::getGUID(Name);
     uint64_t CallerProbeId = PseudoProbeDwarfDiscriminator::extractProbeIndex(
         InlinedAt->getDiscriminator());
     ReversedInlineStack.emplace_back(CallerGuid, CallerProbeId);
     InlinedAt = InlinedAt->getInlinedAt();
   }
 
-  SmallVector<InlineSite, 8> InlineStack(llvm::reverse(ReversedInlineStack));
+  SmallVector<InlineSite, 8> InlineStack =
+      to_vector<8>(llvm::reverse(ReversedInlineStack));
   Asm->OutStreamer->emitPseudoProbe(Guid, Index, Type, Attr, InlineStack);
 }

llvm/lib/CodeGen/CodeGenPrepare.cpp

bool CodeGenPrepare::runOnFunction(Function &F) {
 
   if (!DisableBranchOpts) {
     MadeChange = false;
     // Use a set vector to get deterministic iteration order. The order the
     // blocks are removed may affect whether or not PHI nodes in successors
     // are removed.
     SmallSetVector<BasicBlock*, 8> WorkList;
     for (BasicBlock &BB : F) {
-      SmallVector<BasicBlock *, 2> Successors(successors(&BB));
+      auto Successors = to_vector<2>(successors(&BB));
       MadeChange |= ConstantFoldTerminator(&BB, true);
       if (!MadeChange) continue;
 
       for (BasicBlock *Succ : Successors)
         if (pred_empty(Succ))
           WorkList.insert(Succ);
     }
 
     // Delete the dead blocks and any of their dead successors.
     MadeChange |= !WorkList.empty();
     while (!WorkList.empty()) {
       BasicBlock *BB = WorkList.pop_back_val();
-      SmallVector<BasicBlock*, 2> Successors(successors(BB));
+      auto Successors = to_vector<2>(successors(BB));
 
       DeleteDeadBlock(BB);
 
       for (BasicBlock *Succ : Successors)
         if (pred_empty(Succ))
           WorkList.insert(Succ);
     }
 
if (const auto *GEP = dyn_cast<GetElementPtrInst>(Ptr)) {
     if (!GEP->hasIndices())
       return false;
 
     // If the GEP and the gather/scatter aren't in the same BB, don't optimize.
     // FIXME: We should support this by sinking the GEP.
     if (MemoryInst->getParent() != GEP->getParent())
       return false;
 
-    SmallVector<Value *, 2> Ops(GEP->operands());
+    auto Ops = to_vector_of<Value *, 2>(GEP->operands());
 
     bool RewriteGEP = false;
 
     if (Ops[0]->getType()->isVectorTy()) {
       Ops[0] = getSplatValue(Ops[0]);
       if (!Ops[0])
         return false;
       RewriteGEP = true;

llvm/lib/CodeGen/GlobalISel/RegBankSelect.cpp

#endif
   // Walk the function and assign register banks to all operands.
   // Use a RPOT to make sure all registers are assigned before we choose
   // the best mapping of the current instruction.
   ReversePostOrderTraversal<MachineFunction*> RPOT(&MF);
   for (MachineBasicBlock *MBB : RPOT) {
     // Set a sensible insertion point so that subsequent calls to
     // MIRBuilder.
     MIRBuilder.setMBB(*MBB);
-    SmallVector<MachineInstr *> WorkList(
-        make_pointer_range(reverse(MBB->instrs())));
+    SmallVector<MachineInstr *> WorkList =
+        to_vector(make_pointer_range(reverse(MBB->instrs())));
 
     while (!WorkList.empty()) {
       MachineInstr &MI = *WorkList.pop_back_val();
 
       // Ignore target-specific post-isel instructions: they should use proper
       // regclasses.
       if (isTargetSpecificOpcode(MI.getOpcode()) && !MI.isPreISelOpcode())
         continue;

llvm/lib/CodeGen/IfConversion.cpp

void IfConverter::MergeBlocks(BBInfo &ToBBI, BBInfo &FromBBI, bool AddEdges) {
 
   // Force normalizing the successors' probabilities of ToBBI.BB to convert all
   // unknown probabilities into known ones.
   // FIXME: This usage is too tricky and in the future we would like to
   // eliminate all unknown probabilities in MBB.
   if (ToBBI.IsBrAnalyzable)
     ToBBI.BB->normalizeSuccProbs();
 
-  SmallVector<MachineBasicBlock *, 4> FromSuccs(FromMBB.successors());
+  SmallVector<MachineBasicBlock *, 4> FromSuccs =
+      to_vector<4>(FromMBB.successors());
   MachineBasicBlock *NBB = getNextBlock(FromMBB);
   MachineBasicBlock *FallThrough = FromBBI.HasFallThrough ? NBB : nullptr;
   // The edge probability from ToBBI.BB to FromMBB, which is only needed when
   // AddEdges is true and FromMBB is a successor of ToBBI.BB.
   auto To2FromProb = BranchProbability::getZero();
   if (AddEdges && ToBBI.BB->isSuccessor(&FromMBB)) {
     // Remove the old edge but remember the edge probability so we can calculate
     // the correct weights on the new edges being added further down.

llvm/lib/CodeGen/LiveDebugValues/InstrRefBasedImpl.cpp

 bool InstrRefBasedLDV::vlocJoin(
     MachineBasicBlock &MBB, LiveIdxT &VLOCOutLocs,
     SmallPtrSet<const MachineBasicBlock *, 8> &BlocksToExplore,
     DbgValue &LiveIn) {
   LLVM_DEBUG(dbgs() << "join MBB: " << MBB.getNumber() << "\n");
   bool Changed = false;
 
   // Order predecessors by RPOT order, for exploring them in that order.
-  SmallVector<MachineBasicBlock *, 8> BlockOrders(MBB.predecessors());
+  SmallVector<MachineBasicBlock *, 8> BlockOrders =
+      to_vector<8>(MBB.predecessors());
 
   auto Cmp = [&](MachineBasicBlock *A, MachineBasicBlock *B) {
     return BBToOrder[A] < BBToOrder[B];
   };
 
   llvm::sort(BlockOrders, Cmp);
 
   unsigned CurBlockRPONum = BBToOrder[&MBB];

llvm/lib/CodeGen/MachineBlockPlacement.cpp

 // them.
 void MachineBlockPlacement::findDuplicateCandidates(
     SmallVectorImpl<MachineBasicBlock *> &Candidates,
     MachineBasicBlock *BB,
     BlockFilterSet *BlockFilter) {
   MachineBasicBlock *Fallthrough = nullptr;
   BranchProbability DefaultBranchProb = BranchProbability::getZero();
   BlockFrequency BBDupThreshold(scaleThreshold(BB));
-  SmallVector<MachineBasicBlock *, 8> Preds(BB->predecessors());
-  SmallVector<MachineBasicBlock *, 8> Succs(BB->successors());
+  SmallVector<MachineBasicBlock *, 8> Preds = to_vector<8>(BB->predecessors());
+  SmallVector<MachineBasicBlock *, 8> Succs = to_vector<8>(BB->successors());
 
   // Sort for highest frequency.
   auto CmpSucc = [&](MachineBasicBlock *A, MachineBasicBlock *B) {
     return MBPI->getEdgeProbability(BB, A) > MBPI->getEdgeProbability(BB, B);
   };
   auto CmpPred = [&](MachineBasicBlock *A, MachineBasicBlock *B) {
     return MBFI->getBlockFreq(A) > MBFI->getBlockFreq(B);
   };

llvm/lib/CodeGen/MachineSink.cpp

 SmallVector<MachineBasicBlock *, 4> &
 MachineSinking::GetAllSortedSuccessors(MachineInstr &MI, MachineBasicBlock *MBB,
                                        AllSuccsCache &AllSuccessors) const {
   // Do we have the sorted successors in cache ?
   auto Succs = AllSuccessors.find(MBB);
   if (Succs != AllSuccessors.end())
     return Succs->second;
 
-  SmallVector<MachineBasicBlock *, 4> AllSuccs(MBB->successors());
+  SmallVector<MachineBasicBlock *, 4> AllSuccs =
+      to_vector<4>(MBB->successors());
 
   // Handle cases where sinking can happen but where the sink point isn't a
   // successor. For example:
   //
   //   x = computation
   //   if () {} else {}
   //   use x
   //

llvm/lib/CodeGen/PreISelIntrinsicLowering.cpp

if (CB->getCalledFunction() != &F) {
       U.set(FCache.getCallee());
       continue;
     }
 
     auto *CI = cast<CallInst>(CB);
     assert(CI->getCalledFunction() && "Cannot lower an indirect call!");
 
     IRBuilder<> Builder(CI->getParent(), CI->getIterator());
-    SmallVector<Value *, 8> Args(CI->args());
+    auto Args = to_vector_of<Value *, 8>(CI->args());
     CallInst *NewCI = Builder.CreateCall(FCache, Args);
     NewCI->setName(CI->getName());
 
     // Try to set the most appropriate TailCallKind based on both the current
     // attributes and the ones that we could get from ObjCARC's special
     // knowledge of the runtime functions.
     //
     // std::max respects both requirements of notail and tail here:

llvm/lib/CodeGen/ReachingDefAnalysis.cpp

void ReachingDefAnalysis::getGlobalUses(MachineInstr *MI, MCRegister PhysReg,
   // Collect the uses that each def touches within the block.
   getReachingLocalUses(MI, PhysReg, Uses);
 
   // Handle live-out values.
   if (auto *LiveOut = getLocalLiveOutMIDef(MI->getParent(), PhysReg)) {
     if (LiveOut != MI)
       return;
 
-    SmallVector<MachineBasicBlock *, 4> ToVisit(MBB->successors());
+    SmallVector<MachineBasicBlock *, 4> ToVisit =
+        to_vector<4>(MBB->successors());
     SmallPtrSet<MachineBasicBlock*, 4>Visited;
     while (!ToVisit.empty()) {
       MachineBasicBlock *MBB = ToVisit.pop_back_val();
       if (Visited.count(MBB) || !MBB->isLiveIn(PhysReg))
         continue;
       if (getLiveInUses(MBB, PhysReg, Uses))
         llvm::append_range(ToVisit, MBB->successors());
       Visited.insert(MBB);

llvm/lib/CodeGen/ReplaceWithVeclib.cpp

if (!TLIFunc) {
     LLVM_DEBUG(dbgs() << DEBUG_TYPE << ": Adding `" << TLIName
                       << "` to `@llvm.compiler.used`.\n");
     ++NumFuncUsedAdded;
   }
 
   // Replace the call to the vector intrinsic with a call
   // to the corresponding function from the vector library.
   IRBuilder<> IRBuilder(&CI);
-  SmallVector<Value *> Args(CI.args());
+  auto Args = to_vector_of<Value *>(CI.args());
   // Preserve the operand bundles.
   SmallVector<OperandBundleDef, 1> OpBundles;
   CI.getOperandBundlesAsDefs(OpBundles);
   CallInst *Replacement = IRBuilder.CreateCall(TLIFunc, Args, OpBundles);
   assert(OldFunc->getFunctionType() == TLIFunc->getFunctionType() &&
          "Expecting function types to be identical");
   CI.replaceAllUsesWith(Replacement);
   if (isa<FPMathOperator>(Replacement)) {

llvm/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp

 void SelectionDAGLegalize::ExpandFPLibCall(SDNode* Node,
                                            RTLIB::Libcall LC,
                                            SmallVectorImpl<SDValue> &Results) {
   if (LC == RTLIB::UNKNOWN_LIBCALL)
     llvm_unreachable("Can't create an unknown libcall!");
 
   if (Node->isStrictFPOpcode()) {
     EVT RetVT = Node->getValueType(0);
-    SmallVector<SDValue, 4> Ops(drop_begin(Node->ops()));
+    auto Ops = to_vector_of<SDValue, 4>(drop_begin(Node->ops()));
     TargetLowering::MakeLibCallOptions CallOptions;
     // FIXME: This doesn't support tail calls.
     std::pair<SDValue, SDValue> Tmp = TLI.makeLibCall(DAG, LC, RetVT,
                                                       Ops, CallOptions,
                                                       SDLoc(Node),
                                                       Node->getOperand(0));
     Results.push_back(Tmp.first);
     Results.push_back(Tmp.second);

llvm/lib/CodeGen/SelectionDAG/ScheduleDAGSDNodes.cpp

static bool AddGlue(SDNode *N, SDValue Glue, bool AddGlue, SelectionDAG *DAG) {
   // Don't add a glue operand to something that already uses glue.
   if (GlueDestNode &&
       N->getOperand(N->getNumOperands()-1).getValueType() == MVT::Glue) {
     return false;
   }
   // Don't add glue to something that already has a glue value.
   if (N->getValueType(N->getNumValues() - 1) == MVT::Glue) return false;
 
-  SmallVector<EVT, 4> VTs(N->values());
+  SmallVector<EVT, 4> VTs = to_vector<4>(N->values());
   if (AddGlue)
     VTs.push_back(MVT::Glue);
 
   CloneNodeWithValues(N, DAG, VTs, Glue);
 
   return true;
 }
 

llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

void SelectionDAGBuilder::visitIntrinsicCall(const CallInst &I,
   }
   case Intrinsic::dbg_value: {
     const DbgValueInst &DI = cast<DbgValueInst>(I);
     assert(DI.getVariable() && "Missing variable");
 
     DILocalVariable *Variable = DI.getVariable();
     DIExpression *Expression = DI.getExpression();
     dropDanglingDebugInfo(Variable, Expression);
-    SmallVector<Value *, 4> Values(DI.getValues());
+    SmallVector<Value *, 4> Values = to_vector<4>(DI.getValues());
     if (Values.empty())
       return;
 
     if (llvm::is_contained(Values, nullptr))
       return;
 
     bool IsVariadic = DI.hasArgList();
     if (!handleDebugValue(Values, Variable, Expression, dl, DI.getDebugLoc(),

llvm/lib/CodeGen/SjLjEHPrepare.cpp

static void MarkBlocksLiveIn(BasicBlock *BB,
   for (BasicBlock *B : inverse_depth_first_ext(BB, Visited))
     LiveBBs.insert(B);
 }
 
 /// substituteLPadValues - Substitute the values returned by the landingpad
 /// instruction with those returned by the personality function.
 void SjLjEHPrepare::substituteLPadValues(LandingPadInst *LPI, Value *ExnVal,
                                          Value *SelVal) {
-  SmallVector<Value *, 8> UseWorkList(LPI->users());
+  auto UseWorkList = to_vector_of<Value *, 8>(LPI->users());
   while (!UseWorkList.empty()) {
     Value *Val = UseWorkList.pop_back_val();
     auto *EVI = dyn_cast<ExtractValueInst>(Val);
     if (!EVI)
       continue;
     if (EVI->getNumIndices() != 1)
       continue;
     if (*EVI->idx_begin() == 0)

llvm/lib/CodeGen/TailDuplicator.cpp

 }
 
 bool TailDuplicator::duplicateSimpleBB(
     MachineBasicBlock *TailBB, SmallVectorImpl<MachineBasicBlock *> &TDBBs,
     const DenseSet<Register> &UsedByPhi,
     SmallVectorImpl<MachineInstr *> &Copies) {
   SmallPtrSet<MachineBasicBlock *, 8> Succs(TailBB->succ_begin(),
                                             TailBB->succ_end());
-  SmallVector<MachineBasicBlock *, 8> Preds(TailBB->predecessors());
+  SmallVector<MachineBasicBlock *, 8> Preds =
+      to_vector<8>(TailBB->predecessors());
   bool Changed = false;
   for (MachineBasicBlock *PredBB : Preds) {
     if (PredBB->hasEHPadSuccessor() || PredBB->mayHaveInlineAsmBr())
       continue;
 
     if (bothUsedInPHI(*PredBB, Succs))
       continue;
 

llvm/lib/CodeGen/WasmEHPrepare.cpp

bool WasmEHPrepare::prepareThrows(Function &F) {
   for (User *U : ThrowF->users()) {
     // A call to @llvm.wasm.throw() is only generated from __cxa_throw()
     // builtin call within libcxxabi, and cannot be an InvokeInst.
     auto *ThrowI = cast<CallInst>(U);
     if (ThrowI->getFunction() != &F)
       continue;
     Changed = true;
     auto *BB = ThrowI->getParent();
-    SmallVector<BasicBlock *, 4> Succs(successors(BB));
+    SmallVector<BasicBlock *, 4> Succs = to_vector<4>(successors(BB));
     auto &InstList = BB->getInstList();
     InstList.erase(std::next(BasicBlock::iterator(ThrowI)), InstList.end());
     IRB.SetInsertPoint(BB);
     IRB.CreateUnreachable();
     eraseDeadBBsAndChildren(Succs);
   }
 
   return Changed;

llvm/lib/CodeGen/WinEHPrepare.cpp

if (const auto *Cleanup = dyn_cast<CleanupPadInst>(Pad)) {
             Worklist.emplace_back(I, CleanupState);
       // Remember this pad's state.
       FuncInfo.EHPadStateMap[Cleanup] = CleanupState;
     } else {
       // Walk the handlers of this catchswitch in reverse order since all but
       // the last need to set the following one as its TryParentState.
       const auto *CatchSwitch = cast<CatchSwitchInst>(Pad);
       int CatchState = -1, FollowerState = -1;
-      SmallVector<const BasicBlock *, 4> CatchBlocks(CatchSwitch->handlers());
+      SmallVector<const BasicBlock *, 4> CatchBlocks =
+          to_vector<4>(CatchSwitch->handlers());
       for (const BasicBlock *CatchBlock : llvm::reverse(CatchBlocks)) {
         // Create the entry for this catch with the appropriate handler
         // properties.
         const auto *Catch = cast<CatchPadInst>(CatchBlock->getFirstNonPHI());
         uint32_t TypeToken = static_cast<uint32_t>(
             cast<ConstantInt>(Catch->getArgOperand(0))->getZExtValue());
         CatchState =
             addClrEHHandler(FuncInfo, HandlerParentState, FollowerState,

llvm/lib/IR/AutoUpgrade.cpp

else if (Name[5] == 'w' && VecWidth == 256)
       IID = Intrinsic::x86_avx2_pavg_w;
     else if (Name[5] == 'w' && VecWidth == 512)
       IID = Intrinsic::x86_avx512_pavg_w_512;
     else
       llvm_unreachable("Unexpected intrinsic");
   } else
     return false;
 
-  SmallVector<Value *, 4> Args(CI.args());
+  auto Args = to_vector_of<Value *, 4>(CI.args());
   Args.pop_back();
   Args.pop_back();
   Rep = Builder.CreateCall(Intrinsic::getDeclaration(CI.getModule(), IID),
                            Args);
   unsigned NumArgs = CI.arg_size();
   Rep = EmitX86Select(Builder, CI.getArgOperand(NumArgs - 1), Rep,
                       CI.getArgOperand(NumArgs - 2));
   return true;
if (IsX86 && (Name.startswith("sse2.pcmp") ||
         IID = Intrinsic::x86_avx512_fpclass_pd_512;
       else
         llvm_unreachable("Unexpected intrinsic");
 
       Rep = Builder.CreateCall(Intrinsic::getDeclaration(F->getParent(), IID),
                                { CI->getOperand(0), CI->getArgOperand(1) });
       Rep = ApplyX86MaskOn1BitsVec(Builder, Rep, CI->getArgOperand(2));
     } else if (IsX86 && Name.startswith("avx512.cmp.p")) {
-      SmallVector<Value *, 4> Args(CI->args());
+      auto Args = to_vector_of<Value *, 4>(CI->args());
       Type *OpTy = Args[0]->getType();
       unsigned VecWidth = OpTy->getPrimitiveSizeInBits();
       unsigned EltWidth = OpTy->getScalarSizeInBits();
       Intrinsic::ID IID;
       if (VecWidth == 128 && EltWidth == 32)
         IID = Intrinsic::x86_avx512_mask_cmp_ps_128;
       else if (VecWidth == 256 && EltWidth == 32)
         IID = Intrinsic::x86_avx512_mask_cmp_ps_256;
const auto &DefaultCase = [&]() -> void {
 
     // This must be an upgrade from a named to a literal struct.
     auto *OldST = cast<StructType>(CI->getType());
     assert(OldST != NewFn->getReturnType() && "Return type must have changed");
     assert(OldST->getNumElements() ==
                cast<StructType>(NewFn->getReturnType())->getNumElements() &&
            "Must have same number of elements");
 
-    SmallVector<Value *> Args(CI->args());
+    auto Args = to_vector_of<Value *>(CI->args());
     Value *NewCI = Builder.CreateCall(NewFn, Args);
     Value *Res = PoisonValue::get(OldST);
     for (unsigned Idx = 0; Idx < OldST->getNumElements(); ++Idx) {
       Value *Elem = Builder.CreateExtractValue(NewCI, Idx);
       Res = Builder.CreateInsertValue(Res, Elem, Idx);
     }
     CI->replaceAllUsesWith(Res);
     CI->eraseFromParent();
     return;
   };
   CallInst *NewCall = nullptr;
   switch (NewFn->getIntrinsicID()) {
   default: {
     DefaultCase();
     return;
   }
   case Intrinsic::arm_neon_vst1:
   case Intrinsic::arm_neon_vst2:
   case Intrinsic::arm_neon_vst3:
   case Intrinsic::arm_neon_vst4:
   case Intrinsic::arm_neon_vst2lane:
   case Intrinsic::arm_neon_vst3lane:
   case Intrinsic::arm_neon_vst4lane: {
-    SmallVector<Value *, 4> Args(CI->args());
+    auto Args = to_vector_of<Value *, 4>(CI->args());
     NewCall = Builder.CreateCall(NewFn, Args);
     break;
   }
 
   case Intrinsic::arm_neon_bfdot:
   case Intrinsic::arm_neon_bfmmla:
   case Intrinsic::arm_neon_bfmlalb:
   case Intrinsic::arm_neon_bfmlalt:

   case Intrinsic::x86_xop_vfrcz_sd:
     NewCall = Builder.CreateCall(NewFn, {CI->getArgOperand(1)});
     break;
 
   case Intrinsic::x86_xop_vpermil2pd:
   case Intrinsic::x86_xop_vpermil2ps:
   case Intrinsic::x86_xop_vpermil2pd_256:
   case Intrinsic::x86_xop_vpermil2ps_256: {
-    SmallVector<Value *, 4> Args(CI->args());
+    auto Args = to_vector_of<Value *, 4>(CI->args());
     VectorType *FltIdxTy = cast<VectorType>(Args[2]->getType());
     VectorType *IntIdxTy = VectorType::getInteger(FltIdxTy);
     Args[2] = Builder.CreateBitCast(Args[2], IntIdxTy);
     NewCall = Builder.CreateCall(NewFn, Args);
     break;
   }
 
   case Intrinsic::x86_sse41_ptestc:

   case Intrinsic::x86_sse41_insertps:
   case Intrinsic::x86_sse41_dppd:
   case Intrinsic::x86_sse41_dpps:
   case Intrinsic::x86_sse41_mpsadbw:
   case Intrinsic::x86_avx_dp_ps_256:
   case Intrinsic::x86_avx2_mpsadbw: {
     // Need to truncate the last argument from i32 to i8 -- this argument models
     // an inherently 8-bit immediate operand to these x86 instructions.
-    SmallVector<Value *, 4> Args(CI->args());
+    auto Args = to_vector_of<Value *, 4>(CI->args());
 
     // Replace the last argument with a trunc.
     Args.back() = Builder.CreateTrunc(Args.back(), Type::getInt8Ty(C), "trunc");
     NewCall = Builder.CreateCall(NewFn, Args);
     break;
   }
 
   case Intrinsic::x86_avx512_mask_cmp_pd_128:
   case Intrinsic::x86_avx512_mask_cmp_pd_256:
   case Intrinsic::x86_avx512_mask_cmp_pd_512:
   case Intrinsic::x86_avx512_mask_cmp_ps_128:
   case Intrinsic::x86_avx512_mask_cmp_ps_256:
   case Intrinsic::x86_avx512_mask_cmp_ps_512: {
-    SmallVector<Value *, 4> Args(CI->args());
+    auto Args = to_vector_of<Value *, 4>(CI->args());
     unsigned NumElts =
         cast<FixedVectorType>(Args[0]->getType())->getNumElements();
     Args[3] = getX86MaskVec(Builder, Args[3], NumElts);
 
     NewCall = Builder.CreateCall(NewFn, Args);
     Value *Res = ApplyX86MaskOn1BitsVec(Builder, NewCall, nullptr);
 
     NewCall->takeName(CI);
     CI->replaceAllUsesWith(Res);
     CI->eraseFromParent();
     return;
   }
 
   case Intrinsic::thread_pointer: {
     NewCall = Builder.CreateCall(NewFn, {});
     break;
   }
 
   case Intrinsic::invariant_start:
   case Intrinsic::invariant_end: {
-    SmallVector<Value *, 4> Args(CI->args());
+    auto Args = to_vector_of<Value *, 4>(CI->args());
     NewCall = Builder.CreateCall(NewFn, Args);
     break;
   }
   case Intrinsic::masked_load:
   case Intrinsic::masked_store:
   case Intrinsic::masked_gather:
   case Intrinsic::masked_scatter: {
-    SmallVector<Value *, 4> Args(CI->args());
+    auto Args = to_vector_of<Value *, 4>(CI->args());
     NewCall = Builder.CreateCall(NewFn, Args);
     NewCall->copyMetadata(*CI);
     break;
   }
 
   case Intrinsic::memcpy:
   case Intrinsic::memmove:
   case Intrinsic::memset: {

llvm/lib/IR/Constants.cpp

if (Constant *C = getWithOperands(NewOps, getType(), true))
     return C;
 
   // Update to the new value.
   return getContext().pImpl->ExprConstants.replaceOperandsInPlace(
       NewOps, this, From, To, NumUpdated, OperandNo);
 }
 
 Instruction *ConstantExpr::getAsInstruction(Instruction *InsertBefore) const {
-  SmallVector<Value *, 4> ValueOperands(operands());
-  ArrayRef<Value*> Ops(ValueOperands);
+  ArrayRef<Value *> Ops = to_vector_of<Value *, 4>(operands());
 
   switch (getOpcode()) {
   case Instruction::Trunc:
   case Instruction::ZExt:
   case Instruction::SExt:
   case Instruction::FPTrunc:
   case Instruction::FPExt:
   case Instruction::UIToFP:

llvm/lib/IR/LLVMContextImpl.cpp

 static const Metadata *get_hashable_data(const MDOperand &X) { return X.get(); }
 
 } // end namespace llvm
 
 unsigned MDNodeOpsKey::calculateHash(MDNode *N, unsigned Offset) {
   unsigned Hash = hash_combine_range(N->op_begin() + Offset, N->op_end());
 #ifndef NDEBUG
   {
-    SmallVector<Metadata *, 8> MDs(drop_begin(N->operands(), Offset));
+    auto MDs = to_vector_of<Metadata *, 8>(drop_begin(N->operands(), Offset));
     unsigned RawHash = calculateHash(MDs);
     assert(Hash == RawHash &&
            "Expected hash of MDOperand to equal hash of Metadata*");
   }
 #endif
   return Hash;
 }
 

llvm/lib/IR/Operator.cpp

 }
 
 bool GEPOperator::accumulateConstantOffset(
     const DataLayout &DL, APInt &Offset,
     function_ref<bool(Value &, APInt &)> ExternalAnalysis) const {
   assert(Offset.getBitWidth() ==
              DL.getIndexSizeInBits(getPointerAddressSpace()) &&
          "The offset bit width does not match DL specification.");
-  SmallVector<const Value *> Index(llvm::drop_begin(operand_values()));
+  SmallVector<const Value *> Index =
+      to_vector(llvm::drop_begin(operand_values()));
   return GEPOperator::accumulateConstantOffset(getSourceElementType(), Index,
                                                DL, Offset, ExternalAnalysis);
 }
 
 bool GEPOperator::accumulateConstantOffset(
     Type *SourceType, ArrayRef<const Value *> Index, const DataLayout &DL,
     APInt &Offset, function_ref<bool(Value &, APInt &)> ExternalAnalysis) {
   bool UsedExternalAnalysis = false;

llvm/lib/IR/Verifier.cpp

void Verifier::visitBasicBlock(BasicBlock &BB) {
   InstsInThisBlock.clear();
 
   // Ensure that basic blocks have terminators!
   Check(BB.getTerminator(), "Basic Block does not have terminator!", &BB);
 
   // Check constraints that this basic block imposes on all of the PHI nodes in
   // it.
   if (isa<PHINode>(BB.front())) {
-    SmallVector<BasicBlock *, 8> Preds(predecessors(&BB));
+    auto Preds = to_vector<8>(predecessors(&BB));
     SmallVector<std::pair<BasicBlock*, Value*>, 8> Values;
     llvm::sort(Preds);
     for (const PHINode &PN : BB.phis()) {
       Check(PN.getNumIncomingValues() == Preds.size(),
             "PHINode should have one entry for each predecessor of its "
             "parent basic block!",
             &PN);
 

 
 void Verifier::visitGetElementPtrInst(GetElementPtrInst &GEP) {
   Type *TargetTy = GEP.getPointerOperandType()->getScalarType();
 
   Check(isa<PointerType>(TargetTy),
         "GEP base pointer is not a vector or a vector of pointers", &GEP);
   Check(GEP.getSourceElementType()->isSized(), "GEP into unsized type!", &GEP);
 
-  SmallVector<Value *, 16> Idxs(GEP.indices());
+  auto Idxs = to_vector_of<Value *, 16>(GEP.indices());
   Check(
       all_of(Idxs, [](Value *V) { return V->getType()->isIntOrIntVectorTy(); }),
       "GEP indexes must be integers", &GEP);
   Type *ElTy =
       GetElementPtrInst::getIndexedType(GEP.getSourceElementType(), Idxs);
   Check(ElTy, "Invalid indices for GEP pointer type!", &GEP);
 
   Check(GEP.getType()->isPtrOrPtrVectorTy() &&

llvm/lib/Transforms/Utils/BasicBlockUtils.cpp

static bool removeRedundantDbgInstrsUsingForwardScan(BasicBlock *BB) {
   for (auto &I : *BB) {
     if (DbgValueInst *DVI = dyn_cast<DbgValueInst>(&I)) {
       DebugVariable Key(DVI->getVariable(),
                         NoneType(),
                         DVI->getDebugLoc()->getInlinedAt());
       auto VMI = VariableMap.find(Key);
       // Update the map if we found a new value/expression describing the
       // variable, or if the variable wasn't mapped already.
-      SmallVector<Value *, 4> Values(DVI->getValues());
+      SmallVector<Value *, 4> Values = to_vector<4>(DVI->getValues());
       if (VMI == VariableMap.end() || VMI->second.first != Values ||
           VMI->second.second != DVI->getExpression()) {
         VariableMap[Key] = {Values, DVI->getExpression()};
         continue;
       }
       // Found an identical mapping. Remember the instruction for later removal.
       ToBeRemoved.push_back(DVI);
     }

llvm/lib/Transforms/Utils/CallPromotionUtils.cpp

 static void createRetPHINode(Instruction *OrigInst, Instruction *NewInst,
                              BasicBlock *MergeBlock, IRBuilder<> &Builder) {
 
   if (OrigInst->getType()->isVoidTy() || OrigInst->use_empty())
     return;
 
   Builder.SetInsertPoint(&MergeBlock->front());
   PHINode *Phi = Builder.CreatePHI(OrigInst->getType(), 0);
-  SmallVector<User *, 16> UsersToUpdate(OrigInst->users());
+  SmallVector<User *, 16> UsersToUpdate = to_vector<16>(OrigInst->users());
   for (User *U : UsersToUpdate)
     U->replaceUsesOfWith(OrigInst, Phi);
   Phi->addIncoming(OrigInst, OrigInst->getParent());
   Phi->addIncoming(NewInst, NewInst->getParent());
 }
 
 /// Cast a call or invoke instruction to the given type.
 ///

 ///     ; Uses of the original return value are replaced by uses of the bitcast.
 ///     %t1 = bitcast i32 %t0 to ...
 ///     br label %normal_dst
 ///
 static void createRetBitCast(CallBase &CB, Type *RetTy, CastInst **RetBitCast) {
 
   // Save the users of the calling instruction. These uses will be changed to
   // use the bitcast after we create it.
-  SmallVector<User *, 16> UsersToUpdate(CB.users());
+  SmallVector<User *, 16> UsersToUpdate = to_vector<16>(CB.users());
 
   // Determine an appropriate location to create the bitcast for the return
   // value. The location depends on if we have a call or invoke instruction.
   Instruction *InsertBefore = nullptr;
   if (auto *Invoke = dyn_cast<InvokeInst>(&CB))
     InsertBefore =
         &SplitEdge(Invoke->getParent(), Invoke->getNormalDest())->front();
   else

llvm/lib/Transforms/Utils/CodeExtractor.cpp

for (PHINode &PN : ExitBB->phis()) {
         continue;
 
       // Create block for new PHIs and add it to the list of outlined if it
       // wasn't done before.
       if (!NewBB) {
         NewBB = BasicBlock::Create(ExitBB->getContext(),
                                    ExitBB->getName() + ".split",
                                    ExitBB->getParent(), ExitBB);
-        SmallVector<BasicBlock *, 4> Preds(predecessors(ExitBB));
+        SmallVector<BasicBlock *, 4> Preds = to_vector<4>(predecessors(ExitBB));
         for (BasicBlock *PredBB : Preds)
           if (Blocks.count(PredBB))
             PredBB->getTerminator()->replaceUsesOfWith(ExitBB, NewBB);
         BranchInst::Create(ExitBB, NewBB);
         Blocks.insert(NewBB);
       }
 
       // Split this PHI.

llvm/lib/Transforms/Utils/Debugify.cpp

if (DbgValF) {
     Changed = true;
   }
 
   // Strip out the module-level Debug Info Version metadata.
   // FIXME: There must be an easier way to remove an operand from a NamedMDNode.
   NamedMDNode *NMD = M.getModuleFlagsMetadata();
   if (!NMD)
     return Changed;
-  SmallVector<MDNode *, 4> Flags(NMD->operands());
+  SmallVector<MDNode *, 4> Flags = to_vector<4>(NMD->operands());
   NMD->clearOperands();
   for (MDNode *Flag : Flags) {
     auto *Key = cast<MDString>(Flag->getOperand(1));
     if (Key->getString() == "Debug Info Version") {
       Changed = true;
       continue;
     }
     NMD->addOperand(Flag);

llvm/lib/Transforms/Utils/GuardUtils.cpp

 static cl::opt<uint32_t> PredicatePassBranchWeight(
     "guards-predicate-pass-branch-weight", cl::Hidden, cl::init(1 << 20),
     cl::desc("The probability of a guard failing is assumed to be the "
              "reciprocal of this value (default = 1 << 20)"));
 
 void llvm::makeGuardControlFlowExplicit(Function *DeoptIntrinsic,
                                         CallInst *Guard, bool UseWC) {
   OperandBundleDef DeoptOB(*Guard->getOperandBundle(LLVMContext::OB_deopt));
-  SmallVector<Value *, 4> Args(drop_begin(Guard->args()));
+  auto Args = to_vector_of<Value *, 4>(drop_begin(Guard->args()));
 
   auto *CheckBB = Guard->getParent();
   auto *DeoptBlockTerm =
       SplitBlockAndInsertIfThen(Guard->getArgOperand(0), Guard, true);
 
   auto *CheckBI = cast<BranchInst>(CheckBB->getTerminator());
 
   // SplitBlockAndInsertIfThen inserts control flow that branches to

llvm/lib/Transforms/Utils/InlineFunction.cpp

for (Function::iterator BB = FirstNewBlock, E = Caller->end(); BB != E;
               ArgAttrs.push_back(Attrs.getParamAttrs(ArgNo));
           }
 
           // Add VarArg attributes.
           ArgAttrs.append(VarArgsAttrs.begin(), VarArgsAttrs.end());
           Attrs = AttributeList::get(CI->getContext(), Attrs.getFnAttrs(),
                                      Attrs.getRetAttrs(), ArgAttrs);
           // Add VarArgs to existing parameters.
-          SmallVector<Value *, 6> Params(CI->args());
+          auto Params = to_vector_of<Value *, 6>(CI->args());
           Params.append(VarArgsToForward.begin(), VarArgsToForward.end());
           CallInst *NewCI = CallInst::Create(
               CI->getFunctionType(), CI->getCalledOperand(), Params, "", CI);
           NewCI->setDebugLoc(CI->getDebugLoc());
           NewCI->setAttributes(Attrs);
           NewCI->setCallingConv(CI->getCallingConv());
           CI->replaceAllUsesWith(NewCI);
           CI->eraseFromParent();
if (Caller->getReturnType() == CB.getType()) {
         // never actually execute at runtime); but all
         // @llvm.experimental.deoptimize declarations have to have the same
         // calling convention in a well-formed module.
         auto CallingConv = DeoptCall->getCalledFunction()->getCallingConv();
         NewDeoptIntrinsic->setCallingConv(CallingConv);
         auto *CurBB = RI->getParent();
         RI->eraseFromParent();
 
-        SmallVector<Value *, 4> CallArgs(DeoptCall->args());
+        auto CallArgs = to_vector_of<Value *, 4>(DeoptCall->args());
 
         SmallVector<OperandBundleDef, 1> OpBundles;
         DeoptCall->getOperandBundlesAsDefs(OpBundles);
         auto DeoptAttributes = DeoptCall->getAttributes();
         DeoptCall->eraseFromParent();
         assert(!OpBundles.empty() &&
                "Expected at least the deopt operand bundle");
 

llvm/lib/Transforms/Utils/Local.cpp

for (auto *PredOfBB : predecessors(BB))
         Updates.push_back({DominatorTree::Delete, PredOfBB, BB});
     Updates.push_back({DominatorTree::Delete, BB, Succ});
   }
 
   if (isa<PHINode>(Succ->begin())) {
     // If there is more than one pred of succ, and there are PHI nodes in
     // the successor, then we need to add incoming edges for the PHI nodes
     //
-    const PredBlockVector BBPreds(predecessors(BB));
+    const PredBlockVector BBPreds = to_vector(predecessors(BB));
 
     // Loop over all of the PHI nodes in the successor of BB.
     for (BasicBlock::iterator I = Succ->begin(); isa<PHINode>(I); ++I) {
       PHINode *PN = cast<PHINode>(I);
 
       redirectValuesFromPredecessorsToPhi(BB, BBPreds, PN);
     }
   }
if (DTU) {
     for (BasicBlock *UniqueSuccessor : UniqueSuccessors)
       Updates.push_back({DominatorTree::Delete, BB, UniqueSuccessor});
     DTU->applyUpdates(Updates);
   }
   return NumInstrsRemoved;
 }
 
 CallInst *llvm::createCallMatchingInvoke(InvokeInst *II) {
-  SmallVector<Value *, 8> Args(II->args());
+  auto Args = to_vector_of<Value *, 8>(II->args());
   SmallVector<OperandBundleDef, 1> OpBundles;
   II->getOperandBundlesAsDefs(OpBundles);
   CallInst *NewCall = CallInst::Create(II->getFunctionType(),
                                        II->getCalledOperand(), Args, OpBundles);
   NewCall->setCallingConv(II->getCallingConv());
   NewCall->setAttributes(II->getAttributes());
   NewCall->setDebugLoc(II->getDebugLoc());
   NewCall->copyMetadata(*II);
BasicBlock *llvm::changeToInvokeAndSplitBasicBlock(CallInst *CI,
   // basic block.
   BasicBlock *Split = SplitBlock(BB, CI, DTU, /*LI=*/nullptr, /*MSSAU*/ nullptr,
                                  CI->getName() + ".noexc");
 
   // Delete the unconditional branch inserted by SplitBlock
   BB->getInstList().pop_back();
 
   // Create the new invoke instruction.
-  SmallVector<Value *, 8> InvokeArgs(CI->args());
+  auto InvokeArgs = to_vector_of<Value *, 8>(CI->args());
   SmallVector<OperandBundleDef, 1> OpBundles;
 
   CI->getOperandBundlesAsDefs(OpBundles);
 
   // Note: we're round tripping operand bundles through memory here, and that
   // can potentially be avoided with a cleverer API design that we do not have
   // as of this time.
 

llvm/lib/Transforms/Utils/LoopRotationUtils.cpp

if (!isa<ConstantInt>(PHBI->getCondition()) ||
                                             OrigPreheader, NewHeader,
                                             CriticalEdgeSplittingOptions(DT, LI, MSSAU).setPreserveLCSSA());
       NewPH->setName(NewHeader->getName() + ".lr.ph");
 
       // Preserve canonical loop form, which means that 'Exit' should have only
       // one predecessor. Note that Exit could be an exit block for multiple
       // nested loops, causing both of the edges to now be critical and need to
       // be split.
-      SmallVector<BasicBlock *, 4> ExitPreds(predecessors(Exit));
+      SmallVector<BasicBlock *, 4> ExitPreds = to_vector<4>(predecessors(Exit));
       bool SplitLatchEdge = false;
       for (BasicBlock *ExitPred : ExitPreds) {
         // We only need to split loop exit edges.
         Loop *PredLoop = LI->getLoopFor(ExitPred);
         if (!PredLoop || PredLoop->contains(Exit) ||
             ExitPred->getTerminator()->isIndirectTerminator())
           continue;
         SplitLatchEdge |= L->getLoopLatch() == ExitPred;

llvm/lib/Transforms/Utils/LoopUnrollRuntime.cpp

static void ConnectProlog(Loop *L, Value *BECount, unsigned Count,
 
   // If BECount <u (Count - 1) then (BECount + 1) % Count == (BECount + 1)
   // This means %xtraiter is (BECount + 1) and all of the iterations of this
   // loop were executed by the prologue.  Note that if BECount <u (Count - 1)
   // then (BECount + 1) cannot unsigned-overflow.
   Value *BrLoopExit =
       B.CreateICmpULT(BECount, ConstantInt::get(BECount->getType(), Count - 1));
   // Split the exit to maintain loop canonicalization guarantees
-  SmallVector<BasicBlock *, 4> Preds(predecessors(OriginalLoopLatchExit));
+  SmallVector<BasicBlock *, 4> Preds =
+      to_vector<4>(predecessors(OriginalLoopLatchExit));
   SplitBlockPredecessors(OriginalLoopLatchExit, Preds, ".unr-lcssa", DT, LI,
                          nullptr, PreserveLCSSA);
   // Add the branch to the exit block (around the unrolled loop)
   B.CreateCondBr(BrLoopExit, OriginalLoopLatchExit, NewPreHeader);
   InsertPt->eraseFromParent();
   if (DT) {
     auto *NewDom = DT->findNearestCommonDominator(OriginalLoopLatchExit,
                                                   PrologExit);
for (BasicBlock *Succ : successors(Latch)) {
     }
   }
 
   Instruction *InsertPt = NewExit->getTerminator();
   IRBuilder<> B(InsertPt);
   Value *BrLoopExit = B.CreateIsNotNull(ModVal, "lcmp.mod");
   assert(Exit && "Loop must have a single exit block only");
   // Split the epilogue exit to maintain loop canonicalization guarantees
-  SmallVector<BasicBlock*, 4> Preds(predecessors(Exit));
+  SmallVector<BasicBlock *, 4> Preds = to_vector<4>(predecessors(Exit));
   SplitBlockPredecessors(Exit, Preds, ".epilog-lcssa", DT, LI, nullptr,
                          PreserveLCSSA);
   // Add the branch to the exit block (around the unrolling loop)
   B.CreateCondBr(BrLoopExit, EpilogPreHeader, Exit);
   InsertPt->eraseFromParent();
   if (DT) {
     auto *NewDom = DT->findNearestCommonDominator(Exit, NewExit);
     DT->changeImmediateDominator(Exit, NewDom);