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

References

  265   bool isUnaryOp() const { return IsOperator && Args.size() == 1; }
  266   bool isBinaryOp() const { return IsOperator && Args.size() == 2; }
  659   if (Kind && ArgNames.size() != Kind)
  822   if (CalleeF->arg_size() != Args.size())
  826   for (unsigned i = 0, e = Args.size(); i != e; ++i) {
  993   for (unsigned i = 0, e = VarNames.size(); i != e; ++i) {
 1028   for (unsigned i = 0, e = VarNames.size(); i != e; ++i)
 1037   std::vector<Type *> Doubles(Args.size(), Type::getDoubleTy(*TheContext));

  265   bool isUnaryOp() const { return IsOperator && Args.size() == 1; }
  266   bool isBinaryOp() const { return IsOperator && Args.size() == 2; }
  659   if (Kind && ArgNames.size() != Kind)
  822   if (CalleeF->arg_size() != Args.size())
  826   for (unsigned i = 0, e = Args.size(); i != e; ++i) {
  993   for (unsigned i = 0, e = VarNames.size(); i != e; ++i) {
 1028   for (unsigned i = 0, e = VarNames.size(); i != e; ++i)
 1037   std::vector<Type *> Doubles(Args.size(), Type::getDoubleTy(*TheContext));

  265   bool isUnaryOp() const { return IsOperator && Args.size() == 1; }
  266   bool isBinaryOp() const { return IsOperator && Args.size() == 2; }
  659   if (Kind && ArgNames.size() != Kind)
  821   if (CalleeF->arg_size() != Args.size())
  825   for (unsigned i = 0, e = Args.size(); i != e; ++i) {
  992   for (unsigned i = 0, e = VarNames.size(); i != e; ++i) {
 1027   for (unsigned i = 0, e = VarNames.size(); i != e; ++i)
 1036   std::vector<Type *> Doubles(Args.size(), Type::getDoubleTy(TheContext));

  265   bool isUnaryOp() const { return IsOperator && Args.size() == 1; }
  266   bool isBinaryOp() const { return IsOperator && Args.size() == 2; }
  644   if (Kind && ArgNames.size() != Kind)
  807   if (CalleeF->arg_size() != Args.size())
  811   for (unsigned i = 0, e = Args.size(); i != e; ++i) {
  978   for (unsigned i = 0, e = VarNames.size(); i != e; ++i) {
 1013   for (unsigned i = 0, e = VarNames.size(); i != e; ++i)
 1022   std::vector<Type *> Doubles(Args.size(), Type::getDoubleTy(TheContext));

  282   bool isUnaryOp() const { return IsOperator && Args.size() == 1; }
  283   bool isBinaryOp() const { return IsOperator && Args.size() == 2; }
  661   if (Kind && ArgNames.size() != Kind)
  831   if (CalleeF->arg_size() != Args.size())
  835   for (unsigned i = 0, e = Args.size(); i != e; ++i) {
 1002   for (unsigned i = 0, e = VarNames.size(); i != e; ++i) {
 1037   for (unsigned i = 0, e = VarNames.size(); i != e; ++i)
 1046   std::vector<Type *> Doubles(Args.size(), Type::getDoubleTy(TheContext));

  453   if (CalleeF->arg_size() != Args.size())
  457   for (unsigned i = 0, e = Args.size(); i != e; ++i) {
  468   std::vector<Type *> Doubles(Args.size(), Type::getDoubleTy(TheContext));

  481   if (CalleeF->arg_size() != Args.size())
  485   for (unsigned i = 0, e = Args.size(); i != e; ++i) {
  496   std::vector<Type *> Doubles(Args.size(), Type::getDoubleTy(TheContext));

  608   if (CalleeF->arg_size() != Args.size())
  612   for (unsigned i = 0, e = Args.size(); i != e; ++i) {
  770   std::vector<Type *> Doubles(Args.size(), Type::getDoubleTy(TheContext));

  248   bool isUnaryOp() const { return IsOperator && Args.size() == 1; }
  249   bool isBinaryOp() const { return IsOperator && Args.size() == 2; }
  591   if (Kind && ArgNames.size() != Kind)
  720   if (CalleeF->arg_size() != Args.size())
  724   for (unsigned i = 0, e = Args.size(); i != e; ++i) {
  882   std::vector<Type *> Doubles(Args.size(), Type::getDoubleTy(TheContext));

  270   bool isUnaryOp() const { return IsOperator && Args.size() == 1; }
  271   bool isBinaryOp() const { return IsOperator && Args.size() == 2; }
  664   if (Kind && ArgNames.size() != Kind)
  827   if (CalleeF->arg_size() != Args.size())
  831   for (unsigned i = 0, e = Args.size(); i != e; ++i) {
  998   for (unsigned i = 0, e = VarNames.size(); i != e; ++i) {
 1033   for (unsigned i = 0, e = VarNames.size(); i != e; ++i)
 1042   std::vector<Type *> Doubles(Args.size(), Type::getDoubleTy(TheContext));

  271   bool isUnaryOp() const { return IsOperator && Args.size() == 1; }
  272   bool isBinaryOp() const { return IsOperator && Args.size() == 2; }
  665   if (Kind && ArgNames.size() != Kind)
  826   if (CalleeF->arg_size() != Args.size())
  830   for (unsigned i = 0, e = Args.size(); i != e; ++i) {
  997   for (unsigned i = 0, e = VarNames.size(); i != e; ++i) {
 1032   for (unsigned i = 0, e = VarNames.size(); i != e; ++i)
 1041   std::vector<Type *> Doubles(Args.size(), Type::getDoubleTy(TheContext));

  373   bool isUnaryOp() const { return IsOperator && Args.size() == 1; }
  374   bool isBinaryOp() const { return IsOperator && Args.size() == 2; }
  779   if (Kind && ArgNames.size() != Kind)
  987   if (CalleeF->arg_size() != Args.size())
  991   for (unsigned i = 0, e = Args.size(); i != e; ++i) {
 1162   for (unsigned i = 0, e = VarNames.size(); i != e; ++i) {
 1199   for (unsigned i = 0, e = VarNames.size(); i != e; ++i)
 1208   std::vector<Type *> Doubles(Args.size(), Type::getDoubleTy(TheContext));

  192   Main(ArgV.size() - 1, ArgV.data());

40935   for( ; i < Candidates.size() - 1; i++)

80490   for( ; i < Candidates.size() - 1; i++)

16420   for( ; i < Candidates.size() - 1; i++)

11759   for( ; i < Candidates.size() - 1; i++)

 7246   for( ; i < Candidates.size() - 1; i++)

 9282   for( ; i < Candidates.size() - 1; i++)

   88       : Data(Vec.data()), Length(Vec.size()) {}
  130       : Data(Vec.data()), Length(Vec.size()) {}

  206   unsigned getPathLength() const { return VisitStack.size(); }

  483     for (unsigned i = 0, n = createdNodes.size(); i < n; ++i) {

   60   size_type size() const { return Vector.size(); }
  104       I = Vector.size() - 1;
  123       I = Vector.size() - 1;
  136       I = Vector.size() - 1;

   93     auto InsertResult = M.insert({X, V.size()});
  102     if (Index != (ptrdiff_t)(V.size() - 1)) {
  105       Index = (ptrdiff_t)V.size();
  121     ptrdiff_t StartIndex = V.size();
  124     for (ptrdiff_t i = V.size() - 1; i >= StartIndex; --i) {
  169     if (I->second == (ptrdiff_t)(V.size() - 1)) {

  214     if (CurrentSCC.size() > 1)

   78     return vector_.size();
  135     assert(n < vector_.size() && "SetVector access out of range!");

   48     Val = static_cast<unsigned>(Vector.size()) + 1;
   87   size_t size() const { return Vector.size(); }

  199     assert(i < UnknownInsts.size());
  305     for (size_t i = 0, e = UnknownInsts.size(); i != e; ++i)

  450     assert(Head.Index < Working.size());
  662     for (uint32_t Index = 0; Index < BFI.Working.size(); ++Index)
  874     assert(Node.Index < RPOT.size());
 1056     BlockNode NewNode(Freqs.size());
 1069   assert(RPOT.size() - 1 <= BlockNode::getMaxIndex() &&
 1080   Working.reserve(RPOT.size());
 1081   for (size_t Index = 0; Index < RPOT.size(); ++Index)
 1083   Freqs.resize(RPOT.size());
 1113   for (size_t Index = 0; Index < RPOT.size(); ++Index) {

  194   inline unsigned size() const { return (unsigned)CalledFunctions.size(); }
  202     assert(i < CalledFunctions.size() && "Invalid index");

   99   bool isSingular() const { return Nodes.size() == 1; }
  100   unsigned size() const { return Nodes.size(); }

   74   bool isDegeneratePartition() { return Intervals.size() == 1; }

  170     return Blocks.size();
  428       assert(i != Blocks.size() && "Loop does not contain BB!");

  611   for (unsigned i = 0; i < TopLevelLoops.size(); ++i)

  126   bool isComplete() const { return PostBlocks.size() == L->getNumBlocks(); }
  161     return 1 + PostBlocks.size() - getPostorder(BB);
  243     DFS.PostNumbers[BB] = DFS.PostBlocks.size();

   59     for (unsigned i = 0, e = BasicBlocks.size(); i != e; ++i)
   95   unsigned                 size() const { return BasicBlocks.size(); }

  223   size_t size() const { return Array->size(); }

   59     for (unsigned i = 0, e = static_cast<unsigned>(BlockInfoRecords.size());
  526     if (AbbrevNo >= CurAbbrevs.size())

  192     for (unsigned i = 0, e = static_cast<unsigned>(BlockInfoRecords.size());
  301     assert(AbbrevNo < CurAbbrevs.size() && "Invalid abbrev #!");
  493     return static_cast<unsigned>(CurAbbrevs.size())-1 +
  540     return Info.Abbrevs.size()-1+bitc::FIRST_APPLICATION_ABBREV;

  157       NumFixedArgs = (FixedArgs == ~0U) ? Args.size() : FixedArgs;
  173       NumFixedArgs = (FixedArgs == ~0U) ? Args.size() : FixedArgs;

  136   size_t size() const { return SafePoints.size(); }
  141   size_t roots_size() const { return Roots.size(); }

 1035     assert(v.size() > 0 &&
 1059     assert(v.size() > 0 &&
 1253     for(size_t i=0; i<v.size(); ++i) {
 1286     assert(v.size() >= 1);

   54       NumNodesSolelyBlocking.resize(SUnits->size(), 0);
   58       NumNodesSolelyBlocking.resize(SUnits->size(), 0);
   69       assert(NodeNum < (*SUnits).size());
   74       assert(NodeNum < NumNodesSolelyBlocking.size());

  277     return (unsigned)Predecessors.size();
  293     return (unsigned)Successors.size();

  390   int getObjectIndexEnd() const { return (int)Objects.size()-NumFixedObjects; }
  396   unsigned getNumObjects() const { return Objects.size(); }
  444     assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() &&
  451     assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() &&
  458     assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() &&
  465     assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() &&
  472     assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() &&
  484     assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() &&
  492     assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() &&
  500     assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() &&
  506     assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() &&
  512     assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() &&
  518     assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() &&
  526     assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() &&
  534     assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() &&
  540     assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() &&
  664     assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() &&
  674     assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() &&
  681     assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() &&
  688     assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() &&
  694     assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() &&
  706     assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() &&
  715     assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() &&
  723     assert(unsigned(ObjectIdx + NumFixedObjects) < Objects.size() &&
  729     assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() &&

  587     assert(N < MBBNumbering.size() && "Illegal block number");
  596   unsigned getNumBlockIDs() const { return (unsigned)MBBNumbering.size(); }
  708     return (unsigned)MBBNumbering.size()-1;
  715     assert(N < MBBNumbering.size() && "Illegal basic block #");

  183   unsigned getOccurrenceCount() const { return Candidates.size(); }

  172         : SUnits(SUs), Blocked(SUs.size()), B(SUs.size()), AdjK(SUs.size()) {
  172         : SUnits(SUs), Blocked(SUs.size()), B(SUs.size()), AdjK(SUs.size()) {
  172         : SUnits(SUs), Blocked(SUs.size()), B(SUs.size()), AdjK(SUs.size()) {
  173       Node2Idx = new std::vector<int>(SUs.size());
  185       B.assign(SUnits.size(), SmallPtrSet<SUnit *, 4>());

  546   unsigned size() const { return Queue.size(); }

   75         AdjEdgeIdx Idx = AdjEdgeIds.size();
  181       assert(NId < Nodes.size() && "Out of bound NodeId");
  185       assert(NId < Nodes.size() && "Out of bound NodeId");
  199         NId = Nodes.size();
  214         EId = Edges.size();
  239         : CurNId(CurNId), EndNId(G.Nodes.size()), FreeNodeIds(G.FreeNodeIds) {
  263         : CurEId(CurEId), EndEId(G.Edges.size()), FreeEdgeIds(G.FreeEdgeIds) {
  289       NodeItr end() const { return NodeItr(G.Nodes.size(), G); }
  294         return G.Nodes.size() - G.FreeNodeIds.size();
  294         return G.Nodes.size() - G.FreeNodeIds.size();
  306       EdgeItr end() const { return EdgeItr(G.Edges.size(), G); }
  501       return getNode(NId).getAdjEdgeIds().size();

  100     : NumOpts(OptVec.size()), Opts(new unsigned[NumOpts]) {

   84       NumNodesSolelyBlocking.resize(SUnits->size(), 0);
   94       assert(NodeNum < (*SUnits).size());
   99       assert(NodeNum < NumNodesSolelyBlocking.size());

  388     SUnits.emplace_back(MI, (unsigned)SUnits.size());

  163   unsigned getNumSubtrees() const { return SubtreeConnectLevels.size(); }
  172     assert(SU->NodeNum < DFSNodeData.size() &&  "New Node");

 3486       NumFixedArgs = ArgsList.size();
 3499       NumFixedArgs = ArgsList.size();

  146       Size = static_cast<SizeType>(Items.size());
  156       Size = static_cast<SizeType>(Items.size());

   59   unsigned size() const { return (unsigned)Instructions.size(); }

  120     if (Index < Offsets.size())

  241     assert(Die >= First && Die < First + DieArray.size());
  445     return DieArray.size();
  460     assert(Index < DieArray.size());

  159     return Lines.size();
  162     assert(i < Lines.size());
  166     assert(i < Lines.size());
  182     const auto LHSSize = Lines.size();
  183     const auto RHSSize = RHS.Lines.size();

   85   size_t size() const { return Ranges.size(); }
   90     assert(i < Ranges.size());

   75   uint32_t getNumBlocks() const { return StreamLayout.Blocks.size(); }

   82     while (Index < Map->Buckets.size()) {
  212   uint32_t capacity() const { return Buckets.size(); }

   56     SymIndexId Id = Cache.size();
   86     SymIndexId Id = Cache.size();
  118     SymIndexId SymId = Cache.size();

   60   uint32_t getRecordCount() const { return TypeRecords.size(); }

  231   size_t edges_size() const { return Edges.size(); }
  726     std::unique_ptr<Section> Sec(new Section(Name, Prot, Sections.size()));

  214       SourceModuleHandle H = SourceModules.size();

  362     if (NumStubs <= FreeStubs.size())
  365     unsigned NewStubsRequired = NumStubs - FreeStubs.size();
  366     unsigned NewBlockId = IndirectStubsInfos.size();

  401       if (NumStubs <= FreeStubs.size())
  404       unsigned NewStubsRequired = NumStubs - FreeStubs.size();
  414       unsigned NewBlockId = RemoteIndirectStubsInfos.size();

  175     int ArgC = Args.size() + 1;

  585     if (auto Err = serializeSeq(C, static_cast<uint64_t>(V.size())))

   87     return Operations.size();

 2326   unsigned getNumElements() const { return Elements.size(); }
 2329     assert(I < Elements.size() && "Index out of range");

 1077   size_t input_size() const { return Inputs.size(); }

 1040       if (!S.second.SummaryList.size() ||

  504     for (unsigned Idx = 0, Size = Passes.size(); Idx != Size; ++Idx) {

   56   size_t size() const { return StructTypes.size(); }

  134     return _symbols.size();
  139     if (index < _symbols.size())
  146     if (index < _symbols.size())
  152     if (index < _symbols.size())

  342   size_t size() const { return Sections.size(); }
  358   size_t symbol_size() const { return Symbols.size(); }
  385   size_t indirect_symbol_size() const { return IndirectSymbols.size(); }
  414   size_t data_region_size() const { return DataRegions.size(); }

  602     return StringRef(&Values[0], Values.size());

  282   unsigned getNumWinFrameInfos() { return WinFrameInfos.size(); }

   89     return ObjectForArch(this, Architectures.size());
   96   uint32_t getNumberOfObjects() const { return Architectures.size(); }

  146   uint32_t getNumberOfSymbols() const { return Symbols.size(); }

   89   unsigned getNumOptions() const { return OptionInfos.size(); }

  437   size_t size() const { return Instantiations.size(); }
  447     for (unsigned I = 1, E = Instantiations.size(); I < E; ++I)
  552   unsigned getMismatchedCount() const { return FuncHashMismatches.size(); }

  237               llvm::ConstantInt::get(Int32Ty,  FunctionRecords.size()))

   74   size_t size() const { return Offsets.size(); }

  170   uint32_t getLength() override { return Data.size(); }
  186     if (RequiredSize > Data.size())

 1472   size_type size() const { return Storage.size(); }

  102     Adapters.reserve(rhs.Adapters.size());
  113       if (R.Index >= Adapters.size()) {

   93   size_t getNumChildren() const { return Children.size(); }
  799     for (i = 0; i < PredBlocks.size(); ++i)
  810     for (i = i + 1; i < PredBlocks.size(); ++i) {

  305     const unsigned NextDFSNum(NumToNode.size());
  358     assert(NumToNode.size() == 1 && "SNCAInfo must be freshly constructed");
  598     for (size_t i = 1, e = NumToNode.size(); i != e; ++i) {
  620     for (size_t i = 1, e = NumToNode.size(); i != e; ++i) {

  184   size_t size() const { return V.size(); }

  103   bool isValidBufferID(unsigned i) const { return i && i <= Buffers.size(); }
  138     return Buffers.size();
  159     return Buffers.size();

 1885   static size_t size(IO &io, T &seq) { return seq.size(); }
 1888     if (index >= seq.size())

   95     if (Holder.Infos.size() > 1) {

  609         SccSize[Node->getFunction()] = I->size();

   46     if (Bytes.size() < Pos + Size) {
  159     return minBeforeBytes() + TM->Bits->Before.Bytes.size();
  165     return minAfterBytes() + TM->Bits->After.Bytes.size();

   66   size_type size() const { return Records.size(); }

  226     for (unsigned i = 0, e = UnknownInsts.size(); i != e; ++i)
  245   for (unsigned i = 0, e = UnknownInsts.size(); i != e; ++i) {
  283   if (1 != UnknownInsts.size())
  532     for (unsigned i = 0, e = AS.UnknownInsts.size(); i != e; ++i)
  684     OS << "\n    " << UnknownInsts.size() << " Unknown instructions: ";
  685     for (unsigned i = 0, e = UnknownInsts.size(); i != e; ++i) {

  486   for (size_t Index = 0; Index < BFI.Freqs.size(); ++Index) {
  523   for (size_t Index = 0; Index < Working.size(); ++Index)
  535   for (size_t Index = 0; Index < Working.size(); ++Index) {
  601   assert(Node.Index < Freqs.size() && "Expected legal index");
  640   for (uint32_t Index = 0; Index < BFI.Working.size(); ++Index)
  781     if (I->size() < 2)

  448   if (SccI.SccHeaders.size() <= static_cast<unsigned>(SccNum))
  967     if (Scc.size() == 1)

   78       auto NumLevels = Levels.size();
   86       assert(Level < Levels.size());
   90       assert(Level < Levels.size());
   94     unsigned getNumLevels() const { return Levels.size(); }

  202   for (unsigned i = 0, e = CalledFunctions.size(); i != e; ++i)

  550     assert(i != Nodes.size() && "Node not in SCC");

  511     for (unsigned i = 0, e = SCC.size(); i != e && !KnowNothing; ++i) {
  619     for (unsigned i = 1, e = SCC.size(); i != e; ++i)

   34   for (unsigned i = 0, e = Intervals.size(); i != e; ++i)
   42   for(unsigned i = 0, e = Intervals.size(); i != e; ++i)
   85   for (unsigned i = 0, e = Intervals.size(); i != e; ++i)
  111   for (unsigned i = 0, e = Intervals.size(); i != e; ++i)

  778     Count = Cache.size();
  830   unsigned NumSortedEntries = Cache.size();
 1049   switch (Cache.size() - NumSortedEntries) {
 1064     if (Cache.size() != 1) {
 1228   unsigned NumSortedEntries = Cache->size();
 1243       if (Cache && NumSortedEntries != Cache->size()) {
 1326     if (Cache && NumSortedEntries != Cache->size()) {
 1328       NumSortedEntries = Cache->size();
 1420     NumSortedEntries = Cache->size();
 1439       NumSortedEntries = Cache->size();
 1511   for (unsigned i = 0, e = PInfo.size(); i != e; ++i) {

  444     for (; RefCnt < Refs.size(); ++RefCnt)
  787     assert(GlobalList.second.SummaryList.size() == 1 &&

  110   bool inbounds(StratifiedIndex Idx) const { return Idx < Links.size(); }
  274       StratifiedIndex Number = StratLinks.size();
  317     for (unsigned I = 0, E = Links.size(); I < E; ++I) {
  587     auto Link = Links.size();
  592   bool inbounds(StratifiedIndex N) const { return N < Links.size(); }

  551   unsigned VarID = NumberedVals.size();
  946     auto I = ForwardRefValIDs.find(NumberedVals.size());
 1072     auto I = ForwardRefValIDs.find(NumberedVals.size());
 1440   GlobalValue *Val = ID < NumberedVals.size() ? NumberedVals[ID] : nullptr;
 2912   Value *Val = ID < NumberedVals.size() ? NumberedVals[ID] : nullptr;
 2960       NameID = NumberedVals.size();
 2962     if (unsigned(NameID) != NumberedVals.size())
 2964                      Twine(NumberedVals.size()) + "'");
 3024     if (NameID != -1 && unsigned(NameID) != NumberedVals.size()) {
 3026                        Twine(NumberedVals.size()) + "'");
 3029     BB = GetBB(NumberedVals.size(), Loc);
 3032                        Twine(NumberedVals.size()) + "'");
 3049     ForwardRefValIDs.erase(NumberedVals.size());
 3250       if (Fn.UIntVal < NumberedVals.size())
 5360     if (NameID != NumberedVals.size())
 5362                       Twine(NumberedVals.size()) + "'");
 5466     auto I = ForwardRefValIDs.find(NumberedVals.size());
 5471                      Twine(NumberedVals.size()) + "' disagree: "
 5527     ID.UIntVal = NumberedVals.size() - 1;
 5583   if (!Fn.hasName()) FunctionNumber = NumberedVals.size()-1;
 7426     GV = Fn.UIntVal < NumberedVals.size() ? NumberedVals[Fn.UIntVal] : nullptr;
 7590       IdToIndexMap[GVId].push_back(std::make_pair(TI.size(), Loc));
 7966   if (ID == NumberedValueInfos.size())
 7970     if (ID > NumberedValueInfos.size())
 8343       IdToIndexMap[GVId].push_back(std::make_pair(Calls.size(), Loc));
 8430       IdToIndexMap[GVId].push_back(std::make_pair(VTableFuncs.size(), Loc));
 8494       IdToIndexMap[VC.GVId].push_back(std::make_pair(Refs.size(), VC.Loc));
 8586       IdToIndexMap[ID].push_back(std::make_pair(TypeTests.size(), Loc));
 8626     if (ParseVFuncId(VFuncId, IdToIndexMap, VFuncIdList.size()))
 8665     if (ParseConstVCall(ConstVCall, IdToIndexMap, ConstVCallList.size()))
 8868   if (GVId < NumberedValueInfos.size()) {

  110     for (unsigned i = 0, e = Info->RecordNames.size(); i != e; ++i)
  686       for (unsigned i = 0, e = Stats.CodeFreq.size(); i != e; ++i)
  694       for (unsigned i = 0, e = FreqPairs.size(); i != e; ++i) {
  847     if (BlockStats.CodeFreq.size() <= Code)

  639     if (ID >= FunctionBBs.size()) return nullptr; // Invalid ID
  644     if (i-1 < MAttributes.size())
 1187   if (ID >= TypeList.size())
 1698       if (NumRecords != TypeList.size())
 1846       if (NumRecords >= TypeList.size())
 1875       if (NumRecords >= TypeList.size())
 1911     if (NumRecords >= TypeList.size())
 2372       if (Record[0] >= TypeList.size() || !TypeList[Record[0]])
 2811         if (FwdBBs.size() < BBID + 1)
 2875         assert(ID < FunctionBBs.size() && "Basic block not found");
 3120     if (Record[5] - 1 >= SectionTable.size())
 3167       if (ComdatID > ComdatList.size())
 3251     if (Record[6] - 1 >= SectionTable.size())
 3260     if (Record[8] - 1 >= GCTable.size())
 3278       if (ComdatID > ComdatList.size())
 3801         for (unsigned i = 0, e = FunctionBBs.size(); i != e; ++i)
 3806         if (BBRefs.size() > FunctionBBs.size())
 3806         if (BBRefs.size() > FunctionBBs.size())
 3810         for (unsigned I = 0, E = FunctionBBs.size(), RE = BBRefs.size(); I != E;
 3810         for (unsigned I = 0, E = FunctionBBs.size(), RE = BBRefs.size(); I != E;
 5105       if (Record.size() < 1 || Record[0] >= BundleTags.size())
 5138       CurBB = CurBBNo < FunctionBBs.size() ? FunctionBBs[CurBBNo] : nullptr;
 5734   assert(ROCnt + WOCnt <= Refs.size());
 5735   unsigned FirstWORef = Refs.size() - WOCnt;
 5739   for (; RefNo < Refs.size(); ++RefNo)
 6627   if (MsOrErr->size() != 1)

  649     if (ID < MDStringRef.size())
  655     if (ID < (MDStringRef.size() + GlobalMetadataBitPosIndex.size())) {
  655     if (ID < (MDStringRef.size() + GlobalMetadataBitPosIndex.size())) {
  916       MetadataList.resize(MDStringRef.size() +
  917                           GlobalMetadataBitPosIndex.size());
  986   assert(ID < (MDStringRef.size()) + GlobalMetadataBitPosIndex.size());
  986   assert(ID < (MDStringRef.size()) + GlobalMetadataBitPosIndex.size());
  987   assert(ID >= MDStringRef.size() && "Unexpected lazy-loading of MDString");
  997           GlobalMetadataBitPosIndex[ID - MDStringRef.size()]))
 1057     if (ID < MDStringRef.size())
 1064       if (ID < (MDStringRef.size() + GlobalMetadataBitPosIndex.size())) {
 1064       if (ID < (MDStringRef.size() + GlobalMetadataBitPosIndex.size())) {
 2034         if (Idx < (MDStringRef.size() + GlobalMetadataBitPosIndex.size()) &&
 2034         if (Idx < (MDStringRef.size() + GlobalMetadataBitPosIndex.size()) &&

   64   unsigned size() const { return ValuePtrs.size(); }
   81     assert(i < ValuePtrs.size());

  189     GlobalValueId = VE.getValues().size();
  794   for (unsigned i = 0, e = Attrs.size(); i != e; ++i) {
  864   TypeVals.push_back(TypeList.size());
  869   for (unsigned i = 0, e = TypeList.size(); i != e; ++i) {
 2539   for (unsigned i = 0, e = Vals.size(); i != e; ++i) {
 2541       writeConstants(i, Vals.size(), true);
 3134   assert(Order.Shuffle.size() >= 2 && "Shuffle too small");
 3180   Vals.push_back(VE.getBasicBlocks().size());
 3425                               Log2_32_Ceil(VE.getTypes().size() + 1)));
 3581   NameVals.push_back(args.size());
 4419             {Strtab.data(), Strtab.size()});

  234   assert(List.size() == Stack.back().Shuffle.size() && "Wrong size");
  345   unsigned FirstConstant = Values.size();
  435   OptimizeConstants(FirstConstant, Values.size());
  645     MetadataMap[N].ID = MDs.size();
  680   Entry.ID = MDs.size();
  704   Index.ID = MDs.size();
  726   assert(MetadataMap.size() == MDs.size() &&
  754   MDs.reserve(OldMDs.size());
  764   if (MDs.size() == Order.size())
  769   FunctionMDs.reserve(OldMDs.size());
  771   for (unsigned I = MDs.size(), E = Order.size(), ID = MDs.size(); I != E;
  771   for (unsigned I = MDs.size(), E = Order.size(), ID = MDs.size(); I != E;
  781       ID = MDs.size();
  796   NumModuleMDs = MDs.size();
  843       ValueMap[V] = Values.size();
  850   ValueID = Values.size();
  887   *TypeID = Types.size();
  926     Entry = AttributeLists.size();
  938       Entry = AttributeGroups.size();
  945   NumModuleValues = Values.size();
  957   FirstFuncConstantID = Values.size();
  967     ValueMap[&BB] = BasicBlocks.size();
  971   OptimizeConstants(FirstFuncConstantID, Values.size());
  977   FirstInstID = Values.size();
 1007   for (unsigned i = NumModuleValues, e = Values.size(); i != e; ++i)
 1009   for (unsigned i = NumModuleMDs, e = MDs.size(); i != e; ++i)
 1011   for (unsigned i = 0, e = BasicBlocks.size(); i != e; ++i)
 1040   return Log2_32_Ceil(getTypes().size() + 1);

  163   unsigned numMDs() const { return MDs.size(); }
  201   bool hasMDs() const { return NumModuleMDs < MDs.size(); }

  113   unsigned idx = GroupNodes.size();
  575   for (unsigned i = 0, e = Regs.size(); i != e; ++i) {
  598   for (unsigned i = 0, e = Regs.size(); i != e; ++i) {
  660     for (unsigned i = 0, e = Regs.size(); i != e; ++i) {
  773   for (unsigned i = 0, e = SUnits.size(); i != e; ++i) {
  785     for (unsigned i = 0, e = SUnits.size(); i != e; ++i) {
  850       for (unsigned i = 0, e = Edges.size(); i != e; ++i) {

  181   for (unsigned i = 0, e = CInfos.size(); i != e; ++i) {
  183     for (unsigned j = 0, ee = CI.Codes.size(); j != ee; ++j) {

  106     Entry = TypeInfos.size();

  344       Asm->emitInt32(Hash->Values.size());
  438     Index += Bucket.value().size();

  718   for (unsigned i = 0, e = DeadBlockSyms.size(); i != e; ++i) {
 1716   for (unsigned i = 0, e = CP.size(); i != e; ++i) {
 1815   for (unsigned JTI = 0, e = JT.size(); JTI != e; ++JTI) {
 1828       for (unsigned ii = 0, ee = JTBBs.size(); ii != ee; ++ii) {
 1853     for (unsigned ii = 0, ee = JTBBs.size(); ii != ee; ++ii)

   52   if (BufNum > 0 && BufNum <= DiagInfo->LocInfos.size())

 2416     if (Methods.size() == 1)
 2424       OverloadedMethodRecord OMR(Methods.size(), MethodList, Name);

  162   New->setNumber(Abbreviations.size());
  163   Die.setAbbrevNumber(Abbreviations.size());

   99     Entries.push_back({BeginSym, EndSym, DWARFBytes.size(), Comments.size()});
  150       return Comments.size() - Entries[EI].CommentOffset;

  218     const char *Comment = (Byte.index() < TmpBuf->Comments.size())
 2360       } else if (NewBase != Begin || P.second.size() > 1) {
 2600     ContentSize += (List.size() + 1) * TupleSize;

  460         unsigned I = 0, E = CU.ExprRefedBaseTypes.size();

  105   for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
  107   for (unsigned j = 0, M = DIELocs.size(); j < M; ++j)

   47   unsigned LSize = LIds.size(), RSize = RIds.size();
   47   unsigned LSize = LIds.size(), RSize = RIds.size();
   89   FilterOffsets.reserve(FilterIds.size());
  111     if (NumShared < TypeIds.size()) {
  117         unsigned SizePrevIds = PrevLPI->TypeIds.size();
  132       for (unsigned J = NumShared, M = TypeIds.size(); J != M; ++J) {
  358   LandingPads.reserve(PadInfos.size());
  360   for (unsigned i = 0, N = PadInfos.size(); i != N; ++i)
  625     Entry = TypeInfos.size();

  229   BitVector JTIsLive(JTI->getJumpTables().size());
  795   for (unsigned i = 0, e = SameTails.size(); i != e; ++i) {
  892   std::vector<MachineBasicBlock::iterator> NextCommonInsts(SameTails.size());
  893   for (unsigned int i = 0 ; i != SameTails.size() ; ++i) {
  907     for (unsigned int i = 0 ; i < NextCommonInsts.size() ; i++) {
  967       for (unsigned i = 0, e = MergePotentials.size(); i != e; ++i) dbgs()
  984   while (MergePotentials.size() > 1) {
 1006     unsigned commonTailIndex = SameTails.size();
 1009     if (SameTails.size() == 2 &&
 1013     else if (SameTails.size() == 2 &&
 1021       for (unsigned i = 0, e = SameTails.size(); i != e; ++i) {
 1034     if (commonTailIndex == SameTails.size() ||
 1059     for (unsigned int i=0, e = SameTails.size(); i != e; ++i) {
 1086     if (MergePotentials.size() == TailMergeThreshold)
 1094   if (MergePotentials.size() == TailMergeThreshold)
 1095     for (unsigned i = 0, e = MergePotentials.size(); i != e; ++i)
 1099   if (MergePotentials.size() >= 2)
 1147       if (MergePotentials.size() == TailMergeThreshold)
 1205     if (MergePotentials.size() == TailMergeThreshold)
 1206       for (unsigned i = 0, e = MergePotentials.size(); i != e; ++i)
 1209     if (MergePotentials.size() >= 2)
 1215     if (MergePotentials.size() == 1 &&

 4395   for (unsigned i = 0, e = TargetConstraints.size(); i != e; ++i) {
 5039   for (unsigned i = 0, e = TargetConstraints.size(); i != e; ++i) {
 6889   if (UGEPIs.size() == 0)

  454   for (unsigned i = 0, e = SUnits.size(); i != e; ++i) {

   67   assert((InsnClass.size() <= DFA_MAX_RESTERMS) &&
  220   if (CurrentPacketMIs.size() > 1) {

   20   assert(Reg < AliasMap.size() && "Invalid register");

  296   if (BlockIndex < (LoadCmpBlocks.size() - 1)) {
  379     for (unsigned i = 0; i < InList.size() - 1; i = i + 2) {
  383     if (InList.size() % 2 != 0)
  393     while (OrList.size() != 1) {
  408   BasicBlock *NextBB = (BlockIndex == (LoadCmpBlocks.size() - 1))
  419   if (BlockIndex == LoadCmpBlocks.size() - 1) {
  479   BasicBlock *NextBB = (BlockIndex == (LoadCmpBlocks.size() - 1))
  490   if (BlockIndex == LoadCmpBlocks.size() - 1) {

   87   LLVM_DEBUG(dbgs() << WFMP << "  #faulting PCs: " << FFI.size() << "\n");
   88   OS.EmitIntValue(FFI.size(), 4);

  970   for (unsigned i = 1; i < MemOps.size(); i++)
  987   for (unsigned I = 0; I < MemOps.size(); I++) {
  993       assert(I == MemOps.size() - 1 && I != 0);
 1228   for (unsigned I = 0; I < MemOps.size(); ++I) {

  532   if (v.size() >= 1 && v[0].first != 1)
  534   for (size_t i = 0; i < v.size(); ++i) {
  537     if (i + 1 < v.size() && v[i + 1].first != v[i].first + 1) {
  551   if (v.size() == 0 || v[0].first != 1)
  553   for (size_t i = 0; i < v.size(); ++i) {
  555     if (i + 1 == v.size() || v[i + 1].first != v[i].first + 1) {
  603     for (std::size_t i = VecIdx + 1; i < Vec.size(); ++i)

  300     EncounteredUGS.resize(UsedGlobalSets.size());
  343             CurGVOnlySetIdx = UsedGlobalSets.size();
  373             UsedGlobalSets.size();
  399     for (size_t i = 0, e = UsedGlobalSets.size(); i != e; ++i) {
  418   for (size_t i = 0, e = UsedGlobalSets.size(); i != e; ++i) {
  490     if (Tys.size() < 2) {

 1295     unsigned NumChildren = Children.size();
 1366     unsigned NumChildren = Children.size();

  146   dbgs() << "  Number of Queue Entries: " << Queue.size() << "\n";

   61   for (unsigned i = 0, e = Kills.size(); i != e; ++i)
   77     for (unsigned i = 0, e = Kills.size(); i != e; ++i)
  100   for (unsigned i = 0, e = VRInfo.Kills.size(); i != e; ++i)
  148   for (unsigned i = 0, e = VRInfo.Kills.size(); i != e; ++i)
  657     for (unsigned j = 0, e2 = VirtRegInfo[Reg].Kills.size(); j != e2; ++j)
  742   for (unsigned i = 0, e = VI.Kills.size(); i != e; ++i)

  296   PseudoIdempotentInstCount = PseudoIdempotentInstructions.size();
  468       dbgs() << "Total Basic Blocks: " << RPOList.size() << "\n";

 1745     if (GVIdx >= PFS.IRSlots.GlobalValues.size())

  379   if (YamlMF.CallSitesInfo.size() && !TM.Options.EnableDebugEntryValues)

  310   if (VRegs.size() == 0)

  650              Probs.size() &&
 1345     return Sum.getCompl() / (Probs.size() - KnownProbNum);
 1363   assert(Probs.size() == Successors.size() && "Async probability list!");
 1363   assert(Probs.size() == Successors.size() && "Async probability list!");
 1365   assert(index < Probs.size() && "Not a current successor!");
 1372   assert(Probs.size() == Successors.size() && "Async probability list!");
 1372   assert(Probs.size() == Successors.size() && "Async probability list!");
 1374   assert(index < Probs.size() && "Not a current successor!");

 1158     unsigned count() const { return Edges.size() - 1; }

  750     OpenChildren[Node] = Children.size();

   58   int Index = (int)Objects.size() - NumFixedObjects - 1;
   68   int Index = (int)Objects.size() - NumFixedObjects - 1;
   79   return (int)Objects.size()-NumFixedObjects-1;
  222   for (unsigned i = 0, e = Objects.size(); i != e; ++i) {

  281   return FrameInstructions.size() - 1;
  321   assert(BlockNo <= MBBNumbering.size() && "Mismatch!");
  612   assert(JTI < JumpTableInfo->getJumpTables().size() && "Invalid JTI!");
  634   unsigned N = LandingPads.size();
  717   for (unsigned i = 0; i != LandingPads.size(); ) {
  755         (LandingPad.TypeIds.size() == 1 && !LandingPad.TypeIds[0]))
  791   for (unsigned i = 0, N = TypeInfos.size(); i != N; ++i)
  795   return TypeInfos.size();
  804     unsigned i = *I, j = TyIds.size();
  818   int FilterID = -(1 + FilterIds.size());
  819   FilterIds.reserve(FilterIds.size() + TyIds.size() + 1);
  819   FilterIds.reserve(FilterIds.size() + TyIds.size() + 1);
  821   FilterEnds.push_back(FilterIds.size());
  908   return JumpTables.size()-1;
  917   for (size_t i = 0, e = JumpTables.size(); i != e; ++i)
  930   for (size_t j = 0, e = JTE.MBBs.size(); j != e; ++j)
  943   for (unsigned i = 0, e = JumpTables.size(); i != e; ++i) {
  945     for (unsigned j = 0, f = JumpTables[i].MBBs.size(); j != f; ++j)
 1002   for (unsigned i = 0, e = Constants.size(); i != e; ++i)
 1068   for (unsigned i = 0, e = Constants.size(); i != e; ++i)
 1077   return Constants.size()-1;
 1095   return Constants.size()-1;
 1102   for (unsigned i = 0, e = Constants.size(); i != e; ++i) {

  699     unsigned NumChildren = Children.size();

  117   Entry.Index = BBCallbacks.size() - 1;
  256   for (unsigned i = 0; i < Personalities.size(); ++i)

  480     for (unsigned PfxEndIdx = 0, End = Str.size(); PfxEndIdx < End;
  550         if (LeafChildren.size() >= 2) {
  961       << " from " << NV("NumOccurrences", CandidatesForRepeatedSeq.size())
  970     for (unsigned i = 1, e = CandidatesForRepeatedSeq.size(); i < e; i++) {
  994   for (size_t i = 0, e = OF.Candidates.size(); i < e; i++) {
 1056                                               EndIt, MBB, FunctionList.size(),
 1064     if (CandidatesForRepeatedSeq.size() < 2)
 1077     if (OF.Candidates.size() < 2)

 1115   for (unsigned i = 0, e = SUnits.size(); i != e; ++i) {
 1143   BitVector Added(SUnits.size());
 1145   for (int i = 0, e = SUnits.size(); i != e; ++i) {
 1260   for (int i = 0, e = SUnits.size(); i != e; ++i) {
 1364   ScheduleInfo.resize(SUnits.size());
 1429     for (unsigned i = 0; i < SUnits.size(); i++) {
 1726   for (unsigned i = 0; i < SUnits.size(); ++i) {
 2643   for (int i = 0, e = SSD->SUnits.size(); i < e; ++i) {
 2830   for (int i = 0, e = SSD->SUnits.size(); i != e; ++i) {

  474   for (unsigned i = 0, e = LiveIns.size(); i != e; ++i)

 1051   for (unsigned i = 0, e = RegionPressure.size(); i < e; ++i) {
 1070   unsigned CritIdx = 0, CritEnd = RegionCriticalPSets.size();
 1284   DFSResult->resize(SUnits.size());
 1607     unsigned ChainPredID = DAG->SUnits.size();

  256   for (unsigned i = 0, e = Sequence.size(); i != e; i++) {
  535   for (unsigned i = 0, e = SUnits.size(); i != e; ++i) {
  550   Sequence.reserve(SUnits.size());
  555     for (unsigned i = 0, e = PendingQueue.size(); i != e; ++i) {
  662   for (unsigned i = 0, e = Sequence.size(); i != e; ++i)
  665   assert(Sequence.size() - Noops == ScheduledNodes &&
  679   for (unsigned i = 0, e = Sequence.size(); i != e; i++) {

  506   for (unsigned i = 0, e = CSI.size(); i != e; ++i) {

  660     PBQPRAGraph::RawVector NodeCosts(VRegAllowed.size() + 1, 0);
  664     for (unsigned i = 0; i != VRegAllowed.size(); ++i)

 3650   for (unsigned i = 0, e = MBBs.size(); i != e; ++i) {

  434   return SUnits.size() - DeadNodes;
  470   unsigned DAGSize = SUnits.size();
  573   WorkList.reserve(SUnits.size());
  584       if (s >= Node2Index.size())
  613   WorkList.reserve(SUnits.size());
  646   VisitedBack.resize(SUnits.size());

  741     PDiffs->init(SUnits.size());
 1059   assert(N <= NodeNums.size());
 1238   SchedDFSImpl(SchedDFSResult &r): R(r), SubtreeClasses(R.DFSNodeData.size()) {
 1239     RootSet.setUniverse(R.DFSNodeData.size());
 1334     for (unsigned Idx = 0, End = R.DFSNodeData.size(); Idx != End; ++Idx) {

 2255   FuncInfo.OrigNumPHINodesToUpdate = FuncInfo.PHINodesToUpdate.size();

  165   NumNodesSolelyBlocking.resize(SUnits->size(), 0);
  167   for (unsigned i = 0, e = SUnits->size(); i != e; ++i) {
  267   for (unsigned i = 0, e = Packet.size(); i != e; ++i)
  313   if (Packet.size() >= InstrItins->SchedModel.IssueWidth) {

  542   Sequence.reserve(SUnits.size());
  768   unsigned NumNodes = Sequence.size();

  278     unsigned NumSUnits = SUnits.size();
  288     unsigned NumSUnits = SUnits.size();
  611   for (unsigned i = 0, e = PendingQueue.size(); i != e; ++i) {
  930   unsigned LookAhead = std::min((unsigned)Sequence.size(),
 1611   Sequence.reserve(SUnits.size());
 2010   SethiUllmanNumbers.assign(SUnits->size(), 0);
 2017   unsigned SUSize = SethiUllmanNumbers.size();
 2018   if (SUnits->size() > SUSize)
 2031   assert(SU->NodeNum < SethiUllmanNumbers.size());

   74   SUnits.emplace_back(N, (unsigned)SUnits.size());
  443   for (unsigned su = 0, e = SUnits.size(); su != e; ++su) {
  706   for (unsigned i = 0, e = Sequence.size(); i != e; i++) {
  722   for (unsigned i = 0, e = Sequence.size(); i != e; ++i)
  725   assert(Sequence.size() - Noops == ScheduledNodes &&
  887   for (unsigned i = 0, e = Sequence.size(); i != e; i++) {

  173   for (unsigned i = 0, e = SUnits.size(); i != e; ++i) {
  184   Sequence.reserve(SUnits.size());
  188     for (unsigned i = 0, e = PendingQueue.size(); i != e; ++i) {

 1510       ValueTypeNodes.size())
 1550   if ((unsigned)Cond >= CondCodeNodes.size())
 5836   unsigned NumMemOps = MemOps.size();
 6010   unsigned NumMemOps = MemOps.size();
 6107   unsigned NumMemOps = MemOps.size();
 8419   for (size_t I = 0; I != Order.size(); ++I) {

 2196   if (Cases.size() != 2) return true;
 2279         for (unsigned i = 1, e = SL->SwitchCases.size(); i != e; ++i) {
 2292       for (unsigned i = 1, e = SL->SwitchCases.size(); i != e; ++i)
 2910   for (unsigned i = 0, e = SL->JTCases.size(); i != e; ++i)
 2915   for (unsigned i = 0, e = SL->BitTestCases.size(); i != e; ++i)
 8331           InlineAsm::getFlagWord(InlineAsm::Kind_Imm, Ops.size());
 9097     for (unsigned i = 0, e = Args.size(); i != e; ++i) {
 9111   for (unsigned i = 0, e = Args.size(); i != e; ++i) {
10447   if (SwitchPeelThreshold > 100 || !FuncInfo.BPI || Clusters.size() < 2 ||
10455   for (unsigned Index = 0; Index < Clusters.size(); ++Index) {

 1698                     << FuncInfo->PHINodesToUpdate.size() << "\n";
 1699              for (unsigned i = 0, e = FuncInfo->PHINodesToUpdate.size(); i != e;
 1706   for (unsigned i = 0, e = FuncInfo->PHINodesToUpdate.size(); i != e; ++i) {
 1831     for (unsigned pi = 0, pe = FuncInfo->PHINodesToUpdate.size();
 1860   for (unsigned i = 0, e = SDB->SL->JTCases.size(); i != e; ++i) {
 1884     for (unsigned pi = 0, pe = FuncInfo->PHINodesToUpdate.size();
 1903   for (unsigned i = 0, e = SDB->SL->SwitchCases.size(); i != e; ++i) {
 1940             assert(pn != FuncInfo->PHINodesToUpdate.size() &&
 2040   unsigned i = InlineAsm::Op_FirstOperand, e = InOps.size();
 2075         InlineAsm::getFlagWord(InlineAsm::Kind_Mem, SelOps.size());
 2084   if (e != InOps.size())
 2842     if (N.getOpcode() < OpcodeOffset.size())
 2861       if (Opc >= OpcodeOffset.size())
 2868     if (N.getOpcode() < OpcodeOffset.size())

 4197     if (OpInfo.multipleAlternatives.size() > maCount)
 4198       maCount = OpInfo.multipleAlternatives.size();
 4283         for (unsigned cIndex = 0, eIndex = ConstraintOperands.size();
 4320       for (unsigned cIndex = 0, eIndex = ConstraintOperands.size();
 4331   for (unsigned cIndex = 0, eIndex = ConstraintOperands.size();
 4387   if (maIndex >= (int)info.multipleAlternatives.size())
 4394   for (unsigned i = 0, e = rCodes->size(); i != e; ++i) {
 4476   assert(OpInfo.Codes.size() > 1 && "Doesn't have multiple constraint options");
 4482   for (unsigned i = 0, e = OpInfo.Codes.size(); i != e; ++i) {
 4530   if (OpInfo.Codes.size() == 1) {

  108   for (unsigned I = 0; I != Roots.size(); ++I) {
  119       ConstantInt::get(Int32Ty, Roots.size(), false),
  159   for (size_t I = 0; I != Roots.size(); I++)
  322   for (unsigned I = 0, E = Roots.size(); I != E; ++I) {
  365   for (unsigned I = 0, E = Roots.size(); I != E; ++I) {

  427   LLVM_DEBUG(dbgs() << WSMP << "#callsites = " << CSInfos.size() << '\n');
  428   OS.EmitIntValue(CSInfos.size(), 4);

  331   for (unsigned i = 0, e = SSIntervals.size(); i != e; ++i) {
  344   for (unsigned i = 0, e = SSIntervals.size(); i != e; ++i) {
  353   for (unsigned i = 0, e = SSIntervals.size(); i != e; ++i)

   51   for (unsigned i = 1, e = Clusters.size(); i < e; ++i)
   63   const int64_t N = Clusters.size();
  256                                      JTCases.size() - 1, Prob);
  271   for (unsigned i = 1; i < Clusters.size(); ++i)
  285   const int64_t N = Clusters.size();
  416     for (j = 0; j < CBV.size(); ++j)
  419     if (j == CBV.size())
  455                                     BitTestCases.size() - 1, TotalProb);
  470   const unsigned N = Clusters.size();

  202       for (unsigned j = 0, ee = LI->second.size(); j != ee; ++j) {
  502         for (unsigned j = 0, ee = LI->second.size(); j != ee; ++j) {

  150   for (unsigned i = 0, e = DeadBlocks.size(); i != e; ++i) {

   67     Size += sizeof(support::ulittle32_t) * Item.second.size();
   89     Imp.Count = Item->getValue().size();

   37   uint32_t Size = sizeof(FrameData) * Frames.size();

   71   Size += Entries.size() * sizeof(InlineeSourceLineHeader);
   74     Size += Entries.size() * sizeof(uint32_t);
   98     if (auto EC = Writer.writeInteger<uint32_t>(E.ExtraFiles.size()))

   94   assert(B.Lines.size() == B.Columns.size());
   94   assert(B.Lines.size() == B.Columns.size());
  115     assert(B.Lines.size() == B.Columns.size() || B.Columns.empty());
  115     assert(B.Lines.size() == B.Columns.size() || B.Columns.empty());
  117     BlockHeader.NumLines = B.Lines.size();
  141     Size += B.Lines.size() * sizeof(LineNumberEntry);
  143       Size += B.Columns.size() * sizeof(ColumnNumberEntry);

   34   return RVAs.size() * sizeof(uint32_t);

  139   if (Records.size() <= Index.toArrayIndex())
  148 uint32_t LazyRandomTypeCollection::capacity() { return Records.size(); }

  526   Values.reserve(Abbr.Attributes.size());
  533   assert(Abbr->Attributes.size() == Values.size());
  567   assert(Abbr->Attributes.size() == Values.size());

   65   if (AbbrCode < FirstAbbrCode || AbbrCode >= FirstAbbrCode + Decls.size())

  150   if (Addrs.size() > 0) {
  161   if (Index < Addrs.size())

   73     return FileIndex < FileNames.size();
   74   return FileIndex != 0 && FileIndex <= FileNames.size();
  116   for (uint32_t I = 0; I != StandardOpcodeLengths.size(); ++I)
  123     for (uint32_t I = 0; I != IncludeDirectories.size(); ++I) {
  133     for (uint32_t I = 0; I != FileNames.size(); ++I) {
  483   unsigned RowNumber = LineTable->Rows.size();
  824           assert(Opcode - 1U < Prologue.StandardOpcodeLengths.size());
 1060     if (Entry.DirIdx < IncludeDirectories.size())
 1063     if (0 < Entry.DirIdx && Entry.DirIdx <= IncludeDirectories.size())

  112   if (OpCode >= Descriptions.size())

  376       Dies.reserve(Dies.size() + getDebugInfoSize() / 14);
  413       DieArray.size() > 1)
  548   if (DieArray.size() > (unsigned)KeepCUDie) {
  708   for (size_t I = getDIEIndex(Die) + 1, EndIdx = DieArray.size(); I < EndIdx;
  741   if (I >= DieArray.size())
  751   for (size_t I = getDIEIndex(Die) + 1, EndIdx = DieArray.size(); I < EndIdx;

  710     uint32_t MaxDirIndex = LineTable->Prologue.IncludeDirectories.size();
  775                 << LineTable->Prologue.FileNames.size()

   35   const auto NextIndex = Files.size();
   62   if (Funcs.size() > UINT32_MAX)
   72   Hdr.UUIDSize = static_cast<uint8_t>(UUID.size());
   74   Hdr.NumAddresses = static_cast<uint32_t>(Funcs.size());
   78   if (UUID.size() > sizeof(Hdr.UUID))
   80                              "invalid UUID size %u", (uint32_t)UUID.size());
   91   if (UUID.size() > 0)
   92     memcpy(Hdr.UUID, UUID.data(), UUID.size());
  113   for (size_t i = 0, n = Funcs.size(); i < n; ++i)
  121   size_t NumFiles = Files.size();
  190   auto NumBefore = Funcs.size();
  242   OS << "Pruned " << NumBefore - Funcs.size() << " functions, ended with "
  243      << Funcs.size() << " total\n";

  133   if (Lines.size() == 1) {
  166     const size_t NumDeltaInfos = DeltaInfos.size();

   86   O.writeULEB(Ranges.size());

  178   return StreamData.size() - 1;
  188   return StreamData.size() - 1;
  224 uint32_t MSFBuilder::getNumStreams() const { return StreamData.size(); }
  240   Size += StreamData.size() * sizeof(ulittle32_t); // StreamSizes
  243     assert(ExpectedNumBlocks == D.second.size() &&
  263   if (NumDirectoryBlocks > DirectoryBlocks.size()) {
  267     uint32_t NumExtraBlocks = NumDirectoryBlocks - DirectoryBlocks.size();
  273   } else if (NumDirectoryBlocks < DirectoryBlocks.size()) {
  274     uint32_t NumUnnecessaryBlocks = DirectoryBlocks.size() - NumDirectoryBlocks;
  294     ulittle32_t *Sizes = Allocator.Allocate<ulittle32_t>(StreamData.size());
  295     L.StreamSizes = ArrayRef<ulittle32_t>(Sizes, StreamData.size());
  296     L.StreamMap.resize(StreamData.size());
  297     for (uint32_t I = 0; I < StreamData.size(); ++I) {
  300           Allocator.Allocate<ulittle32_t>(StreamData[I].second.size());
  302                                 StreamData[I].second.size(), BlockList);
  304           ArrayRef<ulittle32_t>(BlockList, StreamData[I].second.size());

   62   assert(StreamIndex < Layout.StreamMap.size() && "Invalid stream index");
  330   assert(StreamIndex < Layout.StreamMap.size() && "Invalid stream index");

  112   Layout.NumFiles = SourceFiles.size();

  115   uint32_t Index = ModiList.size();
  148          sizeof(SectionContribs[0]) * SectionContribs.size();
  161   Offset += ModiList.size() * sizeof(ulittle16_t);       // ModIndices
  162   Offset += ModiList.size() * sizeof(ulittle16_t);       // ModFileCounts
  200   uint16_t ModiCount = std::min<uint32_t>(UINT16_MAX, ModiList.size());
  305         sizeof(object::FpoData) * OldFpoData.size();

   81   Size += HashRecords.size() * sizeof(PSHashRecord);
   83   Size += HashBuckets.size() * sizeof(uint32_t);
   98   Header.HrSize = HashRecords.size() * sizeof(PSHashRecord);
   99   Header.NumBuckets = HashBitmap.size() * 4 + HashBuckets.size() * 4;
  152   HashRecords.reserve(Records.size());
  166         ulittle32_t(HashRecords.size() * SizeOfHROffsetCalc);
  195   Size += PSH->Records.size() * sizeof(uint32_t); // AddrMap
  336   Header.AddrMap = PSH->Records.size() * 4;

   52                     (Features.size() + 1) * sizeof(uint32_t);

   68   if (auto EC = Writer.writeInteger<uint32_t>(NamesBuffer.size()))
   72   StringRef Data(NamesBuffer.data(), NamesBuffer.size());
   85          + NamesBuffer.size()                          // String data
   92   assert(NamesBuffer.size() > Offset);
  118   uint32_t Offset = NamesBuffer.size();

   37   return static_cast<uint32_t>(MatchOffsets.size());
   42   if (N >= MatchOffsets.size())

   55   return static_cast<uint32_t>(Matches.size());
   59   if (N < Matches.size()) {

   91   return Enumerators.size();

   35 uint32_t NativeTypeVTShape::getCount() const { return Record.Slots.size(); }

  232   assert(SymbolId < Cache.size());
  235   if (SymbolId == 0 || SymbolId >= Cache.size())
  289   if (Index >= Compilands.size())

  165   if (Bucket > HashMap.size())

   52                              TypeRecords.size()),
   68   uint32_t Count = TypeRecords.size();
  104   assert((TypeRecords.size() == TypeHashes.size() || TypeHashes.empty()) &&
  104   assert((TypeRecords.size() == TypeHashes.size() || TypeHashes.empty()) &&
  106   return TypeHashes.size() * sizeof(ulittle32_t);
  110   return TypeIndexOffsets.size() * sizeof(codeview::TypeIndexOffset);
  129     ulittle32_t *H = Allocator.Allocate<ulittle32_t>(TypeHashes.size());
  130     MutableArrayRef<ulittle32_t> HashBuffer(H, TypeHashes.size());
  131     for (uint32_t I = 0; I < TypeHashes.size(); ++I) {

   50   uint32_t getChildCount() const override { return Args.size(); }
   54     if (Index >= Args.size())

  199   AllBases.reserve(Bases.size() + VirtualBaseSyms.size());
  199   AllBases.reserve(Bases.size() + VirtualBaseSyms.size());
  216   assert(VTables.size() <= 1);

  341   Values.reserve(InputArgv.size());
  343   Array = std::make_unique<char[]>((InputArgv.size()+1)*PtrSize);
  348   for (unsigned i = 0; i != InputArgv.size(); ++i) {
  365                          (GenericValue*)(&Array[InputArgv.size()*PtrSize]),
  431   GVArgc.IntVal = APInt(32, argv.size());
 1050     for (unsigned i = 0; i < Val.AggregateVal.size(); ++i) {
 1259       for (unsigned i = 0, e = NonCanonicalGlobals.size(); i != e; ++i) {

   70     R.AggregateVal.resize(Src.AggregateVal.size());
   78         for (unsigned i = 0; i < R.AggregateVal.size(); ++i)
   81         for (unsigned i = 0; i < R.AggregateVal.size(); ++i)
  447     for( size_t _i=0; _i<Src1.AggregateVal.size(); _i++)
  590     assert(Src1.AggregateVal.size() == Src2.AggregateVal.size());
  590     assert(Src1.AggregateVal.size() == Src2.AggregateVal.size());
  591     Dest.AggregateVal.resize( Src1.AggregateVal.size() );
  593       for( size_t _i=0;_i<Src1.AggregateVal.size();_i++)
  600       for( size_t _i=0;_i<Src1.AggregateVal.size();_i++)
  621     assert(Src1.AggregateVal.size() == Src2.AggregateVal.size());
  621     assert(Src1.AggregateVal.size() == Src2.AggregateVal.size());
  622     Dest.AggregateVal.resize( Src1.AggregateVal.size() );
  624       for( size_t _i=0;_i<Src1.AggregateVal.size();_i++)
  631         for( size_t _i=0;_i<Src1.AggregateVal.size();_i++)
  652       assert(Src1.AggregateVal.size() == Src2.AggregateVal.size());
  652       assert(Src1.AggregateVal.size() == Src2.AggregateVal.size());
  653       Dest.AggregateVal.resize( Src1.AggregateVal.size() );
  654       for( size_t _i=0; _i<Src1.AggregateVal.size(); _i++)
  743     assert(Src1.AggregateVal.size() == Src2.AggregateVal.size());
  743     assert(Src1.AggregateVal.size() == Src2.AggregateVal.size());
  744     R.AggregateVal.resize(Src1.AggregateVal.size());
  802         for (unsigned i = 0; i < R.AggregateVal.size(); ++i)
  807           for (unsigned i = 0; i < R.AggregateVal.size(); ++i)
  847       assert(Src1.AggregateVal.size() == Src2.AggregateVal.size());
  847       assert(Src1.AggregateVal.size() == Src2.AggregateVal.size());
  848       assert(Src2.AggregateVal.size() == Src3.AggregateVal.size());
  848       assert(Src2.AggregateVal.size() == Src3.AggregateVal.size());
  849       Dest.AggregateVal.resize( Src1.AggregateVal.size() );
  850       for (size_t i = 0; i < Src1.AggregateVal.size(); ++i)
 1127       ArgIndex.UIntPairVal.first = ECStack.size() - 1;
 1197     uint32_t src1Size = uint32_t(Src1.AggregateVal.size());
 1198     assert(src1Size == Src2.AggregateVal.size());
 1224     uint32_t src1Size = uint32_t(Src1.AggregateVal.size());
 1225     assert(src1Size == Src2.AggregateVal.size());
 1251     size_t src1Size = Src1.AggregateVal.size();
 1252     assert(src1Size == Src2.AggregateVal.size());
 1277     unsigned NumElts = Src.AggregateVal.size();
 1297     unsigned size = Src.AggregateVal.size();
 1318     unsigned size = Src.AggregateVal.size();
 1340     unsigned size = Src.AggregateVal.size();
 1362     unsigned size = Src.AggregateVal.size();
 1385     unsigned size = Src.AggregateVal.size();
 1423     unsigned size = Src.AggregateVal.size();
 1457     unsigned size = Src.AggregateVal.size();
 1489     unsigned size = Src.AggregateVal.size();
 1564       SrcNum = Src.AggregateVal.size();
 1808   if(Src1.AggregateVal.size() > indx) {
 1846   if(Src1.AggregateVal.size() <= indx)
 1879   unsigned src1Size = (unsigned)Src1.AggregateVal.size();
 1880   unsigned src2Size = (unsigned)Src2.AggregateVal.size();
 1881   unsigned src3Size = (unsigned)Src3.AggregateVal.size();

  187   for (unsigned I = 0, E = Sections.size() - 1; I != E; ++I) {

  656   for (unsigned I = 0, S = EventListeners.size(); I < S; ++I) {

 1676          << "      " << KV.second.pendingQueries().size()

  465   EHFrameRanges.reserve(EHFrameRanges.size() + TrackedEHFrameRanges.size());

  450   for (size_t Idx = 0, Cnt = SectionSizes.size(); Idx < Cnt; Idx++) {

   35   cl::ParseCommandLineOptions(CLArgs.size(), CLArgs.data());
   62   for (int I = 1, E = Args.size(); I < E; ++I)
   67   CLArgs.reserve(Args.size());
   71   cl::ParseCommandLineOptions(CLArgs.size(), CLArgs.data());
  126   for (int I = 1, E = Args.size(); I < E; ++I)
  131   CLArgs.reserve(Args.size());
  135   cl::ParseCommandLineOptions(CLArgs.size(), CLArgs.data());

  239   assert(List.size() == Stack.back().Shuffle.size() && "Wrong size");
  510   if (NumberedTypes.size() == Type2Number.size())
  515     assert(P.second < NumberedTypes.size() && "Didn't get a dense numbering?");
 3376   for (unsigned I = 0, E = NumberedTypes.size(); I != E; ++I) {
 4161   assert(Order.Shuffle.size() >= 2 && "Shuffle too small");
 4163   for (unsigned I = 1, E = Order.Shuffle.size(); I != E; ++I)

 1017   if (Expr->Elements.size() >= PatternSize &&
 1023     if (Expr->Elements.size() == PatternSize)
 1027                                           Expr->Elements.size() - PatternSize));

  149       if (N >= ConstraintsSoFar.size() || ConstraintsSoFar[N].Type != isOutput||
  157             ConstraintsSoFar[N].multipleAlternatives.size())
  164         scInfo.MatchingInput = ConstraintsSoFar.size();
  169                 ConstraintsSoFar.size())
  172         ConstraintsSoFar[N].MatchingInput = ConstraintsSoFar.size();
  207   if (index < multipleAlternatives.size()) {
  264   for (unsigned i = 0, e = Constraints.size(); i != e; ++i) {

  929   for (unsigned i = 0, e = II.size(); i != e; ++i)
 1057     for (unsigned i = 0, e = II.size(); i != e; ++i) {

  185       if (P.second.SummaryList.size())
  203     O << "SCC (" << utostr(I->size()) << " node" << (I->size() == 1 ? "" : "s")
  203     O << "SCC (" << utostr(I->size()) << " node" << (I->size() == 1 ? "" : "s")

  259         AddUint64(ByArg.first.size());
  442   for (unsigned I = 0; I != FOrErr->Mods.size(); ++I) {
  443     size_t Begin = File->Symbols.size();
  450     File->ModuleSymIndices.push_back({Begin, File->Symbols.size()});
  463   assert(Mods.size() == 1 && "Expect only one bitcode module");
  579   for (unsigned I = 0; I != Input->Mods.size(); ++I)

  153   for (int i = 0, e = undefs.size(); i != e; ++i)
  640     cl::ParseCommandLineOptions(CodegenArgv.size(), CodegenArgv.data());

  132     return GVSummaryList.size() > 1;
  899     ProducedBinaries.resize(Modules.size());
  906     ProducedBinaryFiles.resize(Modules.size());
  952   auto ModuleCount = Modules.size();
 1028   ModulesOrdering.resize(Modules.size());

  347   return SectionTable.size();
  951   for (unsigned i = 0, e = Relocs.size(); i != e; ++i) {
 1064   const unsigned NumSections = SectionTable.size();
 1247       (SectionTable.size() + 1 >= ELF::SHN_LORESERVE) ? (uint16_t)ELF::SHN_UNDEF
 1248                                                       : SectionTable.size() + 1,

   79   if (FuncId >= Functions.size())
   87   if (FuncId >= Functions.size())
  102   if (FuncId >= Functions.size())
  266   size_t Offset = MCCVLines.size();
  321   if (L >= MCCVLines.size())

 2651   const unsigned NParameters = M ? M->Parameters.size() : 0;
 2729       if (A.size() <= PI)
 2771   if (ActiveMacros.size() == MaxNestingDepth) {
 2803       NameLoc, CurBuffer, getTok().getLoc(), TheCondStack.size());
 4604   while (TheCondStack.size() != ActiveMacros.back()->CondStackDepth) {
 5548       DirectiveLoc, CurBuffer, getTok().getLoc(), TheCondStack.size());
 5640   if (A.size() != 1 || A.front().size() != 1)
 5640   if (A.size() != 1 || A.front().size() != 1)

  113 unsigned MCStreamer::getNumFrameInfos() { return DwarfFrameInfos.size(); }
  849   CurFrame->LastFrameInst = CurFrame->Instructions.size();

  195   uint8_t numInst = info->Instructions.size();
  473     if (Instrs.size() != EpilogInstrs.size())
  473     if (Instrs.size() != EpilogInstrs.size())
  477     for (unsigned i = 0; i < Instrs.size(); ++i)
  617   uint8_t numInst = info->Instructions.size();
  627     for (uint32_t i = 0; i < EpilogInstrs.size(); i++) {

  439   W.write<uint32_t>(Options.size());
  783   unsigned NumDataRegions = Asm.getDataRegions().size();
  798   unsigned NumSymbols = LocalSymbolData.size() + ExternalSymbolData.size() +
  798   unsigned NumSymbols = LocalSymbolData.size() + ExternalSymbolData.size() +
  799     UndefinedSymbolData.size();
  854     unsigned NumRelocs = Relocs.size();
  916     unsigned NumLocalSymbols = LocalSymbolData.size();
  918     unsigned NumExternalSymbols = ExternalSymbolData.size();
  920     unsigned NumUndefinedSymbols = UndefinedSymbolData.size();

  906   encodeULEB128(Relocs.size(), W.OS);
 1001       encodeULEB128(C.second.size(), W.OS);
 1262         WasmIndices[cast<MCSymbolWasm>(Begin)] = CustomSections.size();

  569     if (Section->Relocations.size() >= 0xffff)
  644   if (Sec.Relocations.size() >= 0xffff) {
  648     R.VirtualAddress = Sec.Relocations.size() + 1;
  913       bool RelocationsOverflow = Sec->Relocations.size() >= 0xffff;
  920         Sec->Header.NumberOfRelocations = Sec->Relocations.size();
  929       Offset += COFF::RelocationSize * Sec->Relocations.size();
  956   if (Sections.size() > INT32_MAX)
  960   UseBigObj = Sections.size() > COFF::MaxNumberOfSections16;
  961   Header.NumberOfSections = Sections.size();

  359   assert(RegID && RegID < RegisterMappings.size());

  161   assert(Index < Resources.size() && "Invalid processor resource index!");
  179   assert(Index < Resources.size() && "Invalid resource use!");

   49   NextAvailableSlotIdx %= Queue.size();
   67   return NextSlotIdx % Queue.size();
   80   CurrentInstructionSlotIdx %= Queue.size();
   86   assert(Queue.size() > TokenID);

   33   dbgs() << "[SCHEDULER]: WaitSet size is: " << WaitSet.size() << '\n';
   34   dbgs() << "[SCHEDULER]: ReadySet size is: " << ReadySet.size() << '\n';
   35   dbgs() << "[SCHEDULER]: IssuedSet size is: " << IssuedSet.size() << '\n';
  151   PendingSet.resize(PendingSet.size() - PromotedElements);
  188   WaitSet.resize(WaitSet.size() - RemovedElements);
  193   unsigned QueueIndex = ReadySet.size();
  194   for (unsigned I = 0, E = ReadySet.size(); I != E; ++I) {
  196     if (QueueIndex == ReadySet.size() ||
  208   if (QueueIndex == ReadySet.size())
  213   std::swap(ReadySet[QueueIndex], ReadySet[ReadySet.size() - 1]);
  240   IssuedSet.resize(IssuedSet.size() - RemovedElements);

  114   for (unsigned I = 0, E = Worklist.size(); I < E; ++I) {

  294     NumSyms += M.Symbols.size();
  581       MaxOffset += M.Symbols.size() * 4;

   61   size_t S = B.size();
   74   size_t Pos = B.size();
   75   size_t Offset = B.size();
   88   support::ulittle32_t Length(B.size() - Offset);
  249   auto S = Buffer.size();
  315   StringRef F{reinterpret_cast<const char *>(Buffer.data()), Buffer.size()};
  376   StringRef F{reinterpret_cast<const char *>(Buffer.data()), Buffer.size()};
  458   StringRef F{reinterpret_cast<const char *>(Buffer.data()), Buffer.size()};
  566   char *Buf = Alloc.Allocate<char>(Buffer.size());
  567   memcpy(Buf, Buffer.data(), Buffer.size());
  568   return {MemoryBufferRef(StringRef(Buf, Buffer.size()), ImportName)};

  102     R.Size = Objs.size();
  104                   reinterpret_cast<const char *>(Objs.data() + Objs.size()));
  129   Mod.Begin = Syms.size();
  130   Mod.End = Syms.size() + Msymtab.symbols().size();
  131   Mod.UncBegin = Uncommons.size();
  167   auto P = ComdatMap.insert(std::make_pair(C, Comdats.size()));
  405   if (FC.TheReader.getNumModules() != BFC.Mods.size())

   75   for (unsigned I = 0, N = Addresses.size() - 1; I < N; ++I) {

  346   if (Functions.size() != FunctionTypes.size()) {
  346   if (Functions.size() != FunctionTypes.size()) {
  392   if (Functions.size() != FunctionTypes.size()) {
  392   if (Functions.size() != FunctionTypes.size()) {
  421       if (Count > DataSegments.size())
  473   ImportedGlobals.reserve(Imports.size());
  474   ImportedFunctions.reserve(Imports.size());
  475   ImportedEvents.reserve(Imports.size());
  554         if (Index >= DataSegments.size())
  656         if (Index >= DataSegments.size())
  752   if (SectionIndex >= Sections.size())
  778       if (Reloc.Index >= Signatures.size())
  943   uint32_t NumTypes = Signatures.size();
  986   GlobalSection = Sections.size();
  991     Global.Index = NumImportedGlobals + Globals.size();
 1005   EventSection = Sections.size();
 1010     Event.Index = NumImportedEvents + Events.size();
 1062   return Index < NumImportedFunctions + FunctionTypes.size();
 1070   return Index < NumImportedGlobals + Globals.size();
 1078   return Index < NumImportedEvents + Events.size();
 1086   return Index < Symbols.size() && Symbols[Index].isTypeFunction();
 1090   return Index < Symbols.size() && Symbols[Index].isTypeGlobal();
 1094   return Index < Symbols.size() && Symbols[Index].isTypeEvent();
 1098   return Index < Symbols.size() && Symbols[Index].isTypeData();
 1102   return Index < Symbols.size() && Symbols[Index].isTypeSection();
 1135   CodeSection = Sections.size();
 1137   if (FunctionCount != FunctionTypes.size()) {
 1149     Function.Index = NumImportedFunctions + Functions.size();
 1201   DataSection = Sections.size();
 1278   Ref.d.b = Symbols.size(); // Symbol index
 1468   RelocRef.d.b = Sec.Relocations.size();
 1521   Ref.d.a = Sections.size();
 1540   assert(Ref.d.a < Sections.size());
 1556   assert(Ref.d.a < Sections.size());
 1558   assert(Ref.d.b < Sec.Relocations.size());

  236   if (Context.size() >= 1) {
  241   if (Context.size() >= 2) {
  246   if (Context.size() >= 3) {
  323   return MinGW && Context.size() == 3 && !Context[0].IsString &&
  348   uint32_t Origin = InputFilenames.size();
  370   uint32_t Origin = InputFilenames.size();
  434                                      Origin, Data.size(), Child);
  506                             Origin, Data.size(), Result);
  542     auto NewChild = createStringNode(StringTable.size());
  678     uint32_t StringSize = String.size() * sizeof(UTF16) + sizeof(uint16_t);
  699     SectionTwoSize += alignTo(Entry.size(), sizeof(uint64_t));
  793     CurrentOffset += alignTo(RawDataEntry.size(), sizeof(uint64_t));
  946     Entry->DataSize = Data[DataNodes->getDataIndex()].size();
  958     uint16_t Length = String.size();

   45     return static_cast<int32_t>(Obj.Sections.size()) >
  214   CP.SectionTableSize = COFF::SectionSize * CP.Obj.Sections.size();
  263         S.Header.NumberOfRelocations = S.Relocations.size();
  300   CP.Obj.Header.NumberOfSections = CP.Obj.Sections.size();

  254                   Value.Bytes.size());

  245     uint32_t TotalLen = sizeof(RecordPrefix) + Data.size();
  250     ::memcpy(Buffer + sizeof(RecordPrefix), Data.data(), Data.size());

   69   uint32_t Size = 8 + 8 * DebugH.Hashes.size();

   75             onValue((uint64_t)FormVal->BlockData.size(), true);
   78                                           FormVal->BlockData.size()),
   82             auto writeSize = FormVal->BlockData.size();
   86                                           FormVal->BlockData.size()),
   91             auto writeSize = FormVal->BlockData.size();
   95                                           FormVal->BlockData.size()),
  100             auto writeSize = FormVal->BlockData.size();
  104                                           FormVal->BlockData.size()),

   19   return 0 == DebugStrings.size() + AbbrevDecls.size();
   19   return 0 == DebugStrings.size() + AbbrevDecls.size();

  266   Header.e_phoff = Doc.ProgramHeaders.size() ? sizeof(Header) : 0;
  269   Header.e_phentsize = Doc.ProgramHeaders.size() ? sizeof(Elf_Phdr) : 0;
  270   Header.e_phnum = Doc.ProgramHeaders.size();
  281       Doc.Header.SHNum ? (uint16_t)*Doc.Header.SHNum : Doc.Sections.size();
  378   SHeaders.resize(Doc.Sections.size());
  380   for (size_t I = 0; I < Doc.Sections.size(); ++I) {
  666       if (YamlPhdr.Sections.size())
  742   SHeader.sh_size = SHeader.sh_entsize * Section.Relocations.size();
  784   SHeader.sh_size = Shndx.Entries.size() * SHeader.sh_entsize;
  795   SHeader.sh_size = SHeader.sh_entsize * Section.Members.size();
  822   SHeader.sh_size = Section.Entries.size() * SHeader.sh_entsize;
  860   support::endian::write<uint32_t>(OS, Section.Bucket->size(),
  862   support::endian::write<uint32_t>(OS, Section.Chain->size(),
  869   SHeader.sh_size = (2 + Section.Bucket->size() + Section.Chain->size()) * 4;
  869   SHeader.sh_size = (2 + Section.Bucket->size() + Section.Chain->size()) * 4;
  882   for (size_t I = 0; I < Section.Entries.size(); ++I) {
  891     VerDef.vd_cnt = E.VerNames.size();
  892     if (I == Section.Entries.size() - 1)
  896           sizeof(Elf_Verdef) + E.VerNames.size() * sizeof(Elf_Verdaux);
  899     for (size_t J = 0; J < E.VerNames.size(); ++J, ++AuxCnt) {
  902       if (J == E.VerNames.size() - 1)
  910   SHeader.sh_size = Section.Entries.size() * sizeof(Elf_Verdef) +
  925   for (size_t I = 0; I < Section.VerneedV.size(); ++I) {
  931     if (I == Section.VerneedV.size() - 1)
  935           sizeof(Elf_Verneed) + VE.AuxV.size() * sizeof(Elf_Vernaux);
  936     VerNeed.vn_cnt = VE.AuxV.size();
  940     for (size_t J = 0; J < VE.AuxV.size(); ++J, ++AuxCnt) {
  948       if (J == VE.AuxV.size() - 1)
  956   SHeader.sh_size = Section.VerneedV.size() * sizeof(Elf_Verneed) +
 1005     SHeader.sh_size = 2 * sizeof(uintX_t) * Section.Entries.size();
 1095   for (unsigned I = 0, E = Doc.Sections.size(); I != E; ++I) {
 1172       sizeof(Elf_Ehdr) + sizeof(Elf_Phdr) * Doc.ProgramHeaders.size();

  237     if (LC.PayloadBytes.size() > 0) {
  239                LC.PayloadBytes.size());
  240       BytesWritten += LC.PayloadBytes.size();
  358   OS.write(static_cast<uint8_t>(Entry.Children.size()));
  497   assert(FatFile.FatArchs.size() == FatFile.Slices.size());
  497   assert(FatFile.FatArchs.size() == FatFile.Slices.size());
  498   for (size_t i = 0; i < FatFile.Slices.size(); i++) {

   30          RebaseOpcodes.size() + BindOpcodes.size() + WeakBindOpcodes.size() +
   30          RebaseOpcodes.size() + BindOpcodes.size() + WeakBindOpcodes.size() +
   30          RebaseOpcodes.size() + BindOpcodes.size() + WeakBindOpcodes.size() +
   31              LazyBindOpcodes.size() + ExportTrie.Children.size() +
   31              LazyBindOpcodes.size() + ExportTrie.Children.size() +
   32              NameList.size() + StringTable.size();
   32              NameList.size() + StringTable.size();

  158   File.allocateNewObject<support::ulittle32_t>(S.Entries.size());
  185         InfoList.Infos.size());
  234   std::vector<Directory> StreamDirectory(Obj.Streams.size());
  237   Obj.Header.NumberOfStreams = StreamDirectory.size();

  163   encodeULEB128(Section.Needed.size(), OS);
  176   if (Section.SymbolTable.size()) {
  179     encodeULEB128(Section.SymbolTable.size(), SubSection.getStream());
  216   if (Section.SegmentInfos.size()) {
  218     encodeULEB128(Section.SegmentInfos.size(), SubSection.getStream());
  228   if (Section.InitFunctions.size()) {
  230     encodeULEB128(Section.InitFunctions.size(), SubSection.getStream());
  239   if (Section.Comdats.size()) {
  241     encodeULEB128(Section.Comdats.size(), SubSection.getStream());
  245       encodeULEB128(C.Entries.size(), SubSection.getStream());
  258   if (Section.FunctionNames.size()) {
  263     encodeULEB128(Section.FunctionNames.size(), SubSection.getStream());
  287     encodeULEB128(Field.second->size(), OS);
  298   encodeULEB128(Section.Features.size(), OS);
  325   encodeULEB128(Section.Signatures.size(), OS);
  334     encodeULEB128(Sig.ParamTypes.size(), OS);
  337     encodeULEB128(Sig.ReturnTypes.size(), OS);
  345   encodeULEB128(Section.Imports.size(), OS);
  381   encodeULEB128(Section.FunctionTypes.size(), OS);
  388   encodeULEB128(Section.Exports.size(), OS);
  403   encodeULEB128(Section.Tables.size(), OS);
  412   encodeULEB128(Section.Memories.size(), OS);
  419   encodeULEB128(Section.Globals.size(), OS);
  435   encodeULEB128(Section.Events.size(), OS);
  450   encodeULEB128(Section.Segments.size(), OS);
  455     encodeULEB128(Segment.Functions.size(), OS);
  463   encodeULEB128(Section.Functions.size(), OS);
  474     encodeULEB128(Func.Locals.size(), StringStream);
  491   encodeULEB128(Section.Segments.size(), OS);
  527   encodeULEB128(Sec.Relocations.size(), OS);

  211   for (size_t I = FirstSearchableIndex, E = OptionInfos.size(); I < E; I++) {
  231   for (size_t I = FirstSearchableIndex, E = OptionInfos.size(); I < E; I++) {
  323   for (size_t I = FirstSearchableIndex, E = OptionInfos.size(); I < E; I++) {
  345   const Info *End = OptionInfos.data() + OptionInfos.size();
  493   for (unsigned i = 0, e = OptionHelp.size(); i != e; ++i) {
  501   for (unsigned i = 0, e = OptionHelp.size(); i != e; ++i) {

   51   unsigned I = Expressions.size();
  265   unsigned RecordIndex = Functions.size() - 1;
  585     for (unsigned I = 1, E = Segments.size(); I < E; ++I) {
  615   SmallBitVector FilenameEquivalence(Function.Filenames.size(), false);
  616   for (unsigned I = 0, E = Function.Filenames.size(); I < E; ++I)
  624   SmallBitVector IsNotExpandedFile(Function.Filenames.size(), true);

  125     if (ID >= Expressions.size())
  430         FunctionRecords.insert(std::make_pair(NameRef, Records.size()));
  438                            Filenames.size() - FilenamesBegin);
  460     OldRecord.FilenamesSize = Filenames.size() - FilenamesBegin;
  494     size_t FilenamesBegin = Filenames.size();
  809   if (CurrentRecord >= MappingRecords.size())

  483   Sum.NumEntries += Counts.size();
  484   for (size_t F = 0, E = Counts.size(); F < E; ++F)
  556   bool Mismatch = (Counts.size() != Other.Counts.size());
  556   bool Mismatch = (Counts.size() != Other.Counts.size());
  581   for (size_t I = 0, E = Other.Counts.size(); I < E; ++I) {
  591     for (size_t I = 0, E = Other.Counts.size(); I < E; ++I)
  596     FuncLevelOverlap.Overlap.NumEntries = Other.Counts.size();
  659   if (Counts.size() != Other.Counts.size()) {
  659   if (Counts.size() != Other.Counts.size()) {
  664   for (size_t I = 0, E = Other.Counts.size(); I < E; ++I) {

  126       M += ProfRecord.Counts.size() * sizeof(uint64_t);
  152       LE.write<uint64_t>(ProfRecord.Counts.size());
  276   TheSummary->NumCutoffEntries = Res.size();
  283   for (unsigned I = 0; I < Res.size(); I++)
  404   OS << "# Num Counters:\n" << Func.Counts.size() << "\n";

   40   for (size_t I = 1, E = R.Counts.size(); I < E; ++I)

  344   if (*Idx >= Table.size())

  431   for (uint32_t i = 0; i < SecHdrTable.size(); i++) {
  488   encodeULEB128(Entries.size(), OS);

   37   if (Index >= Offsets.size())
   41         Offsets.size());
   47       (Index == Offsets.size() - 1) ? Buffer.size() : Offsets[Index + 1];

  502   size_t StartingNumFeatures = Features.size();
  534   return StartingNumFeatures != Features.size();

 2191     assert(SortedCategories.size() > 0 && "No option categories registered!");

  104     for (unsigned I = 0, E = ByteSwapped.size(); I != E; ++I)
  107     SrcEnd = &ByteSwapped[ByteSwapped.size() - 1] + 1;

   50   if (Sets.size() <= 1)
   63   if (SplitSets.size() == Sets.size())
   63   if (SplitSets.size() == Sets.size())
   85     if (Sets.size() > 2) {

 1271            << (Req.CheckPrefixes.size() > 1 ? "es " : " ");
 1935   unsigned i = 0, j = 0, e = CheckStrings->size();

  551   ConvertUTF8toUTF32(&In8, In8 + S.size(), &Out32, Out32 + Codepoints.size(),
  554   std::string Res(4 * Codepoints.size(), 0); // 4 bytes per codepoint suffice
  557   ConvertUTF32toUTF8(&In32, In32 + Codepoints.size(), &Out8, Out8 + Res.size(),

   38   return Plugins.isConstructed() ? Plugins->size() : 0;
   43   assert(Plugins.isConstructed() && num < Plugins->size() &&

   48   for (unsigned i = 0, e = IncludeDirectories.size(); i != e && !NewBufOrErr;
   62   for (unsigned i = 0, e = Buffers.size(); i != e; ++i)
  429   for (unsigned r = 0, e = Ranges.size(); r != e; ++r) {

  185       SectionsMap[Section] = Sections.size();

  175   for (size_t i = 0, e = Stats.Stats.size(); i != e; ++i) {
  190   for (size_t i = 0, e = Stats.Stats.size(); i != e; ++i)

  127   for (unsigned i = 0, e = Targets.size(); i != e; ++i) {

  250   assert(TimersToPrint.size() == Records.size() && "Size mismatch");

   76       Index[Tri].push_back(Counts.size());
   92   std::vector<unsigned> CurCounts(Counts.size());

  211     return SQ->Entries.size();
  294     BitValuesUsed.insert(BitValuesUsed.begin(), SQ->Entries.size(), false);
  328     assert(BitValuesUsed.size() == SQ->Entries.size());
  329     for (unsigned i = 0; i < SQ->Entries.size(); ++i) {

   86   if (Sz >= Shared.size())

   35     for (unsigned str = 0, e = Matches.size(); str != e; ++str)
   57     if (Matches.size() > 1 && !IgnoreDuplicates)
   78   for (unsigned i = 0, e = Matches.size(); i != e; ++i)
  117        << LI->second.size() << " string";
  118     if (LI->second.size() != 1) OS << 's';
  138   for (unsigned i = 0, e = Matches.size(); i != e; ++i)
  149        << LI->second.size()
  150        << " string" << (LI->second.size() == 1 ? "" : "s") << " to match.\n";

  228   LLVM_DEBUG(dbgs() << "Scan complete, " << Sequences.size()

  346   LLVM_DEBUG(dbgs() << "Scan complete, " << AllChains.size()
  443   LLVM_DEBUG(dbgs() << "colorChainSet(): #sets=" << GV.size() << "\n");

  707   for (unsigned JTI = 0, e = JT.size(); JTI != e; ++JTI) {

 1837   unsigned Count = CSI.size();

 5093     if (RepeatedSequenceLocs.size() < 2)
 5230         NumBytesNoStackCalls <= RepeatedSequenceLocs.size() * 12) {
 5238     if (RepeatedSequenceLocs.size() < 2) {

  555     for (size_t i = 0; i < DisasmLines.size(); ++i) {

  341       DisasmLines.resize(DisasmLines.size() + 1);
  356       HexLines.resize(HexLines.size() + 1);

   88   assert(SU->NodeNum < SUNumbers.size());
  296   SUSavedCopy.resize(SUnits.size());
  303   SUNumbers.assign(SUnits.size(), 0);
  314   Schedule.reserve(SUnits.size());
  346   assert(SUnits.size() == Schedule.size());
  346   assert(SUnits.size() == Schedule.size());

   87   NumPreds.resize(SUnits.size());
   88   for (unsigned I = 0; I < SUnits.size(); ++I)
  236   Schedule.reserve(SUnits.size());
  271   assert(SUnits.size() == Schedule.size());
  271   assert(SUnits.size() == Schedule.size());

   83   return LoopStack.size();
  387         assert(Lits.size() < 4 && "Too many literals in Instruction Group");
  388         Src.first->setReg(LiteralRegs[Lits.size()]);
  398     for (unsigned i = 0, e = Literals.size(); i < e; i+=2) {
  442       for (unsigned i = 0, e = Literals.size(); i < e; i += 2) {
  463     assert(ClauseContent.size() < 128 && "ALU clause is too big");
  464     ClauseHead.getOperand(7).setImm(ClauseContent.size() - 1);
  474     for (unsigned i = 0, e = Clause.second.size(); i < e; ++i) {
  477     CfCount += 2 * Clause.second.size();
  486     for (unsigned i = 0, e = Clause.second.size(); i < e; ++i) {
  489     CfCount += Clause.second.size();
  669           for (unsigned i = 0, e = FetchClauses.size(); i < e; i++)
  671           for (unsigned i = 0, e = AluClauses.size(); i < e; i++)
  683       for (unsigned i = 0, e = ToPopAfter.size(); i < e; ++i) {

  158       if (CachedConsts.size() == 1) {
  299         .addImm((KCacheBanks.size() < 2)?0:KCacheBanks[1].first) // KB1
  301         .addImm((KCacheBanks.size() < 2)?0:2) // KM1
  303         .addImm((KCacheBanks.size() < 2)?0:KCacheBanks[1].second) // KLINE1

  436   for (unsigned i = 0, e = IGSrcs.size(); i < e; i++) {
  460   for (unsigned i = 0, e = TransSrcs.size(); i < e; ++i) {
  470       return IGSrcs.size() - 1;
  472   return IGSrcs.size();
  482   assert(Idx < SwzCandidate.size());
  486   for (unsigned i = ResetIdx + 1, e = SwzCandidate.size(); i < e; i++) {
  506     if (ValidUpTo == IGSrcs.size())
  521   for (unsigned i = 0, e = TransOps.size(); i < e; ++i) {
  546   for (unsigned i = 0, e = IG.size(); i < e; ++i) {
  585   assert (Consts.size() <= 12 && "Too many operands in instructions group");
  587   for (unsigned i = 0, n = Consts.size(); i < n; ++i) {
  612   for (unsigned i = 0, n = MIs.size(); i < n; i++) {

   75         (AluInstCount + AvailablesAluCount() + Pending[IDAlu].size()) /
   76         (FetchInstCount + Available[IDFetch].size());
   92       unsigned NearRegisterRequirement = 2 * Available[IDFetch].size();
  132     for (unsigned i = 0; i < DAG->SUnits.size(); i++) {
  338   for (unsigned i = 0, e = QSrc.size(); i < e; ++i) {
  399   return AvailableAlus[AluAny].size() + AvailableAlus[AluT_XYZW].size() +
  399   return AvailableAlus[AluAny].size() + AvailableAlus[AluT_XYZW].size() +
  400       AvailableAlus[AluT_X].size() + AvailableAlus[AluT_Y].size() +
  400       AvailableAlus[AluT_X].size() + AvailableAlus[AluT_Y].size() +
  401       AvailableAlus[AluT_Z].size() + AvailableAlus[AluT_W].size() +
  401       AvailableAlus[AluT_Z].size() + AvailableAlus[AluT_W].size() +
  402       AvailableAlus[AluTrans].size() + AvailableAlus[AluDiscarded].size() +
  402       AvailableAlus[AluTrans].size() + AvailableAlus[AluDiscarded].size() +
  403       AvailableAlus[AluPredX].size();

  177     if (CurrentUndexIdx >= Untouched->UndefReg.size())
  190   for (unsigned j = 0, je = RemapChan.size(); j < je; j++) {
  273     for (unsigned j = 0, e = RemapChan.size(); j < e; j++) {
  314   unsigned NeededUndefs = 4 - RSI.UndefReg.size();
  329   PreviousRegSeqByUndefCount[RSI.UndefReg.size()].push_back(RSI.Instr);

  256         for (unsigned i = 0, e = CurrentPacketMIs.size() - 1; i < e; i++) {
  273         for (unsigned i = 0, e = CurrentPacketMIs.size() - 1; i < e; i++) {
  300       for (unsigned i = 0, e = CurrentPacketMIs.size(); i < e; i++) {

 1482     RpotIdxMap[MBB] = BlockInfos.size();

  198   NodeNum2Index[SU->NodeNum] = SUnits.size();
  425   InternalAdditionnalPressure.resize(TopPressure.MaxSetPressure.size());
  429   assert(SUnits.size() == ScheduledSUnits.size() &&
  429   assert(SUnits.size() == ScheduledSUnits.size() &&
  448   HasLowLatencyNonWaitedParent.assign(SUnits.size(), 0);
  487     if (SuccSU->NodeNum >= DAG->SUnits.size())
  513     HasLowLatencyNonWaitedParent.assign(SUnits.size(), 0);
  533   HasLowLatencyNonWaitedParent.resize(SUnits.size(), 0);
  653   if (SU->NodeNum >= DAG->SUnits.size())
  659   unsigned DAGSize = DAG->SUnits.size();
  680   unsigned DAGSize = DAG->SUnits.size();
  735         else if (SubGraph.size() > 5) {
  804   unsigned DAGSize = DAG->SUnits.size();
  898   unsigned DAGSize = DAG->SUnits.size();
  927   unsigned DAGSize = DAG->SUnits.size();
  931          CurrentBottomUpReservedDependencyColoring.size() == DAGSize &&
  932          CurrentTopDownReservedDependencyColoring.size() == DAGSize);
  976   unsigned DAGSize = DAG->SUnits.size();
 1009   unsigned DAGSize = DAG->SUnits.size();
 1035   unsigned DAGSize = DAG->SUnits.size();
 1056   unsigned DAGSize = DAG->SUnits.size();
 1077   unsigned DAGSize = DAG->SUnits.size();
 1116   unsigned DAGSize = DAG->SUnits.size();
 1194   unsigned DAGSize = DAG->SUnits.size();
 1230       int ID = CurrentBlocks.size();
 1261   for (unsigned i = 0, e = CurrentBlocks.size(); i != e; ++i) {
 1266              for (unsigned i = 0, e = CurrentBlocks.size(); i != e; ++i) {
 1286   unsigned DAGSize = CurrentBlocks.size();
 1334   unsigned DAGSize = CurrentBlocks.size();
 1353   PosOld.reserve(DAG->SUnits.size());
 1354   PosNew.reserve(DAG->SUnits.size());
 1396   for (unsigned i = PosOld.size(), e = 0; i != e; --i) {
 1408   LLVM_DEBUG(for (unsigned i = 0, e = CurrentBlocks.size(); i != e; ++i) {
 1415   unsigned DAGSize = CurrentBlocks.size();
 1465   LiveOutRegsNumUsages.resize(Blocks.size());
 1466   for (unsigned i = 0, e = Blocks.size(); i != e; ++i) {
 1491   LastPosHighLatencyParentScheduled.resize(Blocks.size(), 0);
 1492   BlockNumPredsLeft.resize(Blocks.size());
 1493   BlockNumSuccsLeft.resize(Blocks.size());
 1495   for (unsigned i = 0, e = Blocks.size(); i != e; ++i) {
 1497     BlockNumPredsLeft[i] = Block->getPreds().size();
 1502   for (unsigned i = 0, e = Blocks.size(); i != e; ++i) {
 1515     for (unsigned i = 0, e = Blocks.size(); i != e; ++i) {
 1517       int ID = BlocksStruct.TopDownIndex2Block[Blocks.size()-1-i];
 1531   for (unsigned i = 0, e = Blocks.size(); i != e; ++i) {
 1550   for (unsigned i = 0, e = Blocks.size(); i != e; ++i) {
 1788   for (unsigned b = 0; b < ScheduledBlocks.size(); ++b) {
 1831    unsigned DAGSize = SUnits.size();
 1835    for (unsigned i = 0, e = ScheduledSUnits.size(); i != e; ++i) {
 1898   for (unsigned i = 0, e = SUnits.size(); i != e; ++i) {
 1953   IsLowLatencySU.resize(SUnits.size(), 0);
 1954   LowLatencyOffset.resize(SUnits.size(), 0);
 1955   IsHighLatencySU.resize(SUnits.size(), 0);
 1957   for (unsigned i = 0, e = (unsigned)SUnits.size(); i != e; ++i) {
 2018   ScheduledSUnitsInv.resize(SUnits.size());
 2020   for (unsigned i = 0, e = (unsigned)SUnits.size(); i != e; ++i) {

  138   int getCost() { return SUnits.size(); }

 1191         if (CPI >= MCP->getConstants().size())

  311   LLVM_DEBUG(dbgs() << "Verifying " << CPUsers.size() << " CP users.\n");
  312   for (unsigned i = 0, e = CPUsers.size(); i != e; ++i) {
  352                     << MCP->getConstants().size() << " CP entries, aligned to "
  395   AFI->initPICLabelUId(CPEMIs.size());
  418     for (unsigned i = 0, e = CPUsers.size(); i != e; ++i)
  433     for (unsigned i = 0, e = ImmBranches.size(); i != e; ++i)
  465   for (unsigned i = 0, e = CPEntries.size(); i != e; ++i) {
  466     for (unsigned j = 0, je = CPEntries[i].size(); j != je; ++j) {
  519   for (unsigned i = 0, e = CPs.size(); i != e; ++i) {
  557   unsigned i = CPEntries.size();
  595     unsigned Size = JT[JTI].MBBs.size() * sizeof(uint32_t);
  605     JumpTableEntryIndices.insert(std::make_pair(JTI, CPEntries.size() - 1));
  644   for (unsigned i = 0, e = CPEs.size(); i != e; ++i) {
  670   assert(CPI < MCP->getConstants().size() && "Invalid constant pool index.");
  838             JumpTableUserIndices.insert(std::make_pair(CPI, CPUsers.size()));
 1146   for (unsigned i = 0, e = CPEs.size(); i != e; ++i) {
 1383   unsigned NumCPUsers = CPUsers.size();
 1587   for (unsigned i = 0, e = CPEntries.size(); i != e; ++i) {
 1589       for (unsigned j = 0, ee = CPEs.size(); j != ee; ++j) {
 1770   for (unsigned i = 0, e = CPUsers.size(); i != e; ++i) {
 2174     assert(JTI < JT.size());
 2181     for (unsigned j = 0, ee = JTBBs.size(); j != ee; ++j) {
 2368     assert(JTI < JT.size());
 2375     for (unsigned j = 0, ee = JTBBs.size(); j != ee; ++j) {

   83     for (unsigned i = 0, e = Constants.size(); i != e; ++i) {

  415   for (unsigned i = 0, e = CSI.size(); i != e; ++i) {
  987   unsigned i = CSI.size();
 1075   unsigned i = CSI.size();
 1176   for (unsigned i = 0, e = CSI.size(); i != e; ++i) {
 1347   for (unsigned i = 0, e = CSI.size(); i != e; ++i)
 1496       FnSize += Table.MBBs.size() * 4;
 1497   FnSize += MF.getConstantPool()->getConstants().size() * 4;

 4430     if (Ops.size() == 5){
 4434       assert(Ops.size() == 3 &&
 4544     if (Ops.size() == 5) {
 4548       assert(Ops.size() == 3 &&
 4773       AsmNodeOperands[AsmNodeOperands.size() -1] = CurDAG->getTargetConstant(

 9570   unsigned NumLPads = LPadList.size();
 9582           .addImm(LPadList.size())
15952   if (Subtarget->isTargetWindows() && Args.size() >= 2)

   39   for (unsigned i = 0; i < v.size(); ++i) {
   41     if (i + 1 < v[i].first && i + 1 < v.size() &&
   49   assert(v.size() >= 1);

  543     return MemOps.size() * 2;

   64         return ITStates.size() == 1;

  206   for (unsigned i = 0, e = CSI.size(); i != e; ++i) {
  826   for (unsigned i = CSI.size(); i != 0; --i) {
 1025   for (unsigned i = CSI.size(); i != 0; --i) {

  250   for (unsigned i = CSI.size(); i != 0; --i) {

  354   BTFType.Info |= Vars.size();
  375   OffsetToIdMap[Offset] = Table.size();
  390   TypeEntry->setId(TypeEntries.size() + 1);
  398   TypeEntry->setId(TypeEntries.size() + 1);
  702   if (Line < FileContent[FileName].size())
  720   if (!TypeEntries.size() && StringTable.getSize() == 1)
  774     FuncLen += FuncSec.second.size() * BTF::BPFFuncInfoSize;
  778     LineLen += LineSec.second.size() * BTF::BPFLineInfoSize;
  782     FieldRelocLen += FieldRelocSec.second.size() * BTF::BPFFieldRelocSize;
  802     OS.EmitIntValue(FuncSec.second.size(), 4);
  816     OS.EmitIntValue(LineSec.second.size(), 4);
  835       OS.EmitIntValue(FieldRelocSec.second.size(), 4);

   99     return BTFTypeBase::getSize() + EnumValues.size() * BTF::BTFEnumSize;
  126     return BTFTypeBase::getSize() + Members.size() * BTF::BTFMemberSize;
  143     return BTFTypeBase::getSize() + Parameters.size() * BTF::BTFParamSize;
  181     return BTFTypeBase::getSize() + BTF::BTFDataSecVarSize * Vars.size();

 1208   for (unsigned i = 0; i < Pending.size(); ++i) {
 3079   for (unsigned i = G.Ins.size(); i > 0; --i) {
 3209   for (unsigned i = 0, n = ShufIns.size(); i < n; ++i) {
 3252     for (unsigned i = 0, n = Groups.size(); i < n; ++i) {
 3257       for (unsigned j = 0, m = G.Ins.size(); j < m; ++j)
 3262   for (unsigned i = 0, n = Groups.size(); i < n; ++i) {

  167     for (unsigned i = 0, n = Vector.size(); i < n; ++i) {
  176   size_t size() const { return Vector.size(); }
  180     assert(n < Vector.size());

 1094   unsigned Num = NA.size();
 1195       LastCN = (CF != NCM.end()) ? CF->second.size() : 0;
 1248   for (unsigned i = 0; i < BO.size(); ++i) {
 1254   for (unsigned i = BO.size(); i > 0; --i) {

 1981   LLVM_DEBUG(dbgs() << "Collected " << Extenders.size() << " extenders\n");
 1982   for (unsigned I = 0, E = Extenders.size(); I != E; ) {

  272     for (unsigned I = 1, E = CSI.size(); I < E; ++I) {
 1258     for (unsigned I = 0; I < CSI.size(); ++I)
 1263   for (unsigned i = 0, n = CSI.size(); i < n; ++i) {
 1332   for (unsigned i = 0; i < CSI.size(); ++i) {
 1440   for (unsigned i = 0, n = CSI.size(); i < n; ++i) {
 1542     for (unsigned i = 0, n = CSI.size(); i < n; ++i) {
 2433   for (unsigned i = 0, n = CSI.size(); i < n; ++i) {
 2456   unsigned NumCSI = CSI.size();
 2477   unsigned NumCSI = CSI.size();

  272       if (RInd >= CVect.size())
  389       assert(Idx < Seq.size());
  394       return Seq.size();
  445   unsigned S = Seq.size();
  448   assert(Seq.size() <= MaxSize);
  586     for (unsigned i = 0, n = LL.size(); i < n; ++i)
  636   for (unsigned i = 0, n = VRs.size(); i < n; ++i)
  866       for (unsigned i = 0, n = LL.size(); i < n; ++i)
  898       for (unsigned i = 0, n = LL.size(); i < n; ++i) {
 1042     for (unsigned i = 0, n = LL.size(); i < n; ++i)
 1075   for (unsigned i = 0, n = LL.size(); i < n; ++i) {
 1097     for (unsigned i = 1, n = LL.size(); i < n; ++i) {
 1130   for (unsigned i = 0, n = LL.size(); i < n; ) {
 1143     n = LL.size();
 1155   for (unsigned i = LL.size(); i > 0; --i) {
 1292     for (unsigned i = 0, n = LL.size(); i < n; ++i)

  232   for (unsigned I = 0; I < WorkQ.size(); ++I) {
  336     unsigned S = Order.size();
  340     Table.resize(Order.size());
  346     unsigned Size = Order.size();
  366     return Order.size();
  677     return List.size()-1;
  687   unsigned size() const { return List.size(); }
  752   for (unsigned I = 0, E = List.size(); I != E; ++I) {
 1006       assert(Idx >= 0 && unsigned(Idx) < Output.size());
 1347       for (unsigned i = 0, e = T::size(); i != e; ++i) {
 2017   unsigned VecLen = Mask.size();

  126     for (unsigned i = 0, e = Packet.size(); i != e; ++i)
  130     for (unsigned i = 0, e = Packet.size(); i != e; ++i)
  150       Packet.size() >= SchedModel->getIssueWidth()) {
  178   for (unsigned i = 0, e = Packet.size(); i != e; ++i) {
  211              for (unsigned su = 0, e = SUnits.size(); su != e;
  216              for (unsigned su = 0, e = SUnits.size(); su != e;
  277   HighPressureSets.assign(MaxPressure.size(), 0);
  278   for (unsigned i = 0, e = MaxPressure.size(); i < e; ++i) {

  291     for (unsigned i = 0; i < WorkQ.size(); ++i) {
  579   for (unsigned i = 0; i < WorkQ.size(); ++i) {
  585   for (unsigned i = 0, n = WorkQ.size(); i < n; ++i) {

  230     if (G.size() > 1)
  366       Pow2Num = OG.size();
  551     assert(OG.size() > 1 && "Created invalid group");
  552     assert(distance(I, E)+1 >= int(OG.size()) && "Too many elements");
  553     I += OG.size()-1;
  577     assert(G.size() > 1 && "Store group with fewer than 2 elements");

  205   for (unsigned su = 0, e = DAG->SUnits.size(); su != e; ++su) {
  271   for (unsigned i = 0, e = DAG->SUnits.size(); i != e; ++i) {

 1316   if (CurrentPacketMIs.size() == 1)
 1793   if (OldPacketMIs.size() > 1) {

  508   if (foundBranches.size() > 1) {
  509     if (foundBranches.size() > 2) {
  552   if (foundBranches.size() <= 1 && bOnlySlot3 == false && pSlot3Cnt == 1 &&

  271     unsigned N = Ns.size();
  351   assert((Blocks.size() < ((size_t)1 << (8*sizeof(NodeId)-BitsPerIndex))) &&
  369   uint32_t ActiveB = Blocks.size()-1;
  379   for (unsigned i = 0, n = Blocks.size(); i != n; ++i) {
  672   Pos = DS.Stack.size();
  690   unsigned P = nextDown(Stack.size());
  705   unsigned P = Stack.size();
  720   unsigned SS = Stack.size();
  735   assert(P > 0 && P <= Stack.size());
 1480     for (unsigned i = 1; i != MaxRefs.size(); ++i)
 1485     unsigned CS = ClosureIdx.size();
 1506     for (unsigned i = ClosureIdx.size(); i != 0; --i)

  615   for (unsigned i = 0; i < PhiUQ.size(); ++i) {

   41       assert(Idx != 0 && !Map.empty() && Idx-1 < Map.size());
   51       return Map.size();  // Return actual_index + 1.
   60     uint32_t size() const { return Map.size(); }

  193   MFI->setCalleeSavedFrameSize(CSI.size() * 2);
  195   for (unsigned i = CSI.size(); i != 0; --i) {
  219   for (unsigned i = 0, e = CSI.size(); i != e; ++i)

  462   if (Relocs.size() < 2)
  522   assert(Relocs.size() == Sorted.size() && "Some relocs were not consumed");

  124   for (unsigned i = 0, e = CSI.size(); i != e; ++i) {

  294   if (Args.size() >= 1) {
  304     if (Args.size() >=2) {

  191   for (unsigned i = 0, e = CSI.size(); i != e; ++i) {

   87   if (CSI.size()) {
   89     MaxCSFI = CSI[CSI.size() - 1].getFrameIdx();

 1277     for (unsigned I = 0; I < JT.size(); ++I) {
 1280       for (unsigned J = 0; J < MBBs.size(); ++J)

  426   for (unsigned J = 0, E = BBInfo.size(); J !=E; ++J) {
  472   initPICLabelUId(CPEMIs.size());
  491     for (unsigned i = 0, e = CPUsers.size(); i != e; ++i)
  503     for (unsigned i = 0, e = ImmBranches.size(); i != e; ++i)
  554   for (unsigned i = 0, e = CPs.size(); i != e; ++i) {
  613   for (unsigned i = 0, e = CPEs.size(); i != e; ++i) {
  630   assert(CPI < MCP->getConstants().size() && "Invalid constant pool index.");
 1061   for (unsigned i = 0, e = CPEs.size(); i != e; ++i) {
 1117   for (unsigned i = 0, e = CPEs.size(); i != e; ++i) {
 1280   unsigned NumCPUsers = CPUsers.size();
 1444   for (unsigned i = 0, e = CPEntries.size(); i != e; ++i) {
 1446       for (unsigned j = 0, ee = CPEs.size(); j != ee; ++j) {

  450     for (unsigned i = 0; i < CSI.size(); ++i)
  711     for (unsigned i = 0; i < MFI.getCalleeSavedInfo().size(); ++i)
  724     for (unsigned i = 0; i < MFI.getCalleeSavedInfo().size(); ++i)
  800   for (unsigned i = 0, e = CSI.size(); i != e; ++i) {

  163   if (CSI.size()) {
  165     MaxCSFI = CSI[CSI.size() - 1].getFrameIdx();

 1253   for (unsigned i = 0, e = gvars.size(); i != e; ++i) {

 1308   for (unsigned i = 0, e = Args.size(); i != e; ++i, ++OIdx) {
 1459   for (unsigned i = 0, e = Args.size(); i != e; ++i, ++OIdx) {
 2500   for (unsigned i = 0, e = theArgs.size(); i != e; ++i, ++idx, ++InsIdx) {

  289   for (int i = 0, e = Vs.size(); i < e; i++) {

 1687       for (unsigned i = 0, e = Stubs.size(); i != e; ++i) {

 1315     for (unsigned I = 0, E = CSI.size(); I != E; ++I) {
 1884   for (unsigned i = 0, e = CSI.size(); i != e; ++i) {
 2032     for (unsigned i = 0, e = CSI.size(); i != e; ++i) {
 2053     for (unsigned i = 0, e = CSI.size(); i != e; ++i) {
 2203   for (unsigned i = 0, e = CSI.size(); i != e; ++i) {
 2375   for (unsigned i = 0, e = CSI.size(); i != e; ++i) {

  368   for (unsigned i = 0; i < Info.size(); i++) {

  224     for (unsigned i = 0, ie = CIV.size(); i < ie; ++i) {
  227         for (unsigned j = 0, je = C.Codes.size(); j < je; ++j)

  539   SwapEntry.VSEId = SwapVector.size();
  589   for (unsigned EntryIdx = 0; EntryIdx < SwapVector.size(); ++EntryIdx) {
  641   for (unsigned EntryIdx = 0; EntryIdx < SwapVector.size(); ++EntryIdx) {
  752   for (unsigned EntryIdx = 0; EntryIdx < SwapVector.size(); ++EntryIdx) {
  946   for (unsigned EntryIdx = 0; EntryIdx < SwapVector.size(); ++EntryIdx) {
  970   for (unsigned EntryIdx = 0; EntryIdx < SwapVector.size(); ++EntryIdx) {

  162   std::advance(MBBI, CSI.size());
  245   auto LastFrameDestroy = std::prev(MBBI, MFI.getCalleeSavedInfo().size());
  342   if (CSI.size()) {
  344     MaxCSFI = CSI[CSI.size() - 1].getFrameIdx();
  491   if (!isInt<12>(StackSize) && (CSI.size() > 0)) {

  299       AsmNodeOperands[AsmNodeOperands.size() -1] = CurDAG->getTargetConstant(

   32   for (unsigned I = 0, E = Constants.size(); I != E; ++I) {

  148   for (unsigned I = 0, E = CSI.size(); I != E; ++I) {
  194     for (unsigned I = 0, E = CSI.size(); I != E; ++I) {
  207   for (unsigned I = 0, E = CSI.size(); I != E; ++I) {
  239   for (unsigned I = 0, E = CSI.size(); I != E; ++I) {
  272     for (unsigned I = 0, E = CSI.size(); I != E; ++I) {

  155       OS << "BrList:" << BrL.List.size();

 1238       MFI.getResults().size() > 1

   83   unsigned getNumBlocks() const { return Blocks.size(); }

  218   unsigned CurLocal = static_cast<unsigned>(MFI.getParams().size());
  370   MFI.setNumLocals(CurLocal - MFI.getParams().size());
  374     if (RL == Reg2Local.end() || RL->second < MFI.getParams().size())
  377     MFI.setLocal(RL->second - MFI.getParams().size(),

  946   assert(MFI->getParams().size() == Params.size() &&

  935     Value *Args[] = {CI->getArgOperand(0), IRB.getInt32(SetjmpRetPHIs.size()),
  957   for (unsigned I = 0; I < BBs.size(); I++) {
 1032       SwitchInst *SI = IRB.CreateSwitch(Label, Tail, SetjmpRetPHIs.size());
 1037       for (unsigned I = 0; I < SetjmpRetPHIs.size(); I++) {

  120     assert(I < WARegs.size());
  125     assert(I < WARegs.size());

   90   unsigned CurReg = MFI.getParams().size();

 2005     for (unsigned i = 0; i < CSI.size(); ++i) {
 2014   for (unsigned i = CSI.size(); i != 0; --i) {
 2031   for (unsigned i = CSI.size(); i != 0; --i) {
 2078   for (unsigned i = CSI.size(); i != 0; --i) {
 2112   for (unsigned i = CSI.size(); i != 0; --i) {
 2192   for (unsigned i = 0, e = CSI.size(); i != e; ++i) {
 2209   for (unsigned i = 0, e = CSI.size(); i != e; ++i) {

 2203   for (unsigned Idx = 0; Idx < Args.size(); Idx++) {
 4852   for (unsigned i = 0, e = LegalFPImmediates.size(); i != e; ++i) {
31037       .addImm(LPadList.size());
45303       if (Constraints.size() >= 2 &&
45304           Constraints[0].Codes.size() == 1 && Constraints[0].Codes[0] == "A" &&
45305           Constraints[1].Codes.size() == 1 && Constraints[1].Codes[0] == "0") {

   38   for (unsigned i = 0; i < v.size(); ++i) {
   40     if (i + 1 < v[i].first && i + 1 < v.size() &&
   48   assert(v.size() >= 1);

  194   for (unsigned i = 0, e = JTBBs.size(); i != e; ++i) {

  355   unsigned NumEntries = MJTI->getJumpTables()[JTI].MBBs.size();

 1080     return Seq.size();
 1084     if (Index >= Seq.size())

  183         if (Indices.size() == 1 && Indices.front() == 0)
  284             Ops.reserve(ArgIndex.second.size());
  446         if (Operands.size() == 1 && Operands.front() == 0)
  456         for (unsigned i = 0, e = Operands.size(); i != e; ++i) {
  509   if (Prefix.size() > Longer.size())
  509   if (Prefix.size() > Longer.size())

  160     if (Union.size() > MaxFunctionsPerValue)

  163   unsigned NumArgs = Params.size();
  804         NewRetIdxs[i] = RetTypes.size() - 1;
  812     if (RetTypes.size() > 1) {
  820         NRetTy = ArrayType::get(RetTypes[0], RetTypes.size());
  822     } else if (RetTypes.size() == 1)
  853   assert(ArgAttrVec.size() == Params.size());
  923     assert(ArgAttrVec.size() == Args.size());
  984             if (RetTypes.size() > 1)
 1053               if (RetTypes.size() > 1) {

  766     if (ArgumentSCC.size() == 1) {
  814     for (unsigned i = 0, e = ArgumentSCC.size(); i != e; ++i) {
  833     for (unsigned i = 0, e = ArgumentSCC.size(); i != e; ++i) {
  847       for (unsigned i = 0, e = ArgumentSCC.size(); i != e; ++i) {
 1594     if (I->size() != 1)

  718     assert(GlobalList.second.SummaryList.size() == 1 &&

  400   NumFunctions += DeadFunctions.size();
  413   NumVariables += DeadGlobalVars.size();
  417   NumAliases += DeadAliases.size();
  421   NumIFuncs += DeadIFuncs.size();

  562     if (Val >= NewGlobals.size()) Val = 0; // Out of bound array access.
  602   for (unsigned i = 0, e = NewGlobals.size(); i != e; ++i)
  608   return FirstGlobal != NewGlobals.size() ? NewGlobals[FirstGlobal] : nullptr;
 1158   if (FieldNo >= FieldVals.size())
 1338   for (unsigned i = 0, e = FieldMallocs.size(); i != e; ++i) {
 1363   for (unsigned i = 0, e = FieldGlobals.size(); i != e; ++i) {
 1414     for (unsigned i = 0, e = FieldGlobals.size(); i != e; ++i) {

  118     if (I >= SplitGlobals.size())

  185   uint64_t FragmentIndex = Fragments.size() - 1;
  224   if (Bytes.size() < ReqSize)
  614   std::vector<uint64_t> ByteArrayOffsets(ByteArrayInfos.size());
  617   for (unsigned I = 0; I != ByteArrayInfos.size(); ++I) {
  635   for (unsigned I = 0; I != ByteArrayInfos.size(); ++I) {
  655   ByteArraySizeBytes = BAB.Bytes.size();

  423     LLVM_DEBUG(dbgs() << "size of worklist: " << Worklist.size() << '\n');

  214   for (unsigned i = 0, e = Extensions.size(); i != e; ++i)

  264     for (unsigned i = 0, e = Succs.size(); i != e; ++i)

 1500   B.Before.Bytes.resize(alignTo(B.Before.Bytes.size(), Alignment));
 1503   for (size_t I = 0, Size = B.Before.Bytes.size(); I != Size / 2; ++I)
 1521   NewGV->copyMetadata(B.GV, B.Before.Bytes.size());

  244     OS << "  Number of Edges: " << AllEdges.size()

  260   for (unsigned i=0, ie = TransformedFunction.ArgumentIndexMapping.size();
 1612         const unsigned ShadowArgStart = Args.size();

 3663     for (size_t i = 0, n = Constraints.size(); i < n; i++) {

  578       NumOfPGOMemIntrinsics += ValueSites[IPVK_MemOPSize].size();
  583       NumOfCSPGOMemIntrinsics += ValueSites[IPVK_MemOPSize].size();
  631                  (uint64_t)ValueSites[IPVK_IndirectCallTarget].size() << 48 |
  633                  (uint64_t)MST.AllEdges.size() << 32 | JC.getCRC();
  641                     << ", Edges = " << MST.AllEdges.size() << ", ICSites = "
  642                     << ValueSites[IPVK_IndirectCallTarget].size()
  725   EdgeList.reserve(MST.AllEdges.size());
  816       InstrumentBBs.size() + FuncInfo.SIVisitor.getNumOfSelectInsts();
  839   NumOfPGOICall += FuncInfo.ValueSites[IPVK_IndirectCallTarget].size();
 1069       InstrumentBBs.size() + FuncInfo.SIVisitor.getNumOfSelectInsts();
 1072   if (NumCounters != CountFromProfile.size()) {
 1082   ProfileCountSize = CountFromProfile.size();
 1182   LLVM_DEBUG(dbgs() << CountFromProfile.size() << " counts\n");
 1184   for (unsigned I = 0, S = CountFromProfile.size(); I < S; I++) {
 1363   assert(*CurCtrIdx < CountFromProfile.size() &&
 1419   if (NumValueSites != ValueSites.size()) {

   59       size_t Num = Vector.size();
   71       size_t Num = Vector.size();

  378       Itr->second = ConstIntCandVec.size() - 1;
  428     Itr->second = ExprCandVec.size() - 1;

  426     for (unsigned i = 0, e = deps.size(); i != e; ++i) {
 1573     if (ExprIdx.size() < nextValueNumber + 1)
 1631   for (unsigned i = 0; i < deps.size(); i++) {
 1658   if (Num >= ExprIdx.size() || ExprIdx[Num] == 0)

 1152   for (unsigned i = 0, e = Result.Blocks.size(); i != e; ++i) {

  165         while (Dep.size() != Level) {
  170         if (DepMatrix.size() > MaxMemInstrCount) {
  186   unsigned numRows = DepMatrix.size();
  260   unsigned NumRows = DepMatrix.size();
  284     if (Vec->size() != 1)

  282   if (!L->isLoopSimplifyForm() || L->getSubLoops().size() != 1)

 1278   NewBlocks.reserve(LoopBlocks.size());
 1280   for (unsigned i = 0, e = LoopBlocks.size(); i != e; ++i) {
 1342   for (unsigned i = 0, e = NewBlocks.size(); i != e; ++i) {

  411    int size() const { return Comparisons_.size(); }
  442   for (size_t BlockIdx = 0; BlockIdx < Blocks.size(); ++BlockIdx) {
  679   assert(Comparisons_.size() >= 2 && "simplifying trivial BCECmpChain");
  683     for (size_t I = 1; I < Comparisons_.size(); ++I) {
  705   for (int I = static_cast<int>(Comparisons_.size()) - 2; I >= 0; --I) {

 2918   for (unsigned i = 0, e = CongruenceClasses.size(); i != e; ++i) {
 3435     if (Node->getChildren().size() > 1)

  688   assert(ParsePointsNeeded.size() <= Calls.size());
  688   assert(ParsePointsNeeded.size() <= Calls.size());

 3856     int Idx = 0, Size = Offsets.Splits.size();
 3912       for (int Idx = 0, Size = SplitLoads.size(); Idx < Size; ++Idx) {
 3983       assert(SplitLoads->size() == Offsets.Splits.size() + 1 &&
 3983       assert(SplitLoads->size() == Offsets.Splits.size() + 1 &&
 3990     int Idx = 0, Size = Offsets.Splits.size();
 4549   NumPromoted += PromotableAllocas.size();

 2472   int SiblingsCount = (ParentL ? ParentL->getSubLoopsVector().size()

 1171     for (unsigned u = 0, e = Users.size(); u != e; ++u) {

  129   unsigned NumCtors = Ctors.size();
  131   for (unsigned i = 0; i != Ctors.size() && NumCtors > 0; ++i) {

  299   for (size_t I = 0; I != SubLoops.size(); )
  393     PHINode *NewPN = PHINode::Create(PN->getType(), BackedgeBlocks.size(),
  445   for (unsigned i = 0, e = BackedgeBlocks.size(); i != e; ++i) {

  745     for (unsigned i = 0, e = Latches.size(); i != e; ++i) {
  780     for (unsigned i = 0, e = Headers.size(); i != e; ++i) {
  805     for (unsigned i = 0, e = Latches.size(); i != e; ++i) {

  180   assert(L->getSubLoops().size() == 1);
  726   if (!L->isLoopSimplifyForm() || L->getSubLoops().size() != 1)

  414   if (Cases.size() >= 2) {
  459   LLVM_DEBUG(dbgs() << "Clusterify finished. Total clusters: " << Cases.size()

   54     NumPromoted += Allocas.size();

  534   AllocaDbgDeclares.resize(Allocas.size());
  540   for (unsigned AllocaNum = 0; AllocaNum != Allocas.size(); ++AllocaNum) {
  637   RenamePassData::ValVector Values(Allocas.size());
  638   for (unsigned i = 0, e = Allocas.size(); i != e; ++i)
  643   RenamePassData::LocationVector Locations(Allocas.size());

   33   return ArrayType::get(StatTy, Inits.size());
   66           ConstantInt::get(IntPtrTy, Inits.size() - 1),
   87            ConstantInt::get(Int32Ty, Inits.size()),

  758   if (V1->size() > V2->size())
  758   if (V1->size() > V2->size())
  763   if (V1->size() == 1) {
  766     for (unsigned i = 0, e = V2->size(); i != e; ++i)
  774   unsigned i1 = 0, i2 = 0, e1 = V1->size(), e2 = V2->size();
  774   unsigned i1 = 0, i2 = 0, e1 = V1->size(), e2 = V2->size();
  853       assert(ThisCases.size() == 1 && "Branch can only have one case!");
  872     for (unsigned i = 0, e = PredCases.size(); i != e; ++i)
  893   for (unsigned i = 0, e = PredCases.size(); i != e; ++i)
  904   for (unsigned i = 0, e = ThisCases.size(); i != e; ++i)
 1046         if (Weights.size() != 1 + PredCases.size())
 1052         Weights.assign(1 + PredCases.size(), 1);
 1058         if (SuccWeights.size() != 1 + BBCases.size())
 1061         SuccWeights.assign(1 + BBCases.size(), 1);
 1067         for (unsigned i = 0, e = PredCases.size(); i != e; ++i)
 1095         for (unsigned i = 0, e = BBCases.size(); i != e; ++i)
 1123         for (unsigned i = 0, e = PredCases.size(); i != e; ++i)
 1141         for (unsigned i = 0, e = BBCases.size(); i != e; ++i)
 1177           Builder.CreateSwitch(CV, PredDefault, PredCases.size());

   60   } else if (UnreachableBlocks.size() == 1) {
   77   } else if (ReturningBlocks.size() == 1) {
   94     PN = PHINode::Create(F.getReturnType(), ReturningBlocks.size(),

  465     assert(Succs.size() <= 2 &&
  468     if (Succs.size() == 1) {

  196   Sleds.reserve(YAMLSleds.size());

   25   size_t Devices_size = Devices.size();
  106   size_t Devices_size = Devices.size();

  374   size_t Devices_size = Devices.size();

  151   size_t Devices_size = Devices.size();
  310   int64_t size = MapperComponentsPtr->Components.size();

   81     assert(TransTable->TargetsImages.size() > (size_t)device_id &&
  630   assert(TM->Table->TargetsTable.size() > (size_t)device_id &&
  753     tgtArgsPositions[i] = tgt_args.size();
  758   assert(tgt_args.size() == tgt_offsets.size() &&
  758   assert(tgt_args.size() == tgt_offsets.size() &&
  778         &tgt_args[0], &tgt_offsets[0], tgt_args.size(), team_num,
  782         &tgt_args[0], &tgt_offsets[0], tgt_args.size());

  139   assert(TT.TargetsTable.size() == TT.TargetsImages.size() &&
  139   assert(TT.TargetsTable.size() == TT.TargetsImages.size() &&
  146   if (TT.TargetsTable.size() < TargetsTableMinimumSize) {
  261         size_t start = Devices.size();

   69   for (unsigned i = 0, e = Passes.size(); i != e; ++i) {
  143   for (unsigned i = 1, e = Filenames.size(); i != e; ++i) {
  241   unsigned NumPrint = Funcs.size();
  246   if (NumPrint < Funcs.size())
  247     outs() << "... <" << Funcs.size() << " total>";
  252   unsigned NumPrint = GVs.size();
  257   if (NumPrint < GVs.size())
  258     outs() << "... <" << GVs.size() << " total>";

  153   for (unsigned i = 0, e = GVs.size(); i != e; ++i) {
  229   auto *NewValTy = ArrayType::get(NewValElemTy, Used.size());
  246   for (unsigned i = 0, e = Funcs.size(); i != e; ++i) {
  449   for (unsigned i = 0, e = BBs.size(); i != e; ++i)
  764   for (unsigned i = 0, e = Insts.size(); i != e; ++i) {
  838   unsigned NumPrint = std::min<size_t>(NamedMDs.size(), 10);
  841   if (NumPrint < NamedMDs.size())
  842     outs() << "... <" << NamedMDs.size() << " total>";
  903   for (unsigned i = 0, e = NamedMDOps.size(); i != e; ++i) {
  988   if (GVs.size() > 1 && !BugpointIsInterrupted) {
  992     unsigned OldSize = GVs.size();
  998     if (GVs.size() < OldSize)
 1104   if (Functions.size() > 1 && !BugpointIsInterrupted) {
 1108     unsigned OldSize = Functions.size();
 1114     if (Functions.size() < OldSize)
 1137       OldSize += Attrs.size();
 1143       NewSize += Attrs.size();
 1157     unsigned OldSize = Blocks.size();
 1165     if (Blocks.size() < OldSize)
 1179     unsigned OldSize = Blocks.size();
 1183     if (Blocks.size() < OldSize)
 1192     unsigned OldSize = Blocks.size();
 1196     if (Blocks.size() < OldSize)
 1287          << (PassesToRun.size() == 1 ? ": " : "es: ")

  234   for (unsigned i = 0, e = TorList.size(); i != e; ++i) {
  240       ArrayType::get(ArrayElts[0]->getType(), ArrayElts.size()), ArrayElts);
  324   for (unsigned i = 0, e = F.size(); i != e; ++i) {

   50     for (int i = 0, e = PassesToRun.size(); i != e; i++) {

   55       if (TheList.size() == 1) // we are done, it's the base case and it fails
   80     unsigned MidTop = TheList.size();
  107           MidTop = TheList.size();
  131         MidTop = TheList.size();
  139         MidTop = TheList.size();
  161     if (TheList.size() > 2) {
  176         for (unsigned i = 1; i < TheList.size() - 1; ++i) {

  253          << (Funcs.size() == 1 ? "this function is" : "these functions are")
  255          << (BD.getPassesToRun().size() == 1 ? "" : "es") << ":";
  271   for (unsigned i = 0, e = Funcs.size(); i != e; ++i) {
  344     for (unsigned i = 0, e = MiscompiledFunctions.size(); i != e; ++i)
  374     for (unsigned i = 0, e = MiscompiledFunctions.size(); i != e; ++i)
  400       for (unsigned i = 0, e = MisCompFunctions.size(); i != e; ++i) {
  431     for (unsigned i = 0, e = MisCompFunctions.size(); i != e; ++i) {
  490     outs() << "but these " << BBs.size() << " blocks are extracted: ";
  491     for (unsigned i = 0, e = BBs.size() < 10 ? BBs.size() : 10; i != e; ++i)
  491     for (unsigned i = 0, e = BBs.size() < 10 ? BBs.size() : 10; i != e; ++i)
  493     if (BBs.size() > 10)
  506   for (unsigned i = 0, e = FunctionsBeingTested.size(); i != e; ++i) {
  510   for (unsigned i = 0, e = BBs.size(); i != e; ++i) {
  544   for (unsigned i = 0, e = MiscompiledFunctions.size(); i != e; ++i)
  551   unsigned OldSize = Blocks.size();
  566     if (Blocks.size() == OldSize)
  597   for (unsigned i = 0, e = MisCompFunctions.size(); i != e; ++i) {
  636          << (MiscompiledFunctions.size() == 1 ? " is" : "s are")
  661              << (MiscompiledFunctions.size() == 1 ? " is" : "s are")
  684              << (MiscompiledFunctions.size() == 1 ? " is" : "s are")
  748          << (getPassesToRun().size() == 1 ? "" : "es") << ": "

  184   for (unsigned i = 0, e = ToolArgs.size(); i != e; ++i)
  189   for (unsigned i = 0, e = Args.size(); i != e; ++i)
  195              for (unsigned i = 0, e = LLIArgs.size() - 1; i != e; ++i) errs()
  320   for (std::size_t i = 0; i < ExecutorArgs.size(); ++i)
  325   for (unsigned i = 0, e = Args.size(); i != e; ++i)
  450   for (unsigned i = 0, e = ToolArgs.size(); i != e; ++i)
  463              for (unsigned i = 0, e = LLCArgs.size() - 1; i != e; ++i) errs()
  566   for (unsigned i = 0, e = ToolArgs.size(); i != e; ++i)
  569   for (unsigned i = 0, e = SharedLibs.size(); i != e; ++i) {
  575   for (unsigned i = 0, e = Args.size(); i != e; ++i)
  581              for (unsigned i = 0, e = JITArgs.size() - 1; i != e; ++i) errs()
  609   for (size_t I = 0; I < Args.size(); ++I) {
  613     if (I == Args.size())
  677   for (unsigned i = 0, e = ArgsForCC.size(); i != e; ++i)
  688              for (unsigned i = 0, e = CCArgs.size() - 1; i != e; ++i) errs()
  728   for (unsigned i = 0, e = Args.size(); i != e; ++i)
  736       for (unsigned i = 0, e = ProgramArgs.size() - 1; i != e; ++i) errs()
  826   for (unsigned i = 0, e = ArgsForCC.size(); i != e; ++i)
  832              for (unsigned i = 0, e = CCArgs.size() - 1; i != e; ++i) errs()

   89     for (unsigned i = 0, e = args.size(); i != e; ++i) {

  310   unsigned size() const { return Data ? elements().size() : 0; }

 1470   unsigned range_size() const { return Ranges.size(); }
 1480   unsigned fixit_size() const { return FixIts.size(); }

  439     Parent->SubModuleIndex[Name] = Parent->SubModules.size();
  626     return M->getVisibilityID() < ImportLocs.size()

  104     assert(ID < FilenamesByID.size() && "Invalid FilenameID");
  108   unsigned getNumFilenames() const { return FilenamesByID.size(); }

  169   unsigned size() const { return Multilibs.size(); }

  518     return TopLevelDeclsInPreamble.size() + TopLevelDecls.size();
  518     return TopLevelDeclsInPreamble.size() + TopLevelDecls.size();
  625     return CachedCompletionResults.size();

  272     assert(angledDirIdx <= systemDirIdx && systemDirIdx <= dirs.size() &&
  657   unsigned header_file_size() const { return FileInfo.size(); }
  675   unsigned search_dir_size() const { return SearchDirs.size(); }

  369       return LoadedPreprocessedEntities.size();
  447             Self->LoadedPreprocessedEntities.size() + this->I : this->I;
  456       return iterator(this, -(int)LoadedPreprocessedEntities.size());
  461       return iterator(this, PreprocessedEntities.size());
  471       return iterator(this, PreprocessedEntities.size());
  479       assert(end <= LoadedPreprocessedEntities.size());
  481           iterator(this, int(start) - LoadedPreprocessedEntities.size()),
  482           iterator(this, int(end) - LoadedPreprocessedEntities.size()));

 1739     return static_cast<unsigned>(IdentifiersLoaded.size());
 1744     return static_cast<unsigned>(MacrosLoaded.size());
 1749     return static_cast<unsigned>(TypesLoaded.size());
 1754     return static_cast<unsigned>(DeclsLoaded.size());

  382   unsigned num_roots() const { return Roots.size(); }
  383   unsigned num_eops() const { return EndNodes.size(); }

   83     for (std::size_t i = 1; i < ASTs.size(); ++i)

  106     return SelectedNode.get().Children.size();

  121     PartStrings.reserve(Parts.size());

  322   for (unsigned i=0, e = transforms.size(); i != e; ++i)
  365   for (unsigned i=0, e = transforms.size(); i != e; ++i) {

  103   for (unsigned i = 0, e = pairs.size(); i != e; ++i)

  245   for (unsigned i = 0, e = pass.ARCMTMacroLocs.size(); i != e; ++i) {

  182   for (unsigned i = 0, e = MigrateCtx.GCAttrs.size(); i != e; ++i) {
  198   for (unsigned i = 0, e = MigrateCtx.GCAttrs.size(); i != e; ++i) {
  302   for (unsigned i = 0, e = AllProps.size(); i != e; ++i) {
  335   for (unsigned i = 0, e = GCAttrs.size(); i != e; ++i) {

  199   for (unsigned i = 0, e = CachedActions.size(); i != e; ++i) {
  243   for (unsigned i = 0, e = CachedActions.size(); i != e; ++i) {

   88   const size_t Target = Code.size();
  106   const int64_t Position = Code.size() + sizeof(Opcode) + sizeof(int32_t);
  131     if (Code.size() + Size > std::numeric_limits<unsigned>::max()) {
  142     SrcMap.emplace_back(Code.size(), SI);

   26 CodePtr Function::getCodeEnd() const { return Code.data() + Code.size(); }

   48   unsigned I = Globals.size();
   83   assert(Idx < Globals.size());
  177   unsigned I = Globals.size();

   55     assert(Idx < Globals.size());

 3302   while (RecordTypeList.size() > NextToCheckIndex) {

  590     assert((Matchers.size() < USHRT_MAX) && "Too many matchers.");
  591     for (unsigned I = 0, E = Matchers.size(); I != E; ++I) {

   42     : Error(Error), BeginIndex(Error->Errors.size()) {}
   46   if (BeginIndex < Error->Errors.size()) {
   48     for (size_t i = BeginIndex + 1, e = Error->Errors.size(); i < e; ++i) {
  175   if (Content.Messages.size() == 1) {
  178     for (size_t i = 0, e = Content.Messages.size(); i != e; ++i) {
  187   for (size_t i = 0, e = Errors.size(); i != e; ++i) {
  201   for (size_t i = 0, e = Errors.size(); i != e; ++i) {
  204     for (size_t i = 0, e = Error.ContextStack.size(); i != e; ++i) {

  282   unsigned getNumArgs() const override { return ArgKinds.size(); }
  610     if (Constructed.size() > 1) {

  467                                Args.size() + 1);

  122     if (Matchers.size() != 1)
  129     for (size_t i = 0, e = Matchers.size(); i != e; ++i) {
  142     for (size_t i = 0, e = Matchers.size(); i != e; ++i) {
  192     for (size_t i = 0, e = Args.size(); i != e; ++i) {

  133   for (unsigned i = 0; i < Result.size(); ++i) {
  134     for (unsigned j = 0; j < Result.size(); ++j) {
  375     for (unsigned i = 0; i < StmtsByHash.size() - 1; ++i) {
  385       for (; i < StmtsByHash.size(); ++i) {
  528   for (size_t KindIndex = 0; KindIndex < Variables.size(); ++KindIndex) {
  538   Occurences.emplace_back(Variables.size(), Mention);
  566   assert(Other.Occurences.size() == Occurences.size());
  566   assert(Other.Occurences.size() == Occurences.size());
  567   for (unsigned i = 0; i < Occurences.size(); ++i) {
  589     if (OtherOccurence.KindID < Variables.size())
  602     if (ThisOccurence.KindID < Other.Variables.size())

   27     BlockOrder[*I] = Blocks.size() + 1;

  164     return static_cast<unsigned short>(Facts.size() - 1);
  432     assert(*i < VarDefinitions.size());
  485     for (unsigned i = 1, e = VarDefinitions.size(); i < e; ++i) {
  519   unsigned getContextIndex() { return SavedContexts.size()-1; }
  530     unsigned newID = VarDefinitions.size();
  538     unsigned newID = VarDefinitions.size();
  548       unsigned newID = VarDefinitions.size();

  879     static_cast<unsigned>(CurrentArguments.size()), Arena);
  900     static_cast<unsigned>(CurrentInstructions.size()), Arena);

   25   for (unsigned i = 0, e = NoBuiltinFuncs.size(); i != e; ++i)

  278         assert(DiagID - DIAG_UPPER_LIMIT < DiagInfo.size() &&
  285         assert(DiagID - DIAG_UPPER_LIMIT < DiagInfo.size() &&
  299         unsigned ID = DiagInfo.size()+DIAG_UPPER_LIMIT;

   40   for (unsigned i = 0, e = NoBuiltinFuncs.size(); i != e; ++i)

   61     Parent->SubModuleIndex[Name] = Parent->SubModules.size();
  468     for (unsigned I = 0, N = ConfigMacros.size(); I != N; ++I) {
  573   for (unsigned I = 0, N = UnresolvedConflicts.size(); I != N; ++I) {
  582   for (unsigned I = 0, N = Conflicts.size(); I != N; ++I) {
  628     if (ImportLocs.size() <= ID)

  231   auto IterBool = FilenameIDs.try_emplace(Name, FilenamesByID.size());
  359   for (unsigned i = 0, e = MemBufferInfos.size(); i != e; ++i) {
 2051   llvm::errs() << FileInfos.size() << " files mapped, " << MemBufferInfos.size()
 2142   for (unsigned i = 0, e = MemBufferInfos.size(); i != e; ++i)

   87     for (unsigned i = 0, e = Opts.Warnings.size(); i != e; ++i) {
  197     for (unsigned i = 0, e = Opts.Remarks.size(); i != e; ++i) {

 1656                               CGOpts.CmdArgs.size());

 3543   FnBeginRegionCount.push_back(LexicalBlockStack.size());
 3740   FnBeginRegionCount.push_back(LexicalBlockStack.size());
 3819   assert(RCount <= LexicalBlockStack.size() && "Region stack mismatch");
 3822   while (LexicalBlockStack.size() != RCount) {

  515       assert(I->second < CXXGlobalInits.size() &&
  739     for (unsigned i = 0, e = DtorsAndObjects.size(); i != e; ++i) {

 1636     if (EarlyInitList.size() > 0) {
 3731     symtab.addInt(CGM.Int16Ty, Classes.size());
 3733     symtab.addInt(CGM.Int16Ty, Categories.size());

  882   for (unsigned i = 0, e = BFIs.size(); i != e; ++i) {

 1951   if (ResultRegTypes.size() == 1) {
 1954     for (unsigned i = 0, e = ResultRegTypes.size(); i != e; ++i) {
 2208   for (unsigned i = 0, e = InOutArgs.size(); i != e; i++) {
 2265   else if (ResultRegTypes.size() == 1)
 2293   assert(RegResults.size() == ResultRegTypes.size());
 2293   assert(RegResults.size() == ResultRegTypes.size());
 2294   assert(RegResults.size() == ResultTruncRegTypes.size());
 2294   assert(RegResults.size() == ResultTruncRegTypes.size());
 2295   assert(RegResults.size() == ResultRegDests.size());
 2295   assert(RegResults.size() == ResultRegDests.size());
 2298   assert(ResultTypeRequiresCast.size() <= ResultRegDests.size());
 2299   for (unsigned i = 0, e = RegResults.size(); i != e; ++i) {

  994   size_t savedSize = DeferredVTables.size();
 1003   assert(savedSize == DeferredVTables.size() &&

 1905   UsedArray.resize(List.size());
 1906   for (unsigned i = 0, e = List.size(); i != e; ++i) {
 2166     Annotations[0]->getType(), Annotations.size()), Annotations);
 2544     DelayedCXXInitPosition[Global] = CXXGlobalInits.size();

  489     return RegionStack.size() - 1;
  495     size_t Index = RegionStack.size();
  540     if (LastTerminatedRegion->second != RegionStack.size())
  568     assert(RegionStack.size() >= ParentIndex && "parent not in stack");
  570     while (RegionStack.size() > ParentIndex) {
  646           RegionStack.size() < LastTerminatedRegion->second)
  795     LastTerminatedRegion = {EndLoc, RegionStack.size()};
 1123         for (size_t i = RegionStack.size(); i != Index; --i) {
 1416       llvm::ArrayType::get(FunctionRecordTy, FunctionRecords.size());
 1452                                            FunctionNames.size());

   45   Events.reserve(Scan.size());

  820     if (ConfigFiles.size() > 1) {
 1600   Cur = Flags.at(Flags.size() - 1);
 1602   if (Flags.size() >= 2) {
 1603     Prev = Flags.at(Flags.size() - 2);

  100   for (unsigned I = 0, N = Flags.size(); I != N; ++I) {
  264   if (Filtered.size() == 1) {

 1060         Args.getAllArgValues(options::OPT_fopenmp_targets_EQ).size() != 1) {

 1466   for (unsigned I = 0, N = Features.size(); I < N; ++I) {
 1472   for (unsigned I = 0, N = Features.size(); I < N; ++I) {

   81   int MatchingStackIndex = Stack.size() - 1;
  305   if (Previous.is(tok::l_brace) && State.Stack.size() > 1 &&
  306       State.Stack[State.Stack.size() - 2].NestedBlockInlined &&
  307       State.Stack[State.Stack.size() - 2].HasMultipleNestedBlocks)
  724     if (HasTrailingCall && State.Stack.size() > 1 &&
  725         State.Stack[State.Stack.size() - 2].CallContinuation == 0)
  810     if (State.Stack.size() > 1)
  811       State.Stack[State.Stack.size() - 2].LastSpace =
  864       !Style.isCpp() && Current.is(tok::r_brace) && State.Stack.size() > 1 &&
  865       State.Stack[State.Stack.size() - 2].NestedBlockInlined;
  867     for (unsigned i = 0, e = State.Stack.size() - 1; i != e; ++i)
  949       State.Stack.size() > 1) {
  951       return State.Stack[State.Stack.size() - 2].NestedBlockIndent;
  954       return State.Stack[State.Stack.size() - 2].LastSpace;
  972   if (Current.is(tok::r_paren) && State.Stack.size() > 1 &&
  975     return State.Stack[State.Stack.size() - 2].LastSpace;
  977     return State.Stack[State.Stack.size() - 2].LastSpace;
 1084   assert(State.Stack.size());
 1172       !Previous->is(TT_DictLiteral) && State.Stack.size() > 1 &&
 1174     if (State.Stack[State.Stack.size() - 2].NestedBlockInlined && Newline)
 1175       for (unsigned i = 0, e = State.Stack.size() - 1; i != e; ++i)
 1177     State.Stack[State.Stack.size() - 2].NestedBlockInlined = false;
 1296     if (State.Stack.size() == 1) {
 1434   if (State.Stack.size() > 1 &&
 1644     for (unsigned i = 0, e = State.Stack.size(); i != e; ++i)
 1653   for (unsigned i = 0, e = State.Stack.size(); i != e; ++i)
 2196       for (unsigned i = 0, e = State.Stack.size(); i != e; ++i)

  589     return Seq.size();
  593     if (Index >= Seq.size()) {
  594       assert(Index == Seq.size());
 1165   for (unsigned i = 0; i < Styles.size(); ++i) {
 1184   for (int i = Styles.size() - 1; i >= 0; --i) {
 1635     while (Idx < Tokens.size()) {
 1637       while ((End + 1) < Tokens.size() &&
 2057   for (unsigned I = 0; I < Style.JavaImportGroups.size(); I++) {

   57     while (IndentForLevel.size() <= Line.Level)
   72     while (IndentForLevel.size() <= Line.Level)

   43   for (unsigned I = 0, N = ASTFiles.size(); I != N; ++I) {

 1030     TopLevelDeclIDs.reserve(TopLevelDecls.size());
 1152   assert(Clang->getFrontendOpts().Inputs.size() == 1 &&
 1433   Resolved.reserve(TopLevelDeclsInPreamble.size());
 1585   assert(Clang->getFrontendOpts().Inputs.size() == 1 &&
 2211   assert(Clang->getFrontendOpts().Inputs.size() == 1 &&
 2387     Ranges.reserve(SD.Ranges.size());
 2395     FixIts.reserve(SD.FixIts.size());

   42     for (unsigned i = 0, e = CIs.size(); i != e; ++i) {
  124   for (unsigned i = 0, e = includes.size(); i != e; ++i) {

 1975   for (unsigned I = 0, N = TopModule->ConfigMacros.size(); I != N; ++I) {

 2007   for (unsigned i = 0, e = Inputs.size(); i != e; ++i) {
 3618     code = hash_combine(code, hsOpts.SystemHeaderPrefixes.size(), SHPC,
 3619                         hsOpts.UserEntries.size(), UEC);

  193       for (size_t i = 0, e = CI.getFrontendOpts().AddPluginActions.size();

  256   ModuleHeaders.reserve(Inputs.size());
  552         for (unsigned I = 0, N = TargetOpts.FeaturesAsWritten.size();

  475   for (unsigned i = First; i != SearchList.size(); ++i) {
  556   SearchList.reserve(IncludePath.size());
  565   unsigned NumQuoted = SearchList.size();
  572   unsigned NumAngled = SearchList.size();
  601     for (unsigned i = 0, e = SearchList.size(); i != e; ++i) {
  627   for (unsigned i = 0, e = HSOpts.UserEntries.size(); i != e; ++i) {
  638   for (unsigned i = 0, e = HSOpts.SystemHeaderPrefixes.size(); i != e; ++i)

 1162   for (unsigned i = 0, e = InitOpts.Macros.size(); i != e; ++i) {
 1176   for (unsigned i = 0, e = InitOpts.MacroIncludes.size(); i != e; ++i)
 1185   for (unsigned i = 0, e = InitOpts.Includes.size(); i != e; ++i) {

   30   for (size_t i = 0, e = Listeners.size(); i != e; ++i)
   36   for (size_t i = 0, e = Listeners.size(); i != e; ++i)
   48   for (size_t i = 0, e = Listeners.size(); i != e; ++i)
   54   for (size_t i = 0, e = Listeners.size(); i != e; ++i)
   60   for (size_t i = 0, e = Listeners.size(); i != e; ++i)
   66   for (size_t i = 0, e = Listeners.size(); i != e; ++i)
  123   for (size_t i = 0, e = Listeners.size(); i != e; ++i)
  129   for (size_t i = 0, e = Listeners.size(); i != e; ++i)
  135   for (size_t i = 0, e = Listeners.size(); i != e; ++i)
  140   for (size_t i = 0, e = Listeners.size(); i != e; ++i)
  145   for (size_t i = 0, e = Listeners.size(); i != e; ++i)
  150   for (size_t i = 0, e = Listeners.size(); i != e; ++i)
  160   for (size_t i = 0, e = Listeners.size(); i != e; ++i)
  170   for (size_t i = 0, e = Listeners.size(); i != e; ++i)
  174   for (size_t i = 0, e = Listeners.size(); i != e; ++i)
  179   for (size_t i = 0, e = Listeners.size(); i != e; ++i)
  189   for (size_t i = 0, e = Listeners.size(); i != e; ++i)
  194   for (size_t i = 0, e = Listeners.size(); i != e; ++i)
  200   for (size_t i = 0, e = Listeners.size(); i != e; ++i)
  204   for (size_t i = 0, e = Listeners.size(); i != e; ++i)
  209   for (size_t i = 0, e = Listeners.size(); i != e; ++i)

  302   if (Clang->getFrontendOpts().Inputs.size() != 1 ||
  394   return PreambleBounds(PreambleBytes.size(), PreambleEndsAtStartOfLine);
  435   if (PreambleBytes.size() != Bounds.Size ||
  512   PreambleBounds Bounds(PreambleBytes.size(), PreambleEndsAtStartOfLine);

   49   assert(CurTok < RawTokens.size() && "Overran eof!");

 6869   for (unsigned i = 0, e = InstanceMethods.size(); i < e; i++)
 6871   for (unsigned i = 0, e = ClassMethods.size(); i < e; i++)
 6873   for (unsigned i = 0, e = OptInstanceMethods.size(); i < e; i++)
 6875   for (unsigned i = 0, e = OptClassMethods.size(); i < e; i++)
 6927   if (InstanceMethods.size() > 0) {
 6934   if (ClassMethods.size() > 0) {
 6941   if (OptInstanceMethods.size() > 0) {
 6948   if (OptClassMethods.size() > 0) {
 6965   if (AllMethods.size() > 0) {

   34     All.emplace_back(Level, Notes.size());
   38     All.emplace_back(Level, Warnings.size());
   42     All.emplace_back(Level, Remarks.size());
   47     All.emplace_back(Level, Errors.size());

  428     if (!(Prefixes.size() == 1 ? PH.Search(*Prefixes.begin(), true, true)
  897   return DL.size();

  206          e = Clang->getFrontendOpts().Plugins.size(); i != e; ++i) {
  231     unsigned NumArgs = Clang->getFrontendOpts().LLVMArgs.size();

  174     if (Symbols.size() != 1)

  195     if (Symbols.size() != 1)

   91                << FileInfo.size() << " files tracked.\n";
   93   for (unsigned i = 0, e = FileInfo.size(); i != e; ++i) {
  117     for (unsigned i = 0, e = HeaderMaps.size(); i != e; ++i)
  237   for (unsigned Idx = 0, N = SearchDirs.size(); Idx != N; ++Idx) {
  896   for (; i != SearchDirs.size(); ++i) {
  936     for (unsigned j = SystemHeaderPrefixes.size(); j; --j) {
 1014   CacheLookup.HitIdx = SearchDirs.size();
 1163   if (FE->getUID() >= FileInfo.size())
 1191     if (FE->getUID() >= FileInfo.size()) {
 1208   } else if (FE->getUID() >= FileInfo.size()) {
 1634     for (unsigned Idx = 0, N = SearchDirs.size(); Idx != N; ++Idx) {
 1689   for (unsigned Idx = 0, N = SearchDirs.size(); Idx != N; ++Idx) {
 1784   for (unsigned I = 0; I != SearchDirs.size(); ++I) {

   81   for (unsigned i = 0, e = PreExpArgTokens.size(); i != e; ++i)
  166   if (PreExpArgTokens.size() < getNumMacroArguments())

 2155   if (IncludeMacroStack.size() == MaxAllowedIncludeStackDepth-1) {

   74   if (MaxIncludeStackDepth < IncludeMacroStack.size())
   75     MaxIncludeStackDepth = IncludeMacroStack.size();

  103     if (unsigned(-Pos-1) >= LoadedPreprocessedEntities.size()) {
  108     unsigned LoadedIndex = LoadedPreprocessedEntities.size()+Pos;
  126   if (unsigned(Pos) >= PreprocessedEntities.size()) {
  155   unsigned TotalLoaded = LoadedPreprocessedEntities.size();
  215   size_t Count = PreprocessedEntities.size();
  263     return getPPEntityID(PreprocessedEntities.size()-1, /*isLoaded=*/false);
  271     return getPPEntityID(PreprocessedEntities.size()-1, /*isLoaded=*/false);
  321   unsigned Result = LoadedPreprocessedEntities.size();
  322   LoadedPreprocessedEntities.resize(LoadedPreprocessedEntities.size()
  328   unsigned Result = SkippedRanges.size();
  329   SkippedRanges.resize(SkippedRanges.size() + NumRanges);
  337   for (unsigned Index = 0; Index != SkippedRanges.size(); ++Index) {
  353     assert(Index < LoadedPreprocessedEntities.size() &&
  361   assert(Index < PreprocessedEntities.size() &&
  369   assert(Index < LoadedPreprocessedEntities.size() &&

 1474     PartialDiagId.emplace(Diags.size());

  236   unsigned size() const { return Results.size(); }
 1167   SMap[R.Declaration->getDeclName()].Add(R.Declaration, Results.size());
 1342         OverloadSet.Add(Method, Results.size());

 4361                               DiagnosticIdentifiers.size()));
 6180                                               Sanitizers.size()));

11648   while (RecordTypeList.size() > NextToCheckIndex) {

 1031       for (unsigned i = 0, e = CaseRanges.size(); i != e; ++i) {
 1069       for (unsigned i = 0, e = CaseRanges.size(); i != e; ++i) {

   73       S.Context, A, DiagnosticIdentifiers.data(), DiagnosticIdentifiers.size());

  584   for (unsigned I = 0, N = PPOpts.Macros.size(); I != N; ++I) {
  705   for (unsigned I = 0, N = ExistingPPOpts.Includes.size(); I != N; ++I) {
  730   for (unsigned I = 0, N = ExistingPPOpts.MacroIncludes.size(); I != N; ++I) {
 2274   if (ID == 0 || ID > F.InputFilesLoaded.size())
 3110         TypesLoaded.resize(TypesLoaded.size() + F.LocalNumTypes);
 3140         DeclsLoaded.resize(DeclsLoaded.size() + F.LocalNumDecls);
 3204         IdentifiersLoaded.resize(IdentifiersLoaded.size()
 3701         MacrosLoaded.resize(MacrosLoaded.size() + F.LocalNumMacros);
 7498   assert(Index < TypesLoaded.size() && "Type index out-of-range");
 7768   if (Index > DeclsLoaded.size()) {
 7853   if (Index >= DeclsLoaded.size()) {
 7868   if (Index >= DeclsLoaded.size()) {
 8140     = TypesLoaded.size() - std::count(TypesLoaded.begin(), TypesLoaded.end(),
 8143     = DeclsLoaded.size() - std::count(DeclsLoaded.begin(), DeclsLoaded.end(),
 8146     = IdentifiersLoaded.size() - std::count(IdentifiersLoaded.begin(),
 8150     = MacrosLoaded.size() - std::count(MacrosLoaded.begin(),
 8164                  NumTypesLoaded, (unsigned)TypesLoaded.size(),
 8165                  ((float)NumTypesLoaded/TypesLoaded.size() * 100));
 8168                  NumDeclsLoaded, (unsigned)DeclsLoaded.size(),
 8169                  ((float)NumDeclsLoaded/DeclsLoaded.size() * 100));
 8172                  NumIdentifiersLoaded, (unsigned)IdentifiersLoaded.size(),
 8173                  ((float)NumIdentifiersLoaded/IdentifiersLoaded.size() * 100));
 8176                  NumMacrosLoaded, (unsigned)MacrosLoaded.size(),
 8177                  ((float)NumMacrosLoaded/MacrosLoaded.size() * 100));
 8818   assert(ID <= IdentifiersLoaded.size() && "identifier ID out of range");
 9817   unsigned NumInputs = MF.InputFilesLoaded.size();
 9830   unsigned NumInputs = MF.InputFilesLoaded.size();

  122                          sizeof(T) * v.size());
 1442   Record.push_back(DiagOpts.Warnings.size());
 1443   for (unsigned I = 0, N = DiagOpts.Warnings.size(); I != N; ++I)
 1445   Record.push_back(DiagOpts.Remarks.size());
 1446   for (unsigned I = 0, N = DiagOpts.Remarks.size(); I != N; ++I)
 1602   Record.push_back(LangOpts.ModuleFeatures.size());
 1612   Record.push_back(LangOpts.CommentOpts.BlockCommandNames.size());
 1619   Record.push_back(LangOpts.OMPTargetTriples.size());
 1634   Record.push_back(TargetOpts.FeaturesAsWritten.size());
 1635   for (unsigned I = 0, N = TargetOpts.FeaturesAsWritten.size(); I != N; ++I) {
 1638   Record.push_back(TargetOpts.Features.size());
 1639   for (unsigned I = 0, N = TargetOpts.Features.size(); I != N; ++I) {
 1658   Record.push_back(HSOpts.UserEntries.size());
 1659   for (unsigned I = 0, N = HSOpts.UserEntries.size(); I != N; ++I) {
 1668   Record.push_back(HSOpts.SystemHeaderPrefixes.size());
 1669   for (unsigned I = 0, N = HSOpts.SystemHeaderPrefixes.size(); I != N; ++I) {
 1693   Record.push_back(PPOpts.Macros.size());
 1694   for (unsigned I = 0, N = PPOpts.Macros.size(); I != N; ++I) {
 1700   Record.push_back(PPOpts.Includes.size());
 1701   for (unsigned I = 0, N = PPOpts.Includes.size(); I != N; ++I)
 1705   Record.push_back(PPOpts.MacroIncludes.size());
 1706   for (unsigned I = 0, N = PPOpts.MacroIncludes.size(); I != N; ++I)
 1859     InputFileID = InputFileOffsets.size();
 1869           InputFileOffsets.size(),
 1901                                      InputFileOffsets.size(), UserFilesNum};
 2365           PreloadSLocs.push_back(SLocEntryOffsets.size());
 2414         SOURCE_LOCATION_OFFSETS, SLocEntryOffsets.size(),
 2454       Record.push_back(L.second.size());
 2616   for (unsigned I = 0, N = MacroInfosToEmit.size(); I != N; ++I) {
 2628     if (Index == MacroOffsets.size())
 2631       if (Index > MacroOffsets.size())
 2690     RecordData::value_type Record[] = {MACRO_OFFSET, MacroOffsets.size(),
 3210   if (TypeOffsets.size() == Index)
 3212   else if (TypeOffsets.size() < Index) {
 3259     RecordData::value_type Record[] = {TYPE_OFFSET, TypeOffsets.size(),
 3272     RecordData::value_type Record[] = {DECL_OFFSET, DeclOffsets.size(),
 3535           SELECTOR_OFFSETS, SelectorOffsets.size(),
 3845   for (unsigned I = 0, N = IdentifierOffsets.size(); I != N; ++I)
 3850                                      IdentifierOffsets.size(),

 2373   if (DeclOffsets.size() == Index)
 2375   else if (DeclOffsets.size() < Index) {

  321         Writer.write<uint32_t>(Merged->Files.size());

  197         if (SFinder.Sizeofs.size() != 1)

  113       assert(Args.size() == 1);
  123       assert(Args.size() == 1);
  251     size_t E = R.size();
  282     size_t E = R.size();
  406   if (CE->getNumArgs() != ArgTypes.size())
  414   for (size_t I = 0, E = ArgTypes.size(); I != E; ++I) {

  386   if (CD.QualifiedName.size() > 1 && FD) {
  389     size_t NumUnmatched = CD.QualifiedName.size() - 1;

  284   if (SupportsCrossFileDiagnostics && FileIDs.size() > 1) {

  138   int getSize() const { return Nodes.size(); }
  298   while (Expanded < Ids.size())
  502   int getSize() const { return RootIds.size(); }

  107   const std::string TotalNumStr = std::to_string(Files.size());

   27     for (size_t i = 0, e = Args.size(); i < e; ++i) {
   45     for (size_t i = 0, e = Args.size(); i < e; ++i) {
   63     for (size_t i = 0, e = Args.size(); i < e; ++i) {
   79     for (size_t i = 0, e = Args.size(); i < e; ++i) {
  133     for (size_t I = 0, E = Args.size(); I != E; I++) {

  499       Result[Result.size() - 1] =

  155     for (unsigned Pos = 1; Pos < OldArgs.size();) {
  323     Paths.reserve(OriginalPaths.size());
  324     Types.reserve(OriginalPaths.size());
  325     Stems.reserve(OriginalPaths.size());
  326     for (size_t I = 0; I < OriginalPaths.size(); ++I) {

  269   if (Args.size() < 2)
  302   if (Nodes.size() == 1)

   55     assert(SelectionStack.size() == 1 && "stack was not popped");

  194     for (unsigned I = 0; I < NewNames.size(); ++I) {
  249     assert(USRList.size() == NewNames.size());
  249     assert(USRList.size() == NewNames.size());
  253     for (unsigned I = 0; I < NewNames.size(); ++I) {

  126          Expanded < ExpandedTokens.data() + ExpandedTokens.size());
  218          Spelled < (File.SpelledTokens.data() + File.SpelledTokens.size()));
  368     for (unsigned I = 0; I < Result.ExpandedTokens.size() - 1; ++I) {
  378                  Result.ExpandedTokens.size() - 1);
  379     Result.Files[SM.getMainFileID()].EndExpanded = Result.ExpandedTokens.size();
  425     for (; I + 1 < Result.ExpandedTokens.size(); ++I) {
  439     for (unsigned I = 0; I < Result.ExpandedTokens.size(); ++I) {
  523     for (; NextSpelled < File.SpelledTokens.size(); ++NextSpelled) {
  624           M.EndSpelled == File.SpelledTokens.size()

  467   AbsolutePaths.reserve(SourcePaths.size());
  642   assert(ASTs.size() == 1);

  142   assert(Ms.size() == 1 && "Cases must have compatible matchers.");

  186   for (unsigned i=0, e = transforms.size(); i != e; ++i) {

  109   if (ASTs.size() != Files.size())

   75   if (LHS.size() != RHS.size())
   75   if (LHS.size() != RHS.size())
  143     size_t GroupIndex = Results.size() - 1;
  144     if (Results.back().size() >=
  147       if (GroupIndex >= TestRanges.GroupedRanges.size()) {

  156           std::size_t Idx = Args.size() - 1;
  222     llvm::outs() << "Running clang-scan-deps on " << Inputs.size()
  234           if (Index >= Inputs.size())

   54   llvm::cl::ParseCommandLineOptions((int)Args.size(), Args.data(),

   72   out << "Warnings with flags (" << Flagged.size() << "):\n";
   75   out << "Warnings without flags (" << Unflagged.size() << "):\n";
   81       ((double)Flagged.size()) / (Flagged.size() + Unflagged.size()) * 100.0;
   81       ((double)Flagged.size()) / (Flagged.size() + Unflagged.size()) * 100.0;
   81       ((double)Flagged.size()) / (Flagged.size() + Unflagged.size()) * 100.0;
   89   double avgDiagsPerFlag = (double) Flagged.size() / flagHistogram.size();
   94       << flagHistogram["pedantic"].size() << '\n';

  426     for (unsigned i = 1, e = Opts.Features.size(); i != e; ++i)
  598     unsigned NumArgs = Asm.LLVMArgs.size();

  123       assert(Inits.size() == BlockIdCount);
  189       assert(Inits.size() == RecordIdCount);
  383     assert(Block.second.size() < (1U << BitCodeConstants::SubblockIDSize));
  391   assert(RIDs.size() < (1U << BitCodeConstants::SubblockIDSize));

   50   for (unsigned long I = 0; I < Children.size(); I++) {

   60     if (FirstCI != SecondCI || Children.size() != Other.Children.size())
   60     if (FirstCI != SecondCI || Children.size() != Other.Children.size())

  120   for (size_t I = 0; I < Tokens.size(); ++I) {

   88   assert(Invocation->getFrontendOpts().Inputs.size() == 1);
  393   LLVM_DEBUG(llvm::dbgs() << "Having found " << MatchedSymbols.size()

  100                             << Symbols.size() << " results...\n");

   18   this->RegexHeaderMappingTable.reserve(RegexHeaderMappingTable->size());

  276     assert(options.getSourcePathList().size() == 1 &&
  440     assert(FixerReplacements.size() == 1);

  655   for (unsigned I = 0; I < ErrorFixes.size(); ++I) {
  671   std::vector<bool> Apply(ErrorFixes.size(), true);
  690   for (unsigned I = 0; I < ErrorFixes.size(); ++I) {

  109     for (unsigned I = 1, E = FileDirectives.size(); I != E; ++I)
  113     Blocks.push_back(FileDirectives.size()); // Sentinel value.
  117     for (unsigned I = 0, E = FileDirectives.size(); I != E; ++I)
  121     for (unsigned BI = 0, BE = Blocks.size() - 1; BI != BE; ++BI)
  139     for (unsigned BI = 0, BE = Blocks.size() - 1; BI != BE; ++BI) {

   65   IgnoredIntegerValues.resize(IgnoredIntegerValuesInput.size());
   75     IgnoredFloatingPointValues.reserve(IgnoredFloatingPointValuesInput.size());
   76     IgnoredDoublePointValues.reserve(IgnoredFloatingPointValuesInput.size());

  930         Actions.reserve(Actions.size() + Tweaks->size());
  930         Actions.reserve(Actions.size() + Tweaks->size());
 1167   if (Params.positions.size() != 1) {
 1170          Params.positions.size());

 1320     SPAN_ATTACH(Tracer, "returned_results", int64_t(Output.Completions.size()));
 1324         NSema, NIndex, NSemaAndIndex, NIdent, Output.Completions.size(),
 1326     assert(!Opts.Limit || Output.Completions.size() <= Opts.Limit);
 1541         auto Ret = BundleLookup.try_emplace(OverloadSet, Bundles.size());
 1855   OS << "CodeCompleteResult: " << R.Completions.size() << (R.HasMore ? "+" : "")

  241     OS << " (" << (D.Fixes.size() > 1 ? "fixes" : "fix") << " available)";

  129   auto R = NameToIndex.try_emplace(Name, RealPathNames.size());

  162     if (Heap.size() >= N) {
  173     assert(Heap.size() <= N);
  181     assert(Heap.size() <= N);

  221     for (size_t I = 0, E = Cmd->CommandLine.size(); I < E; ++I) {

  142     NonConflicting.reserve(Tokens.size());

  110     if (LRU.size() <= MaxRetainedASTs)

  306       ResultIndex[*ID] = Result.size() - 1;
  509   for (size_t I = 0, E = Params.size(); I != E; ++I) {
  958   if (Index && Results.size() < Limit) {
  980   if (Results.size() > Limit)

  169     log("Enqueueing {0} commands for indexing", ChangedFiles.size());
  170     SPAN_ATTACH(Tracer, "files", int64_t(ChangedFiles.size()));
  177     Tasks.reserve(NeedsReIndexing.size());

  197           llvm::ArrayRef<Ref>(&RefsStorage[RefsStorage.size() - SymRefs.size()],
  209       RefsStorage.size() * sizeof(Ref) + SymsStorage.size() * sizeof(Symbol);
  209       RefsStorage.size() * sizeof(Ref) + SymsStorage.size() * sizeof(Symbol);

   54   SPAN_ATTACH(Tracer, "results", static_cast<int>(Results.size()));

   53     NumRefs += SymRefs.size();

   83   size_t size() const { return Refs.size(); }

   57   size_t size() const { return Relations.size(); }

  167     for (unsigned I = 0; I < Sorted.size(); ++I)
  277   writeVar(IGN.DirectIncludes.size(), OS);
  395   writeVar(Cmd.CommandLine.size(), CmdOS);
  505     Result.Cmd->CommandLine.reserve(Cmd.CommandLine.size());
  568     InternedCmd.CommandLine.reserve(Data.Cmd->CommandLine.size());

  189   size_t size() const { return Symbols.size(); }

   68   this->Corpus = dex::Corpus(Symbols.size());
   69   std::vector<std::pair<float, const Symbol *>> ScoredSymbols(Symbols.size());
   71   for (size_t I = 0; I < Symbols.size(); ++I) {
   82   SymbolQuality.resize(Symbols.size());
   84   for (size_t I = 0; I < ScoredSymbols.size(); ++I) {
   91   for (DocID SymbolRank = 0; SymbolRank < Symbols.size(); ++SymbolRank) {
  289   size_t Bytes = Symbols.size() * sizeof(const Symbol *);
  290   Bytes += SymbolQuality.size() * sizeof(float);

  377   switch (RealChildren.size()) {
  407   switch (RealChildren.size()) {

  232       if (IDs.size() > 1) {
  236             Name, IDs.size());

   23   Ps.reserve(Offsets.size());
   45   Rs.reserve(OffsetRanges.size());

  738         0, AsyncRequests.size() - 1);
  740         0, BlockingRequests.size() - 1);

  658   EXPECT_EQ(Results.Completions.size(), Opts.Limit);
 1035   if (P.size() != arg.parameters.size())
 1035   if (P.size() != arg.parameters.size())
 1037   for (unsigned I = 0; I < P.size(); ++I) {
 1183                      [this, Num] { return Requests.size() == Num; }));
 1204   EXPECT_EQ(Reqs.size(), Num);
 1712   EXPECT_EQ(Results.Completions.size(), 3u);
 1718     EXPECT_TRUE(C.FixIts.size() == 1u || C.Name == "AuxFunction");
 1752   EXPECT_EQ(Results.Completions.size(), 3u);
 1836     EXPECT_EQ(Results.Completions.size(), 1u);
 2158   ASSERT_EQ(Reqs1.size(), 1u);
 2164   ASSERT_EQ(Reqs2.size(), 1u);
 2171   ASSERT_EQ(Reqs3.size(), 2u);

   42   std::vector<DocID> IDs(IDAndScore.size());
   43   for (size_t I = 0; I < IDAndScore.size(); ++I)
  503   EXPECT_EQ(Matches.size(), *Req.Limit);

  712     EXPECT_EQ(D.Fixes.size(), 1u);

  547     for (unsigned I = 0; I < Refs.size(); ++I) {
  571     for (unsigned I = 0; I < Refs.size(); ++I)

   50   EXPECT_THAT(Paths.size(), IndexFile.Sources->size());

  144   EXPECT_EQ(Matches.size(), *Req.Limit);

   57     std::vector<int> Matches(Matchers.size());
   59     for (size_t J = 0; I < Matchers.size() && J < V.size(); ++J)
   59     for (size_t J = 0; I < Matchers.size() && J < V.size(); ++J)
   62     if (I == Matchers.size()) // We exhausted all matchers.

   39       if (TemplateArgsAtPoints.size() == Points.size())
   39       if (TemplateArgsAtPoints.size() == Points.size())
   43       if (Pos != Points[TemplateArgsAtPoints.size()])

   24   switch (Test.points().size()) {
   61   for (unsigned I = 0; I < Result.size(); ++I) {

   55   if (A.points().size() != 0) {
   56     assert(A.ranges().size() == 0 &&

 2146                     .size());

  325   if (IncludePaths.size() == 0) {

  986     for (unsigned I = 0, N = H->second.size(); I != N; ++I) {

  117   int ModuleMapCount = ModuleMaps.size();

  103   if (HeaderFileNames.size() != 0) {

  630   bool hasMismatch() { return MacroExpansionInstances.size() > 1; }
  717   bool hasMismatch() { return ConditionalExpansionInstances.size() > 1; }
  815     assert((HeaderStack.size() == 0) && "Header stack should be empty.");
  919       } while ((TH != H) && (HeaderStack.size() != 0));
  965       H = HeaderPaths.size();
  973     if ((H >= 0) && (H < (HeaderHandle)HeaderPaths.size()))
  986     if (HeaderStack.size() != 0) {
  993     if (HeaderStack.size() != 0)
 1025       H = InclusionPaths.size();
 1038     if ((H >= 0) && (H <= (InclusionPathHandle)InclusionPaths.size()))
 1165           auto Count = (int)ip.size();
 1226           auto Count = (int)ip.size();