reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

Declarations

   35   template<typename T, unsigned N> class SmallVector;

   35 template <typename T, unsigned N> class SmallVector;

References

  843   SmallVector<Metadata *, 8> EltTys;

  389     SmallVector<GEPInfo, 4> AddrInfo;

13731       SmallVector<StringRef, 1> AttrFeatures;
13748       SmallVector<StringRef, 1> AttrFeatures;
13772       SmallVector<StringRef, 1> AttrFeatures;

   84     SmallVector<StringRef, 4> tags;
   86     SmallVector<std::string, 4> tagsStorage;
  100     SmallVector<Expr *, 4> args;
  113     SmallVector<Expr *, 4> args;
  126     SmallVector<Expr *, 4> args;
  305     SmallVector<Expr *, 4> args;
  318     SmallVector<Expr *, 4> args;
  331     SmallVector<Expr *, 4> args;
  444     SmallVector<IdentifierInfo *, 4> cpus;
  457     SmallVector<IdentifierInfo *, 4> cpus;
  536     SmallVector<CallableWhenAttr::ConsumedState, 4> callableStates;
  549     SmallVector<int, 4> encoding;
  787     SmallVector<Expr *, 4> args;
 1008     SmallVector<Expr *, 4> args;
 1319     SmallVector<StringRef, 4> sanitizers;
 1321     SmallVector<std::string, 4> sanitizersStorage;
 1384     SmallVector<ParamIdx, 4> args;
 1431     SmallVector<Expr *, 4> uniforms;
 1436     SmallVector<Expr *, 4> aligneds;
 1441     SmallVector<Expr *, 4> alignments;
 1446     SmallVector<Expr *, 4> linears;
 1451     SmallVector<unsigned, 4> modifiers;
 1456     SmallVector<Expr *, 4> steps;
 1483     SmallVector<StringRef, 4> implVendors;
 1485     SmallVector<std::string, 4> implVendorsStorage;
 1848     SmallVector<ParamIdx, 4> args;
 2036     SmallVector<Expr *, 4> args;
 2066     SmallVector<Expr *, 4> args;
 2163     SmallVector<Expr *, 4> args;
 2191     SmallVector<StringRef, 4> diagnosticIdentifiers;
 2193     SmallVector<std::string, 4> diagnosticIdentifiersStorage;
 2305     SmallVector<Expr *, 4> args;

  474   ArrayRef<T> makeArrayRef(const SmallVector<T, N> &Vec) {

  165   using NodeListTy = SmallVector<NodeType *, 10>;
  166   using EdgeListTy = SmallVector<EdgeType *, 10>;

  308   SmallVector<unsigned, 32> Bits;

  652   SmallVector<uintptr_t,20> stack;

   34     using StorageT = SmallVector<T, 0>;

   33   SmallVector<unsigned, 8> EC;

  790   SmallVector<Entry, 4> path;
 1250   SmallVector<IntervalMapImpl::NodeRef, 4> Refs, NextRefs;

  234                 SmallVector<std::pair<KeyT, ValueT>, N>> {

  257     : public PriorityWorklist<T, SmallVector<T, N>,

 1319 SmallVector<typename std::remove_const<detail::ValueOfRange<R>>::type, Size>

  298     : public SetVector<T, SmallVector<T, N>, SmallDenseSet<T, N>> {

   38   using VecIterTy = typename SmallVector<T, N>::const_iterator;
  138   SmallVector<T, N> Vector;
  141   using VIterator = typename SmallVector<T, N>::const_iterator;
  142   using mutable_iterator = typename SmallVector<T, N>::iterator;

   25 class SmallString : public SmallVector<char, InternalLen> {
   31   SmallString(StringRef S) : SmallVector<char, InternalLen>(S.begin(), S.end()) {}
   35   SmallString(ItTy S, ItTy E) : SmallVector<char, InternalLen>(S, E) {}

  869   SmallVector(const SmallVector &RHS) : SmallVectorImpl<T>(N) {
  874   const SmallVector &operator=(const SmallVector &RHS) {
  874   const SmallVector &operator=(const SmallVector &RHS) {
  879   SmallVector(SmallVector &&RHS) : SmallVectorImpl<T>(N) {
  889   const SmallVector &operator=(SmallVector &&RHS) {
  889   const SmallVector &operator=(SmallVector &&RHS) {
  894   const SmallVector &operator=(SmallVectorImpl<T> &&RHS) {
  899   const SmallVector &operator=(std::initializer_list<T> IL) {
  906 inline size_t capacity_in_bytes(const SmallVector<T, N> &X) {
  924   swap(llvm::SmallVector<T, N> &LHS, llvm::SmallVector<T, N> &RHS) {
  924   swap(llvm::SmallVector<T, N> &LHS, llvm::SmallVector<T, N> &RHS) {

  121   using DenseT = SmallVector<SMSNode, 8>;

  129   using DenseT = SmallVector<ValueT, 8>;

   32   using VecTy = SmallVector<EltTy, 4>;

 1130   SmallVector<void (*)(Function &F, FunctionAnalysisManager &AM,

   49   SmallVector<WeakTrackingVH, 4> AssumeHandles;
   69       DenseMap<AffectedValueCallbackVH, SmallVector<WeakTrackingVH, 1>,
   74   SmallVector<WeakTrackingVH, 1> &getOrInsertAffectedValues(Value *V);

  144     SmallVector<VariableGEPIndex, 4> VarIndices;

  215     using ExitMap = SmallVector<std::pair<BlockNode, BlockMass>, 4>;
  216     using NodeList = SmallVector<BlockNode, 4>;
  217     using HeaderMassList = SmallVector<BlockMass, 1>;
  376     using WeightList = SmallVector<Weight, 4>;

  461     SmallVector<LazyCallGraph::Node *, 4> Nodes;
  572     SmallVector<WeakTrackingVH, 8> CallHandles;

  155   SmallVector<Instruction *, 2> InstList;
  205   using DependenceList = SmallVector<std::unique_ptr<Dependence>, 1>;

   38   using NodeListType = SmallVector<NodeType *, 4>;

  260   SmallVector<DominatorTree::UpdateType, 16> PendUpdates;

   51   SmallVector<BlockT *, IsPostDom ? 4 : 1> Roots;

  362   SmallVector<Instruction *, 2> RedundantCasts;

   24   using ChildrenTy = SmallVector<BasicBlock *, 8>;

  191     using VectorT = SmallVector<Edge, 4>;
  436     SmallVector<Node *, 1> Nodes;
  554     SmallVector<SCC *, 4> SCCs;
  788     SmallVector<RefSCC *, 1> insertIncomingRefEdge(Node &SourceN,
  841     SmallVector<RefSCC *, 1> removeInternalRefEdge(Node &SourceN,
 1146   SmallVector<RefSCC *, 16> PostOrderRefSCCs;

   95   typedef SmallVector<MemAccessInfo, 8> MemAccessInfoList;
  254   SmallVector<Instruction *, 4> getInstructionsForAccess(Value *Ptr,
  271   SmallVector<Instruction *, 16> InstMap;
  301   SmallVector<Dependence, 8> Dependences;
  413     SmallVector<unsigned, 2> Members;
  431   const SmallVector<PointerCheck, 4> &getChecks() const { return Checks; }
  453   SmallVector<PointerInfo, 2> Pointers;
  456   SmallVector<CheckingPtrGroup, 2> CheckingGroups;
  484   SmallVector<PointerCheck, 4>
  492   SmallVector<PointerCheck, 4> Checks;
  580   SmallVector<Instruction *, 4> getInstructionsForAccess(Value *Ptr,

   31 using LoopVectorTy = SmallVector<Loop *, 8>;
  134   SmallVector<const SCEV *, 3> Subscripts;
  137   SmallVector<const SCEV *, 3> Sizes;
  155 using ReferenceGroupTy = SmallVector<std::unique_ptr<IndexedReference>, 8>;
  156 using ReferenceGroupsTy = SmallVector<ReferenceGroupTy, 8>;
  249   SmallVector<LoopTripCountTy, 3> TripCounts;
  252   SmallVector<LoopCacheCostTy, 3> LoopCosts;

  327     SmallVector<LoopT *, 4> PreOrderWorklist;
  341   SmallVector<const LoopT *, 4> getLoopsInPreorder() const {
  342     SmallVector<const LoopT *, 4> PreOrderLoops;
  348   SmallVector<LoopT *, 4> getLoopsInPreorder() {
  349     SmallVector<LoopT *, 4> PreOrderLoops;
  914   SmallVector<LoopT *, 4> getLoopsInPreorder();
  924   SmallVector<LoopT *, 4> getLoopsInReverseSiblingPreorder();

   51   SmallVector<BlockT *, 8> ExitingBlocks;
   77   SmallVector<BlockT *, 8> ExitBlocks;
   88   SmallVector<BlockT *, 4> UniqueExitBlocks;
  132   SmallVector<BlockT *, 8> UniqueExitBlocks;
  285   SmallVector<BlockT *, 8> ExitBBs;
  310     SmallVector<BlockT *, 2> OutsideLoopPreds;
  544     SmallVector<BlockT *, 4> Backedges;
  567 SmallVector<LoopT *, 4> LoopInfoBase<BlockT, LoopT>::getLoopsInPreorder() {
  568   SmallVector<LoopT *, 4> PreOrderLoops, PreOrderWorklist;
  584 SmallVector<LoopT *, 4>
  586   SmallVector<LoopT *, 4> PreOrderLoops, PreOrderWorklist;

 1001   using MemoryAccessSet = SmallVector<MemoryAccess *, 8>;

   76   SmallVector<WeakVH, 16> InsertedPHIs;

   49   SmallVector<Instruction*, 4> InstInputs;

  111   void processPhi(const PHINode *PN, SmallVector<const PHINode *, 8> &Stack);

  138   SmallVector<UseToVisit, 8> Worklist;

  131   SmallVector<BlockT *, 8> ExitingBlocks;

  400       DenseMap<const SCEV *, SmallVector<const SCEVPredicate *, 4>>;
  403   SmallVector<const SCEVPredicate *, 16> Preds;
  523     SmallVector<const SCEV *, 2> Ops = {LHS, RHS};
  529     SmallVector<const SCEV *, 3> Ops = {Op0, Op1, Op2};
  538     SmallVector<const SCEV *, 2> Ops = {LHS, RHS};
  544     SmallVector<const SCEV *, 3> Ops = {Op0, Op1, Op2};
  556     SmallVector<const SCEV *, 4> NewOp(Operands.begin(), Operands.end());
  564   Optional<std::pair<const SCEV *, SmallVector<const SCEVPredicate *, 3>>>
 1271     SmallVector<ExitNotTakenInfo, 1> ExitNotTaken;
 1373   DenseMap<const SCEV *, SmallVector<std::pair<const Loop *, const SCEV *>, 2>>
 1378            SmallVector<PointerIntPair<const Loop *, 2, LoopDisposition>, 2>>
 1414       SmallVector<PointerIntPair<const BasicBlock *, 2, BlockDisposition>, 2>>
 1824   Optional<std::pair<const SCEV *, SmallVector<const SCEVPredicate *, 3>>>
 1898   DenseMap<const Loop *, SmallVector<const SCEV *, 4>> LoopUsers;
 1903            std::pair<const SCEV *, SmallVector<const SCEVPredicate *, 3>>>

  135     SmallVector<SCEVInsertPointGuard *, 8> InsertPointGuards;

  563     SmallVector<const SCEV *, 8> Worklist;
  698       SmallVector<const SCEV *, 2> Operands;
  708       SmallVector<const SCEV *, 2> Operands;
  725       SmallVector<const SCEV *, 2> Operands;
  737       SmallVector<const SCEV *, 2> Operands;
  747       SmallVector<const SCEV *, 2> Operands;
  757       SmallVector<const SCEV *, 2> Operands;
  767       SmallVector<const SCEV *, 2> Operands;
  834       SmallVector<const SCEV *, 2> Operands;

  124   SmallVector<Value *, 64> ValueWorkList;
  127   SmallVector<BasicBlock *, 64> BBWorkList;
  371   SmallVector<bool, 16> SuccFeasible;
  385   SmallVector<bool, 16> SuccFeasible;

  328     SmallVector<const Value *, 4> Operands(U->value_op_begin(),
  679     SmallVector<unsigned, 8> LoadSizes;

  709       SmallVector<Type *, 8> ParamTys(FTy->param_begin(), FTy->param_end());
  838     SmallVector<Type *, 8> ParamTys;
  872       SmallVector<const Value *, 8> Arguments(CS.arg_begin(), CS.arg_end());
  888     SmallVector<const Value *, 4> Operands(I->value_op_begin(),

   83   SmallVector<VFParameter, 8> Parameters; // List of parameter informations.

  355   SmallVector<ValType, 1> Returns;
  356   SmallVector<ValType, 4> Params;
  360   WasmSignature(SmallVector<ValType, 1> &&InReturns,
  361                 SmallVector<ValType, 4> &&InParams)

  168   SmallVector<BitCodeAbbrevOp, 32> OperandList;

  355   SmallVector<Block, 8> BlockScope;

  512     SmallVector<unsigned, 2> V;

  162   SmallVector<HandlerInfo, 1> Handlers;
  272   SmallVector<XRayFunctionEntry, 4> Sleds;

 1070       SmallVector<Type *, 4> Types;
 1173     SmallVector<unsigned, 2> ISDs;
 1187       SmallVector<Type *, 4> ScalarTys;
 1463     SmallVector<unsigned, 2> LegalCost;
 1464     SmallVector<unsigned, 2> CustomCost;
 1511       SmallVector<Type *, 4> ScalarTys;

  203   SmallVector<uint32_t, 16> UsedRegs;
  204   SmallVector<CCValAssign, 4> PendingLocs;
  205   SmallVector<ISD::ArgFlagsTy, 4> PendingArgFlags;
  251   SmallVector<ByValInfo, 4 > ByValRegs;
  549     SmallVector<T, 16> SecPassArg;
  560     SmallVector<CCValAssign, 16> TmpArgLocs;

   93   SmallVector<DIEAbbrevData, 12> Data;

   74   using Entries = SmallVector<Entry, 4>;

   37   SmallVector<int64_t, 1> LoadChain;

   34   SmallVector<SmallVector<unsigned, 8>, 4> Blocks;
   34   SmallVector<SmallVector<unsigned, 8>, 4> Blocks;

   67   SmallVector<MachineInstr *, 8> Instrs;
  109   SmallVector<DomainValue *, 16> Avail;
  115   std::vector<SmallVector<int, 1>> AliasMap;
  124   using OutRegsInfoMap = SmallVector<LiveRegsDVInfo, 4>;

   94     SmallVector<Value *, 16> OutVals;
   95     SmallVector<ISD::ArgFlagsTy, 16> OutFlags;
   96     SmallVector<Register, 16> OutRegs;
   97     SmallVector<ISD::InputArg, 4> Ins;
   98     SmallVector<Register, 4> InRegs;

  135   SmallVector<MachineInstr*, 8> ArgDbgValues;
  150   SmallVector<unsigned, 50> StatepointStackSlots;

  154   SmallVector<std::unique_ptr<GCStrategy>, 1> GCStrategyList;
  181   using iterator = SmallVector<std::unique_ptr<GCStrategy>, 1>::const_iterator;

   47     SmallVector<Register, 4> Regs;
   51     SmallVector<Register, 2> OrigRegs;
   53     SmallVector<ISD::ArgFlagsTy, 4> Flags;
   83     SmallVector<ArgInfo, 8> OrigArgs;

   67   SmallVector<GISelChangeObserver *, 4> Observers;

   32   SmallVector<MachineInstr *, N> Worklist;

   74     using VRegListT = SmallVector<Register, 1>;
   75     using OffsetListT = SmallVector<uint64_t, 1>;
  158   DenseMap<CFGEdge, SmallVector<MachineBasicBlock *, 1>> MachinePreds;
  162   SmallVector<std::pair<const PHINode *, SmallVector<MachineInstr *, 1>>, 4>
  162   SmallVector<std::pair<const PHINode *, SmallVector<MachineInstr *, 1>>, 4>
  599   SmallVector<MachineBasicBlock *, 1> getMachinePredBBs(CFGEdge Edge) {

  404       Optional<SmallVector<std::function<void(MachineInstrBuilder &)>, 4>>;
  405   using RecordedMIVector = SmallVector<MachineInstr *, 4>;
  406   using NewMIVector = SmallVector<MachineInstrBuilder, 4>;

   58   SmallVector<uint64_t, 4> OnFailResumeAt;

  291         SmallVector<Register, 2> DstRegs;
  297           SmallVector<Register, 2> TmpRegs;
  328         SmallVector<Register, 2> Regs;

  322   SmallVector<LegalizeRule, 2> Rules;
 1189     SmallVector<SizeAndActionsVec, 1> &Actions = ScalarActions[OpcodeIdx];
 1199     SmallVector<SizeAndActionsVec, 1> &Actions =
 1212     SmallVector<SizeAndActionsVec, 1> &Actions =
 1228     SmallVector<SizeAndActionsVec, 1> &Actions =
 1295                   SmallVector<SizeAndActionsVec, 1> &Actions,
 1329   SmallVector<TypeMap, 1> SpecifiedActions[LastOp - FirstOp + 1];
 1330   SmallVector<SizeChangeStrategy, 1>
 1332   SmallVector<SizeChangeStrategy, 1>
 1337   SmallVector<SizeAndActionsVec, 1> ScalarActions[LastOp - FirstOp + 1];
 1338   SmallVector<SizeAndActionsVec, 1> ScalarInVectorActions[LastOp - FirstOp + 1];
 1339   std::unordered_map<uint16_t, SmallVector<SizeAndActionsVec, 1>>
 1341   std::unordered_map<uint16_t, SmallVector<SizeAndActionsVec, 1>>

  329     using InsertionPoints = SmallVector<std::unique_ptr<InsertPoint>, 2>;

  274   using InstructionMappings = SmallVector<const InstructionMapping *, 4>;
  282     SmallVector<int, 8> OpToNewVRegIdx;
  285     SmallVector<Register, 8> NewVRegs;

  127   SmallVector<LexicalScope *, 4> Children;     // Scopes defined in scope.
  129   SmallVector<InsnRange, 4> Ranges;
  248   SmallVector<LexicalScope *, 4> AbstractScopesList;

  199     using Segments = SmallVector<Segment, 2>;
  200     using VNInfoList = SmallVector<VNInfo *, 2>;
  907     SmallVector<LiveRange::Segment, 16> Spills;

  114     SmallVector<LiveInterval*,4> InterferingVRegs;

   72     SmallVector<SlotIndex, 8> RegMaskSlots;
   85     SmallVector<const uint32_t*, 8> RegMaskBits;
   92     SmallVector<std::pair<unsigned, unsigned>, 8> RegMaskBlocks;
   96     SmallVector<LiveRange*, 0> RegUnitRanges;
  474     using ShrinkToUsesWorkList = SmallVector<std::pair<SlotIndex, VNInfo*>, 16>;

  124   SmallVector<LiveInBlock, 16> LiveIn;

  108   using ToShrinkSet = SetVector<LiveInterval *, SmallVector<LiveInterval *, 8>,

  142   std::vector<SmallVector<unsigned, 4>> PHIVarInfo;

   82   using MBBInfoMap = SmallVector<MBBInfo, 4>;
  105   typedef SmallVector<TraversedMBBInfo, 4> TraversalOrder;

   60   mutable SmallVector<CriticalEdge, 32> CriticalEdgesToSplit;

  300   SmallVector<std::pair<int, int64_t>, 32> LocalFrameObjects;

  213   SmallVector<MCSymbol *, 1> BeginLabels;  // Labels prior to invoke.
  214   SmallVector<MCSymbol *, 1> EndLabels;    // Labels after invoke.
  215   SmallVector<SEHHandler, 1> SEHHandlers;  // SEH handlers active at this lpad.
  318   DenseMap<MCSymbol*, SmallVector<unsigned, 4>> LPadToCallSiteMap;
  394   using CallSiteInfo = SmallVector<ArgRegPair, 1>;
  421   using VariableDbgInfoMapTy = SmallVector<VariableDbgInfo, 4>;

   78     SmallVector<MachineOperand, 4> BrCond;
  143   using NodeSetType = SmallVector<NodeSet, 8>;
  163     SmallVector<SmallPtrSet<SUnit *, 4>, 10> B;
  164     SmallVector<SmallVector<int, 4>, 16> AdjK;
  164     SmallVector<SmallVector<int, 4>, 16> AdjK;
  437   llvm::SmallVector<uint64_t, DefaultProcResSize> ProcResourceMasks;
  439   llvm::SmallVector<uint64_t, DefaultProcResSize> ProcResourceCount;

   92   SmallVector<MCPhysReg, 16> UpdatedCSRs;
  101   IndexedMap<std::pair<unsigned, SmallVector<unsigned, 4>>,
  810   const std::pair<unsigned, SmallVector<unsigned, 4>>

  586   SmallVector<unsigned, 16> RemainingCounts;
  655   SmallVector<unsigned, 16> ExecutedResCounts;
  668   SmallVector<unsigned, 16> ReservedCycles;
  672   SmallVector<unsigned, 16> ReservedCyclesIndex;
 1014   SmallVector<SUnit*, 8> BotRoots;

  234     SmallVector<LiveInReg, 4> LiveIns;
  324     SmallVector<TraceBlockInfo, 4> BlockInfo;
  326     SmallVector<unsigned, 0> ProcResourceDepths;
  327     SmallVector<unsigned, 0> ProcResourceHeights;
  401   SmallVector<FixedBlockInfo, 4> BlockInfo;
  408   SmallVector<unsigned, 0> ProcResourceCycles;

  286   SmallVector<MachineBasicBlock *, 4> Prologs, Epilogs;

   50   using OutRegsInfoMap = SmallVector<LiveRegsDefInfo, 4>;
   62   using MBBRegUnitDefs = SmallVector<int, 1>;
   66   using MBBReachingDefsInfo = SmallVector<MBBDefsInfo, 4>;

   62   SmallVector<MCPhysReg, 4> CalleeSavedAliases;

   53   SmallVector<RegisterMaskPair,8> LiveInRegs;
   54   SmallVector<RegisterMaskPair,8> LiveOutRegs;
  170   SmallVector<RegisterMaskPair, 8> Uses;
  173   SmallVector<RegisterMaskPair, 8> Defs;
  176   SmallVector<RegisterMaskPair, 8> DeadDefs;

   61   SmallVector<ScavengedInfo, 2> Scavenged;

  256     SmallVector<SDep, 4> Preds;  ///< All sunit predecessors.
  257     SmallVector<SDep, 4> Succs;  ///< All sunit successors.
  698     SmallVector<std::pair<SUnit *, SUnit *>, 16> Updates;

  116   using UnderlyingObjectsVector = SmallVector<UnderlyingObject, 4>;

  105   SmallVector<TreeData, 16> DFSTreeData;
  109   std::vector<SmallVector<Connection, 4>> SubtreeConnections;

  149   SmallVector<SDDbgValue*, 32> DbgValues;
  150   SmallVector<SDDbgValue*, 32> ByvalParmDbgValues;
  151   SmallVector<SDDbgLabel*, 4> DbgLabels;
  152   using DbgValMapType = DenseMap<const SDNode *, SmallVector<SDDbgValue *, 2>>;
  778     SmallVector<SDValue, 16> Ops(VT.getVectorNumElements(), Op);
  879     SmallVector<SDValue, 4> Ops;

  884     SmallVector<const SDNode *, 8> DeferredNodes;

  328     SmallVector<std::pair<SlotIndex, SlotIndex>, 8> MBBRanges;
  332     SmallVector<IdxMBBPair, 8> idx2MBBMap;

  238   using LocationVec = SmallVector<Location, 8>;
  239   using LiveOutVec = SmallVector<LiveOutReg, 8>;

   62   using SwiftErrorValues = SmallVector<const Value*, 1>;

  200 using BitTestInfo = SmallVector<BitTestCase, 3>;
  241 using SwitchWorkList = SmallVector<SwitchWorkListItem, 4>;

   48   SmallVector<unsigned, 16> SSAUpdateVRs;

 3460     SmallVector<ISD::OutputArg, 32> Outs;
 3461     SmallVector<SDValue, 32> OutVals;
 3462     SmallVector<ISD::InputArg, 32> Ins;
 3463     SmallVector<SDValue, 4> InVals;

   39   SmallVector<unsigned, 16> ResourceFactors;

   76   SmallVector<WinEHHandlerType, 1> HandlerArray;
   95   SmallVector<CxxUnwindMapEntry, 4> CxxUnwindMap;
   96   SmallVector<WinEHTryBlockMapEntry, 4> TryBlockMap;
   97   SmallVector<SEHUnwindMapEntry, 4> SEHUnwindMap;
   98   SmallVector<ClrEHUnwindMapEntry, 4> ClrEHUnwindMap;

   35   SmallVector<ArrayRef<uint8_t>, 2> SeenRecords;

   68   SmallVector<std::pair<uint32_t, TypeIndex>, 8> Mappings;

  259   SmallVector<RecordLimit, 2> Limits;

   35   SmallVector<uint32_t, 4> SegmentOffsets;

   44   SmallVector<ArrayRef<uint8_t>, 2> SeenRecords;
   47   SmallVector<GloballyHashedType, 2> SeenHashes;

   44   SmallVector<ArrayRef<uint8_t>, 2> SeenRecords;

  692   SmallVector<TypeIndex, MaxArgs> ArgIndices;

   78 using DILineInfoTable = SmallVector<std::pair<uint64_t, DILineInfo>, 16>;
   82   SmallVector<DILineInfo, 4> Frames;

   84   using AttributeSpecVector = SmallVector<AttributeSpec, 8>;

   40     SmallVector<DWARFFormValue, 3> Values;
  100     SmallVector<std::pair<AtomType, Form>, 3> Atoms;
  574   SmallVector<NameIndex, 0> NameIndices;
  588   using const_iterator = SmallVector<NameIndex, 0>::const_iterator;

   36   typedef SmallVector<uint64_t, 2> Operands;

   33     SmallVector<uint8_t, 4> Loc;
   42     SmallVector<Entry, 2> Entries;
   51   using LocationLists = SmallVector<LocationList, 4>;
   84     SmallVector<uint8_t, 4> Loc;
   92     SmallVector<Entry, 2> Entries;
   99   using LocationLists = SmallVector<LocationList, 4>;

   42   using MacroList = SmallVector<Entry, 4>;

   35   SmallVector<CompUnitEntry, 0> CuList;
   42   SmallVector<TypeUnitEntry, 0> TuList;
   49   SmallVector<AddressEntry, 0> AddressArea;
   55   SmallVector<SymTableEntry, 0> SymbolTable;
   58   SmallVector<std::pair<uint32_t, SmallVector<uint32_t, 0>>, 0>
   58   SmallVector<std::pair<uint32_t, SmallVector<uint32_t, 0>>, 0>

  113 class DWARFUnitVector final : public SmallVector<std::unique_ptr<DWARFUnit>, 1> {

   25   using RecordType = SmallVector<uint8_t, 32>;

   89   virtual void getDataBytes(llvm::SmallVector<uint8_t, 32> &bytes) const = 0;

   64   void getDataBytes(SmallVector<uint8_t, 32> &Bytes) const override;

  102   SmallVector<InjectedSourceDescriptor, 2> InjectedSources;

   29   void getDataBytes(llvm::SmallVector<uint8_t, 32> &bytes);

  134   SmallVector<std::unique_ptr<Module>, 1> Modules;
  539   SmallVector<std::string, 4> MAttrs;

   58   using BlockListTy = SmallVector<const BasicBlock *, 8>;
   60       SmallVector<std::pair<const BasicBlock *, const BasicBlock *>, 8>;
   62       SmallVector<std::pair<const BasicBlock *, uint64_t>, 8>;

  169     SmallVector<sys::MemoryBlock, 16> PendingMem;
  170     SmallVector<FreeMemBlock, 16> FreeMem;
  173     SmallVector<sys::MemoryBlock, 16> AllocatedMem;

   91   SmallVector<SourcePred, 2> SourcePreds;

   27   SmallVector<Type *, 16> KnownTypes;

   81   using UpdateMapType = SmallDenseMap<NodePtr, SmallVector<NodePtr, 2>>;
   88   SmallVector<NodePtr, 1> Empty;
  105     SmallVector<cfg::Update<NodePtr>, 4> LegalizedUpdates;

  734     using ParameterEncodingTy = SmallVector<int, 0>;

  462     SmallVector<Constant *, 8> Values({Vs...});

   50     SmallVector<Metadata *, 4> AllEnumTypes;
   52     SmallVector<TrackingMDNodeRef, 4> AllRetainTypes;
   53     SmallVector<Metadata *, 4> AllSubprograms;
   54     SmallVector<Metadata *, 4> AllGVs;
   55     SmallVector<TrackingMDNodeRef, 4> AllImportedModules;
   62     SmallVector<TrackingMDNodeRef, 4> UnresolvedNodes;
   70     DenseMap<MDNode *, SmallVector<TrackingMDNodeRef, 1>> PreservedVariables;
   73     DenseMap<MDNode *, SmallVector<TrackingMDNodeRef, 1>> PreservedLabels;

  140   SmallVector<unsigned char, 8> LegalIntWidths;
  144   using AlignmentsTy = SmallVector<LayoutAlignElem, 16>;
  159   using PointersTy = SmallVector<PointerAlignElem, 8>;
  174   SmallVector<unsigned, 8> NonIntegralAddressSpaces;

  130   SmallVector<DICompileUnit *, 8> CUs;
  131   SmallVector<DISubprogram *, 8> SPs;
  132   SmallVector<DIGlobalVariableExpression *, 8> GVs;
  133   SmallVector<DIType *, 8> TYs;
  134   SmallVector<DIScope *, 8> Scopes;

  274     SmallVector<llvm::Type *, 8> StructFields({elt1, elts...});
  294     SmallVector<llvm::Type *, 8> StructFields({elt1, elts...});
  330     SmallVector<llvm::Type *, 8> StructFields({elt1, elts...});

  517   SmallVector<Argument, 4> Args;

 2532     SmallVector<Value *, 4> IdxList;

 2039   SmallVector<int, 16> getShuffleMask() const {
 2040     SmallVector<int, 16> Mask;
 2071     SmallVector<int, 16> MaskAsInts;
 2092     SmallVector<int, 16> MaskAsInts;
 2129     SmallVector<int, 16> MaskAsInts;
 2153     SmallVector<int, 16> MaskAsInts;
 2173     SmallVector<int, 16> MaskAsInts;
 2223     SmallVector<int, 16> MaskAsInts;
 2245     SmallVector<int, 16> MaskAsInts;
 2293   SmallVector<unsigned, 4> Indices;
 2404   SmallVector<unsigned, 4> Indices;
 3467   Optional<SmallVector<uint32_t, 8> > Weights = None;
 4084   SmallVector<BasicBlock *, 16> getIndirectDests() const {
 4085     SmallVector<BasicBlock *, 16> IndirectDests;

  230   SmallVector<PMDataManager *, 8> PassManagers;
  235   SmallVector<PMDataManager *, 8> IndirectPassManagers;
  247   SmallVector<ImmutablePass *, 16> ImmutablePasses;
  431   SmallVector<Pass *, 16> PassVector;
  454   SmallVector<Pass *, 16> HigherLevelAnalysis;

  360     SmallVector<Type*, sizeof...(ArgsTy)> ArgTys{Args...};

  117   SmallVector<llvm::unique_function<BeforePassFunc>, 4> BeforePassCallbacks;
  118   SmallVector<llvm::unique_function<AfterPassFunc>, 4> AfterPassCallbacks;
  119   SmallVector<llvm::unique_function<AfterPassInvalidatedFunc>, 4>
  121   SmallVector<llvm::unique_function<BeforeAnalysisFunc>, 4>
  123   SmallVector<llvm::unique_function<AfterAnalysisFunc>, 4>

 1178       SmallVector<AnalysisKey *, 4> DeadKeys;

   65   SmallVector<Timer *, 8> TimerStack;

   47     SmallVector<BasicBlock *, 32> PredCache(pred_begin(BB), pred_end(BB));

  114   SmallVector<char, 0> Strtab;

   45   using EntryVecTy = SmallVector<ConstantPoolEntry, 4>;

   32   llvm::SmallVector<MCSection *, 16> SectionOrder;

   26 typedef SmallVector<const MCPaddingFragment *, 8> MCPFRange;

  246   SmallVector<FileInfo, 4> Files;

  215   SmallVector<std::string, 3> MCDwarfDirs;
  216   SmallVector<MCDwarfFile, 3> MCDwarfFiles;

   97   SmallVector<MCDataFragment *, 4> BundleGroups;

  189   SmallVector<char, ContentsSize> Contents;
  210   SmallVector<MCFixup, FixupsSize> Fixups;
  632   SmallVector<std::pair<const MCSymbol *, const MCSymbol *>, 2> Ranges;

  161   SmallVector<MCOperand, 8> Operands;

  106   SmallVector<MCSymbol *, 3> Args;
  141   SmallVector<MCLOHDirective, 32> Directives;

   40   SmallVector<MCSymbol *, 2> PendingLabels;
   48   SmallVector<PendingMCFixup, 2> PendingFixups;

   41   SmallVector<AsmToken, 1> CurTok;

  127   SmallVector<MCPendingError, 0> PendingErrors;

   93   SmallVector<std::pair<unsigned, MCFragment *>, 1> SubsectionFragmentMap;

  215   SmallVector<std::pair<MCSectionSubPair, MCSectionSubPair>, 4> SectionStack;

   53   SmallVector<EncodingInfo, 16> Encodings;

   51   SmallVector<std::unique_ptr<HardwareUnit>, 4> Hardware;

   45   SmallVector<MemoryGroup *, 4> Succ;

   88   SmallVector<RegisterMappingTracker, 4> RegisterFiles;

  347   SmallVector<uint64_t, 8> ProcResID2Mask;
  351   SmallVector<unsigned, 8> ResIndex2ProcResID;

   43   SmallVector<uint64_t, 8> ProcResourceMasks;

  147   SmallVector<std::pair<ReadState *, int>, 4> Users;
  349   SmallVector<WriteDescriptor, 4> Writes; // Implicit writes are at the end.
  350   SmallVector<ReadDescriptor, 4> Reads;   // Implicit reads are at the end.
  354   SmallVector<std::pair<uint64_t, ResourceUsage>, 4> Resources;
  405   SmallVector<WriteState, 4> Defs;
  409   SmallVector<ReadState, 4> Uses;

   57   SmallVector<std::unique_ptr<Stage>, 8> Stages;

   28   SmallVector<std::unique_ptr<Instruction>, 16> Instructions;

   30   SmallVector<std::pair<ResourceRef, ResourceCycles>, 4> UsedResources;
   31   SmallVector<uint64_t, 8> Masks;

   27   SmallVector<InstRef, 8> Buffer;

   80   SmallVector<char, 0> Symtab, Strtab;

  160 Error build(ArrayRef<Module *> Mods, SmallVector<char, 0> &Symtab,
  363   SmallVector<char, 0> Symtab, Strtab;

  111   using NodeList = SmallVector<NodeState, 16>;
  156   SmallVector<SectionInfo, 32> Sections;
  268   using LoadCommandList = SmallVector<LoadCommandInfo, 4>;
  661   using SectionList = SmallVector<const char*, 1>;
  663   using LibraryList = SmallVector<const char*, 1>;
  666   using LibraryShortName = SmallVector<StringRef, 1>;
  667   using BuildToolList = SmallVector<const char*, 1>;

   59   SmallVector<const char *, 2> Values;

  118   using arglist_type = SmallVector<Arg *, 16>;
  439   mutable SmallVector<std::unique_ptr<Arg>, 16> SynthesizedArgs;

   30 using ArgStringList = SmallVector<const char *, 16>;

   51   SmallVector<AnalysisID, 8> Required;
   52   SmallVector<AnalysisID, 2> RequiredTransitive;
   53   SmallVector<AnalysisID, 2> Preserved;
   54   SmallVector<AnalysisID, 0> Used;

  672   SmallVector<std::function<void(FunctionPassManager &, OptimizationLevel)>, 2>
  674   SmallVector<std::function<void(LoopPassManager &, OptimizationLevel)>, 2>
  676   SmallVector<std::function<void(LoopPassManager &, OptimizationLevel)>, 2>
  678   SmallVector<std::function<void(FunctionPassManager &, OptimizationLevel)>, 2>
  680   SmallVector<std::function<void(CGSCCPassManager &, OptimizationLevel)>, 2>
  682   SmallVector<std::function<void(FunctionPassManager &, OptimizationLevel)>, 2>
  684   SmallVector<std::function<void(FunctionPassManager &, OptimizationLevel)>, 2>
  687   SmallVector<std::function<void(ModulePassManager &)>, 2>
  689   SmallVector<std::function<void(ModuleAnalysisManager &)>, 2>
  691   SmallVector<std::function<bool(StringRef, ModulePassManager &,
  695   SmallVector<std::function<bool(ModulePassManager &, ArrayRef<PipelineElement>,
  700   SmallVector<std::function<void(CGSCCAnalysisManager &)>, 2>
  702   SmallVector<std::function<bool(StringRef, CGSCCPassManager &,
  707   SmallVector<std::function<void(FunctionAnalysisManager &)>, 2>
  709   SmallVector<std::function<bool(StringRef, FunctionPassManager &,
  714   SmallVector<std::function<void(LoopAnalysisManager &)>, 2>
  716   SmallVector<std::function<bool(StringRef, LoopPassManager &,
  721   SmallVector<std::function<bool(StringRef Name, AAManager &AA)>, 2>

   52   SmallVector<PrintModuleDesc, 2> ModuleDescStack;

  516   DenseMap<size_t, SmallVector<unsigned, 0>> FilenameHash2RecordIndices;
  669   SmallVector<const CoverageSegment *, 4> Segments;

  260   SmallVector<std::unique_ptr<GCOVFunction>, 16> Functions;
  308   SmallVector<std::unique_ptr<GCOVBlock>, 16> Blocks;
  309   SmallVector<std::unique_ptr<GCOVEdge>, 16> Edges;
  323   using BlockVector = SmallVector<const GCOVBlock *, 4>;
  324   using BlockVectorLists = SmallVector<BlockVector, 4>;
  325   using Edges = SmallVector<GCOVEdge *, 4>;
  384   SmallVector<GCOVEdge *, 16> SrcEdges;
  385   SmallVector<GCOVEdge *, 16> DstEdges;
  386   SmallVector<uint32_t, 16> Lines;
  396   using FunctionVector = SmallVector<const GCOVFunction *, 1>;
  398   using BlockVector = SmallVector<const GCOVBlock *, 4>;
  463   using FileCoverageList = SmallVector<std::pair<std::string, GCOVCoverage>, 4>;

  621   using SamplesWithLocList = SmallVector<const SamplesWithLoc *, 20>;

  667 using InlineCallStack = SmallVector<FunctionSamples *, 10>;

  164   SmallVector<SecHdrTableEntry, 8> SectionHdrLayout;

   75   SmallVector<Argument, 8> TmpArgs;

   52   SmallVector<char, 1024> Encoded;
   54   SmallVector<uint64_t, 64> R;

   90   SmallVector<Argument, 5> Args;

  375   SmallVector<void *, 4> Slabs;
  378   SmallVector<std::pair<void *, size_t>, 0> CustomSizedSlabs;

   39   SmallVector<FreeList*, 8> Bucket;

   41 using NfaPath = SmallVector<uint64_t, 4>;
   82   SmallVector<NfaPath, 4> Paths;

  235   SmallVector<Option *, 4> PositionalOpts;
  236   SmallVector<Option *, 4> SinkOpts;
  286   SmallVector<OptionCategory *, 1>
  637   SmallVector<OptionEnumValue, 4> Values;
  773   SmallVector<OptionInfo, 8> Values;

  987   SmallVector<std::string, 2> Errors;

  152     SmallVector<DomTreeNodeBase *, 64> WorkStack = {this};
  240   SmallVector<NodeT *, IsPostDom ? 4 : 1> Roots;
  356     SmallVector<const DomTreeNodeBase<NodeT> *, 8> WL;
  689     SmallVector<std::pair<const DomTreeNodeBase<NodeT> *,

   67     SmallVector<NodePtr, 2> ReverseChildren;
   78     SmallVector<UpdateT, 4> Updates;
   88     DenseMap<NodePtr, SmallVector<NodePtrAndKind, 4>> FutureSuccessors;
   89     DenseMap<NodePtr, SmallVector<NodePtrAndKind, 4>> FuturePredecessors;
  110     using ResultTy = SmallVector<NodePtr, 8>;
  222     SmallVector<NodePtr, 64> WorkList = {V};
  314     SmallVector<InfoRec *, 32> EvalStack;
  639     std::priority_queue<TreeNodePtr, SmallVector<TreeNodePtr, 8>,
  643     SmallVector<TreeNodePtr, 8> Affected;
  645     SmallVector<TreeNodePtr, 8> VisitedUnaffected;
  774     SmallVector<TreeNodePtr, 8> UnaffectedOnCurrentLevel;
  874     SmallVector<std::pair<NodePtr, TreeNodePtr>, 8> DiscoveredEdgesToReachable;
 1056     SmallVector<NodePtr, 16> AffectedQueue;
 1413       SmallVector<TreeNodePtr, 8> Children(Node->begin(), Node->end());

   41   using ChildrenTy = SmallVector<NodeRef, 8>;
  140       std::priority_queue<DomTreeNodePair, SmallVector<DomTreeNodePair, 32>,
  152   SmallVector<DomTreeNodeBase<NodeTy> *, 32> Worklist;

   43   SmallVector<const char *, 0> Args;

  832   llvm::SmallVector<State, 16> Stack; // Never empty.

   76     llvm::SmallVector<char, 32> Str;

  119     typedef SmallVector<FlagEntry, 10> FlagVector;

   59   SmallVector<char, 0> SV;

  270   SmallVector<SMFixIt, 4> FixIts;

   64   std::unordered_map<unsigned, SmallVector<size_t, 4>> Index{256};

  322   using FileSystemList = SmallVector<IntrusiveRefCntPtr<FileSystem>, 1>;

 1494     SmallVector<std::string, 6> ValidKeys;
 1617   SmallVector<InState, 8> StateStack;
 1906 struct SequenceTraits<SmallVector<T, N>,
 1909     : SequenceTraitsImpl<SmallVector<T, N>, SequenceElementTraits<T>::flow> {};

  575   SmallVector<char, 0> Buffer;

 1433   SmallVector<SMLoc, 4> Locs;
 1434   SmallVector<Init *, 0> TemplateArgs;
 1435   SmallVector<RecordVal, 0> Values;
 1439   SmallVector<std::pair<Record *, SMRange>, 0> SuperClasses;
 1787     SmallVector<std::pair< bool, StringRef>, 4> Parts;
 1920   SmallVector<Init *, 4> Stack;

   81   llvm::StringMap<llvm::SmallVector<size_t, 1>> Points;
   82   llvm::StringMap<llvm::SmallVector<Range, 1>> Ranges;

   56 using TargetList = SmallVector<Target, 5>;

  186 createBlockExtractorPass(const SmallVectorImpl<SmallVector<BasicBlock *, 16>>

  552   SmallVector<IRPosition, 4> IRPositions;
  615   using OpcodeInstMapTy = DenseMap<unsigned, SmallVector<Instruction *, 32>>;
  975   using AAVector = SmallVector<AbstractAttribute *, 64>;
 1369     SmallVector<Attribute, 4> DeducedAttrs;

  118   using UseVector = SmallVector<RetOrArg, 5>;

   31 using BlockSequence = SmallVector<BasicBlock *, 0>;

   62   SmallVector<uint64_t, 16> Offsets;

   27   SmallVector<Instruction*, 256> Worklist;

   77 using ConstantUseListType = SmallVector<ConstantUser, 8>;
  110 using RebasedConstantListType = SmallVector<RebasedConstantInfo, 4>;
  164   using ConstInfoVecType = SmallVector<consthoist::ConstantInfo, 8>;

  182   SmallVector<Instruction *, 8> InstrsToErase;
  193   using LoadDepVect = SmallVector<NonLocalDepResult, 64>;
  194   using AvailValInBlkVect = SmallVector<gvn::AvailableValueInBlock, 64>;
  195   using UnavailBlkVect = SmallVector<BasicBlock *, 64>;
  248   SmallVector<std::pair<Instruction *, unsigned>, 4> toSplit;

   54 using PredValueInfoTy = SmallVector<std::pair<Constant *, BasicBlock *>, 8>;

  117   SmallVector<Loop *, 4> PreOrderLoops, PreOrderWorklist;

  183   DenseMap<const SCEV *, SmallVector<WeakTrackingVH, 2>> SeenExprs;

   76   SetVector<AllocaInst *, SmallVector<AllocaInst *, 16>> Worklist;
   81   SetVector<Instruction *, SmallVector<Instruction *, 8>> DeadInsts;
   91   SetVector<AllocaInst *, SmallVector<AllocaInst *, 16>> PostPromotionWorklist;
  101   SetVector<PHINode *, SmallVector<PHINode *, 2>> SpeculatablePHIs;
  109   SetVector<SelectInst *, SmallVector<SelectInst *, 2>> SpeculatableSelects;

   66 SmallVector<uint8_t, 64>
   73 SmallVector<uint8_t, 64> GetShadowBytesAfterScope(

  193   SmallVector<AllocaInst *, 4> StaticAllocas;
  197   SmallVector<WeakTrackingVH, 8> InlinedCalls;
  204   SmallVector<CallSite, 8> InlinedCallSites;

   48   SmallVector<AllocaInst *, 16> Allocas;

   78                                     SmallVector<Constant *, 8> &Formals);
   83                        SmallVector<Constant *, 8> &Formals);
  106   SmallVector<Function*, 4> CallStack;
  116   SmallVector<std::unique_ptr<GlobalVariable>, 32> AllocaTmps;

   53     llvm::SmallVector<InlineGraphNode *, 8> InlinedCallees;

  169 SmallVector<DomTreeNode *, 16> collectChildrenInLoop(DomTreeNode *N,
  173 SmallVector<Instruction *, 8> findDefsUsedOutsideOfLoop(Loop *L);

   75       SmallVector<RuntimePointerChecking::PointerCheck, 4> Checks);
  125   SmallVector<RuntimePointerChecking::PointerCheck, 4> AliasChecks;

   31                      const llvm::SmallVector<uint32_t, 4> &Weights,

  206     SmallVector<PredicateBase *, 4> Infos;
  207     SmallVector<PredicateBase *, 4> UninsertedInfos;
  257   SmallVector<ValueInfo, 32> ValueInfos;

   43     SmallVector<Use *, 4> Uses;
   49   SmallVector<RewriteInfo, 4> Rewrites;

   94     SmallVector<BBInfo *, 100> BlockList;
  116     SmallVector<BBInfo *, 10> RootList;
  117     SmallVector<BBInfo *, 64> WorkList;
  126     SmallVector<BlkT *, 10> Preds;
  405     SmallVector<PhiT *, 20> WorkList;

   60   using StoreList = SmallVector<StoreInst *, 8>;
   62   using GEPList = SmallVector<GetElementPtrInst *, 8>;

  131   SmallVector<TrieNode *, 4> Roots;

  192   SmallVector<ExternalRelation, 8> RetParamRelations;
  195   SmallVector<ExternalAttribute, 8> RetParamAttributes;

   43 SmallVector<WeakTrackingVH, 1> &
  114   SmallVector<Value *, 16> Affected;
  125   SmallVector<Value *, 16> Affected;

  658   SmallVector<const Value *, 16> Worklist;
 1127   SmallVector<Value *, 8> IntermediateIndices;
 1637   SmallVector<Value *, 4> V1Srcs;

  217   SmallVector<unsigned, 4> UnreachableEdges;
  218   SmallVector<unsigned, 4> ReachableEdges;
  276   SmallVector<uint32_t, 2> Weights;
  277   SmallVector<unsigned, 2> UnreachableIdxs;
  278   SmallVector<unsigned, 2> ReachableIdxs;
  318   SmallVector<BranchProbability, 2> BP;
  364   SmallVector<unsigned, 4> ColdEdges;
  365   SmallVector<unsigned, 4> NormalEdges;
  509   SmallVector<BinaryOperator *, 1> InstChain;
  525   SmallVector<PHINode*, 8> WorkList;
  589   SmallVector<unsigned, 8> BackEdges;
  590   SmallVector<unsigned, 8> ExitingEdges;
  591   SmallVector<unsigned, 8> InEdges; // Edges from header to the loop.
  592   SmallVector<unsigned, 8> UnlikelyEdges;

   34   SmallVector<std::pair<const BasicBlock*, succ_const_iterator>, 8> VisitStack;
  211   SmallVector<BasicBlock*, 32> Worklist;
  225   SmallVector<BasicBlock*, 32> Worklist;

  266   SmallVector<Record, 4> FromRecords, ToRecords;

  170   SmallVector<Value *, 4> ReturnedValues;
  435       SmallVector<Function *, 4> Targets;
  652   const SmallVector<Value *, 4> &getReturnValues() const {

  441   SmallVector<Constant *, 16> Worklist;
  504   SmallVector<Node *, 4> DeadTargets;

   92   SmallVector<CallGraphNode *, 16> Nodes;

  118         SmallVector<BasicBlock*, 32> Worklist;
  230   SmallVector<const Use *, DefaultMaxUsesToExplore> Worklist;

   74   SmallVector<const Value *, 16> Worklist;
   98   SmallVector<const Value *, 16> Worklist;

  202   SmallVector<Constant*, 32> Result;
  771   SmallVector<Constant*, 32> NewIdxs;
  879     SmallVector<Value *, 4> NestedOps(GEP->op_begin() + 1, GEP->op_end());
  919   SmallVector<Constant *, 32> NewIdxs;
 1082   SmallVector<Constant *, 8> Ops;
 1156   SmallVector<Constant *, 8> Ops;
 2396   SmallVector<Constant *, 4> Result(VTy->getNumElements());
 2397   SmallVector<Constant *, 4> Lane(Operands.size());
 2407     SmallVector<Constant *, 32> NewElements;

  133 using BasicBlockListType = SmallVector<BasicBlock *, 8>;

   99       SmallVector<const SCEV *, 3> Subscripts, Sizes;

 3301   SmallVector<const SCEV *, 4> Terms;
 3306   SmallVector<const SCEV *, 4> Sizes;
 3310   SmallVector<const SCEV *, 4> SrcSubscripts, DstSubscripts;
 3451   SmallVector<Subscript, 2> Pair(Pairs);
 3632     SmallVector<Constraint, 4> Constraints(MaxLevels + 1);
 3641       SmallVector<Subscript *, 4> PairsInGroup;
 3854   SmallVector<Subscript, 2> Pair(Pairs);
 3948     SmallVector<Constraint, 4> Constraints(MaxLevels + 1);

   31 using InstructionListType = SmallVector<Instruction *, 2>;

  193   SmallVector<BasicBlock *, 8> TaintStack;

  255   SmallVector<DominatorTree::UpdateType, 8> DeduplicatedUpdates;

   78   SmallVector<std::pair<BasicBlock *, BasicBlock *>, 16> Worklist;

  632   SmallVector<const Value *, 8> Inputs;
  718   SmallVector<const Value *, 8> Inputs;
  901     SmallVector<const Value*, 4> Objects;

  165   SmallVector<Instruction *, 8> Worklist;
  234   SmallVector<Instruction *, 8> Worklist;
  337     SmallVector<Instruction *, 8> NonPHIs;
  338     SmallVector<Instruction *, 8> PHIs;
 1021     SmallVector<Instruction *, 2> Casts;

  421   SmallVector<Value *, 4> Operands;
  615   SmallVector<Constant *, 2> COps;
 1212   SmallVector<Constant *, 4> ConstantArgs;
 1708     SmallVector<BasicBlock *, 4> NewDead;
 1822   typedef SetVector<BasicBlock *, SmallVector<BasicBlock *, 16>,

 2431     SmallVector<const Value *, 8> LHSUObjs, RHSUObjs;
 3442         SmallVector<Value *, 4> IndicesLHS(GLHS->idx_begin(), GLHS->idx_end());
 3446         SmallVector<Value *, 4> IndicesRHS(GRHS->idx_begin(), GRHS->idx_end());
 3721       SmallVector<Value *, 8> NewOps(GEP->getNumOperands());
 3735     SmallVector<Constant *, 8> ConstOps;
 4376   SmallVector<int, 32> Indices;
 5222   SmallVector<Constant *, 4> ConstantArgs;
 5334     SmallVector<Value *, 8> Ops(I->op_begin(), I->op_end());

   80   SmallVector<Constant *, 16> Worklist;
  190   SmallVector<Constant *, 16> Worklist;
  271   SmallVector<const SCC *, 16> Worklist = {this};
  372   SmallVector<const RefSCC *, 4> Worklist;
  533   SmallVector<SCC *, 1> DeletedSCCs;
  599     SmallVector<SCC *, 4> Worklist;
  737   SmallVector<std::pair<Node *, EdgeSequence::call_iterator>, 16> DFSStack;
  738   SmallVector<Node *, 16> PendingSCCStack;
  739   SmallVector<SCC *, 4> NewSCCs;
  742   SmallVector<Node *, 16> Worklist;
  964 SmallVector<LazyCallGraph::RefSCC *, 1>
  974   SmallVector<RefSCC *, 1> DeletedRefSCCs;
 1019     SmallVector<RefSCC *, 4> Worklist;
 1055   SmallVector<SCC *, 16> MergedSCCs;
 1127 SmallVector<LazyCallGraph::RefSCC *, 1>
 1131   SmallVector<RefSCC *, 1> Result;
 1179   SmallVector<Node *, 8> Worklist;
 1192   SmallVector<std::pair<Node *, EdgeSequence::iterator>, 4> DFSStack;
 1193   SmallVector<Node *, 4> PendingRefSCCStack;
 1577   SmallVector<std::pair<Node *, EdgeItT>, 16> DFSStack;
 1578   SmallVector<Node *, 16> PendingSCCStack;
 1707   SmallVector<Node *, 16> Roots;

  308   SmallVector<Value *, 4> ValsToClear(I->second.begin(), I->second.end());
  384     SmallVector<std::pair<BasicBlock*, Value*>, 8> BlockValueStack;
  510   SmallVector<std::pair<BasicBlock *, Value *>, 8> StartingStack(

  233 SmallVector<RuntimePointerChecking::PointerCheck, 4>
  235   SmallVector<PointerCheck, 4> Checks;
  380     SmallVector<CheckingPtrGroup, 2> Groups;
  500   typedef SmallVector<MemAccessInfo, 8> MemAccessInfoList;
  720     SmallVector<MemAccessInfo, 4> Retries;
  906           typedef SmallVector<const Value *, 16> ValueVector;
 1106   SmallVector<std::pair<int64_t, Value *>, 4> OffValPairs;
 1711 SmallVector<Instruction *, 4>
 1716   SmallVector<Instruction *, 4> Insts;
 1795   SmallVector<LoadInst *, 16> Loads;
 1796   SmallVector<StoreInst *, 16> Stores;
 2183 static SmallVector<std::pair<PointerBounds, PointerBounds>, 4> expandBounds(
 2187   SmallVector<std::pair<PointerBounds, PointerBounds>, 4> ChecksWithBounds;

   37   SmallVector<Loop *, 4> PreOrderLoops = LI->getLoopsInReverseSiblingPreorder();

  493   SmallVector<BasicBlock *, 4> LatchesBlocks;
  519   SmallVector<BasicBlock *, 4> LoopLatches;
  964   SmallVector<BasicBlock *, 8> ExitBlocks;
 1015   SmallVector<Metadata *, 4> MDs;

  117       SmallVector<NonLocalDepResult, 4> NLDI;

   22     SmallVector<Value *, 4> Deref;

  374   SmallVector<const Value *, 8> LoadOperandsQueue;
  795   SmallVector<BasicBlock *, 32> DirtyBlocks;
 1217   SmallVector<BasicBlock *, 32> Worklist;
 1221   SmallVector<std::pair<BasicBlock *, PHITransAddr>, 16> PredList;
 1281       SmallVector<BasicBlock *, 16> NewBlocks;
 1576   SmallVector<std::pair<Instruction *, Instruction *>, 8> ReverseDepsToAdd;
 1655     SmallVector<std::pair<Instruction *, ValueIsLoadPair>, 8>

  413   SmallVector<ConstMemoryAccessPair, 8> Worklist;
  521   SmallVector<DefPath, 32> Paths;
  740     SmallVector<TerminatedPath, 4> OtherClobbers;
  774     SmallVector<ListIndex, 16> PausedSearches;
  775     SmallVector<ListIndex, 8> NewPaused;
  776     SmallVector<TerminatedPath, 4> TerminatedPaths;
  860       SmallVector<TerminatedPath, 4> Clobbers;
 1142   SmallVector<RenamePassData, 32> WorkStack;
 1479   SmallVector<MemoryAccess *, 16> VersionStack;
 1496   SmallVector<BasicBlock *, 32> IDFBlocks;
 1967   SmallVector<MemoryAccess *, 32> ActualAccesses;
 1968   SmallVector<MemoryAccess *, 32> ActualDefs;

   73     SmallVector<TrackingVH<MemoryAccess>, 8> PhiOps;
  194   SmallVector<TrackingVH<Value>, 8> Uses;
  342   SmallVector<WeakVH, 8> FixupList(InsertedPHIs.begin(), InsertedPHIs.end());
  375     SmallVector<BasicBlock *, 32> IDFBlocks;
  378     SmallVector<AssertingVH<MemoryPhi>, 4> NewInsertedPHIs;
  454   SmallVector<const BasicBlock *, 16> Worklist;
  749   SmallVector<CFGUpdate, 4> Updates;
  784   SmallVector<CFGUpdate, 4> RevDeleteUpdates;
  785   SmallVector<CFGUpdate, 4> InsertUpdates;
  955   SmallVector<BasicBlock *, 16> BlocksWithDefsToReplace;
  956   SmallVector<WeakVH, 8> InsertedPhis;
 1047   SmallVector<BasicBlock *, 8> BlocksToProcess;
 1053   SmallVector<BasicBlock *, 32> IDFBlocks;
 1327     SmallVector<WeakVH, 16> PhisToOptimize{PhisToCheck.begin(),
 1386   SmallVector<WeakVH, 16> UpdatedPHIs;
 1401   SmallVector<WeakVH, 16> UpdatedPHIs;

   92   SmallVector<const User *, 32> Worklist;
  189     SmallVector<DevirtCallSite, 4> DevirtCalls;
  190     SmallVector<CallInst *, 4> Assumes;
  206     SmallVector<DevirtCallSite, 4> DevirtCalls;
  207     SmallVector<Instruction *, 4> LoadedPtrs;
  208     SmallVector<Instruction *, 4> Preds;
  755   SmallVector<MDNode *, 2> Types;

  164   SmallVector<const BasicBlock *, 4> WorkList;
  383   DenseMap<const Value*, SmallVector<Loop*, 4> > MustExec;

   94   SmallVector<Instruction*, 8> Tmp(InstInputs.begin(), InstInputs.end());
  215     SmallVector<Value*, 8> GEPOps;
  397     SmallVector<Value*, 8> GEPOps;

   50                            SmallVector<const PHINode *, 8> &Stack) {
  115     SmallVector<const PHINode *, 8> Stack;
  125   SmallVector<unsigned int, 8> InvalidComponents;

  990     SmallVector<const SCEV *, 2> Qs, Rs;
 1016     SmallVector<const SCEV *, 2> Qs;
 1300     SmallVector<const SCEV *, 4> Operands;
 1326     SmallVector<const SCEV *, 4> Operands;
 1454   SmallVector<const SCEV *, 4> DiffOps;
 1867       SmallVector<const SCEV *, 4> Ops;
 1900       SmallVector<const SCEV *, 4> Ops;
 1999       SmallVector<const SCEV *, 4> Ops;
 2230     SmallVector<const SCEV *, 4> Ops;
 2303         SmallVector<const SCEV *, 4> MulOps(Mul->op_begin()+1, Mul->op_end());
 2494     SmallVector<const SCEV *, 8> LargeOps;
 2508         SmallVector<const SCEV *, 8> LargeMulOps;
 2574     SmallVector<const SCEV *, 8> NewOps;
 2588       std::map<APInt, SmallVector<const SCEV *, 4>, APIntCompare> MulOpLists;
 2625             SmallVector<const SCEV *, 4> MulOps(Mul->op_begin(),
 2630           SmallVector<const SCEV *, 2> TwoOps = {getOne(Ty), InnerMul};
 2659               SmallVector<const SCEV *, 4> MulOps(Mul->op_begin(),
 2666               SmallVector<const SCEV *, 4> MulOps(OtherMul->op_begin(),
 2671             SmallVector<const SCEV *, 2> TwoOps = {InnerMul1, InnerMul2};
 2696     SmallVector<const SCEV *, 8> LIOps;
 2711       SmallVector<const SCEV *, 4> AddRecOps(AddRec->op_begin(),
 2750         SmallVector<const SCEV *, 4> AddRecOps(AddRec->op_begin(),
 2763               SmallVector<const SCEV *, 2> TwoOps = {
 2973           SmallVector<const SCEV *, 4> NewOps;
 2985           SmallVector<const SCEV *, 4> Operands;
 3034     SmallVector<const SCEV *, 8> LIOps;
 3047       SmallVector<const SCEV *, 4> NewOps;
 3107       SmallVector<const SCEV*, 7> AddRecOps;
 3110         SmallVector <const SCEV *, 7> SumOps;
 3223             SmallVector<const SCEV *, 4> Operands;
 3246         SmallVector<const SCEV *, 4> Operands;
 3279         SmallVector<const SCEV *, 4> Operands;
 3352         SmallVector<const SCEV *, 2> Operands;
 3366         SmallVector<const SCEV *, 2> Operands;
 3380       SmallVector<const SCEV *, 2> Operands;
 3395   SmallVector<const SCEV *, 4> Operands;
 3443       SmallVector<const SCEV *, 4> NestedOperands(NestedAR->op_begin(),
 3682   SmallVector<const SCEV *, 2> Ops = {LHS, RHS};
 3691   SmallVector<const SCEV *, 2> Ops = {LHS, RHS};
 3701   SmallVector<const SCEV *, 2> Ops = { LHS, RHS };
 3711   SmallVector<const SCEV *, 2> Ops = { LHS, RHS };
 3982       SmallVector<const SCEV *, 2> MatchedOperands;
 4130   SmallVector<const SCEV *, 2> Ops = { LHS, RHS };
 4150   SmallVector<const SCEV *, 2> PromotedOps;
 4192   SmallVector<Instruction *, 16> Worklist;
 4683 Optional<std::pair<const SCEV *, SmallVector<const SCEVPredicate *, 3>>>
 4685   SmallVector<const SCEVPredicate *, 3> Predicates;
 4743   SmallVector<const SCEV *, 8> Ops;
 4887   std::pair<const SCEV *, SmallVector<const SCEVPredicate *, 3>> PredRewrite =
 4894 Optional<std::pair<const SCEV *, SmallVector<const SCEVPredicate *, 3>>>
 4904     std::pair<const SCEV *, SmallVector<const SCEVPredicate *, 3>> Rewrite =
 4916   Optional<std::pair<const SCEV *, SmallVector<const SCEVPredicate *, 3>>>
 4921     SmallVector<const SCEVPredicate *, 3> Predicates;
 5065       SmallVector<const SCEV *, 8> Ops;
 5432   SmallVector<const SCEV *, 4> IndexExprs;
 6071   SmallVector<const Instruction *, 8> PoisonStack;
 6164       SmallVector<const SCEV *, 4> AddOps;
 6209       SmallVector<const SCEV *, 4> MulOps;
 6279               SmallVector<const SCEV*, 4> MulOps;
 6703     SmallVector<Instruction *, 16> Worklist;
 6798   SmallVector<const Loop *, 16> LoopWorklist(1, L);
 6799   SmallVector<Instruction *, 32> Worklist;
 6864   SmallVector<Instruction *, 16> Worklist;
 6906   SmallVector<const SCEV *, 2> Ops;
 7061   SmallVector<BasicBlock *, 8> ExitingBlocks;
 7066   SmallVector<EdgeExitInfo, 4> ExitCounts;
 7929     SmallVector<std::pair<PHINode *, Constant *>, 8> PHIsToCompute;
 8004     SmallVector<PHINode *, 8> PHIsToCompute;
 8025   SmallVector<std::pair<const Loop *, const SCEV *>, 2> &Values =
 8216         SmallVector<Constant *, 4> Operands;
 8274         SmallVector<const SCEV *, 8> NewOps(Comm->op_begin(),
 8316       SmallVector<const SCEV *, 8> NewOps(AddRec->op_begin(),
10804       SmallVector<const SCEV *, 4> Operands(op_begin(), op_end());
10876   SmallVector<const SCEV *, 3> Ops;
10988       SmallVector<const SCEV *, 0> Operands;
11028   SmallVector<const SCEV *, 4> Strides;
11062       SmallVector<const SCEV *, 2> Qs;
11122     SmallVector<const SCEV *, 2> Factors;
11182   SmallVector<const SCEV *, 4> NewTerms;
11321   SmallVector<const SCEV *, 4> Terms;
11371   SmallVector<User *, 16> Worklist(Old->user_begin(), Old->user_end());
11491   SmallVector<BasicBlock *, 8> ExitingBlocks;
11922   SmallVector<Loop *, 8> LoopStack(LI.begin(), LI.end());
12192     Optional<std::pair<const SCEV *, SmallVector<const SCEVPredicate *, 3>>>

  286         SmallVector<const SCEV *, 4> NewMulOps(M->op_begin(), M->op_end());
  323   SmallVector<const SCEV *, 8> NoAddRecs(Ops.begin(), Ops.end() - NumAddRecs);
  324   SmallVector<const SCEV *, 8> AddRecs(Ops.end() - NumAddRecs, Ops.end());
  349   SmallVector<const SCEV *, 8> AddRecs;
  409   SmallVector<Value *, 4> GepIndices;
  410   SmallVector<const SCEV *, 8> Ops(op_begin, op_end);
  427     SmallVector<const SCEV *, 8> ScaledOps;
  431         SmallVector<const SCEV *, 8> NewOps;
  695   SmallVector<std::pair<const Loop *, const SCEV *>, 8> OpsAndLoops;
  717       SmallVector<const SCEV *, 4> NewOps;
  732       SmallVector<const SCEV *, 4> NewOps;
  765   SmallVector<std::pair<const Loop *, const SCEV *>, 8> OpsAndLoops;
  887     SmallVector<const SCEV *, 8> NewAddOps(A->op_begin(), A->op_end());
 1015   SmallVector<Instruction*, 4> IVIncs;
 1513     SmallVector<const SCEV *, 4> NewOps(S->getNumOperands());
 1527     SmallVector<const SCEV *, 4> NewOps(S->op_begin(), S->op_end());
 1953   SmallVector<PHINode*, 8> Phis;
 2098   SmallVector<BasicBlock *, 4> ExitingBlocks;

   48   SmallVector<const SCEV *, 8> Operands;

   85   SmallVector<PassAsArgInfo, 4> Calls;
  149   SmallVector<AllocaInfo, 4> Allocas;
  151   SmallVector<ParamInfo, 4> Params;
  283   SmallVector<const Value *, 8> WorkList;
  399   DenseMap<const GlobalValue *, SmallVector<const GlobalValue *, 4>> Callers;
  504   SmallVector<const GlobalValue *, 16> Callees;

  518     SmallVector<BuilderLink *, 8> Found;

  277         SmallVector<BasicBlock *, 4> BlockLoopExits;
  334   using LoopExitVec = SmallVector<BasicBlock *, 4>;

   31   SmallVector<std::pair<NodeRef, EdgeRef>, 8> SCCEdges, NonSCCEdges;

   60   SmallVector<BasicBlock *, 4> ExitingBlocks;
  858   SmallVector<int, 32> Mask(SI->getType()->getVectorNumElements(), -1);
  865   SmallVector<int, 16> ActualMask = SI->getShuffleMask();
 1103   SmallVector<int, 32> ShuffleMask(NumVecElems, 0);
 1130     SmallVector<int, 16> Mask = Shuffle->getShuffleMask();
 1176     SmallVector<const Value *, 2> Operands(I->operand_values());
 1186     SmallVector<const Value *, 2> Operands(I->operand_values());
 1322       SmallVector<Value *, 4> Args(II->arg_operands());

   63         SmallVector<Value *, 8> Indices(GEP->op_begin() + 1, GEP->op_end());

  317   SmallVector<VFParameter, 8> Parameters;

  465   SmallVector<const Value *, 16> WorkSet(1, I);
 1934     SmallVector<const User *, 4> WorkList;
 3357   SmallVector<unsigned, 10> Idxs(idx_range.begin(), idx_range.end());
 3435     SmallVector<unsigned, 5> Idxs;
 3768   SmallVector<const Value *, 4> Worklist;
 3840   SmallVector<const Value *, 4> Working(1, V);
 3844     SmallVector<const Value *, 4> Objs;
 4177   SmallVector<const BranchInst *, 2> GuardingBranches;
 4178   SmallVector<const ExtractValueInst *, 2> Results;

  375   SmallVector<Value *, 16> Worklist;
  570   SmallVector<Metadata *, 4> Intersection;
  596   SmallVector<std::pair<unsigned, MDNode *>, 4> Metadata;
  647   SmallVector<Constant *, 16> Mask;
  659   SmallVector<Constant *, 16> MaskVec;
  669   SmallVector<Constant *, 16> Mask;
  679   SmallVector<Constant *, 16> Mask;
  688   SmallVector<Constant *, 16> Mask;
  729   SmallVector<Value *, 8> ResList;
  732     SmallVector<Value *, 8> TmpList;
 1156   SmallVector<Value *, 4> VL;

 2650   SmallVector<ArgInfo, 8> ArgList;
 2664   SmallVector<Type*, 16> ArgListTy;
 2675   SmallVector<Type*, 8> Elts;
 2728   SmallVector<Type*, 8> Body;
 3113     SmallVector<Constant*, 16> Elts;
 3131     SmallVector<Constant*, 16> Elts;
 3170     SmallVector<Constant*, 16> Elts;
 3341     SmallVector<unsigned, 4> Indices;
 3359     SmallVector<unsigned, 4> Indices;
 3547     SmallVector<Constant*, 16> Elts;
 3724   SmallVector<Metadata *, 16> Elts;
 3895 struct MDFieldList : public MDFieldImpl<SmallVector<Metadata *, 4>> {
 4311   SmallVector<Metadata *, 4> MDs;
 4946   SmallVector<uint64_t, 8> Elements;
 5372   SmallVector<ArgInfo, 8> ArgList;
 5421   SmallVector<AttributeSet, 8> Attrs;
 5968   SmallVector<std::pair<ConstantInt*, BasicBlock*>, 32> Table;
 6010   SmallVector<BasicBlock*, 16> DestList;
 6048   SmallVector<ParamInfo, 16> ArgList;
 6049   SmallVector<OperandBundleDef, 2> BundleList;
 6090   SmallVector<Value *, 8> Args;
 6091   SmallVector<AttributeSet, 8> ArgAttrs;
 6243   SmallVector<BasicBlock *, 32> Table;
 6289   SmallVector<Value *, 8> Args;
 6312   SmallVector<Value *, 8> Args;
 6358   SmallVector<ParamInfo, 16> ArgList;
 6359   SmallVector<OperandBundleDef, 2> BundleList;
 6374   SmallVector<BasicBlock *, 16> IndirectDests;
 6420   SmallVector<Value *, 8> Args;
 6421   SmallVector<AttributeSet, 8> ArgAttrs;
 6670   SmallVector<std::pair<Value*, BasicBlock*>, 16> PHIVals;
 6769   SmallVector<ParamInfo, 16> ArgList;
 6770   SmallVector<OperandBundleDef, 2> BundleList;
 6819   SmallVector<AttributeSet, 8> Attrs;
 6821   SmallVector<Value*, 8> Args;
 7204   SmallVector<Value*, 16> Indices;
 7246   SmallVector<unsigned, 4> Indices;
 7265   SmallVector<unsigned, 4> Indices;
 7396   SmallVector<unsigned, 16> Indexes;
 7413   SmallVector<unsigned, 16> Indexes;

  114     SmallVector<Instruction*, 64> InstsWithTBAATag;

   78   SmallVector<StackLevel, 4> Stack;
  183   SmallVector<WriterStackLevel, 4> Stack;

  778   SmallVector<uint64_t, 64> Record;

  178   SmallVector<uint64_t, 64> Record;
  262   SmallVector<uint64_t, 64> Record;
  343   SmallVector<uint64_t, 64> Record;
  501   SmallVector<Instruction *, 64> InstructionList;
  567   SmallVector<SyncScope::ID, 8> SSIDs;
 1355   SmallVector<uint64_t, 64> Record;
 1357   SmallVector<AttributeList, 8> Attrs;
 1570   SmallVector<uint64_t, 64> Record;
 1681   SmallVector<uint64_t, 64> Record;
 1785       SmallVector<Type*, 8> ArgTys;
 1804       SmallVector<Type*, 8> ArgTys;
 1825       SmallVector<Type*, 8> EltTys;
 1858       SmallVector<Type*, 8> EltTys;
 1928   SmallVector<uint64_t, 64> Record;
 1970   SmallVector<uint64_t, 64> Record;
 2076   SmallVector<uint64_t, 64> Record;
 2147   SmallVector<uint64_t, 64> Record;
 2316   SmallVector<uint64_t, 8> Words(Vals.size());
 2327   SmallVector<uint64_t, 64> Record;
 2434       SmallVector<Constant*, 16> Elts;
 2472         SmallVector<uint8_t, 16> Elts(Record.begin(), Record.end());
 2478         SmallVector<uint16_t, 16> Elts(Record.begin(), Record.end());
 2484         SmallVector<uint32_t, 16> Elts(Record.begin(), Record.end());
 2490         SmallVector<uint64_t, 16> Elts(Record.begin(), Record.end());
 2496         SmallVector<uint16_t, 16> Elts(Record.begin(), Record.end());
 2502         SmallVector<uint32_t, 16> Elts(Record.begin(), Record.end());
 2508         SmallVector<uint64_t, 16> Elts(Record.begin(), Record.end());
 2597       SmallVector<Constant*, 16> Elts;
 2834   SmallVector<uint64_t, 64> Record;
 3016   SmallVector<uint64_t, 64> Record;
 3410   SmallVector<uint64_t, 64> Record;
 3731   SmallVector<uint64_t, 64> Record;
 3979       SmallVector<Value*, 16> GEPIdx;
 4007       SmallVector<unsigned, 4> EXTRACTVALIdx;
 4048       SmallVector<unsigned, 4> INSERTVALIdx;
 4300       SmallVector<BasicBlock *, 2> Handlers;
 4339       SmallVector<Value *, 2> Args;
 4380           SmallVector<ConstantInt*, 1> CaseVals;
 4411           for (SmallVector<ConstantInt*, 1>::iterator cvi = CaseVals.begin(),
 4505       SmallVector<Value*, 16> Ops;
 4506       SmallVector<Type *, 16> ArgsFullTys;
 4559       SmallVector<BasicBlock *, 16> IndirectDests;
 4592       SmallVector<Value*, 16> Args;
 5033       SmallVector<Value*, 16> Args;
 5034       SmallVector<Type*, 16> ArgsFullTys;
 5412   SmallVector<uint64_t, 64> Record;
 5493   SmallVector<uint64_t, 64> Record;
 5748   SmallVector<uint64_t, 64> Record;
 6184   SmallVector<uint64_t, 64> Record;
 6300       SmallVector<uint64_t, 1> Record;
 6526   SmallVector<uint64_t, 64> Record;

  113   SmallVector<TrackingMDRef, 1> MetadataPtrs;
  128     SmallVector<std::pair<TrackingMDRef, TempMDTuple>, 1> Arrays;
  352   SmallVector<Metadata *, 32> Ops;
  514       SmallVector<MDNode *, 1> MDs;
  539               SmallVector<uint64_t, 8> Ops;
  686   SmallVector<uint64_t, 64> Record;
  903   SmallVector<uint64_t, 64> Record;
  994   SmallVector<uint64_t, 64> Record;
 1170     SmallVector<Metadata *, 8> Elts;
 1208     SmallVector<Metadata *, 8> Elts;
 1247     SmallVector<Metadata *, 8> DwarfOps;
 1823     SmallVector<uint64_t, 6> Buffer;
 1982   SmallVector<uint64_t, 64> Record;
 2086   SmallVector<uint64_t, 64> Record;

  158   SmallVector<Constant *, 64> NewOps;

  209   void writePerModuleFunctionSummaryRecord(SmallVector<uint64_t, 64> &NameVals,
  216                                   SmallVector<uint64_t, 64> &NameVals,
  585   SmallVector<unsigned, 64> Vals;
  744   SmallVector<uint64_t, 64> Record;
  793   SmallVector<uint64_t, 64> Record;
  814   SmallVector<uint64_t, 64> TypeVals;
 1094   SmallVector<unsigned, 64> Vals;
 1235   SmallVector<unsigned, 64> Vals;
 2043   SmallVector<uint64_t, 64> Record;
 2116     SmallVector<uint64_t, 4> Record;
 2138   SmallVector<uint64_t, 64> Record;
 2147   SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
 2158   SmallVector<uint64_t, 64> Record;
 2168   SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
 2191   SmallVector<uint64_t, 64> Record;
 2195   SmallVector<StringRef, 8> Names;
 2221   SmallVector<StringRef, 8> Tags;
 2229   SmallVector<uint64_t, 64> Record;
 2242   SmallVector<StringRef, 8> SSNs;
 2249   SmallVector<uint64_t, 64> Record;
 2305   SmallVector<uint64_t, 64> Record;
 2569   SmallVector<unsigned, 64> Record;
 2877     SmallVector<uint64_t, 128> Vals64;
 3098   SmallVector<uint64_t, 64> NameVals;
 3141   SmallVector<uint64_t, 64> Record(Order.Shuffle.begin(), Order.Shuffle.end());
 3176   SmallVector<unsigned, 64> Vals;
 3477   SmallVector<unsigned, 64> Vals;
 3515   SmallVector<uint64_t, 64> Record;
 3579     SmallVector<uint64_t, 64> &NameVals, const std::vector<uint64_t> &args,
 3591     SmallVector<uint64_t, 64> &NameVals, StringTableBuilder &StrtabBuilder,
 3604 static void writeTypeIdSummaryRecord(SmallVector<uint64_t, 64> &NameVals,
 3624     SmallVector<uint64_t, 64> &NameVals, StringTableBuilder &StrtabBuilder,
 3638     SmallVector<uint64_t, 64> &NameVals, GlobalValueSummary *Summary,
 3681     const GlobalVariable &V, SmallVector<uint64_t, 64> &NameVals,
 3831   SmallVector<uint64_t, 64> NameVals;
 3964   SmallVector<AliasSummary *, 64> Aliases;
 3969   SmallVector<uint64_t, 64> NameVals;
 4196   SmallVector<unsigned, 1> Vals = {bitc::BITCODE_CURRENT_EPOCH};
 4396   SmallVector<char, 0> Symtab;
 4461   SmallVector<char, 0> Buffer;
 4504   SmallVector<char, 0> Buffer;
 4545   SmallVector<unsigned, 64> Vals;
 4664   SmallVector<char, 0> Buffer;

  175   SmallVector<Entry, 64> List;
  379   SmallVector<std::pair<unsigned, MDNode *>, 8> MDs;
  581   SmallVector<const MDNode *, 64> Worklist;
  614   SmallVector<const MDNode *, 32> DelayedDistinctNodes;
  618   SmallVector<std::pair<const MDNode *, MDNode::op_iterator>, 32> Worklist;
  734   SmallVector<MDIndex, 64> Order;
  979   SmallVector<LocalAsMetadata *, 8> FnLocalMDVector;

  438   SmallVector<uint64_t, 64> Record;

   30   SmallVector<MCPhysReg, 16> Hints;

  650   SmallVector<unsigned, 4> RetPath, CallPath;
  651   SmallVector<CompositeType *, 4> RetSubTypes, CallSubTypes;
  681     SmallVector<unsigned, 4> TmpRetPath(RetPath.rbegin(), RetPath.rend());
  682     SmallVector<unsigned, 4> TmpCallPath(CallPath.rbegin(), CallPath.rend());
  700   SmallVector<const MachineBasicBlock *, 16> Worklist = {MBB};
  739   SmallVector<const MachineBasicBlock *, 16> EHScopeBlocks;
  740   SmallVector<const MachineBasicBlock *, 16> UnreachableBlocks;
  741   SmallVector<const MachineBasicBlock *, 16> SEHCatchPads;
  742   SmallVector<std::pair<const MachineBasicBlock *, int>, 16> CatchRetSuccessors;

  148     const SmallVector<Atom, 4> Atoms;
  217   DenseMap<uint32_t, SmallVector<AttributeEncoding, 2>> Abbreviations;
  229   SmallVector<AttributeEncoding, 2> getUniformAttributes() const;
  412 SmallVector<typename Dwarf5AccelTableWriter<DataT>::AttributeEncoding, 2>
  414   SmallVector<AttributeEncoding, 2> UA;
  524   SmallVector<AttributeEncoding, 2> UniformAttributes = getUniformAttributes();
  555   SmallVector<unsigned, 1> CUIndex(CUs.size());

   64   SmallVector<const MCExpr *, 64> Entries(Pool.size());

 1288   SmallVector<const GlobalVariable *, 8> FailedCandidates;
 1499   SmallVector<const GlobalAlias *, 16> AliasStack;
 1697     SmallVector<unsigned, 4> CPEs;
 1715   SmallVector<SectionCPs, 4> CPSections;
 2003   SmallVector<Structor, 8> Structors;

  333   SmallVector<StringRef, 5> QualifiedNameComponents;
 1471   SmallVector<StringRef, 5> QualifiedNameComponents;
 1858   SmallVector<TypeIndex, 8> ReturnAndArgTypeIndices;
 1897   SmallVector<TypeIndex, 8> ArgTypeIndices;
 1937   SmallVector<VFTableSlotKind, 4> Slots(VSlotCount, VFTableSlotKind::Near);
 2585   SmallVector<const DICompositeType *, 4> TypesToEmit;
 2597   SmallVector<const LocalVariable *, 6> Params;
 2984     SmallVector<DIGlobalVariableExpression *, 1> GVEs;
 3008       SmallVector<CVGlobalVariable, 1> *VariableList;

   90     SmallVector<std::pair<const MCSymbol *, const MCSymbol *>, 1> Ranges;
   98     SmallVector<LocalVarDefRange, 1> DefRanges;
  108     SmallVector<LocalVariable, 1> InlinedLocals;
  109     SmallVector<const DILocation *, 1> ChildSites;
  119     SmallVector<LocalVariable, 1> Locals;
  120     SmallVector<CVGlobalVariable, 1> Globals;
  121     SmallVector<LexicalBlock *, 1> Children;
  140     SmallVector<const DILocation *, 1> ChildSites;
  142     SmallVector<LocalVariable, 1> Locals;
  143     SmallVector<CVGlobalVariable, 1> Globals;
  148     SmallVector<LexicalBlock *, 1> ChildBlocks;
  193   DenseMap<const LexicalScope *, SmallVector<LocalVariable, 1>> ScopeVariables;
  197   typedef SmallVector<CVGlobalVariable, 1> GlobalVariableList;
  201   SmallVector<CVGlobalVariable, 1> ComdatVariables;
  204   SmallVector<CVGlobalVariable, 1> GlobalVariables;
  260   SmallVector<const DICompositeType *, 4> DeferredCompleteTypes;

   86   SmallVector<const DIE *, 1> Parents;

  101 using RegDescribedVarsMap = std::map<unsigned, SmallVector<InlinedEntity, 1>>;
  143   SmallVector<EntryIndex, 4> IndicesToErase;
  169     SmallVector<EntryIndex, 4> IndicesToErase;
  295           SmallVector<unsigned, 32> RegsToClobber;

   94   SmallVector<LexicalScope *, 4> WorkList;

   99   SmallVector<DbgValueLoc, 1> Values;

   48   SmallVector<List, 4> Lists;
   49   SmallVector<Entry, 32> Entries;

  426   SmallVector<DIE *, 8> Children;
  469                                          SmallVector<RangeSpan, 2> Range) {
  502     DIE &Die, SmallVector<RangeSpan, 2> Ranges) {
  513   SmallVector<RangeSpan, 2> List;
  645     SmallVector<uint64_t, 8> Ops;
  700 static SmallVector<const DIVariable *, 2> dependencies(DbgVariable *Var) {
  701   SmallVector<const DIVariable *, 2> Result;
  717 static SmallVector<DbgVariable *, 8>
  719   SmallVector<DbgVariable *, 8> Result;
  720   SmallVector<PointerIntPair<DbgVariable *, 1>, 8> WorkList;
  841   SmallVector<DIE *, 8> Children;
  978     DIE &CallSiteDIE, SmallVector<DbgCallSiteParam, 4> &Params) {

   61   using ImportedEntityList = SmallVector<const MDNode *, 8>;
   73   SmallVector<RangeSpan, 2> CURanges;
  191   void addScopeRangeList(DIE &ScopeDIE, SmallVector<RangeSpan, 2> Range);
  193   void attachRangesOrLowHighPC(DIE &D, SmallVector<RangeSpan, 2> Ranges);
  258                                       SmallVector<DbgCallSiteParam, 4> &Params);
  350   SmallVector<RangeSpan, 2> takeRanges() { return std::move(CURanges); }

  628     SmallVector<unsigned, 4> ExplicitFwdRegDefs;
  629     SmallVector<unsigned, 4> ImplicitFwdRegDefs;
  945   DenseMap<DIGlobalVariable *, SmallVector<DwarfCompileUnit::GlobalExpr, 1>>
  948     SmallVector<DIGlobalVariableExpression *, 1> GVs;
 1389   SmallVector<OpenRange, 4> OpenRanges;
 1461     SmallVector<DbgValueLoc, 4> Values;
 1564     SmallVector<DebugLocEntry, 8> Entries;
 2487   MapVector<MCSection *, SmallVector<SymbolCU, 8>> SectionMap;
 2508     SmallVector<SymbolCU, 8> &List = I.second;

  128   mutable SmallVector<FrameIndexExpr, 1>
  273 using ParamSet = SmallVector<DbgCallSiteParam, 4>;
  309   SmallVector<std::unique_ptr<DbgEntity>, 64> ConcreteEntities;
  317   SetVector<const DISubprogram *, SmallVector<const DISubprogram *, 16>,
  343   SmallVector<

  120   SmallVector<Register, 2> DwarfRegs;

  127 DwarfFile::addRange(const DwarfCompileUnit &CU, SmallVector<RangeSpan, 2> R) {

   46   SmallVector<RangeSpan, 2> Ranges;
   50                 SmallVector<RangeSpan, 2> Ranges)
   67   SmallVector<std::unique_ptr<DwarfCompileUnit>, 1> CUs;
   73   SmallVector<RangeSpanList, 1> CURangeLists;
   88     SmallVector<DbgVariable *, 8> Locals;
   94   using LabelList = SmallVector<DbgLabel *, 4>;
  114                                                 SmallVector<RangeSpan, 2> R);

   86   SmallVector<const StringMapEntry<EntryTy> *, 64> Entries;

  740   SmallVector<const DIScope *, 1> Parents;

   88   SmallVector<int, 16> FilterOffsets;
  357   SmallVector<const LandingPadInfo *, 64> LandingPads;
  370   SmallVector<ActionEntry, 32> Actions;
  371   SmallVector<unsigned, 64> FirstActions;
  375   SmallVector<CallSiteEntry, 64> CallSites;

  665   SmallVector<std::pair<const MCExpr *, int>, 4> IPToStateTable;
  777     SmallVector<MCSymbol *, 1> HandlerMaps;
 1105   SmallVector<ClrClause, 8> Clauses;
 1146   SmallVector<std::pair<const MCSymbol *, int>, 4> HandlerStack;
 1149   SmallVector<int, 4> MinClauseMap((size_t)NumStates, NumStates);

  207   SmallVector<Instruction *, 1> AtomicInsts;
 1281   SmallVector<ExtractValueInst *, 2> PrunedInsts;
 1691   SmallVector<Value *, 6> Args;
 1770   SmallVector<Type *, 6> ArgTys;

  202     SmallVector<MachineOperand, 4> Cond;
  520   SmallVector<MachineOperand, 4> Cond;
 1173       SmallVector<MachineOperand, 4> Cond;
 1177         SmallVector<MachineOperand, 4> NewCond(Cond);
 1224   SmallVector<BlockFrequency, 2> EdgeFreqLs(TailMBB.succ_size());
 1446   SmallVector<MachineOperand, 4> PriorCond;
 1528       SmallVector<MachineOperand, 4> NewPriorCond(PriorCond);
 1563         SmallVector<MachineOperand, 4> NewPriorCond(PriorCond);
 1591       SmallVector<MachineOperand, 4> PredCond;
 1621   SmallVector<MachineOperand, 4> CurCond;
 1634       SmallVector<MachineOperand, 4> NewCond(CurCond);
 1706               SmallVector<MachineOperand, 4> NewCurCond;
 1751         SmallVector<MachineOperand, 4> PredCond;
 1812       SmallVector<MachineOperand, 4> PrevCond;
 1969   SmallVector<MachineOperand, 4> Cond;

   82   SmallVector<BasicBlockInfo, 16> BlockInfo;
  305   SmallVector<MachineOperand, 4> Cond;

   70   SmallVector<MachineInstr *, 8> SetjmpCalls;

  224   SmallVector<MachineBasicBlock *, 4> Stack;

  248     SmallVector<MCPhysReg, 8> RemainingRegs;
  266   SmallVector<CCValAssign, 4> RVLocs1;
  270   SmallVector<CCValAssign, 4> RVLocs2;

  239 using SExts = SmallVector<Instruction *, 16>;
  284         SmallVector<std::pair<AssertingVH<GetElementPtrInst>, int64_t>, 32>>
  510       SmallVector<BasicBlock *, 2> Successors(succ_begin(&BB), succ_end(&BB));
  524       SmallVector<BasicBlock*, 2> Successors(succ_begin(BB), succ_end(BB));
  543     SmallVector<Instruction *, 2> Statepoints;
  567   SmallVector<WeakTrackingVH, 16> Blocks;
  632   SmallVector<Loop *, 16> LoopList(LI->begin(), LI->end());
  644   SmallVector<WeakTrackingVH, 16> Blocks;
  881     DenseMap<GCRelocateInst *, SmallVector<GCRelocateInst *, 2>>
  970     SmallVector<Value *, 2> OffsetV;
 1045   SmallVector<GCRelocateInst *, 2> AllRelocateCalls;
 1059   DenseMap<GCRelocateInst *, SmallVector<GCRelocateInst *, 2>> RelocateInstMap;
 1913       SmallVector<Value*, 2> PtrOps;
 2014   SmallVector<BasicBlock*, 4> TailCallBBs;
 2379     SmallVector<Value *, 4> OriginalValues;
 2520     SmallVector<InstructionAndIdx, 4> OriginalUses;
 2522     SmallVector<DbgValueInst *, 1> DbgValues;
 2659   SmallVector<std::unique_ptr<TypePromotionAction>, 16> Actions;
 2866   SmallVector<PHINode *, 32> NodeList;
 3001     SmallVector<Value *, 32> WorkList;
 3075   SmallVector<ExtAddrMode, 16> AddrModes;
 3197     SmallVector<Value *, 2> NullValue;
 3252     SmallVector<Value *, 32> TraverseOrder;
 3283     SmallVector<PHIPair, 8> WorkList;
 3419     SmallVector<Value *, 32> Worklist;
 4573   SmallVector<std::pair<Instruction*,unsigned>, 16> MemoryUses;
 4587   SmallVector<Instruction*, 32> MatchedAddrModeInsts;
 4664   SmallVector<Value*, 8> worklist;
 4672   SmallVector<Instruction*, 16> AddrModeInsts;
 5145     SmallVector<Instruction *, 4> NewExts;
 5176     SmallVector<Instruction *, 2> NewlyMovedExts;
 5468   SmallVector<Instruction *, 1> Exts;
 5469   SmallVector<Instruction *, 2> SpeculativelyMovedExts;
 5561       SmallVector<Instruction *, 1> Exts;
 5562       SmallVector<Instruction *, 2> Chains;
 5712   SmallVector<Instruction *, 8> WorkList;
 5714   SmallVector<Instruction *, 8> AndsToMaybeRemove;
 5939   SmallVector<SelectInst *, 2> ASI;
 6101   SmallVector<int, 16> Mask(SVI->getShuffleMask());
 6171   SmallVector<Use *, 4> OpsToSink;
 6181   SmallVector<Use *, 4> ToReplace;
 6300   SmallVector<Instruction *, 4> InstsToBePromoted;
 6428     SmallVector<Constant *, 4> ConstVec;
 7075   SmallVector<Instruction*, 4> Insts;

  599     SmallVector<unsigned, 2> ForbidRegs;

  184   SmallVector<ResumeInst*, 16> Resumes;
  185   SmallVector<LandingPadInst*, 16> CleanupLPads;

  120   SmallVector<PHIInfo, 8> PHIs;
  124   SmallVector<MachineOperand, 4> Cond;
  365   SmallVector<unsigned, 8> Reads;
  688     SmallVector<MachineOperand, 0> EmptyCond;
  818   SmallVector<const MachineBasicBlock*, 1> ExtraBlocks;
  889     SmallVector<MachineBasicBlock*, 4> RemovedBlocks;
 1024     SmallVector<MachineBasicBlock *, 4> RemovedBlocks;

  288   SmallVector<int, 4> used;
  329   SmallVector<int, 4> Regs;

   86   using LoadEntryVector = SmallVector<LoadEntry, 8>;

   80   SmallVector<IntrinsicInst *, 4> Worklist;

  193   SmallVector<AllocaInst *, 32> Roots;

  135   SmallVector<LLT, 8> LLTs;
  136   SmallVector<uint64_t, 8> Offsets;
  158   SmallVector<LLT, 8> LLTs;
  159   SmallVector<uint64_t, 8> Offsets;
  172   SmallVector<CCValAssign, 16> ArgLocs;
  410   SmallVector<CCValAssign, 16> ArgLocs1;
  416   SmallVector<CCValAssign, 16> ArgLocs2;

   94   SmallVector<Register, 4> Ops;
  177   SmallVector<Register, 4> Ops;
  214   SmallVector<int, 8> ConcatSrcs(NumConcat, -1);
  215   SmallVector<int, 8> Mask;
  459   SmallVector<MachineOperand *, 4> Uses;
 1210   SmallVector<Register, 16> LoadVals;

  165   SmallVector<LLT, 4> SplitTys;
  188   SmallVector<LLT, 4> SplitTys;
  948   SmallVector<Value *, 1> Indices;
 1269   SmallVector<llvm::SrcOp, 4> VRegs;
 1300     SmallVector<const Value *, 4> Allocas;
 1549   SmallVector<ArrayRef<Register>, 8> Args;
 1758   SmallVector<LLT, 2> Tys;
 1930   SmallVector<MachineInstr *, 4> Insts;
 2082   SmallVector<LLT, 4> SplitTys;
 2132     SmallVector<Register, 4> Ops;
 2142     SmallVector<Register, 4> Ops;
 2160     SmallVector<Register, 4> Ops;
 2297   SmallVector<ArrayRef<Register>, 8> VRegArgs;

   25   SmallVector<LLT, 4> Types = TypesInit;
   34   SmallVector<std::pair<LLT, LLT>, 4> Types = TypesInit;
   44   SmallVector<TypePairAndMemDesc, 4> TypesAndMemDesc = TypesAndMemDescInit;

   90   SmallVector<MachineInstr *, 4> NewMIs;
  215   SmallVector<MachineInstr *, 128> RetryList;
  267       SmallVector<MachineInstr *, 4> DeadInstructions;

  384   SmallVector<CallLowering::ArgInfo, 3> Args;
  397   SmallVector<CallLowering::ArgInfo, 3> Args;
  615     SmallVector<Register, 2> DstRegs;
  635     SmallVector<Register, 4> PartRegs;
  645     SmallVector<Register, 1> LeftoverRegs;
  696     SmallVector<Register, 4> Srcs = {MI.getOperand(1).getReg()};
  727     SmallVector<Register, 2> Src1Regs, Src2Regs, DstRegs;
  762     SmallVector<Register, 2> Src1Regs, Src2Regs, DstRegs;
  913     SmallVector<Register, 2> DstRegs;
  914     SmallVector<SmallVector<Register, 2>, 2> SrcRegs;
  914     SmallVector<SmallVector<Register, 2>, 2> SrcRegs;
 1022     SmallVector<Register, 2> DstRegs;
 1024     SmallVector<Register, 2> SrcRegs;
 1135     SmallVector<Register, 8> Parts;
 1229   SmallVector<Register, 8> Parts;
 1230   SmallVector<Register, 8> NewMergeRegs;
 1231   SmallVector<Register, 8> Unmerges;
 2287   SmallVector<Register, 2> DstRegs;
 2340       SmallVector<SrcOp, 4> SrcOps;
 2356     SmallVector<SrcOp, 4> SrcOps;
 2372   SmallVector<Register, 2> DstRegs, Src0Regs, Src1Regs, Src2Regs;
 2439   SmallVector<MachineInstrBuilder, 4> NewInsts;
 2441   SmallVector<Register, 4> DstRegs, LeftoverDstRegs;
 2442   SmallVector<Register, 4> PartRegs, LeftoverRegs;
 2529   SmallVector<Register, 4> SrcRegs, DstRegs;
 2592   SmallVector<Register, 2> Src1Regs, Src2Regs, DstRegs;
 2667   SmallVector<Register, 2> DstRegs, Src0Regs, Src1Regs, Src2Regs;
 2706   SmallVector<Register, 4> DstRegs, LeftoverDstRegs;
 2707   SmallVector<MachineInstrBuilder, 4> NewInsts;
 2727   SmallVector<Register, 4> PartRegs, LeftoverRegs;
 2811   SmallVector<Register, 8> ConcatOps;
 2812   SmallVector<Register, 8> SubBuildVector;
 2879   SmallVector<Register, 8> NarrowRegs, NarrowLeftoverRegs;
 3363   SmallVector<Register, 4> Factors;
 3433   SmallVector<Register, 2> Src1Parts, Src2Parts, DstTmpRegs;
 3462   SmallVector<Register, 2> SrcRegs, DstRegs;
 3463   SmallVector<uint64_t, 2> Indexes;
 3529   SmallVector<Register, 2> SrcRegs, DstRegs;
 3530   SmallVector<uint64_t, 2> Indexes;
 3595   SmallVector<Register, 4> DstRegs, DstLeftoverRegs;
 3596   SmallVector<Register, 4> Src0Regs, Src0LeftoverRegs;
 3597   SmallVector<Register, 4> Src1Regs, Src1LeftoverRegs;
 3642   SmallVector<Register, 4> DstRegs, DstLeftoverRegs;
 3643   SmallVector<Register, 4> Src1Regs, Src1LeftoverRegs;
 3644   SmallVector<Register, 4> Src2Regs, Src2LeftoverRegs;
 4113   SmallVector<int, 32> Mask;
 4133   SmallVector<Register, 32> BuildVec;

  478   SmallVector<LLT, 2> Types;
  498   SmallVector<LegalityQuery::MemDesc, 2> MemDescrs;
  629   const SmallVector<SizeAndActionsVec, 1> &Actions =

  585   SmallVector<SrcOp, 8> TmpVec(Ops.begin(), Ops.end());
  595   SmallVector<DstOp, 8> TmpVec(Res.begin(), Res.end());
  603   SmallVector<Register, 8> TmpVec;
  614   SmallVector<DstOp, 8> TmpVec(Res.begin(), Res.end());
  624   SmallVector<SrcOp, 8> TmpVec(Ops.begin(), Ops.end());
  630   SmallVector<SrcOp, 8> TmpVec(Res.getLLTTy(*getMRI()).getNumElements(), Src);
  640   SmallVector<SrcOp, 8> TmpVec(Ops.begin(), Ops.end());
  649   SmallVector<SrcOp, 8> TmpVec(Ops.begin(), Ops.end());

  296   SmallVector<RepairingPlacement, 4> LocalRepairPts;
  625   SmallVector<RepairingPlacement, 4> RepairPts;

  176   SmallVector<const ValueMapping *, 8> OperandsMapping(NumOperandsForMapping);
  301   SmallVector<size_t, 8> Hashes(NumBreakDowns);

  221   SmallVector<std::pair<unsigned, unsigned>, 4> SeenOpcodes;

  604   DenseMap<std::pair<unsigned, StringRef>, SmallVector<GlobalVariable *, 16>>

  149       SmallVector<MachineOperand, 4> BrCond;
  150       SmallVector<MachineOperand, 4> Predicate;
 1031   SmallVector<MachineOperand, 4> RevCond(BBI.BrCond.begin(), BBI.BrCond.end());
 1188     SmallVector<MachineOperand, 4> RevPred(Pred.begin(), Pred.end());
 1189     SmallVector<MachineOperand, 4> Cond(BBI.BrCond.begin(), BBI.BrCond.end());
 1215   SmallVector<BBState, 16> BBStack(1, MBB);
 1278     SmallVector<MachineOperand, 4>
 1468   SmallVector<MachineOperand, 0> NoCond;
 1485   SmallVector<std::pair<MCPhysReg, const MachineOperand*>, 4> Clobbers;
 1533   SmallVector<MachineOperand, 4> Cond(BBI.BrCond.begin(), BBI.BrCond.end());
 1619   SmallVector<MachineOperand, 4> Cond(BBI.BrCond.begin(), BBI.BrCond.end());
 1698     SmallVector<MachineOperand, 4> RevCond(CvtBBI->BrCond.begin(),
 1790   SmallVector<MachineOperand, 4> RevCond(BBI.BrCond.begin(), BBI.BrCond.end());
 1793   SmallVector<MachineOperand, 4> *Cond1 = &BBI.BrCond;
 1794   SmallVector<MachineOperand, 4> *Cond2 = &RevCond;
 1859       SmallVector<std::pair<MCPhysReg, const MachineOperand*>, 4> Dummy;
 1944       SmallVector<MCPhysReg, 4> Defs;
 2260   SmallVector<MachineBasicBlock *, 4> FromSuccs(FromMBB.succ_begin(),

  302   SmallVector<NullCheck, 16> NullCheckList;
  582   SmallVector<MachineInstr *, 8> InstsSeenSoFar;

   87   SmallVector<IndirectBrInst *, 1> IndirectBrs;
  115   SmallVector<BasicBlock *, 4> BBs;

  178   SmallVector<unsigned, 8> RegsToSpill;
  188   SmallVector<MachineInstr*, 8> DeadDefs;
  427   SmallVector<std::pair<LiveInterval*, VNInfo*>, 8> WorkList;
  491   SmallVector<std::pair<LiveInterval*, VNInfo*>, 8> WorkList;
  545   SmallVector<std::pair<MachineInstr *, unsigned>, 8> Ops;
  810   SmallVector<unsigned, 8> FoldOps;
  994     SmallVector<std::pair<MachineInstr*, unsigned>, 8> Ops;
 1307   SmallVector<MachineDomTreeNode *, 32>::reverse_iterator RIt = Orders.rbegin();
 1323   SmallVector<MachineDomTreeNode *, 32> Orders;
 1351   SmallVector<MachineDomTreeNode *, 32>::reverse_iterator RIt = Orders.rbegin();
 1456   SmallVector<unsigned, 4> NewVRegs;
 1484     SmallVector<MachineInstr *, 16> SpillsToRm;

   92     SmallVector<RegUnitInfo, 4> RegUnits;
   95     SmallVector<BlockInterference, 8> Blocks;

  108                             SmallVector<Instruction *, 32> &DeadInsts);
  112                              SmallVector<Instruction *, 32> &DeadInsts);
  281     LoadInst *LI, SmallVector<Instruction *, 32> &DeadInsts) {
  285   SmallVector<ShuffleVectorInst *, 4> Shuffles;
  286   SmallVector<ExtractElementInst *, 4> Extracts;
  317   SmallVector<unsigned, 4> Indices;
  382       SmallVector<int, 4> Indices;
  418     StoreInst *SI, SmallVector<Instruction *, 32> &DeadInsts) {
  457   SmallVector<Instruction *, 32> DeadInsts;

  180   SmallVector<std::pair<BOps, APInt>, 4> B;
  996         SmallVector<Value *, 4> Indices;
 1205   SmallVector<unsigned, 4> Indices;
 1232     SmallVector<uint32_t, 4> Mask;

   45   SmallVector<Value *, 8> Args(ArgBegin, ArgEnd);

   57   SmallVector<InsnRange, 4> MIRanges;
  235   SmallVector<LexicalScope *, 4> WorkStack;

  380   using TransferMap = SmallVector<TransferDebugPair, 4>;
  388       DenseMap<FragmentOfVar, SmallVector<DIExpression::FragmentInfo, 1>>;

  192   SmallVector<MachineOperand, 4> locations;
  399   SmallVector<std::unique_ptr<UserValue>, 8> userValues;
  402   SmallVector<std::unique_ptr<UserLabel>, 2> userLabels;
  405   using VRMap = DenseMap<unsigned, SmallVector<UserValue *, 4>>;
  772   SmallVector<std::pair<LiveInterval*, const VNInfo*>, 8> CopyValues;
  836   SmallVector<std::pair<SlotIndex, DbgValueLocation>, 16> Defs;
  862       SmallVector<SlotIndex, 16> Kills;
 1165   SmallVector<unsigned, 4> LocNoMap(locations.size());

  892   SmallVector<VNInfo *, 8> ToBeRemoved;
 1382     SmallVector<unsigned, 8> VNIMapping;
 1383     SmallVector<LiveInterval::SubRange*, 8> SubRanges;

  316   SmallVector<unsigned, 8> NewRanges;
  431         SmallVector<SlotIndex,8> Undefs;
  685   SmallVector<std::pair<const LiveRange*, LiveRange::const_iterator>, 8> RU;
  687   SmallVector<std::pair<const LiveInterval::SubRange*,

  158   SmallVector<SlotIndex, 4> Undefs;
  352   SmallVector<unsigned, 16> WorkList(1, UseMBBNum);

  225   SmallVector<unsigned, 8> Ops;
  285   SmallVector<unsigned, 8> RegsToErase;
  432     SmallVector<LiveInterval*, 8> SplitLIs;

  512   SmallVector<unsigned, 4> UseRegs;
  513   SmallVector<unsigned, 4> DefRegs;
  514   SmallVector<unsigned, 1> RegMasks;
  566   SmallVector<unsigned, 4> Defs;

   75     SmallVector<int64_t, 16> LocalOffsets;
  299   SmallVector<FrameRef, 64> FrameReferenceInsns;

   30   SmallVector<MachineBasicBlock *, 4> Workqueue;
   31   SmallVector<TraversedMBBInfo, 4> MBBTraversalOrder;

   74   SmallVector<const GlobalVariable*, 8> TlsVars;

  838     SmallVector<MachineBasicBlock*,4> Successors;
  887   SmallVector<ParsedMachineOperand, 8> Operands;
  954   SmallVector<MachineMemOperand *, 2> MemOperands;
 1104   SmallVector<MachineOperand, 4> ImplicitOperands;
 1358   SmallVector<std::pair<unsigned, unsigned>, 4> TiedRegisterPairs;
 1850   SmallVector<uint64_t, 8> Elements;
 2298   SmallVector<Constant *, 32> ShufMask;

  561     SmallVector<MCPhysReg, 16> CalleeSavedRegisters;

  148   SmallVector<StringRef, 8> SSNs;
  577   SmallVector<BranchProbability,8> Normalized(MBB.Probs.begin(),
  581   SmallVector<BranchProbability,8> Equal(Normalized.size());
  588   SmallVector<MachineBasicBlock*,8> GuessedSuccs;

  539   SmallVector<MachineOperand, 4> Cond;
  839   SmallVector<MachineOperand, 4> Cond;
  901   SmallVector<unsigned, 4> KilledRegs;
  921   SmallVector<unsigned, 4> UsedRegs;
  943   SmallVector<MachineInstr*, 4> Terminators;
  953     SmallVector<MachineInstr*, 4> NewTerminators;
  968     SmallVector<MachineOperand, 4> Cond;
 1123   SmallVector<MachineOperand, 4> Cond;

  220   SmallVector<MachineBasicBlock *, 4> Blocks;
  333   SmallVector<MachineBasicBlock *, 16> BlockWorkList;
  334   SmallVector<MachineBasicBlock *, 16> EHPadWorkList;
  414       SmallVector<MachineBasicBlock *, 4> &Successors);
  508       MutableArrayRef<SmallVector<WeightedEdge, 8>> Edges);
  632     SmallVector<MachineBasicBlock *, 4> &Successors) {
  764   SmallVector<MachineBasicBlock *, 4> SuccSuccs;
  943     MutableArrayRef<SmallVector<MachineBlockPlacement::WeightedEdge, 8>>
 1002   SmallVector<WeightedEdge, 8> Edges[2];
 1477   SmallVector<MachineBasicBlock *, 4> Successors;
 1505   SmallVector<std::tuple<BranchProbability, MachineBasicBlock *>, 4>
 2330   SmallVector<std::pair<MachineBasicBlock *, BlockFrequency>, 4> ExitsWithFreq;
 2560   SmallVector<MachineOperand, 4> Cond; // For AnalyzeBranch.
 2707   SmallVector<MachineOperand, 4> Cond; // For AnalyzeBranch.
 2949   SmallVector<MachineBasicBlock *, 8> DuplicatedPreds;

  105     using PhysDefVector = SmallVector<std::pair<unsigned, unsigned>, 2>;
  112     SmallVector<MachineInstr *, 64> Exps;
  513   SmallVector<std::pair<unsigned, unsigned>, 8> CSEPairs;
  514   SmallVector<unsigned, 2> ImplicitDefsToUpdate;
  515   SmallVector<unsigned, 2> ImplicitDefs;
  738   SmallVector<MachineDomTreeNode*, 32> Scopes;
  739   SmallVector<MachineDomTreeNode*, 8> WorkList;
  850   SmallVector<MachineDomTreeNode *, 32> BBs;

  113                           SmallVector<MachineCombinerPattern, 16> &Patterns);
  160   SmallVector<unsigned, 16> InstrDepth;
  379   SmallVector <const MachineBasicBlock *, 1> MBBarr;
  384   SmallVector<const MCSchedClassDesc *, 16> InsInstrsSC;
  385   SmallVector<const MCSchedClassDesc *, 16> DelInstrsSC;
  431                                      SmallVector<MachineInstr *, 16> InsInstrs,
  432                                      SmallVector<MachineInstr *, 16> DelInstrs,
  463     SmallVector<MachineCombinerPattern, 16> &Patterns) {
  467     SmallVector<MachineInstr *, 16> InsInstrs;
  468     SmallVector<MachineInstr *, 16> DelInstrs;
  512     SmallVector<MachineCombinerPattern, 16> Patterns;
  547       SmallVector<MachineInstr *, 16> InsInstrs;
  548       SmallVector<MachineInstr *, 16> DelInstrs;

   79     SmallVector<unsigned, 4> DefRegs;
  224   DenseMap<MachineInstr*, SmallVector<MachineInstr*, 2>> CopyDbgUsers;
  556     SmallVector<unsigned, 2> Defs;

  677         SmallVector<const GlobalValue *, 4> FilterList;

  376   SmallVector<MachineMemOperand *, 2> MMOs;
  436   SmallVector<MachineMemOperand *, 2> MergedMMOs;
 1099   SmallVector<unsigned, 8> GroupIdx;
 1722     SmallVector<StringRef, 0> SSNs;
 1791   SmallVector<unsigned,4> DeadOps;
 1870   SmallVector<unsigned,4> DeadOps;
 1979   SmallVector<size_t, 8> HashComponents;
 2123   SmallVector<MachineInstr *, 2> DbgValues;
 2145 using MMOList = SmallVector<const MachineMemOperand *, 2>;

  138   SmallVector<unsigned, 32> LocalDefs;
  142   SmallVector<unsigned, 8> ExternUses;
  146   SmallVector<MachineOperand*, 4> Defs;

  114     SmallVector<MachineBasicBlock *, 8> ExitBlocks;
  122     SmallVector<unsigned, 8> RegPressure;
  126     SmallVector<unsigned, 8> RegLimit;
  129     SmallVector<SmallVector<unsigned, 8>, 16> BackTrace;
  129     SmallVector<SmallVector<unsigned, 8>, 16> BackTrace;
  340   SmallVector<MachineLoop *, 8> Worklist(MLI->begin(), MLI->end());
  497   SmallVector<CandidateInfo, 32> Candidates;
  619     SmallVector<MachineBasicBlock*, 8> CurrentLoopExitingBlocks;
  675   SmallVector<MachineDomTreeNode*, 32> Scopes;
  676   SmallVector<MachineDomTreeNode*, 8> WorkList;
  758   SmallVector<MachineInstr *, 8> Candidates;
  816     SmallVector<MachineOperand, 4> Cond;
 1057   SmallVector<const MachineInstr*, 8> Work(1, MI);
 1308   SmallVector<MachineInstr *, 2> NewMIs;
 1374     SmallVector<unsigned, 2> Defs;
 1389     SmallVector<const TargetRegisterClass*, 2> OrigRCs;

   62         SmallVector<MachineOperand *, 4> Uses;
  120     SmallVector<MachineOperand, 4> Cond;

  607   SmallVector<SUnit *, 8> Worklist;
  661   MapVector<const Value *, SmallVector<SUnit *, 4>> PendingLoads;
  669       SmallVector<const Value *, 4> Objs;
  674         SmallVector<SUnit *, 4> &SUs = PendingLoads[V];
  678       SmallVector<const Value *, 4> Objs;
  683         MapVector<const Value *, SmallVector<SUnit *, 4>>::iterator I =
  756   SmallVector<SDep, 4> RemoveDeps;
  870     SmallVector<SDep, 4> Deps;
 1017   SmallVector<ResourceManager*, 8> Resources;
 1114   SmallVector<std::pair<SUnit *, SDep>, 8> DepsAdded;
 1124   for (SmallVector<std::pair<SUnit *, SDep>, 8>::iterator I = DepsAdded.begin(),
 1294     SmallVector<SUnit *, 4> PHISUs;
 1296     SmallVector<SUnit *, 4> SrcSUs;
 1316     SmallVector<SUnit *, 8> UseSUs;
 1548   SmallVector<RegisterMaskPair, 8> LiveOutRegs;
 2341   SmallVector<SDep, 8> Worklist;
 2364   SmallVector<SDep, 8> Worklist;

  160   SmallVector<std::pair<MachineBasicBlock*, unsigned>, 8> PredValues;

  464 using MBBRegionsVector = SmallVector<SchedRegion, 16>;
  755   SmallVector<SUnit*, 8> TopRoots, BotRoots;
 1031     SmallVector<RegisterMaskPair, 8> LiveUses;
 1203   SmallVector<SUnit*, 8> TopRoots, BotRoots;
 1448       SmallVector<RegisterMaskPair, 8> LiveUses;
 1558   SmallVector<MemOpInfo, 32> MemOpRecords;
 1601   SmallVector<SmallVector<SUnit*,4>, 32> StoreChainDependents;
 1601   SmallVector<SmallVector<SUnit*,4>, 32> StoreChainDependents;
 1766   SmallVector<SUnit*,8> LocalUses;
 1781   SmallVector<SUnit*,8> GlobalUses;

  106         std::map<MachineBasicBlock *, SmallVector<MachineBasicBlock *, 4>>;
  181     SmallVector<MachineBasicBlock *, 4> &
  582 SmallVector<MachineBasicBlock *, 4> &
  590   SmallVector<MachineBasicBlock *, 4> AllSuccs(MBB->succ_begin(),
  951   SmallVector<MachineInstr *, 4> DbgUsersToSink;
  991   SmallVector<MachineInstr *, 4> DbgDefUsers;
 1249     SmallVector<unsigned, 2> UsedOpsInCopy;
 1251     SmallVector<unsigned, 2> DefedRegsInCopy;
 1310     SmallVector<MachineInstr *, 4> DbgValsToSink;

  109   SmallVector<unsigned, 32> PRCycles(PRKinds);
  523   SmallVector<const MachineBasicBlock*, 16> WorkList;
  703   SmallVector<unsigned, 8> Kills;
  704   SmallVector<unsigned, 8> LiveDefOps;
  784   SmallVector<DataDep, 8> Deps;
  841   SmallVector<const MachineBasicBlock*, 8> Stack;
  897   SmallVector<unsigned, 8> ReadOps;
 1003   SmallVector<const MachineBasicBlock*, 8> Stack;
 1043   SmallVector<DataDep, 8> Deps;
 1183   SmallVector<DataDep, 1> Deps;

  105     using RegVector = SmallVector<unsigned, 16>;
  106     using RegMaskVector = SmallVector<const uint32_t *, 4>;
  673   SmallVector<MachineOperand, 4> Cond;
  925   SmallVector<LLT, 4> Types;
 1438     SmallVector<int, 32> MaskIdxes;
 2613   SmallVector<SlotIndex, 4> Undefs;
 2755   SmallVector<StackStateOfBB, 8> SPState;

  124   SmallVector<MachineBasicBlock *, 4> PrologBBs;
  164   SmallVector<MachineBasicBlock *, 4> EpilogBBs;
  240     SmallVector<MachineOperand, 0> Cond;
  256   SmallVector<MachineOperand, 4> Cond;
  326     SmallVector<MachineOperand, 4> Cond1;
  859   SmallVector<MachineInstr *, 4> PrevInsts;
  867     SmallVector<MachineOperand, 4> Cond;
  953   SmallVector<MachineMemOperand *, 2> NewMMOs;
 1375   SmallVector<Optional<Register>, 4> Defaults;
 1519   SmallVector<Register, 4> PhiDefaults;
 1649   SmallVector<MachineBasicBlock *, 8> Blocks;
 1682     SmallVector<MachineInstr *, 4> Uses;
 1700   SmallVector<MachineOperand, 4> Cond;
 1743     SmallVector<std::pair<MachineInstr *, Register>, 4> Subs;
 1774     SmallVector<MachineOperand, 4> Cond;
 1868   SmallVector<std::pair<KernelOperandInfo, KernelOperandInfo>, 8> KOIs;
 2016     SmallVector<char, 16> SV;

  184     using RecurrenceCycle = SmallVector<RecurrenceInstr, 4>;
  285     SmallVector<RegSubRegPair, 2> RegSrcs;
  493   SmallVector<MachineOperand*, 8> Uses;
  496   SmallVector<MachineOperand*, 8> ExtendedUses;
  631   SmallVector<MachineOperand, 4> Cond;
  670   SmallVector<RegSubRegPair, 4> SrcToLook;
 1136     SmallVector<RegSubRegPair, 4> NewPHISrcs;
 1279   SmallVector<RegSubRegPair, 4> RewritePairs;
 1904   SmallVector<RegSubRegPairAndIdx, 8> RegSeqInputRegs;

  294   SmallVector<const TargetRegisterClass*, 4> CriticalPathRCs;

   84     SmallVector<Value *, 8> Args(CI->arg_begin(), CI->arg_end());

   76 using MBBVector = SmallVector<MachineBasicBlock *, 4>;
  173     SmallDenseMap<MachineBasicBlock *, SmallVector<MachineInstr *, 4>, 4>;
  180   SmallVector<const MachineInstr *, 4> FrameIndexValues;
  470   SmallVector<MachineBasicBlock *, 8> WorkList;
  674   SmallVector<int, 16> AllocatedFrameSlots;
  889     SmallVector<int, 2> SFIs;
  996   SmallVector<int, 8> ObjectsToAllocate;
 1051     SmallVector<int, 2> SFIs;
 1144   SmallVector<int, 8> SPState;
 1233           SmallVector<uint64_t, 2> Ops = {dwarf::DW_OP_deref_size, Size};

  110     using VirtRegVec = SmallVector<unsigned, 4>;

  208   SmallVector<LiveInterval*, 8> Intfs;
  259   SmallVector<unsigned, 8> PhysRegSpillCands;

  102     DenseMap<unsigned, SmallVector<MachineInstr *, 2>> LiveDbgValueMap;
  131     SmallVector<unsigned, 16> VirtDead;
  132     SmallVector<MachineInstr *, 32> Coalesced;
  917   SmallVector<unsigned, 8> PartialDefs;

  352   SmallVector<SpillPlacement::BlockConstraint, 8> SplitConstraints;
  367     SmallVector<unsigned, 8> ActiveBlocks;
  392   SmallVector<GlobalSplitCandidate, 32> GlobalCand;
  398   SmallVector<unsigned, 32> BundleCand;
  536   using HintsInfo = SmallVector<HintInfo, 4>;
 1061   SmallVector<LiveInterval*, 8> Intfs;
 1772   SmallVector<unsigned, 8> IntvMap;
 1975   SmallVector<unsigned, 8> UsedCands;
 2037   SmallVector<unsigned, 8> IntvMap;
 2132   SmallVector<unsigned, 8> IntvMap;
 2259   SmallVector<unsigned, 8> RegMaskGaps;
 2316   SmallVector<float, 8> GapWeight;
 2428   SmallVector<unsigned, 8> IntvMap;
 2631   SmallVector<unsigned, 4> CurrentNewVRegs;
 2919   SmallVector<unsigned, 2> RecoloringCandidates;
 3170         SmallVector<const MachineMemOperand *, 2> Accesses;

  640       SmallVector<unsigned, 8> NewVRegs;
  733       SmallVector<unsigned, 8> NewVRegs;

  102   SmallVector<MCPhysReg, 16> CSRAlias;

  150     SmallVector<MachineInstr*, 8> WorkList;
  151     SmallVector<MachineInstr*, 8> LocalWorkList;
  158     SmallVector<MachineInstr*, 8> DeadDefs;
  161     SmallVector<unsigned, 8> InflateRegs;
  313         SmallVector<LiveInterval*, 8> SplitLIs;
  545   SmallVector<unsigned, 8> NewRegs;
 1149   SmallVector<SlotIndex, 8> EndPoints;
 1310   SmallVector<MachineOperand, 4> ImplicitOps;
 1332   SmallVector<unsigned, 4> NewMIImplDefs;
 1684     SmallVector<unsigned,8> Ops;
 2196   SmallVector<int, 8> Assignments;
 2278   SmallVector<Val, 8> Vals;
 2859     SmallVector<std::pair<SlotIndex, LaneBitmask>, 8> TaintExtent;
 3049         SmallVector<SlotIndex,8> EndPoints;
 3212   SmallVector<VNInfo*, 16> NewVNInfo;
 3239   SmallVector<SlotIndex, 8> EndPoints;
 3303   SmallVector<VNInfo*, 16> NewVNInfo;
 3376   SmallVector<SlotIndex, 8> EndPoints;
 3382   SmallVector<unsigned, 8> ShrinkRegs;
 3577     SmallVector<MachineInstr*, 2> LocalTerminals;
 3578     SmallVector<MachineInstr*, 2> GlobalTerminals;
 3605     SmallVector<MachineInstr*, 2> Terminals;

   75   SmallVector<const FuncPtrRegMaskPair *, 64> FPRMPairVector;

  126   SmallVector<SubRangeInfo, 4> SubRangeInfos;
  134   SmallVector<LiveInterval*, 4> Intervals;
  268   SmallVector<unsigned, 8> VNIMapping;
  269   SmallVector<LiveInterval::SubRange*, 8> SubRanges;

  284   SmallVector<const Value *, 8> WorkList;
  744   SmallVector<AllocaInst *, 16> StaticAllocas;
  745   SmallVector<AllocaInst *, 4> DynamicAllocas;
  746   SmallVector<Argument *, 4> ByValArguments;
  747   SmallVector<ReturnInst *, 4> Returns;
  754   SmallVector<Instruction *, 4> StackRestorePoints;

   73     SmallVector<Instruction *, 8> WorkList;
  215     SmallVector<unsigned, 8> Start;

   93   SmallVector<LiveRange, 8> LiveRanges;
   98   SmallVector<Instruction *, 8> Markers;
  106   DenseMap<BasicBlock *, SmallVector<std::pair<unsigned, Marker>, 4>> BBMarkers;

   38   SmallVector<StackRegion, 16> Regions;
   46   SmallVector<StackObject, 8> StackObjects;

  219   SmallVector<SUnit*, 8> WorkList;
  234   SmallVector<SUnit*, 8> WorkList;
  265   SmallVector<SUnit*, 8> WorkList;
  296   SmallVector<SUnit*, 8> WorkList;

  155         SmallVector<Value *, 4> Objs;

  145     SmallVector<SDNode *, 64> Worklist;
 1725   SmallVector<SDNode *, 8> TFs;     // List of token factors to visit.
 1726   SmallVector<SDValue, 8> Ops;      // Ops for replacing token factor.
 1790   SmallVector<std::pair<SDNode *, unsigned>, 8> Worklist;
 1791   SmallVector<unsigned, 8> OpWorkCount; // Count of work for each Op.
 1873         SmallVector<SDValue, 8> PrunedOps;
 1900     SmallVector<SDValue, 8> Ops;
 4871   SmallVector<LoadSDNode*, 8> Loads;
 5718         SmallVector<int, 4> Mask(NumElts);
 6421 static Optional<bool> isBigEndian(const SmallVector<int64_t, 4> &ByteOffsets,
 6478   SmallVector<StoreSDNode *, 8> Stores;
 6502   SmallVector<int64_t, 4> ByteOffsets(Width, INT64_MAX);
 6686   SmallVector<int64_t, 4> ByteOffsets(ByteWidth);
 7582     SmallVector<SDValue, 16> ShiftValues;
 8941   SmallVector<SDValue, 8> Elts;
 9039     SmallVector<SDValue, 4> Ops;
 9092   SmallVector<SDNode *, 4> SetCCs;
 9117   SmallVector<SDValue, 4> Loads;
 9118   SmallVector<SDValue, 4> Chains;
 9196   SmallVector<SDNode*, 4> SetCCs;
 9323   SmallVector<SDNode *, 4> SetCCs;
 9505       SmallVector<SDNode*, 4> SetCCs;
 9819       SmallVector<SDNode*, 4> SetCCs;
10012     SmallVector<SDNode*, 4> SetCCs;
10649     SmallVector<SDValue, 8> TruncOps;
10679       SmallVector<SDValue, 8> Opnds;
10724     SmallVector<EVT, 8> VTs;
10749       SmallVector<SDValue, 8> Opnds;
11184     SmallVector<int, 8> NewMask;
11218     SmallVector<SDValue, 8> Ops;
11261     SmallVector<SDValue, 8> Ops;
11293   SmallVector<SDValue, 8> Ops;
13583   SmallVector<const SDNode *, 16> Worklist;
13589   SmallVector<SDNode *, 16> OtherUses;
13813       SmallVector<const SDNode *, 8> Worklist;
14617   SmallVector<LoadedSlice, 4> LoadedSlices;
14679   SmallVector<SDValue, 8> ArgChains;
15087   SmallVector<SDValue, 8> Chains;
15130       SmallVector<SDValue, 8> BuildVector;
15159       SmallVector<SDValue, 8> Ops;
15430   SmallVector<const SDNode *, 8> Worklist;
15521   SmallVector<MemOpLink, 8> StoreNodes;
15772     SmallVector<MemOpLink, 8> LoadNodes;
16345   SmallVector<SDValue, 8> Chains = {N->getOperand(0)};
16523       SmallVector<int, 16> NewMask(Mask.begin(), Mask.end());
16560   SmallVector<int, 16> Mask(NumMaskVals);
16577   SmallVector<SDValue, 8> ConcatOps(ExtendRatio, DAG.getUNDEF(SubVecVT));
16610       SmallVector<SDValue, 8> Ops(NumElts, InVal);
16648   SmallVector<SDValue, 8> Ops;
17127   SmallVector<SDValue, 8> Ops(NewBVElems, Filler);
17192       SmallVector<SDValue, 2> ConcatOps(NumConcats, DAG.getUNDEF(InVT1));
17237       SmallVector<SDValue, 2> ConcatOps(2, DAG.getUNDEF(InVT2));
17250   SmallVector<int, 8> Mask(ShuffleNumElems, -1);
17329   SmallVector<int, 32> ShufMask(NumMaskElts, -1);
17386   SmallVector<int, 8> VectorMask(NumElems, -1);
17387   SmallVector<SDValue, 8> VecIn;
17447     SmallVector<unsigned, 8> IndexVec(NumElems, 0);
17501   SmallVector<SDValue, 4> Shuffles;
17555       SmallVector<int, 8> Mask(NumElems, -1);
17648           SmallVector<SDValue, 8> Ops(N->getNumOperands(), Splat);
17715   SmallVector<SDValue, 8> Ops;
17777   SmallVector<int, 8> Mask;
17863       SmallVector<SDValue, 4> Ops(In->op_begin(), In->op_end());
17919     SmallVector<SDValue, 8> Opnds;
18379   SmallVector<int, 16> Mask0(HalfNumElts, -1);
18380   SmallVector<int, 16> Mask1(HalfNumElts, -1);
18419   SmallVector<SDValue, 4> Ops;
18523   SmallVector<SDValue, 8> Ops;
18729   SmallVector<int, 32> NewMask;
18771   SmallVector<int, 16> CommutedMask(Mask.begin(), Mask.end());
18861     SmallVector<int, 8> NewMask;
18877     SmallVector<int, 8> NewMask;
18914       SmallVector<int, 16> ZeroMask(VT.getVectorNumElements(), 0);
18955       SmallVector<SDValue, 8> Ops(NumElts, Splatted);
19008       SmallVector<int, 8> NewMask;
19033         SmallVector<int, 8> InnerMask =
19035         SmallVector<int, 8> OuterMask =
19039         SmallVector<int, 8> NewMask;
19106     SmallVector<int, 4> Mask;
19202       SmallVector<int, 8> NewMask(InVecT.getVectorNumElements(), -1);
19373     SmallVector<SDValue, 8> Ops(N0->op_begin(), N0->op_end());
19471     SmallVector<int, 8> Indices;
19569     SmallVector<SDValue, 8> Ops(VT.getVectorNumElements(), DAG.getUNDEF(EltVT));
19575   SmallVector<SDValue, 8> Ops(VT.getVectorNumElements(), ScalarBO);
19663       SmallVector<SDValue, 4> ConcatOps;
19807     SmallVector<const SDNode *, 16> Worklist;
20195   SmallVector<SDNode *, 8> Built;
20216   SmallVector<SDNode *, 8> Built;
20236   SmallVector<SDNode *, 8> Built;
20606   SmallVector<SDValue, 8> Chains;     // List of chains to visit.
20716   SmallVector<SDValue, 8> Aliases;
20754   SmallVector<StoreSDNode *, 8> ChainedStores;
20817   SmallVector<SDValue, 8> TFOps;

  307   SmallVector<MachineInstr *, 1> DbgValues;
  806   SmallVector<MachineOperand, 32> Ops;
  937   SmallVector<MachineOperand, 32> Ops;
 1045   SmallVector<MachineOperand, 8> Ops;
 1064   SmallVector<MachineOperand, 8> Ops;
 1084   SmallVector<Attribute::AttrKind, 2> Attrs;
 1139   SmallVector<EVT, 4> RetTys;
 1142   SmallVector<ISD::OutputArg, 4> Outs;
 1781   SmallVector<EVT, 4> AggValueVTs;

   92   SmallVector<ISD::OutputArg, 4> Outs;
  281       SmallVector<EVT, 4> ValueVTs;
  365   SmallVector<EVT, 4> ValueVTs;
  416   SmallVector<EVT, 1> ValueVTs;
  532     SmallVector<EVT, 4> ValueVTs;

  929   SmallVector<Register, 8> UsedRegs;
 1070     SmallVector<unsigned, 8> GroupIdx;
 1073     SmallVector<unsigned, 8> ECRegs;

  271   SmallVector<int, 8> NewMask;
  413       SmallVector<int, 8> ShufOps;
 1237         SmallVector<SDValue, 8> ResultVals;
 1292   SmallVector<const SDNode *, 16> Worklist;
 1350   SmallVector<SDValue, 6> NewLoadOperands(NewLoad->op_begin(),
 1400   SmallVector<SDValue, 8> Stores;
 1817     SmallVector<std::pair<SDValue, SmallVector<int, 16>>, 16> IntermedVals,
 1817     SmallVector<std::pair<SDValue, SmallVector<int, 16>>, 16> IntermedVals,
 1835         SmallVector<int, 16> ShuffleVec(NumElems, -1);
 1837         SmallVector<int, 16> FinalIndices;
 1881     SmallVector<int, 16> ShuffleVec(NumElems, -1);
 1938     SmallVector<Constant*, 16> CV;
 1980       SmallVector<int, 8> ShuffleVec(NumElems, -1);
 2655   SmallVector<SDValue, 8> Results;
 2955     SmallVector<int, 32> NewMask;
 3006     SmallVector<SDValue, 16> Ops;
 3256     SmallVector<SDValue, 4> Halves;
 3667     SmallVector<SDValue, 8> Scalars;
 3751   SmallVector<SDValue, 8> Results;
 4123   SmallVector<SDValue, 8> Results;
 4423     SmallVector<SDValue, 8> NewOps;
 4465     SmallVector<SDValue, 8> NewOps;
 4547     SmallVector<SDValue, 8> NewElts;

 1099   SmallVector<SDValue, 8> Parts(NumRegs);
 1363   SmallVector<SDValue, 16> NewOps;
 1491     SmallVector<SDValue, 4> NewOps(N->op_begin(), N->op_end());
 1510   SmallVector<SDValue, 4> NewOps(N->op_begin(), N->op_end());
 1518   SmallVector<SDValue, 5> NewOps(N->op_begin(), N->op_end());
 1538   SmallVector<SDValue, 5> NewOps(N->op_begin(), N->op_end());
 2923   SmallVector<SDValue, 4> Result;
 4085   SmallVector<SDValue, 8> Ops;
 4128   SmallVector<SDValue, 8> Ops;
 4196   SmallVector<SDValue, 8> Ops(NumOutElem);
 4305   SmallVector<SDValue, 8> NewOps;

   76   SmallVector<SDNode*, 16> NewNodes;
  882   SmallVector<SDValue, 8> Results;
  920   SmallVector<SDValue, 8> Results;
  996   SmallVector<SDValue, 8> Ops(NumOps);

  134   SmallVector<SDNode*, 128> Worklist;

  120       SmallVector<SDValue, 8> Vals;
  356     SmallVector<SDValue, 8> Ops;
  381   SmallVector<SDValue, 16> NewElts;
  448   SmallVector<SDValue, 16> Ops(NumElts);

  238   SmallVector<SDValue, 8> Ops;
  544   SmallVector<SDValue, 4> Operands(Op.getNumOperands());
  578   SmallVector<SDValue, 4> Operands(Op.getNumOperands());
  634     SmallVector<SDValue, 8> Vals;
  635     SmallVector<SDValue, 8> LoadChains;
  658     SmallVector<SDValue, 8> LoadVals;
  986   SmallVector<int, 16> ShuffleMask;
 1050   SmallVector<int, 16> ShuffleMask;
 1075   SmallVector<int, 16> ShuffleMask;
 1101     SmallVector<int, 16> BSWAPMask;
 1378   SmallVector<SDValue, 32> OpValues;
 1379   SmallVector<SDValue, 32> OpChains;
 1381     SmallVector<SDValue, 4> Opers;
 1422   SmallVector<SDValue, 8> Ops(NumElems);

  229   SmallVector<SDValue, 4> Opers;
  263     SmallVector<SDValue, 1> ElemsLHS, ElemsRHS;
  707   SmallVector<SDValue, 8> Ops(N->getNumOperands());
 1120   SmallVector<SDValue, 8> LoOps(N->op_begin(), N->op_begin()+LoNumElts);
 1123   SmallVector<SDValue, 8> HiOps(N->op_begin()+LoNumElts, N->op_end());
 1141   SmallVector<SDValue, 8> LoOps(N->op_begin(), N->op_begin()+NumSubvectors);
 1144   SmallVector<SDValue, 8> HiOps(N->op_begin()+NumSubvectors, N->op_end());
 1290   SmallVector<int, 8> SplitHi(InNumElements, -1);
 1307   SmallVector<SDValue, 4> OpsLo;
 1308   SmallVector<SDValue, 4> OpsHi;
 1356   SmallVector<SDValue, 8> Scalars;
 1357   SmallVector<SDValue, 4> Operands(N->getNumOperands());
 1367   SmallVector<SDValue, 8> Chains;
 1836   SmallVector<int, 16> Ops;
 1889       SmallVector<SDValue, 16> SVOps;
 2533   SmallVector<SDValue, 32> Elts;
 2986       SmallVector<SDValue, 16> SubConcatOps(OpsToConcat);
 3049   SmallVector<SDValue, 16> ConcatOps(CurNumElts);
 3113   SmallVector<SDValue, 4> InOps;
 3116   SmallVector<SDValue, 16> ConcatOps(CurNumElts);
 3117   SmallVector<SDValue, 16> Chains;
 3144       SmallVector<SDValue, 4> EOps;
 3171         SmallVector<SDValue, 4> EOps;
 3302       SmallVector<SDValue, 16> Ops(NumConcat, DAG.getUNDEF(InVT));
 3323   SmallVector<SDValue, 16> Ops(WidenNumElts, DAG.getUNDEF(EltVT));
 3343   SmallVector<SDValue, 4> NewOps(N->op_begin(), N->op_end());
 3347   SmallVector<EVT, 2> WidenVTs = { WidenVT, MVT::Other };
 3358   SmallVector<EVT, 2> EltVTs = { EltVT, MVT::Other };
 3359   SmallVector<SDValue, 16> Ops(WidenNumElts, DAG.getUNDEF(EltVT));
 3360   SmallVector<SDValue, 32> OpChains;
 3404   SmallVector<SDValue, 16> Ops;
 3557         SmallVector<SDValue, 16> Ops(NewNumElts, DAG.getUNDEF(InVT));
 3584   SmallVector<SDValue, 16> NewOps(N->op_begin(), N->op_end());
 3606       SmallVector<SDValue, 16> Ops(NumConcat);
 3629         SmallVector<int, 16> MaskOps(WidenNumElts, -1);
 3644   SmallVector<SDValue, 16> Ops(WidenNumElts);
 3686   SmallVector<SDValue, 16> Ops(WidenNumElts);
 3714   SmallVector<SDValue, 16> LdChain;  // Chain for the series of load
 3849   SmallVector<SDValue, 4> Ops;
 3883     SmallVector<SDValue, 16> SubOps(NumSubVecs, DAG.getUNDEF(SubVT));
 4067   SmallVector<int, 16> NewMask;
 4315   SmallVector<SDValue, 16> Ops(NumElts);
 4317     SmallVector<SDValue, 4> NewOps(N->op_begin(), N->op_end());
 4318     SmallVector<SDValue, 32> OpChains;
 4403   SmallVector<SDValue, 16> Ops(NumElts);
 4442   SmallVector<SDValue, 16> StChain;
 4804     SmallVector<SDValue, 16> ConcatOps(NumConcat);
 4813   SmallVector<SDValue, 16> LdOps;
 4837         SmallVector<SDValue, 16> Loads;
 4868   SmallVector<SDValue, 16> ConcatOps(End);
 4900   SmallVector<SDValue, 16> WidenOps(NumOps);
 4936   SmallVector<SDValue, 16> Ops(WidenNumElts);
 5092     SmallVector<SDValue, 16> Ops(NumConcat);
 5108   SmallVector<SDValue, 16> Ops(WidenNumElts);

   49     SmallVector<SUnit *, 16> Queue;
  234     SmallVector<SDNode*, 2> NewNodes;
  278     SmallVector<SDep, 4> ChainSuccs;
  279     SmallVector<SDep, 4> LoadPreds;
  280     SmallVector<SDep, 4> NodePreds;
  281     SmallVector<SDep, 4> NodeSuccs;
  358   SmallVector<std::pair<SUnit *, SDep>, 4> DelDeps;
  394   SmallVector<std::pair<SUnit *, SDep>, 4> DelDeps;
  540   SmallVector<SUnit*, 4> NotReady;
  541   DenseMap<SUnit*, SmallVector<unsigned, 4> > LRegsMap;
  548       SmallVector<unsigned, 4> LRegs;
  593           SmallVector<SUnit*, 2> Copies;
  718   SmallVector<SDNode*, 8> Glues;

  174   SmallVector<SUnit*, 4> Interferences;
  176   using LRegsMapT = DenseMap<SUnit *, SmallVector<unsigned, 4>>;
  983   SmallVector<SDNode *, 2> NewNodes;
 1057   SmallVector<SDep, 4> ChainPreds;
 1058   SmallVector<SDep, 4> ChainSuccs;
 1059   SmallVector<SDep, 4> LoadPreds;
 1060   SmallVector<SDep, 4> NodePreds;
 1061   SmallVector<SDep, 4> NodeSuccs;
 1197   SmallVector<std::pair<SUnit *, SDep>, 4> DelDeps;
 1236   SmallVector<std::pair<SUnit *, SDep>, 4> DelDeps;
 1467       SmallVector<unsigned, 4> LRegs;
 1576       SmallVector<SUnit*, 2> Copies;
 1953   SmallVector<WorkState, 16> WorkList;

  142   SmallVector<SDValue, 8> Ops(N->op_begin(), N->op_end());
  150   SmallVector<MachineMemOperand *, 2> MMOs;
  175   SmallVector<EVT, 4> VTs(N->value_begin(), N->value_end());
  224   SmallVector<int64_t, 4> Offsets;
  266   SmallVector<SDNode*, 4> Loads;
  340   SmallVector<SDNode*, 64> Worklist;
  345   SmallVector<SUnit*, 8> CallSUnits;
  681   SmallVector<SDNode *, 4> GluedNodes;
  831   SmallVector<std::pair<unsigned, MachineInstr*>, 32> Orders;
  903     SmallVector<SDNode *, 4> GluedNodes;
  978     SmallVector<MachineInstr*, 8> DbgMIs;

  682   SmallVector<SDNode*, 128> DeadNodes;
  732   SmallVector<SDNode*, 16> DeadNodes(1, N);
 1234     SmallVector<SDValue, 2> EltParts;
 1253     SmallVector<SDValue, 8> Ops;
 1588   SmallVector<int, 8> MaskVec(Mask.begin(), Mask.end());
 1744   SmallVector<int, 8> MaskVec(SV.getMask().begin(), SV.getMask().end());
 4234   SmallVector<SDValue, 16> Elts;
 4844   SmallVector<SDValue, 4> Outputs;
 4933   SmallVector<SDValue, 4> ScalarResults;
 4935     SmallVector<SDValue, 4> ScalarOps;
 5212       SmallVector<SDValue, 8> Ops;
 5606   SmallVector<SDValue, 8> ArgChains;
 5745                           SmallVector<SDValue, 32> &OutChains, unsigned From,
 5746                           unsigned To, SmallVector<SDValue, 16> &OutLoadChains,
 5747                           SmallVector<SDValue, 16> &OutStoreChains) {
 5750   SmallVector<SDValue, 16> GluedLoadChains;
 5833   SmallVector<SDValue, 16> OutLoadChains;
 5834   SmallVector<SDValue, 16> OutStoreChains;
 5835   SmallVector<SDValue, 32> OutChains;
 6007   SmallVector<SDValue, 8> LoadValues;
 6008   SmallVector<SDValue, 8> LoadChains;
 6009   SmallVector<SDValue, 8> OutChains;
 6105   SmallVector<SDValue, 8> OutChains;
 6557   SmallVector<EVT, 4> VTs;
 7198   SmallVector<SDValue, 8> NewOps(Ops.begin(), Ops.end());
 7736     SmallVector<SDNode *, 16> DeadNodes;
 7795   SmallVector<SDValue, 3> Ops;
 8037   SmallVector<SDDbgValue *, 2> ClonedDVs;
 8085   SmallVector<SDDbgValue *, 2> ClonedDVs;
 8473   SmallVector<UseMemo, 4> Uses;
 9005   SmallVector<const SDNode *, 16> Worklist;
 9119   SmallVector<SDValue, 8> Scalars;
 9120   SmallVector<SDValue, 4> Operands(N->getNumOperands());
 9200   SmallVector<SDValue, 8> LHSScalars;
 9201   SmallVector<SDValue, 8> RHSScalars;
 9207   SmallVector<SDValue, 8> ResScalars;
 9208   SmallVector<SDValue, 8> OvScalars;

  393     SmallVector<SDValue, 8> Ops(NumIntermediates);
  643     SmallVector<SDValue, 16> Ops;
  739   SmallVector<SDValue, 8> Ops(NumIntermediates);
  770 RegsForValue::RegsForValue(const SmallVector<unsigned, 4> &regs, MVT regvt,
  810   SmallVector<SDValue, 4> Values(ValueVTs.size());
  811   SmallVector<SDValue, 8> Parts;
  895   SmallVector<SDValue, 8> Parts(NumRegs);
  913   SmallVector<SDValue, 8> Chains(NumRegs);
  994 SmallVector<std::pair<unsigned, unsigned>, 4>
  996   SmallVector<std::pair<unsigned, unsigned>, 4> OutVec;
 1472       SmallVector<SDValue, 4> Constants;
 1489       SmallVector<SDValue, 4> Ops;
 1507       SmallVector<EVT, 4> ValueVTs;
 1512       SmallVector<SDValue, 4> Constants(NumElts);
 1534     SmallVector<SDValue, 16> Ops;
 1740   SmallVector<std::pair<MachineBasicBlock *, BranchProbability>, 1> UnwindDests;
 1768   SmallVector<ISD::OutputArg, 8> Outs;
 1769   SmallVector<SDValue, 8> OutVals;
 1790     SmallVector<EVT, 1> PtrValueVTs;
 1800     SmallVector<EVT, 4> ValueVTs, MemVTs;
 1801     SmallVector<uint64_t, 4> Offsets;
 1806     SmallVector<SDValue, 4> Chains(NumValues);
 1823     SmallVector<EVT, 4> ValueVTs;
 1857         SmallVector<SDValue, 4> Parts(NumParts);
 2150     SmallVector<BranchProbability, 2> Probs{TProb / 2, FProb};
 2183     SmallVector<BranchProbability, 2> Probs{TProb, FProb / 2};
 2776       SmallVector<SDValue, 8> Ops;
 2805   SmallVector<std::pair<MachineBasicBlock *, BranchProbability>, 1> UnwindDests;
 2878   SmallVector<EVT, 2> ValueVTs;
 3027   SmallVector<const User *, 16> UsersToVisit{Inst};
 3251   SmallVector<EVT, 4> ValueVTs;
 3257   SmallVector<SDValue, 4> Values(NumValues);
 3365       SmallVector<SDValue, 3> Ops(BaseOps.begin(), BaseOps.end());
 3564   SmallVector<int, 8> Mask;
 3584       SmallVector<int, 8> ConcatSrcs(NumConcat, -1);
 3604         SmallVector<SDValue, 8> ConcatOps;
 3626     SmallVector<SDValue, 8> MOps1(NumConcat, UndefVal);
 3627     SmallVector<SDValue, 8> MOps2(NumConcat, UndefVal);
 3635     SmallVector<int, 8> MappedOps(PaddedMaskNumElts, -1);
 3702       SmallVector<int, 8> MappedOps(Mask.begin(), Mask.end());
 3720   SmallVector<SDValue,8> Ops;
 3757   SmallVector<EVT, 4> AggValueVTs;
 3759   SmallVector<EVT, 4> ValValueVTs;
 3764   SmallVector<SDValue, 4> Values(NumAggValues);
 3809   SmallVector<EVT, 4> ValValueVTs;
 3820   SmallVector<SDValue, 4> Values(NumValValues);
 4034   SmallVector<EVT, 4> ValueVTs, MemVTs;
 4035   SmallVector<uint64_t, 4> Offsets;
 4069   SmallVector<SDValue, 4> Values(NumValues);
 4070   SmallVector<SDValue, 4> Chains(std::min(MaxParallelChains, NumValues));
 4130   SmallVector<EVT, 4> ValueVTs;
 4131   SmallVector<uint64_t, 4> Offsets;
 4169   SmallVector<EVT, 4> ValueVTs;
 4170   SmallVector<uint64_t, 4> Offsets;
 4206   SmallVector<EVT, 4> ValueVTs, MemVTs;
 4207   SmallVector<uint64_t, 4> Offsets;
 4221   SmallVector<SDValue, 4> Chains(std::min(MaxParallelChains, NumValues));
 4770   SmallVector<SDValue, 8> Ops;
 4813   SmallVector<EVT, 4> ValueVTs;
 5503   SmallVector<std::pair<unsigned, unsigned>, 8> ArgRegsAndSizes;
 6576     SmallVector<const Value *, 4> Allocas;
 6717     SmallVector<SDValue, 8> Ops;
 6748     SmallVector<SDValue, 8> Ops;
 6795     SmallVector<SDValue, 16> Ops;
 6810     SmallVector<BranchFunnelTarget, 8> Targets;
 6985   SmallVector<EVT, 4> ValueVTs;
 7799 using SDISelAsmOperandInfoVector = SmallVector<SDISelAsmOperandInfo, 16>;
 7888   SmallVector<unsigned, 4> Regs;
 8265           SmallVector<unsigned, 4> Regs;
 8411   SmallVector<EVT, 1> ResultVTs;
 8412   SmallVector<SDValue, 1> ResultValues;
 8413   SmallVector<SDValue, 8> OutChains;
 8525   SmallVector<EVT, 1> ValueVTs;
 8531   SmallVector<SDValue, 1> Ops;
 8605   SmallVector<SDValue, 4> Ops;
 8693   SmallVector<SDValue, 32> Ops;
 8805   SmallVector<SDValue, 8> Ops;
 8860     SmallVector<EVT, 3> ValueVTs;
 8970   SmallVector<Attribute::AttrKind, 2> Attrs;
 8991   SmallVector<EVT, 4> RetTys;
 8992   SmallVector<uint64_t, 4> Offsets;
 8998     SmallVector<EVT, 4> OldRetTys;
 8999     SmallVector<uint64_t, 4> OldOffsets;
 9015   SmallVector<ISD::OutputArg, 4> Outs;
 9112     SmallVector<EVT, 4> ValueVTs;
 9200       SmallVector<SDValue, 4> Parts(NumParts);
 9258   SmallVector<SDValue, 4> InVals;
 9289   SmallVector<SDValue, 4> ReturnValues;
 9293     SmallVector<EVT, 1> PVTs;
 9302     SmallVector<SDValue, 4> Chains(NumValues);
 9584   SmallVector<ISD::InputArg, 16> Ins;
 9588     SmallVector<EVT, 1> ValueVTs;
 9613     SmallVector<EVT, 4> ValueVTs;
 9728   SmallVector<SDValue, 8> InVals;
 9754     SmallVector<EVT, 1> ValueVTs;
 9778   SmallVector<SDValue, 4> Chains;
 9781     SmallVector<SDValue, 4> ArgValues;
 9782     SmallVector<EVT, 4> ValueVTs;
 9984       SmallVector<EVT, 4> ValueVTs;

  133   SmallVector<SDValue, 8> PendingLoads;
  144   SmallVector<SDValue, 8> PendingExports;
  418   DenseMap<MachineBasicBlock *, SmallVector<unsigned, 4>> LPadToCallSiteMap;
  566     SmallVector<const Value *, 16> Bases;
  567     SmallVector<const Value *, 16> Ptrs;
  570     SmallVector<const GCRelocateInst *, 16> GCRelocates;
  814   SmallVector<EVT, 4> ValueVTs;
  824   SmallVector<MVT, 4> RegVTs;
  829   SmallVector<unsigned, 4> Regs;
  832   SmallVector<unsigned, 4> RegCount;
  839   RegsForValue(const SmallVector<unsigned, 4> &regs, MVT regvt, EVT valuevt,
  887   SmallVector<std::pair<unsigned, unsigned>, 4> getRegsAndSizes() const;

  473   SmallVector<StringRef, 0> SSNs;

  548     SmallVector<MachineBasicBlock*, 4> Returns;
  739   SmallVector<SDNode*, 128> Worklist;
 1063   SmallVector<SDNode *, 4> Nodes;
 1130       SmallVector<SDNode *, 4> Nodes;
 1909     SmallVector<MachineBasicBlock *, 2> Succs;
 2106   SmallVector<const SDNode *, 16> WorkList;
 2285   SmallVector<SDNode*, 4> NowDeadNodes;
 2345   SmallVector<const SDNode *, 8> Worklist;
 2346   SmallVector<SDValue, 3> InputChains;
 2689   SmallVector<SDValue, 4> NodeStack;
 2804   SmallVector<SDValue, 8> NodeStack;
 2810   SmallVector<MatchScope, 8> MatchScopes;
 2815   SmallVector<std::pair<SDValue, SDNode*>, 8> RecordedNodes;
 2819   SmallVector<MachineMemOperand*, 2> MatchedMemRefs;
 2830   SmallVector<SDNode*, 3> ChainNodesMatched;
 3025       SmallVector<SDValue, 8> Operands;
 3377       SmallVector<EVT, 4> VTs;
 3403       SmallVector<SDValue, 8> Ops;
 3491         SmallVector<MachineMemOperand *, 4> FilteredMemRefs;

  279     SmallVector<SDNode *, 4> GluedNodes;

  283   SmallVector<const Value *, 64> NewBases, NewPtrs;
  284   SmallVector<const GCRelocateInst *, 64> NewRelocs;
  662   SmallVector<SDValue, 10> LoweredMetaArgs;
  663   SmallVector<MachineMemOperand*, 16> MemRefs;
  700     SmallVector<SDValue, 8> TSOps;
  728   SmallVector<SDValue, 40> Ops;
  791     SmallVector<SDValue, 8> TEOps;

  123   SmallVector<const CallInst *, 10> PendingGCRelocateCalls;

 2219         SmallVector<SDValue, 32> Ops(Op->op_begin(), Op->op_end());
 2403     SmallVector<int, 32> NewMask(ShuffleMask.begin(), ShuffleMask.end());
 4573   SmallVector<SDValue, 16> Shifts, Factors;
 4654   SmallVector<SDValue, 16> MagicFactors, Factors, Shifts, ShiftMasks;
 4760   SmallVector<SDValue, 16> PreShifts, PostShifts, MagicFactors, NPQFactors;
 4911   SmallVector<SDNode *, 2> Built;
 4955   SmallVector<SDValue, 16> PAmts, KAmts, QAmts;
 5078   SmallVector<SDNode *, 7> Built;
 5130   SmallVector<SDValue, 16> PAmts, AAmts, KAmts, QAmts;
 5477     SmallVector<SDValue, 4> Ops;
 5773   SmallVector<SDValue, 2> Result;
 6364   SmallVector<SDValue, 8> Vals;
 6365   SmallVector<SDValue, 8> LoadChains;
 6441   SmallVector<SDValue, 8> Stores;
 6505     SmallVector<SDValue, 8> Stores;
 6668     SmallVector<SDValue, 8> Stores;
 7360   SmallVector<SDValue, 8> Ops;

  107   SmallVector<Constant *, 16> Metadata;
  234   SmallVector<std::pair<CallInst *, AllocaInst *>, 16> MetaRoots;

  425         SmallVector<MachineBasicBlock*, 4> ExitBlocks;

  137   SmallVector<Value *, 8> UseWorkList(LPI->user_begin(), LPI->user_end());
  281       SmallVector<Instruction *, 16> Users;
  354   SmallVector<ReturnInst *, 16> Returns;
  355   SmallVector<InvokeInst *, 16> Invokes;

   90   using LinkVector = SmallVector<std::pair<BlockFrequency, unsigned>, 4>;

   56   SmallVector<unsigned, 8> Linked;
   60   SmallVector<unsigned, 8> RecentPositive;
   63   SmallVector<BlockFrequency, 8> BlockFrequencies;

   82   SmallVector<const MachineBasicBlock *, 1> EHPadSuccessors;
  557   SmallVector<unsigned, 8> PossibleIndexes;
  951   SmallVector<SmallPtrSet<VNInfo *, 8>, 8> EqualVNs(Parent->getNumValNums());
 1010   SmallVector<DomPair, 8> NearestDom(Parent->getNumValNums());
 1012   SmallVector<BlockFrequency, 8> Costs(Parent->getNumValNums());
 1099   SmallVector<VNInfo*, 8> BackCopies;
 1279   SmallVector<SlotIndex, 4> Undefs;
 1313   SmallVector<ExtPoint,4> ExtPoints;
 1391       SmallVector<SlotIndex, 4> Undefs;
 1408   SmallVector<MachineInstr*, 8> Dead;
 1445   SmallVector<const VNInfo *, 4> WorkList;
 1535     SmallVector<LiveInterval*, 8> SplitLIs;

   57   SmallVector<std::pair<SlotIndex, SlotIndex>, 8> LastInsertPoint;
  143   SmallVector<SlotIndex, 8> UseSlots;
  146   SmallVector<BlockInfo, 8> UseBlocks;

  409   SmallVector<const MachineBasicBlock *, 8> BasicBlockNumbering;
  413   SmallVector<std::unique_ptr<LiveInterval>, 16> Intervals;
  416   SmallVector<SmallVector<SlotIndex, 4>, 16> LiveStarts;
  416   SmallVector<SmallVector<SlotIndex, 4>, 16> LiveStarts;
  426   SmallVector<MachineInstr*, 8> Markers;
  490                             SmallVector<int, 4> &slots,
  583                                          SmallVector<int, 4> &slots,
  633   SmallVector<int, 8> NumStartLifetimes(NumSlot, 0);
  634   SmallVector<int, 8> NumEndLifetimes(NumSlot, 0);
  721     SmallVector<int, 4> slots;
  814   SmallVector<SlotIndex, 16> Starts;
  815   SmallVector<bool, 16> DefinitelyInUse;
  834       SmallVector<int, 4> slots;
 1024       SmallVector<MachineMemOperand *, 2> NewMMOs;
 1032             SmallVector<Value *, 4> Objs;
 1155   SmallVector<int, 8> SortedSlots;

   73     SmallVector<SmallVector<MachineMemOperand *, 8>, 16> SSRefs;
   73     SmallVector<SmallVector<MachineMemOperand *, 8>, 16> SSRefs;
   76     SmallVector<unsigned, 16> OrigAlignments;
   79     SmallVector<unsigned, 16> OrigSizes;
   85     SmallVector<BitVector, 2> AllColors;
   88     SmallVector<int, 2> NextColors = { -1 };
   91     SmallVector<BitVector, 2> UsedColors;
   94     SmallVector<SmallVector<LiveInterval*,4>, 16> Assignments;
   94     SmallVector<SmallVector<LiveInterval*,4>, 16> Assignments;
  211   SmallVector<Pair *, 16> Intervals;
  324   SmallVector<int, 16> SlotMapping(NumObjs, -1);
  325   SmallVector<float, 16> SlotWeights(NumObjs, 0.0);
  326   SmallVector<SmallVector<int, 4>, 16> RevMap(NumObjs);
  326   SmallVector<SmallVector<int, 4>, 16> RevMap(NumObjs);
  427   SmallVector<MachineInstr*, 4> toErase;

  181       SmallVector<std::pair<MachineBasicBlock *, Register>, 4> VRegs;

   68   SmallVector<unsigned, 8> TotalCases(N);
  104   SmallVector<unsigned, 8> MinPartitions(N);
  106   SmallVector<unsigned, 8> LastElement(N);
  109   SmallVector<unsigned, 8> PartitionsScore(N);
  288   SmallVector<unsigned, 8> MinPartitions(N);
  290   SmallVector<unsigned, 8> LastElement(N);

  160   SmallVector<MachineBasicBlock *, 8> TDBBs;
  161   SmallVector<MachineInstr *, 16> Copies;
  167   SmallVector<MachineInstr *, 8> NewPHIs;
  572   SmallVector<MachineOperand, 4> PredCond;
  688     SmallVector<MachineOperand, 4> PredCond;
  704   SmallVector<MachineBasicBlock *, 8> Preds(TailBB->pred_begin(),
  715     SmallVector<MachineOperand, 4> PredCond;
  779   SmallVector<MachineOperand, 4> PredCond;
  842     SmallVector<std::pair<unsigned, RegSubRegPair>, 4> CopyInfos;
  879   SmallVector<MachineOperand, 4> PriorCond;
  898       SmallVector<std::pair<unsigned, RegSubRegPair>, 4> CopyInfos;
  961     SmallVector<std::pair<unsigned, RegSubRegPair>, 4> CopyInfos;

 1467   SmallVector<EVT, 4> ValueVTs;
 1879   SmallVector<StringRef, 4> OverrideVector;
 1939   SmallVector<StringRef, 4> OverrideVector;

   67   SmallVector<Module::ModuleFlagEntry, 8> ModuleFlags;
  313   SmallVector<Module::ModuleFlagEntry, 8> ModuleFlags;
  889       SmallVector<std::string, 4> StrOptions;

  324   SmallVector<InsertedPass, 4> InsertedPasses;

  390   const std::pair<unsigned, SmallVector<unsigned, 4>> &Hints_MRI =

  168   using TiedPairList = SmallVector<std::pair<unsigned, unsigned>, 4>;
  774   SmallVector<unsigned, 4> VirtRegPairs;
  907   SmallVector<unsigned, 2> Uses;
  908   SmallVector<unsigned, 2> Kills;
  909   SmallVector<unsigned, 2> Defs;
 1128     SmallVector<unsigned, 2> OtherDefs;
 1365         SmallVector<MachineInstr *, 2> NewMIs;
 1425           SmallVector<unsigned, 4> OrigRegs;
 1808   SmallVector<unsigned, 4> OrigRegs;

  274   SmallVector<SubRangeIteratorPair, 4> SubRanges;
  407     SmallVector<MachineInstr *, 2> MIs({&MI});
  495   SmallVector<Register, 8> SuperDeads;
  496   SmallVector<Register, 8> SuperDefs;
  497   SmallVector<Register, 8> SuperKills;

  155   SmallVector<BasicBlock *, 8> WL(BBs.begin(), BBs.end());
  190     SmallVector<BasicBlock *, 4> Succs(succ_begin(BB), succ_end(BB));
  205   SmallVector<BasicBlock *, 16> CatchPads;
  206   SmallVector<BasicBlock *, 16> CleanupPads;

  245     SmallVector<const CatchPadInst *, 2> Handlers;
  506   SmallVector<std::pair<const Instruction *, int>, 8> Worklist;
  551       SmallVector<const BasicBlock *, 4> CatchBlocks(CatchSwitch->handlers());
  692   SmallVector<PHINode *, 16> PHINodes;
  807     SmallVector<CatchReturnInst *, 2> FixupCatchrets;
  894       SmallVector<Use *, 16> UsesToRename;
 1114   SmallVector<std::pair<BasicBlock *, Value *>, 4> Worklist;

   92   SmallVector<MachineInstr *, 4> Terminators;

   36   SmallVector<TiReference, 4> Refs;

  487   SmallVector<TiReference, 4> Refs;
  517   SmallVector<TiReference, 2> Refs;

   49   SmallVector<TypeIndex, 1> Refs;

   50   typedef SmallVector<FlagEntry, 10> FlagVector;

  196   SmallVector<uint8_t, 256> RemapStorage;
  403   SmallVector<TiReference, 4> Refs;

  213   SmallVector<DWARFFormValue, 3> AtomForms;

  953   SmallVector<DWARFDie, 4> InlinedChain;
 1168   SmallVector<DWARFDie, 4> InlinedChain;

   40 using ContentDescriptors = SmallVector<ContentDescriptor, 4>;

 1178 static SmallVector<StringRef, 2> getNames(const DWARFDie &DIE,
 1180   SmallVector<StringRef, 2> Result;

   97 void NativeRawSymbol::getDataBytes(SmallVector<uint8_t, 32> &bytes) const {

   20 void PDBSymbolCustom::getDataBytes(llvm::SmallVector<uint8_t, 32> &bytes) {

  438       SmallVector<NormalizedSymbol *, 8> BlockSyms;

  159   SmallVector<char, 4096> ObjBufferSV;
  257   SmallVector<Module*, 16> ModsToAdd;

  188   SmallVector<object::OwningBinary<object::Archive>, 2> Archives;
  189   SmallVector<std::unique_ptr<MemoryBuffer>, 2> Buffers;
  191   SmallVector<std::unique_ptr<object::ObjectFile>, 2> LoadedObjects;

   33   SmallVector<char, 0> ObjBufferSV;

  317   SmallVector<ReturnInst *, 8> Returns; // Ignore returns cloned.

   26 SmallVector<const BasicBlock *, 8> findBBwithCalls(const Function &F,
   28   SmallVector<const BasicBlock *, 8> BBs;
   91   SmallVector<std::pair<const BasicBlock *, uint64_t>, 8> BBFreqs;

   27     SmallVector<char, 1> ClonedModuleBuffer;

  150   SmallVector<std::pair<RelocationValueRef, RelocationEntry>, 8> PendingRelocs;
  155   SmallVector<SID, 2> UnregisteredEHFrameSections;

  254   typedef SmallVector<SectionEntry, 64> SectionList;
  275   typedef SmallVector<RelocationEntry, 64> RelocationList;

   49   SmallVector<EHFrameRelatedSections, 2> UnregisteredEHFrameSections;

   30   SmallVector<SID, 2> UnregisteredEHFrameSections;
   31   SmallVector<SID, 2> RegisteredEHFrameSections;

   45   SmallVector<StringRef, 4> Opts;
   82   SmallVector<StringRef, 4> Opts;

  107   SmallVector<Instruction *, 32> Insts;
  120   SmallVector<Value *, 2> Srcs;
  186   SmallVector<Instruction *, 32> InstsBefore;

  186   SmallVector<Entry, 64> List;
 1052   SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
 1077   SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
 1702   SmallVector<DINode::DIFlags, 8> SplitFlags;
 1726   SmallVector<DISubprogram::DISPFlags, 8> SplitFlags;
 2365   SmallVector<StringRef, 8> MDNames;
 2367   SmallVector<StringRef, 8> SSNs;
 3307   SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
 3427     SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
 3526     SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
 4078   SmallVector<std::pair<unsigned, MDNode *>, 4> InstMD;
 4115   SmallVector<const MDNode *, 16> Nodes;

  745   SmallVector<Attribute, 8> SortedAttrs(Attrs.begin(), Attrs.end());
  770   SmallVector<Attribute, 8> Attrs;
  991   SmallVector<std::pair<unsigned, AttributeSet>, 8> AttrPairVec;
  995     SmallVector<Attribute, 4> AttrVec;
 1032   SmallVector<AttributeSet, 4> AttrVec(attrIdxToArrayIdx(MaxIndex) + 1);
 1065   SmallVector<AttributeSet, 8> AttrSets;
 1085   SmallVector<AttributeSet, 8> AttrSets(Index + 1);
 1092   SmallVector<std::pair<unsigned, Attribute>, 8> Attrs;
 1100   SmallVector<std::pair<unsigned, Attribute>, 8> Attrs;
 1121   SmallVector<AttributeSet, 8> NewAttrSets(MaxSize);
 1173   SmallVector<AttributeSet, 4> AttrSets(this->begin(), this->end());
 1189   SmallVector<AttributeSet, 4> AttrSets(this->begin(), this->end());
 1209   SmallVector<AttributeSet, 4> AttrSets(this->begin(), this->end());
 1222   SmallVector<AttributeSet, 4> AttrSets(this->begin(), this->end());
 1237   SmallVector<AttributeSet, 4> AttrSets(this->begin(), this->end());
 1253   SmallVector<AttributeSet, 4> AttrSets(this->begin(), this->end());

  528       SmallVector<Type *, 4> Tys(fArgs.begin(), fArgs.end());
  600     SmallVector<StringRef, 2> Groups;
 1620   SmallVector<Value *, 4> Args(CI.arg_operands().begin(),
 1670       SmallVector<Metadata *, 1> Elts;
 1697       SmallVector<Metadata *, 1> Elts;
 1985       SmallVector<Value *, 4> Args;
 2257       SmallVector<uint32_t, 8> ShuffleMask(NumDstElts);
 2302       SmallVector<uint32_t, 8> ShuffleMask(0);
 2322       SmallVector<uint32_t, 8> ShuffleMask(NumDstElts);
 2412       SmallVector<uint32_t, 16> Idxs(NumElts);
 2432       SmallVector<uint32_t, 8> Idxs(DstNumElts);
 2475       SmallVector<uint32_t, 8> Idxs(DstNumElts);
 2494       SmallVector<uint32_t, 8> Idxs(NumElts);
 2517       SmallVector<uint32_t, 8> ShuffleMask(NumElts);
 2551       SmallVector<uint32_t, 8> Idxs(NumElts);
 2569       SmallVector<uint32_t, 16> Idxs(NumElts);
 2588       SmallVector<uint32_t, 16> Idxs(NumElts);
 2610       SmallVector<uint32_t, 16> Idxs(NumElts);
 2637       SmallVector<uint32_t, 16> Idxs(NumElts);
 2655       SmallVector<uint32_t, 64> Idxs(NumElts);
 2671       SmallVector<uint32_t, 64> Idxs(NumElts);
 3207       SmallVector<uint32_t, 32> Idxs(NumElts);
 3254         SmallVector<uint32_t, 32> Idxs(NumElts);
 3498     SmallVector<Value *, 2> Args;
 3509     SmallVector<Value *, 2> Args;
 3533     SmallVector<Value *, 4> Args(CI->arg_operands().begin(),
 3593     SmallVector<Value *, 4> Args(CI->arg_operands().begin(),
 3659     SmallVector<Value *, 4> Args(CI->arg_operands().begin(),
 3679     SmallVector<Value *, 4> Args(CI->arg_operands().begin(),
 3844         SmallVector<StringRef, 4> ValueComp;
 3878       SmallVector<Value *, 2> Args;
 4018         SmallVector<StringRef, 4> ValueComp;
 4049     SmallVector<StringRef, 5> Components;
 4113   SmallVector<Metadata *, 8> Ops;
 4130   SmallVector<Metadata *, 8> Ops;
 4148   SmallVector<StringRef, 4> Groups;

   59   SmallVector<Constant*, 16> Result;
  112         SmallVector<Value*, 8> IdxList;
  575     SmallVector<Constant*, 16> res;
  741     SmallVector<Constant*, 16> Result;
  806       SmallVector<Constant *, 8> Ops;
  840   SmallVector<Constant*, 16> Result;
  873   SmallVector<Constant*, 32> Result;
  923   SmallVector<Constant*, 32> Result;
  971     SmallVector<Constant*, 16> Result;
 1309     SmallVector<Constant*, 16> Result;
 1923     SmallVector<Constant*, 4> ResElts;
 2257         SmallVector<Value*, 16> NewIndices;
 2332   SmallVector<Constant *, 8> NewIdxs;

  467   SmallVector<const Constant *, 8> WorkList;
  944   SmallVector<ElementTy, 16> Elts;
  957   SmallVector<ElementTy, 16> Elts;
 1053   SmallVector<Type*, 16> EltTypes(VecSize);
 1157   SmallVector<Constant*, 32> Elts(NumElts, V);
 1230   SmallVector<Constant*, 8> NewOps;
 2586   SmallVector<uint8_t, 64> ElementVals;
 2655       SmallVector<uint8_t, 16> Elts(NumElts, CI->getZExtValue());
 2659       SmallVector<uint16_t, 16> Elts(NumElts, CI->getZExtValue());
 2663       SmallVector<uint32_t, 16> Elts(NumElts, CI->getZExtValue());
 2667     SmallVector<uint64_t, 16> Elts(NumElts, CI->getZExtValue());
 2673       SmallVector<uint16_t, 16> Elts(
 2678       SmallVector<uint32_t, 16> Elts(
 2683       SmallVector<uint64_t, 16> Elts(
 2860   SmallVector<Constant*, 8> Values;
 2903   SmallVector<Constant*, 8> Values;
 2937   SmallVector<Constant*, 8> Values;
 2963   SmallVector<Constant*, 8> NewOps;
 2986   SmallVector<Value *, 4> ValueOperands(op_begin(), op_end());

  187   const SmallVector<unsigned, 4> Indices;
  219   const SmallVector<unsigned, 4> Indices;
  592       SmallVector<Constant *, 32> Storage;

  333   SmallVector<Module::ModuleFlagEntry, 8> MFEs;
  900   SmallVector<std::pair<unsigned, MDNode *>, 8> MVEs;
 1072   SmallVector<Metadata *, 8> MDs;
 1226     SmallVector<DIGlobalVariableExpression *, 1> GVEs;
 1250     SmallVector<DIGlobalVariableExpression *, 1> GVEs;
 1273     SmallVector<DIGlobalVariableExpression *, 1> GVEs;

   53   SmallVector<Metadata *, 16> RetainedNodes;
   77   SmallVector<Metadata *, 16> RetainValues;
  612   SmallVector<llvm::Metadata *, 16> Elts;
  671     DenseMap<MDNode *, SmallVector<TrackingMDNodeRef, 1>> &PreservedVariables,
  740   SmallVector<uint64_t, 8> Addr(Signed.begin(), Signed.end());

  297   SmallVector<Metadata *, 4> Args;
  507     SmallVector<Metadata *, 8> Ops;
  568   SmallVector<MDNode *, 16> ToVisit;
  652         SmallVector<std::pair<unsigned, MDNode *>, 2> MDs;
  667     SmallVector<MDNode *, 8> Ops;

   66   SmallVector<Metadata *, 2> Ops;
  118   SmallVector<unsigned, 3> Components = {BD, DF, CI};
  641   SmallVector<Metadata *, 11> Ops = {
 1034   SmallVector<uint64_t, 8> Ops;
 1086   SmallVector<uint64_t, 16> NewOps;
 1127   SmallVector<uint64_t, 16> NewOps;
 1138   SmallVector<uint64_t, 8> Ops;

   86   SmallVector<DILocation *, 3> InlinedAtLocations;

  919   SmallVector<unsigned char, 8> IITValues;
  972     SmallVector<Type *, 8> Elts;
 1051   SmallVector<IITDescriptor, 8> Table;
 1057   SmallVector<Type*, 8> ArgTys;
 1347   SmallVector<DeferredIntrinsicMatchPair, 2> DeferredChecks;
 1396   SmallVector<Type *, 4> ArgTys;
 1398     SmallVector<Intrinsic::IITDescriptor, 8> Table;

  719   SmallVector<std::pair<unsigned, MDNode *>, 4> TheMDs;
  750   SmallVector<uint32_t, 1> Weights;

  486   SmallVector<Metadata *, 3> Vals;
 1827   SmallVector<Constant*, 16> NewMask(NumMaskElts);
 2065   SmallVector<int, 16> Mask = getShuffleMask();
 3928   SmallVector<uint32_t, 8> Weights;

  130     SmallVector<MetadataAsValue *, 8> MDVs;
  186     SmallVector<Metadata *, 8> MDs(N->op_begin() + Offset, N->op_end());

 1176   SmallVector<std::pair<unsigned, TrackingMDNodeRef>, 2> Attachments;
 1219   SmallVector<Attachment, 1> Attachments;

  617     SmallVector<Pass *, 12> LastUses;
  618     SmallVector<Pass *, 12> LastPMUses;
 1019   SmallVector<Pass *, 12> DeadPasses;
 1076   SmallVector<Pass *, 12> TransferLastUses;
 1085   SmallVector<Pass *, 12> LastUses;
 1086   SmallVector<Pass *, 8> UsedPasses;
 1087   SmallVector<AnalysisID, 8> ReqAnalysisNotAvailable;
 1205   SmallVector<Pass *, 12> LUses;
 1827   SmallVector<Pass *, 1> LU;