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

References

 1509   return Idx >= Table.size() ? nullptr : &ExactFPImmsList[Table[Idx]._index];
 4967   return Idx >= Table.size() ? nullptr : &TSBsList[Table[Idx]._index];

  709   return Idx >= Table.size() ? nullptr : &Table[Idx];
  734   return Idx >= Table.size() ? nullptr : &Table[Idx];
  790   return Idx >= Table.size() ? nullptr : &MIMGDimInfoTable[Table[Idx]._index];

  111       : Data(A.data()), Length(A.size()) {}
  179       assert(N+M <= size() && "Invalid specifier");
  184     ArrayRef<T> slice(size_t N) const { return slice(N, size() - N); }
  188       assert(size() >= N && "Dropping more elements than exist");
  189       return slice(N, size() - N);
  194       assert(size() >= N && "Dropping more elements than exist");
  195       return slice(0, size() - N);
  212       if (N >= size())
  214       return drop_back(size() - N);
  219       if (N >= size())
  221       return drop_front(size() - N);
  331     iterator end() const { return data() + this->size(); }
  345       return data()[this->size()-1];
  351       assert(N + M <= this->size() && "Invalid specifier");
  357       return slice(N, this->size() - N);
  362       assert(this->size() >= N && "Dropping more elements than exist");
  363       return slice(N, this->size() - N);
  367       assert(this->size() >= N && "Dropping more elements than exist");
  368       return slice(0, this->size() - N);
  387       if (N >= this->size())
  389       return drop_back(this->size() - N);
  394       if (N >= this->size())
  396       return drop_front(this->size() - N);
  417       assert(Index < this->size() && "Invalid index!");
  429         : MutableArrayRef<T>(new T[Data.size()], Data.size()) {
  429         : MutableArrayRef<T>(new T[Data.size()], Data.size()) {

  373       unsigned OldCapacity = Bits.size();
  824     std::memmove(Dest.begin(), Src.begin(), Dest.size() * sizeof(BitWord));
  840     assert(Dest.size() == Src.size());
  840     assert(Dest.size() == Src.size());
  842     std::memmove(Dest.begin(), Src.begin(), Dest.size() * sizeof(BitWord));
  865     if (Bits.size() > UsedWords)
  885     size_t NewCapacity = std::max<size_t>(NumBitWords(NewSize), Bits.size() * 2);
  894     if (B.size() > 0)
  895       memset(B.data(), 0 - (int)t, B.size() * sizeof(BitWord));
  927   size_t getMemorySize() const { return Bits.size() * sizeof(BitWord); }
  928   size_t getBitCapacity() const { return Bits.size() * BITWORD_SIZE; }

   56   return StringRef(reinterpret_cast<const char *>(Input.begin()), Input.size());

  127                 : Elts.size() == 1

   57   typename ArrayRef<T>::size_type m = FromArray.size();
   58   typename ArrayRef<T>::size_type n = ToArray.size();

  385   for (unsigned i = 0; i < getBlocks().size(); ++i) {

  109     for (unsigned Idx = 0, Size = Operands.size(); Idx != Size; ++Idx)
  726     return static_cast<T *>(this)->getCallCost(F, Arguments.size(), U);
  839     ParamTys.reserve(Arguments.size());
  840     for (unsigned Idx = 0, Size = Arguments.size(); Idx != Size; ++Idx)

   15 HANDLE_LOAD_COMMAND(LC_SEGMENT, 0x00000001u, segment_command)
   16 HANDLE_LOAD_COMMAND(LC_SYMTAB, 0x00000002u, symtab_command)
   18 HANDLE_LOAD_COMMAND(LC_SYMSEG, 0x00000003u, symseg_command)
   19 HANDLE_LOAD_COMMAND(LC_THREAD, 0x00000004u, thread_command)
   20 HANDLE_LOAD_COMMAND(LC_UNIXTHREAD, 0x00000005u, thread_command)
   22 HANDLE_LOAD_COMMAND(LC_LOADFVMLIB, 0x00000006u, fvmlib_command)
   24 HANDLE_LOAD_COMMAND(LC_IDFVMLIB, 0x00000007u, fvmlib_command)
   26 HANDLE_LOAD_COMMAND(LC_IDENT, 0x00000008u, ident_command)
   28 HANDLE_LOAD_COMMAND(LC_FVMFILE, 0x00000009u, fvmfile_command)
   30 HANDLE_LOAD_COMMAND(LC_PREPAGE, 0x0000000Au, load_command)
   31 HANDLE_LOAD_COMMAND(LC_DYSYMTAB, 0x0000000Bu, dysymtab_command)
   32 HANDLE_LOAD_COMMAND(LC_LOAD_DYLIB, 0x0000000Cu, dylib_command)
   33 HANDLE_LOAD_COMMAND(LC_ID_DYLIB, 0x0000000Du, dylib_command)
   34 HANDLE_LOAD_COMMAND(LC_LOAD_DYLINKER, 0x0000000Eu, dylinker_command)
   35 HANDLE_LOAD_COMMAND(LC_ID_DYLINKER, 0x0000000Fu, dylinker_command)
   37 HANDLE_LOAD_COMMAND(LC_PREBOUND_DYLIB, 0x00000010u, prebound_dylib_command)
   38 HANDLE_LOAD_COMMAND(LC_ROUTINES, 0x00000011u, routines_command)
   39 HANDLE_LOAD_COMMAND(LC_SUB_FRAMEWORK, 0x00000012u, sub_framework_command)
   40 HANDLE_LOAD_COMMAND(LC_SUB_UMBRELLA, 0x00000013u, sub_umbrella_command)
   41 HANDLE_LOAD_COMMAND(LC_SUB_CLIENT, 0x00000014u, sub_client_command)
   42 HANDLE_LOAD_COMMAND(LC_SUB_LIBRARY, 0x00000015u, sub_library_command)
   44 HANDLE_LOAD_COMMAND(LC_TWOLEVEL_HINTS, 0x00000016u, twolevel_hints_command)
   46 HANDLE_LOAD_COMMAND(LC_PREBIND_CKSUM, 0x00000017u, prebind_cksum_command)
   48 HANDLE_LOAD_COMMAND(LC_LOAD_WEAK_DYLIB, 0x80000018u, dylib_command)
   49 HANDLE_LOAD_COMMAND(LC_SEGMENT_64, 0x00000019u, segment_command_64)
   50 HANDLE_LOAD_COMMAND(LC_ROUTINES_64, 0x0000001Au, routines_command_64)
   51 HANDLE_LOAD_COMMAND(LC_UUID, 0x0000001Bu, uuid_command)
   52 HANDLE_LOAD_COMMAND(LC_RPATH, 0x8000001Cu, rpath_command)
   53 HANDLE_LOAD_COMMAND(LC_CODE_SIGNATURE, 0x0000001Du, linkedit_data_command)
   54 HANDLE_LOAD_COMMAND(LC_SEGMENT_SPLIT_INFO, 0x0000001Eu, linkedit_data_command)
   55 HANDLE_LOAD_COMMAND(LC_REEXPORT_DYLIB, 0x8000001Fu, dylib_command)
   56 HANDLE_LOAD_COMMAND(LC_LAZY_LOAD_DYLIB, 0x00000020u, dylib_command)
   57 HANDLE_LOAD_COMMAND(LC_ENCRYPTION_INFO, 0x00000021u, encryption_info_command)
   58 HANDLE_LOAD_COMMAND(LC_DYLD_INFO, 0x00000022u, dyld_info_command)
   59 HANDLE_LOAD_COMMAND(LC_DYLD_INFO_ONLY, 0x80000022u, dyld_info_command)
   60 HANDLE_LOAD_COMMAND(LC_LOAD_UPWARD_DYLIB, 0x80000023u, dylib_command)
   61 HANDLE_LOAD_COMMAND(LC_VERSION_MIN_MACOSX, 0x00000024u, version_min_command)
   62 HANDLE_LOAD_COMMAND(LC_VERSION_MIN_IPHONEOS, 0x00000025u, version_min_command)
   63 HANDLE_LOAD_COMMAND(LC_FUNCTION_STARTS, 0x00000026u, linkedit_data_command)
   64 HANDLE_LOAD_COMMAND(LC_DYLD_ENVIRONMENT, 0x00000027u, dylinker_command)
   65 HANDLE_LOAD_COMMAND(LC_MAIN, 0x80000028u, entry_point_command)
   66 HANDLE_LOAD_COMMAND(LC_DATA_IN_CODE, 0x00000029u, linkedit_data_command)
   67 HANDLE_LOAD_COMMAND(LC_SOURCE_VERSION, 0x0000002Au, source_version_command)
   68 HANDLE_LOAD_COMMAND(LC_DYLIB_CODE_SIGN_DRS, 0x0000002Bu, linkedit_data_command)
   69 HANDLE_LOAD_COMMAND(LC_ENCRYPTION_INFO_64, 0x0000002Cu,
   71 HANDLE_LOAD_COMMAND(LC_LINKER_OPTION, 0x0000002Du, linker_option_command)
   72 HANDLE_LOAD_COMMAND(LC_LINKER_OPTIMIZATION_HINT, 0x0000002Eu, linkedit_data_command)
   73 HANDLE_LOAD_COMMAND(LC_VERSION_MIN_TVOS, 0x0000002Fu, version_min_command)
   74 HANDLE_LOAD_COMMAND(LC_VERSION_MIN_WATCHOS, 0x00000030u, version_min_command)
   75 HANDLE_LOAD_COMMAND(LC_NOTE, 0x00000031u, note_command)
   76 HANDLE_LOAD_COMMAND(LC_BUILD_VERSION, 0x00000032u, build_version_command)

   87       return StringRef((const char *)Buffer.begin(), Buffer.size());

  112     return pos <= BitcodeBytes.size();
  116     return BitsInCurWord == 0 && BitcodeBytes.size() <= NextChar;
  164     if (NextChar >= BitcodeBytes.size())
  167                                NextChar, BitcodeBytes.size());
  172     if (BitcodeBytes.size() >= NextChar + sizeof(word_t)) {
  179       BytesRead = BitcodeBytes.size() - NextChar;
  298   size_t SizeInBytes() const { return BitcodeBytes.size(); }
  301   void skipToEnd() { NextChar = BitcodeBytes.size(); }

  325         assert(RecordIdx < Vals.size() && "Invalid abbrev/record");
  336           assert(RecordIdx == Vals.size() &&
  349           EmitVBR(static_cast<uint32_t>(Vals.size()-RecordIdx), 6);
  352           for (unsigned e = Vals.size(); RecordIdx != e; ++RecordIdx)
  360           assert(RecordIdx == Vals.size() &&
  371         assert(RecordIdx < Vals.size() && "Invalid abbrev/record");
  376     assert(RecordIdx == Vals.size() && "Not all record operands emitted!");
  387       EmitVBR(static_cast<uint32_t>(Bytes.size()), 6);
  414       auto Count = static_cast<uint32_t>(makeArrayRef(Vals).size());

  983       assert(Indices.size() <= Factor &&
 1000       Cost += Indices.size() * InsSubCost;
 1188       for (unsigned i = 0, ie = Tys.size(); i != ie; ++i) {
 1512       for (unsigned i = 0, ie = Tys.size(); i != ie; ++i) {
 1520       for (unsigned i = 0, ie = Tys.size(); i != ie; ++i) {

  345     for (unsigned i = 0; i < Regs.size(); ++i)
  348     return Regs.size();
  373     if (FirstUnalloc == Regs.size())
  386     if (RegsRequired > Regs.size())
  389     for (unsigned StartIdx = 0; StartIdx <= Regs.size() - RegsRequired;
  414     if (FirstUnalloc == Regs.size())
  451     for (unsigned i = 0; i < ShadowRegs.size(); ++i)

   47       assert(DstOps.size() == 1 && "Invalid dst ops");
   48       assert(SrcOps.size() == 2 && "Invalid src ops");
   58       assert(DstOps.size() == 1 && "Invalid dst ops");
   59       assert(SrcOps.size() == 2 && "Invalid src ops");

  566     assert(Regs.size() == 1 &&

  151               MMOs.size(), HasPreInstrSymbol + HasPostInstrSymbol,
  154           ExtraInfo(MMOs.size(), HasPreInstrSymbol, HasPostInstrSymbol,
  582   bool hasOneMemOperand() const { return memoperands().size() == 1; }
  585   unsigned getNumMemOperands() const { return memoperands().size(); }

 1556     unsigned NumElems = Mask.size();

   41   uint32_t length() const { return RecordData.size(); }
   44     if (RecordData.size() < sizeof(RecordPrefix))
   54                      RecordData.size());
   74     if (StreamBuffer.size() < sizeof(RecordPrefix))
   81     if (StreamBuffer.size() < RealLen)

  322     Result.Bytes = Data.take_front(Data.size() - Next.size());
  322     Result.Bytes = Data.take_front(Data.size() - Next.size());

   82     assert(H.size() == 8);

  573   uint32_t getEntryCount() const { return getSlots().size(); }

  129     if (Index < Files.size())
  147                        AddrOffsets.size()/sizeof(T));
  165     if (Index < AIO.size())

   27     return Item.RecordData.size();

  704     return getRaw(StringRef(Data, Elts.size() * sizeof(ElementTy)), Elts.size(),
  704     return getRaw(StringRef(Data, Elts.size() * sizeof(ElementTy)), Elts.size(),
 1159         Ty, C, makeArrayRef((Value * const *)IdxList.data(), IdxList.size()),

 1304     for (unsigned i = 1; i < Ops.size(); i++)
 1330     for (unsigned i = 1; i < Ops.size(); i++)
 1562       assert(Ops.size() == 2 && "Invalid number of operands!");
 1567       assert(Ops.size() == 1 && "Invalid number of operands!");
 1702       for (i = 0, e = IdxList.size(); i != e; ++i)
 1721       for (i = 0, e = IdxList.size(); i != e; ++i)

  911     unsigned Values = 1 + unsigned(IdxList.size());
  927     unsigned Values = 1 + unsigned(IdxList.size());
 1451     return new (ComputeNumOperands(Args.size()))
 1460         ComputeNumOperands(Args.size(), CountBundleInputs(Bundles));
 1461     const unsigned DescriptorBytes = Bundles.size() * sizeof(BundleOpInfo);
 1474     return new (ComputeNumOperands(Args.size()))
 1482         ComputeNumOperands(Args.size(), CountBundleInputs(Bundles));
 1483     const unsigned DescriptorBytes = Bundles.size() * sizeof(BundleOpInfo);
 1692                    (Args.size() + CountBundleInputs(Bundles) + 1),
 1693                unsigned(Args.size() + CountBundleInputs(Bundles) + 1),
 1703                    (Args.size() + CountBundleInputs(Bundles) + 1),
 1704                unsigned(Args.size() + CountBundleInputs(Bundles) + 1),
 3704     int NumOperands = ComputeNumOperands(Args.size());
 3716         ComputeNumOperands(Args.size(), CountBundleInputs(Bundles));
 3717     unsigned DescriptorBytes = Bundles.size() * sizeof(BundleOpInfo);
 3727     int NumOperands = ComputeNumOperands(Args.size());
 3738         ComputeNumOperands(Args.size(), CountBundleInputs(Bundles));
 3739     unsigned DescriptorBytes = Bundles.size() * sizeof(BundleOpInfo);
 3965     int NumOperands = ComputeNumOperands(Args.size(), IndirectDests.size());
 3965     int NumOperands = ComputeNumOperands(Args.size(), IndirectDests.size());
 3978     int NumOperands = ComputeNumOperands(Args.size(), IndirectDests.size(),
 3978     int NumOperands = ComputeNumOperands(Args.size(), IndirectDests.size(),
 3980     unsigned DescriptorBytes = Bundles.size() * sizeof(BundleOpInfo);
 3992     int NumOperands = ComputeNumOperands(Args.size(), IndirectDests.size());
 3992     int NumOperands = ComputeNumOperands(Args.size(), IndirectDests.size());
 4004     int NumOperands = ComputeNumOperands(Args.size(), IndirectDests.size(),
 4004     int NumOperands = ComputeNumOperands(Args.size(), IndirectDests.size(),
 4006     unsigned DescriptorBytes = Bundles.size() * sizeof(BundleOpInfo);
 4410     unsigned Values = 1 + Args.size();
 4417     unsigned Values = 1 + Args.size();
 4451     unsigned Values = 1 + Args.size();
 4458     unsigned Values = 1 + Args.size();

 1002     if (!V.getSummaryList().size())
 1378     if (!N.getSummaryList().size()) // handle external function
 1388     if (!N.getSummaryList().size()) // handle external function
 1398     if (!N.getSummaryList().size()) // handle external function
 1407     if (!N.getSummaryList().size()) // handle external function

   61         Encodings(S.size()) {}

   40   unsigned size() const { return Sequence.size(); }
   41   bool hasNext() const { return Current < (Iterations * Sequence.size()); }
   46     return SourceRef(Current, *Sequence[Current % Sequence.size()]);

  312   if (Index >= Sections.size())
  324   if (Index >= ShndxTable.size())
  328         Twine(ShndxTable.size()));
  382   if (Index >= Symbols.size())
  487   if (Index >= Sections.size())
  612   return StringRef(Data.begin(), Data.size());
  645   if (V.size() != Syms)
  646     return createError("SHT_SYMTAB_SHNDX has " + Twine(V.size()) +

  380         if (Contents[0] != ARMBuildAttrs::Format_Version || Contents.size() == 1)

  269   size_t getNumModules() const { return Modules.size(); }
  284     ComdatTable.reserve(Comdats.size());
  296     Specifiers.reserve(DependentLibraries.size());

  112       assert(Storage.size() % Stride == 0);
  116       return Storage.size() == R.Storage.size();
  116       return Storage.size() == R.Storage.size();
  120       assert(Storage.size() >= sizeof(minidump::MemoryInfo));
  192     if (Stream->size() >= sizeof(T))

  453   return StringRef(reinterpret_cast<const char *>(Res->data()), Res->size());

   37     assert(S.size() == 8 && "Invalid hash size!");

  154         Size(Content.size()) {}

   82       return Data.size() / 2;
   83     return Data.size();

  797         const_cast<InstrProfValueSiteRecord *>(AR.data()), AR.size());
  877   return getValueSitesForKind(ValueKind).size();

   57   uint32_t getLength() override { return Data.size(); }
   63     return StringRef(CharData, Data.size());
  116     if (auto EC = checkOffsetForWrite(Offset, Buffer.size()))
  120     ::memcpy(DataPtr + Offset, Buffer.data(), Buffer.size());
  150     if (auto EC = checkOffsetForWrite(Offset, Buffer.size()))
  185     uint32_t RequiredSize = Offset + Buffer.size();
  189     ::memcpy(Data.data() + Offset, Buffer.data(), Buffer.size());

   76     ItemEndOffsets.reserve(Items.size());
   94     assert(Idx < Items.size() && "binary search for offset failed");

  154     if (Array.size() > UINT32_MAX / sizeof(T))
  160                           Array.size() * sizeof(T)));

   72   Operations.reserve(AllUpdates.size());
   99   for (size_t i = 0, e = AllUpdates.size(); i != e; ++i) {

   88                        Data.size())),

 1156     const size_t NumUpdates = Updates.size();

  283                           Value.size());
  293                           Value.size());

  776     assert(Operands.size() == 1 &&
  831     assert(Operands.size() == 2 &&
  886     assert(Operands.size() == 3 &&

   57     Worklist.reserve(List.size()+16);
   58     WorklistMap.reserve(List.size());
   59     LLVM_DEBUG(dbgs() << "IC: ADDING: " << List.size()

  772   for (unsigned i = 1, e = Ops.size(); i != e; ++i) {
  844   for (unsigned i = 1, e = Ops.size(); i != e; ++i)
  849         if (Ops.size() == 2 && ResElemTy->isIntegerTy(8)) {
  871                 makeArrayRef((Value * const *)Ops.data() + 1, Ops.size() - 1)));
 1050         return ConstantFoldCall(Call, F, Ops.slice(0, Ops.size() - 1), TLI);
 1690   assert(Operands.size() == 1 && "Wrong number of operands.");
 2029   assert(Operands.size() == 2 && "Wrong number of operands.");
 2282   assert(Operands.size() == 3 && "Wrong number of operands.");
 2377   if (Operands.size() == 1)
 2380   if (Operands.size() == 2)
 2383   if (Operands.size() == 3)
 2397   SmallVector<Constant *, 4> Lane(Operands.size());
 2441     for (unsigned J = 0, JE = Operands.size(); J != JE; ++J) {

 3995   if (Ops.size() == 1)
 4009   if (Ops.size() == 2) {
 4182   unsigned NumIdxs = Idxs.size();
 4186     unsigned NumInsertValueIdxs = InsertValueIdxs.size();

 1107   OffValPairs.reserve(VL.size());
 1143   SortedIndices.resize(VL.size());

 1245     assert(pred_size(New) == Preds.size() &&
 1256       assert(PredsSet.size() == Preds.size() &&

  623   assert(AliaseeVI.getSummaryList().size() == 1 &&

 2365       (Type == scAddExpr || Type == scMulExpr) && Ops.size() == 2 &&
 2796     const SCEV **O = SCEVAllocator.Allocate<const SCEV *>(Ops.size());
 2799         SCEVAddExpr(ID.Intern(SCEVAllocator), O, Ops.size());
 2812   for (unsigned i = 0, e = Ops.size(); i != e; ++i)
 2819     const SCEV **O = SCEVAllocator.Allocate<const SCEV *>(Ops.size());
 2822         SCEVAddRecExpr(ID.Intern(SCEVAllocator), O, Ops.size(), L);
 2835   for (unsigned i = 0, e = Ops.size(); i != e; ++i)
 2841     const SCEV **O = SCEVAllocator.Allocate<const SCEV *>(Ops.size());
 2844                                         O, Ops.size());
 3543   for (unsigned i = 0, e = Ops.size(); i != e; ++i)
 7031   ExitNotTaken.reserve(ExitCounts.size());

 3433     unsigned size = I->getNumIndices() + idx_range.size();

  605     for (int J = 1, E = VL.size(); MD && J != E; ++J) {
  726   unsigned NumVecs = Vecs.size();

 7330     if (++NumUses > Indexes.size())
 7336   if (Order.size() != Indexes.size() || NumUses > Indexes.size())
 7336   if (Order.size() != Indexes.size() || NumUses > Indexes.size())

  464   const unsigned char *EndBufPtr = BufPtr + Bytes.size();
  469     if (Bytes.size() < BWH_HeaderSize)
  508   if (Record.size() != 2)
  615   uint64_t BufferSizeBits = Stream.getBitcodeBytes().size() * CHAR_BIT;

  153   if (Idx > Record.size())
  156   for (unsigned i = Idx, e = Record.size(); i != e; ++i)
 2316   SmallVector<uint64_t, 8> Words(Vals.size());
 3065     if (Record.size() < 2)
 3095   if (Record.size() < 6)
 3126   if (Record.size() > 6 && !GlobalValue::isLocalLinkage(Linkage))
 3131   if (Record.size() > 7)
 3135   if (Record.size() > 8)
 3139   if (Record.size() > 9)
 3151   if (Record.size() > 10)
 3165   if (Record.size() > 11) {
 3175   if (Record.size() > 12) {
 3180   if (Record.size() > 13) {
 3186   if (Record.size() > 15)
 3200   if (Record.size() < 8)
 3216   if (Record.size() > 16)
 3259   if (Record.size() > 8 && Record[8]) {
 3265   if (Record.size() > 9)
 3268   if (Record.size() > 10 && Record[10] != 0)
 3271   if (Record.size() > 11)
 3276   if (Record.size() > 12) {
 3286   if (Record.size() > 13 && Record[13] != 0)
 3289   if (Record.size() > 14 && Record[14] != 0)
 3292   if (Record.size() > 15) {
 3300   if (Record.size() > 18)
 3332   if (Record.size() < (3 + (unsigned)NewRecord))
 3366   if (OpNum != Record.size()) {
 3374     if (OpNum != Record.size())
 3378     if (OpNum != Record.size())
 3380     if (OpNum != Record.size())
 3383   if (OpNum != Record.size())
 3388   if (OpNum + 1 < Record.size()) {
 5609           if (GVRecord.size() <= 3)
 5631   Ret.reserve(Record.size());
 5642   Ret.reserve(Record.size());
 5643   for (unsigned I = 0, E = Record.size(); I != E; ++I) {
 5706   while (Slot < Record.size())
 5727   while (Slot < Record.size())
 6338     if (BCBegin + 8 >= Stream.getBitcodeBytes().size())

  551     auto N = Expr.size();
  563         if (Expr.size() >= 3 &&
  596         HistoricSize = std::min(SubExpr.size(), HistoricSize);
 1929   if (Record.size() != 2)
 1963   assert(Record.size() % 2 == 0);
 1964   for (unsigned I = 0, E = Record.size(); I != E; I += 2) {

 1874   Record.reserve(N->getElements().size() + 1);
 1974   Record.push_back(Strings.size());
 2071   if (VE.getNonMDStrings().size() > IndexThreshold) {
 2087   IndexPos.reserve(VE.getNonMDStrings().size());
 2092   if (VE.getNonMDStrings().size() > IndexThreshold) {
 3650   NameVals.push_back(FS->refs().size());
 3698     NameVals.push_back(VS->refs().size());

   86       assert(ID <= MDs.size() && "Expected valid ID");

  640   RenameOrder.insert(RenameOrderType::value_type(SuperRC, Order.size()));
  643   unsigned EndR = ((OrigR == Order.size()) ? 0 : OrigR);
  646     if (R == 0) R = Order.size();

   60       Limit = Order.size();

  322       if (ValLoc.size() >= InsertLoc.size() &&
  327         ValLoc.resize(ValLoc.size() - InsertLoc.size());

  172                8 + (Atoms.size() * 4)),
  267   for (size_t i = 0, e = Buckets.size(); i < e; ++i) {
  311   for (size_t i = 0, e = Buckets.size(); i < e; ++i) {
  331   for (size_t i = 0, e = Buckets.size(); i < e; ++i) {
  415   if (CompUnits.size() > 1) {
  416     size_t LargestCUIndex = CompUnits.size() - 1;
  520       Header(CompUnits.size(), Contents.getBucketCount(),
  555   SmallVector<unsigned, 1> CUIndex(CUs.size());

 1881   ProcedureRecord Procedure(ReturnTypeIndex, CC, FO, ArgTypeIndices.size(),

  189     if (GlobalExprs.size() == 1 && Expr && Expr->isConstant()) {

 1470       dbgs() << CurEntry->getValues().size() << " Values:\n";
 1852   size_t NumAbstractScopes = LScopes.getAbstractScopesList().size();
 1871       assert(LScopes.getAbstractScopesList().size() == NumAbstractScopes
 2146                                     DebugLocs.getBytes(Entry).size()),
 2252     Asm->EmitULEB128(DebugLocs.getBytes(Entry).size());
 2253   else if (DebugLocs.getBytes(Entry).size() <= std::numeric_limits<uint16_t>::max())
 2254     Asm->emitInt16(DebugLocs.getBytes(Entry).size());

 1613   assert(Libcalls.size() == 6);

  398   for (unsigned i = 0; i != Order.size(); ++i) {

  115   if (DstOps.size() == 1)
  129   if (DstOps.size() == 1) {
  158     assert(SrcOps.size() == 2 && "Invalid sources");
  159     assert(DstOps.size() == 1 && "Invalid dsts");
  166     assert(DstOps.size() == 1 && "Invalid dst ops");
  167     assert(SrcOps.size() == 2 && "Invalid src ops");

  128   assert(SrcRegs.size() > 1 && "Nothing to pack");
  138   assert(LLTs.size() == SrcRegs.size() && "Regs / types mismatch");
  142   for (unsigned i = 0; i < SrcRegs.size(); ++i) {
  154   assert(DstRegs.size() > 1 && "Nothing to unpack");
  161   assert(LLTs.size() == DstRegs.size() && "Regs / types mismatch");
  163   for (unsigned i = 0; i < DstRegs.size(); ++i)

  877     assert(Regs.size() == 1 && "swifterror should be single pointer");
  885       Regs.size() == 1 ? LI.getMetadata(LLVMContext::MD_range) : nullptr;
  886   for (unsigned i = 0; i < Regs.size(); ++i) {
  919     assert(Vals.size() == 1 && "swifterror should be single pointer");
  927   for (unsigned i = 0; i < Vals.size(); ++i) {
 1013   for (unsigned i = 0; i < ResRegs.size(); ++i) {
 1645       if (VRegs.size() > 1)
 2070         for (unsigned j = 0; j < ValRegs.size(); ++j) {
 2305       assert(VRegs.size() == 1 && "Too many vregs for Swift error");

  229   for (unsigned I = 0, E = LeftoverRegs.size(); I != E; ++I) {
 3354   unsigned SrcParts = Src1Regs.size();

  462   for (unsigned i = 0; i < Query.Types.size(); ++i) {

  538   assert(Ops.size() == Indices.size() && "incompatible args");
  538   assert(Ops.size() == Indices.size() && "incompatible args");
  552   for (unsigned i = 0; i < Ops.size(); ++i) {
  559   if (MaybeMerge && Ops.size() * OpSize == ResTy.getSizeInBits()) {
  567   for (unsigned i = 0; i < Ops.size(); ++i) {
  568     Register ResOut = i + 1 == Ops.size()
  961     assert(DstOps.size() == 1 && "Invalid select");
  962     assert(SrcOps.size() == 3 && "Invalid select");
  983     assert(DstOps.size() == 1 && "Invalid Dst");
  984     assert(SrcOps.size() == 2 && "Invalid Srcs");
  993     assert(DstOps.size() == 1 && "Invalid Dst");
  994     assert(SrcOps.size() == 2 && "Invalid Srcs");
 1003     assert(DstOps.size() == 1 && "Invalid Dst");
 1004     assert(SrcOps.size() == 1 && "Invalid Srcs");
 1010     assert(DstOps.size() == 1 && "Invalid Dst");
 1011     assert(SrcOps.size() == 1 && "Invalid Srcs");
 1017     assert(DstOps.size() == 1 && "Invalid Dst");
 1023     assert(DstOps.size() == 1 && "Invalid Dst Operands");
 1024     assert(SrcOps.size() == 3 && "Invalid Src Operands");
 1049     assert(SrcOps.size() == 1 && "Invalid src for Unmerge");
 1056     assert(DstOps.size() * DstOps[0].getLLTTy(*getMRI()).getSizeInBits() ==
 1063     assert(DstOps.size() == 1 && "Invalid Dst");
 1070     assert(SrcOps.size() * SrcOps[0].getLLTTy(*getMRI()).getSizeInBits() ==
 1073     if (SrcOps.size() == 1)
 1083     assert(DstOps.size() == 1 && "Invalid Dst size");
 1084     assert(SrcOps.size() == 2 && "Invalid Src size");
 1096     assert(DstOps.size() == 1 && "Invalid dst size");
 1097     assert(SrcOps.size() == 3 && "Invalid src size");
 1110     assert((!SrcOps.empty() || SrcOps.size() < 2) &&
 1112     assert(DstOps.size() == 1 && "Invalid DstOps");
 1121     assert(SrcOps.size() * SrcOps[0].getLLTTy(*getMRI()).getSizeInBits() ==
 1127     assert((!SrcOps.empty() || SrcOps.size() < 2) &&
 1129     assert(DstOps.size() == 1 && "Invalid DstOps");
 1144     assert(DstOps.size() == 1 && "Invalid DstOps");
 1145     assert((!SrcOps.empty() || SrcOps.size() < 2) &&
 1154     assert(SrcOps.size() * SrcOps[0].getLLTTy(*getMRI()).getSizeInBits() ==
 1160     assert(DstOps.size() == 2 && "Invalid no of dst operands");
 1161     assert(SrcOps.size() == 3 && "Invalid no of src operands");

  196     for (unsigned i = 0, e = RegMaskSlots.size();
  253   for (unsigned i = RegMaskSlots.size();

  149     for (; i < Mask.size(); i++)
  153     if (i == Mask.size())
  168   if (Mask.size() < 2)
  174     if (Mask.size() * Factor > NumLoadElements)
  196   unsigned NumElts = Mask.size();

 1019   for (unsigned i = 0; i != NewRegs.size(); ++i) {
 1142       for (unsigned i = 0; i != NewRegs.size(); ++i)

  421     for (unsigned i = 0, e = RegsBeingSpilled.size(); i != e; ++i) {

  159   assert(RegMasks.size() == RegMaskNames.size());
  159   assert(RegMasks.size() == RegMaskNames.size());
  160   for (size_t I = 0, E = RegMasks.size(); I < E; ++I)
 1359   for (unsigned I = 0, E = Operands.size(); I != E; ++I) {

  702   for (unsigned N = TyInfo.size(); N; --N)
  709   std::vector<unsigned> IdsInFilter(TyInfo.size());
  710   for (unsigned I = 0, E = TyInfo.size(); I != E; ++I)

  328       MMOs.size() + HasPreInstrSymbol + HasPostInstrSymbol + HasHeapAllocMarker;
  407   if (LHS.size() != RHS.size())
  407   if (LHS.size() != RHS.size())
  423   if (MIs.size() == 1) {

  332       CurrNode.SuffixIdx = Str.size() - CurrNodeLen;

  383   assert(L.getBlocks().size() == 1 && "SMS works on single blocks only.");

  870       for (unsigned K = 0; K != PRDepths.size(); ++K)
  986   for (unsigned i = Trace.size(); i; --i) {
 1054       for (unsigned K = 0; K != PRHeights.size(); ++K)
 1203     for (unsigned K = 0; K != PRDepths.size(); ++K)
 1206     for (unsigned K = 0; K != PRDepths.size(); ++K)
 1253   for (unsigned K = 0; K != PRDepths.size(); ++K) {
 1269   Instrs += ExtraInstrs.size();
 1270   Instrs -= RemoveInstrs.size();

   42   assert(BCOSs.empty() || BCOSs.size() == OSs.size());
   42   assert(BCOSs.empty() || BCOSs.size() == OSs.size());
   44   if (OSs.size() == 1) {
   54     ThreadPool CodegenThreadPool(OSs.size());
   58         std::move(M), OSs.size(),

 1118   unsigned OrderLimit = Order.getOrder().size();
 1191   SplitConstraints.resize(UseBlocks.size());
 1193   for (unsigned i = 0; i != UseBlocks.size(); ++i) {
 1266   for (unsigned i = 0; i != Blocks.size(); ++i) {
 1324     for (int i = 0, e = NewBundles.size(); i != e; ++i) {
 1417   for (unsigned i = 0; i != UseBlocks.size(); ++i) {
 1590   for (unsigned i = 0; i != UseBlocks.size(); ++i) {
 1694   for (unsigned i = 0; i != UseBlocks.size(); ++i) {
 1738   for (unsigned c = 0; c != UsedCands.size(); ++c) {
 1740     for (unsigned i = 0, e = Blocks.size(); i != e; ++i) {
 2027   for (unsigned i = 0; i != UseBlocks.size(); ++i) {
 2099   if (Uses.size() <= 1)
 2102   LLVM_DEBUG(dbgs() << "Split around " << Uses.size()
 2112   for (unsigned i = 0; i != Uses.size(); ++i) {
 2153   assert(SA->getUseBlocks().size() == 1 && "Not a local interval");
 2156   const unsigned NumGaps = Uses.size()-1;
 2233   if (SA->getUseBlocks().size() != 1)
 2246   if (Uses.size() <= 2)
 2248   const unsigned NumGaps = Uses.size()-1;
 2252     for (unsigned i = 0, e = Uses.size(); i != e; ++i)
 2263     LLVM_DEBUG(dbgs() << RMS.size() << " regmasks in block:");
 2267     unsigned re = RMS.size();

  613     for (unsigned I = 0; I != RawPRegOrder.size(); ++I) {

   65     assert(RegMask.size() ==

  110   for (unsigned i = 0; i != RawOrder.size(); ++i) {

 3491   for (unsigned i = 0, e = CurrList.size(); i != e; ++i) {

   84   for (unsigned i = 0, e = SetPressure.size(); i < e; ++i) {
  964   for (unsigned i = 0, e = OldPressureVec.size(); i < e; ++i) {
 1005   unsigned CritIdx = 0, CritEnd = CriticalPSets.size();
 1006   for (unsigned i = 0, e = OldMaxPressureVec.size(); i < e; ++i) {
 1165   unsigned CritIdx = 0, CritEnd = CriticalPSets.size();

  119       : F(F), Allocas(Allocas), NumAllocas(Allocas.size()) {}

  751   return ((DAGCombiner*)DC)->CombineTo(N, &To[0], To.size(), AddTo);
18698   assert(ShufMask.size() == SplatMask.size() && "Mask length mismatch");
18698   assert(ShufMask.size() == SplatMask.size() && "Mask length mismatch");
18718     for (unsigned i = 0, e = UserMask.size(); i != e; ++i)
18743   int MaskSize = Mask.size();
18791   assert(Mask[ShufOp0Index] >= 0 && Mask[ShufOp0Index] < (int)Mask.size() &&
18828   for (int i = 0, e = (int)Mask.size(); i != e; ++i) {

 1324   for (unsigned i = 1, e = LiveRegDefs.size()-1; i != e; ++i) {

 1571   assert(VT.getVectorNumElements() == Mask.size() &&
 1582   int NElts = Mask.size();
 2497     assert(NumElts == SVN->getMask().size() && "Unexpected vector size");
 3465     assert(NumElts == SVN->getMask().size() && "Unexpected vector size");
 4154   int NumOps = Ops.size();
 4194   assert((Ops.size() * Ops[0].getValueType().getVectorNumElements()) ==
 4198   if (Ops.size() == 1)
 4210   for (unsigned i = 0, e = Ops.size(); i != e; ++i) {
 4777     assert(Ops.size() == 2 && "Div/rem should have 2 operands");
 6554   if (Ops.size() == 1)
 6558   VTs.reserve(Ops.size());
 6559   for (unsigned i = 0; i < Ops.size(); ++i)
 7026   assert(Ops.size() == 6 && "Incompatible number of operands");
 7067   assert(Ops.size() == 6 && "Incompatible number of operands");
 7188   switch (Ops.size()) {
 7204   unsigned NumOps = Ops.size();
 7423   unsigned NumVTs = VTs.size();
 7524   unsigned NumOps = Ops.size();
 7572   if (NewMemRefs.size() == 1) {
 7579       Allocator.template Allocate<MachineMemOperand *>(NewMemRefs.size());
 7582   N->NumMemRefs = static_cast<int>(NewMemRefs.size());
 9564   assert(SDNode::getMaxNumOperands() >= Vals.size() &&
 9567       ArrayRecycler<SDUse>::Capacity::get(Vals.size()), OperandAllocator);
 9570   for (unsigned I = 0; I != Vals.size(); ++I) {
 9576   Node->NumOperands = Vals.size();

 8501     assert(ResultValues.size() == ResultTypes.size() &&

  743       OS << " [NoOfDbgValues=" << G->GetDbgValues(this).size() << ']';

  545   const int NumVMSArgs = SI.DeoptState.size();

  127   Args.reserve(Ops.size());
  130   for (unsigned i = 0; i < Ops.size(); ++i) {

  242   if (bundles->getBlocks(n).size() > 100) {

  213     return getUseBlocks().size() - NumGapBlocks + getNumThroughBlocks();

  602   if (!MI.isCopy() || Ops.size() != 1)

  213   for (unsigned i = 0; i != Order.size(); ++i)

   80   uint8_t *Stable = RecordStorage.Allocate<uint8_t>(Record.size());
   81   memcpy(Stable, Record.data(), Record.size());
   82   Record = ArrayRef<uint8_t>(Stable, Record.size());

  105     incrStreamedLen(Bytes.size());

  159   Prefix->RecordLen = Data.size() - sizeof(RecordPrefix::RecordLen);

   72     uint8_t *Copy = Storage.Allocate<uint8_t>(Bytes.size());
   73     ::memcpy(Copy, Bytes.data(), Bytes.size());
   74     Entry.Checksum = makeArrayRef(Copy, Bytes.size());
   86   uint32_t Len = alignTo(sizeof(FileChecksumEntryHeader) + Bytes.size(), 4);
   98     Header.ChecksumSize = FC.Checksum.size();

   29   assert(Item.size() == 16 && "Expected 16-byte GUID");

   90   return insertRecordAs(GHT, Record.size(),
   92                           assert(Data.size() == Record.size());
   92                           assert(Data.size() == Record.size());
   93                           ::memcpy(Data.data(), Record.data(), Record.size());

   85   uint8_t *Stable = Alloc.Allocate<uint8_t>(Data.size());
   86   memcpy(Stable, Data.data(), Data.size());
   87   return makeArrayRef(Stable, Data.size());
   92   assert(Record.size() < UINT32_MAX && "Record too big");
   93   assert(Record.size() % 4 == 0 && "Record is not aligned to 4 bytes!");

   77   uint32_t Size = Indices.size();
   93   uint32_t Size = Indices.size();

   29                    LeafData.size());

   91   EndOffset += Closer.RecordData.size();

  226   uint32_t Size = Indices.size();
  237   uint32_t Size = Indices.size();
  426   W->printNumber("NumArgs", static_cast<uint32_t>(Args.getArgs().size()));
  461   W->printNumber("Length", uint32_t(Record.content().size()));

   61         if (TI.toArrayIndex() >= Prev.size() ||

  456     Size = Slots.size();
  459     for (size_t SlotIndex = 0; SlotIndex < Slots.size(); SlotIndex += 2) {
  461       if ((SlotIndex + 1) < Slots.size()) {

  153     if (LLVM_UNLIKELY(MapPos >= Map.size() || Map[MapPos] == Untranslated))
  237   if (IsSecondPass && MapPos >= Map.size()) {
  381       DestIdx = Dest.insertRecordAs(H, Type.RecordData.size(), DoSerialize);
  386       RemapStorage.resize(Type.RecordData.size());
  409            OriginalType.RecordData.size());

   20   Names.resize(Records.size());
   38   assert(Index.toArrayIndex() < Records.size());
   58 uint32_t TypeTableCollection::size() { return Records.size(); }
   60 uint32_t TypeTableCollection::capacity() { return Records.size(); }

  310         if (!Value.getAsBlock() || Value.getAsBlock().getValue().size() != 16)

   87     DataExtractor Data(StringRef((const char *)Expr.data(), Expr.size()),

   95   V.uval = D.size();
  208   if (Form < makeArrayRef(DWARF5FormClasses).size() &&

  846   uint32_t NumAtoms = AccelTable.getAtomsDesc().size();

   60   OS.write(reinterpret_cast<const char *>(Data.data()), Data.size());

  221   const auto NumAddrInfoOffsets = AddrInfoOffsets.size();
  250   assert(*AddressIndex < AddrInfoOffsets.size());

  160   if (ReqBlocks != Blocks.size())
  369   if (auto EC = DW.writeInteger<uint32_t>(Layout.StreamSizes.size()))

  101       if (Entry.size() >= Size) {
  131         std::make_pair(CacheItem.first, CacheItem.first + CachedAlloc.size());
  245   if (auto EC = checkOffsetForRead(Offset, Buffer.size()))
  248   uint32_t BytesLeft = Buffer.size();
  283     if (Offset + Data.size() < MapEntry.first)
  288       if (MapEntry.first + Alloc.size() < Offset)
  292       Interval WriteInterval = std::make_pair(Offset, Offset + Data.size());
  294           std::make_pair(MapEntry.first, MapEntry.first + Alloc.size());
  390   if (auto EC = checkOffsetForWrite(Offset, Buffer.size()))
  396   uint32_t BytesLeft = Buffer.size();

   80   assert(BulkSymbols.size() % alignOf(CodeViewContainer::Pdb) == 0 &&
   82   SymbolByteSize += BulkSymbols.size();

   94   DbgStreams[(int)Type]->Size = Data.size();
  154   return sizeof(SecMapHeader) + sizeof(SecMapEntry) * SectionMap.size();
  165     NumFileInfos += M->source_files().size();
  211     FileCount = static_cast<uint16_t>(MI->source_files().size());
  416     ulittle16_t Size = static_cast<ulittle16_t>(SectionMap.size());

  252   DeserializedPublics.reserve(Records.size());
  253   PublicsByAddr.reserve(Records.size());
  254   SymOffsets.reserve(Records.size());
  269   AddrMap.reserve(Records.size());
  272     assert(Idx >= 0 && size_t(Idx) < Records.size());

   63       Buffer.size() / sizeof(ulittle32_t));
   69   Buffer = Buffer.slice(Items.size() * sizeof(ulittle32_t));

   29     Offset += Data.size();

   85   return ContainerLayout.StreamSizes.size();

   47   size_t NewSize = TypeRecordBytes + Record.size();

  261   VirtualBases = makeArrayRef(AllBases).drop_front(NonVirtualBases.size());

  284   return !memcmp(dbg_uuid.data(), bin_uuid.data(), dbg_uuid.size());

 2125           ECStack.back().Caller.arg_size() == ArgVals.size()) &&
 2145   assert((ArgVals.size() == F->arg_size() ||
 2146          (ArgVals.size() > F->arg_size() && F->getFunctionType()->isVarArg()))&&

  312   assert(Args.size() == 1);
  431   assert(args.size() < 10 && "Only handle up to 10 args to sscanf right now!");
  434   for (unsigned i = 0; i < args.size(); ++i)
  445   assert(args.size() < 10 && "Only handle up to 10 args to scanf right now!");
  448   for (unsigned i = 0; i < args.size(); ++i)
  461   assert(Args.size() >= 2);

   93       ArgValues.slice(0, std::min(ArgValues.size(), ArgCount));

  164                << (const void *)((char *)SegMem.data() + SegMem.size())
  225                << (const void *)((char *)SegMem.data() + SegMem.size()) << "\n";
  227       while (LastBlockEnd != SegMem.data() + SegMem.size())

  516   assert((FTy->getNumParams() == ArgValues.size() ||
  517           (FTy->isVarArg() && FTy->getNumParams() <= ArgValues.size())) &&
  519   assert(FTy->getNumParams() == ArgValues.size() &&
  525     switch (ArgValues.size()) {

 2099   FullSearchOrder.reserve(SearchOrder.size());

   35   assert((FTy->getNumParams() == ArgValues.size() ||
   36           (FTy->isVarArg() && FTy->getNumParams() <= ArgValues.size())) &&
   38   assert(FTy->getNumParams() == ArgValues.size() &&
   44     switch (ArgValues.size()) {

 1536       for (unsigned i = 0, e = Indices.size(); i != e; ++i)

  720     : NumAttrs(Attrs.size()) {
  905     : Context(C), NumAttrSets(Sets.size()) {
  962         AttributeListImpl::totalSizeToAlloc<AttributeSet>(AttrSets.size()));
 1029   if (MaxIndex == FunctionIndex && Attrs.size() > 1)
 1030     MaxIndex = Attrs[Attrs.size() - 2].first;
 1046   for (size_t I = ArgAttrs.size(); I != 0; --I) {
 1110   if (Attrs.size() == 1)

  552                                           StoreInts[fArgs.size() - 3], Tys);
  555                                           StoreLaneInts[fArgs.size() - 5], Tys);

 2141   for (unsigned i = 1, e = Idxs.size(); i != e; ++i)
 2171       PointeeTy, C, makeArrayRef((Value *const *)Idxs.data(), Idxs.size()));
 2177   if (Idxs.size() == 1 && (Idx0->isNullValue() || isa<UndefValue>(Idx0)))
 2185     for (unsigned i = 0, e = Idxs.size(); i != e; ++i)
 2203       for (unsigned i = 0, e = Idxs.size(); i != e; ++i) {
 2258         NewIndices.reserve(Idxs.size() + CE->getNumOperands());
 2310     if (CE->isCast() && Idxs.size() > 1 && Idx0->isNullValue()) {
 2337   for (unsigned i = 1, e = Idxs.size(); i != e;
 2396     NewIdxs.resize(Idxs.size());
 2454     for (unsigned i = 0, e = Idxs.size(); i != e; ++i)

  995     : Constant(T, VT, OperandTraits<ConstantAggregate>::op_end(this) - V.size(),
  996                V.size()) {
 1003   for (unsigned I = 0, E = V.size(); I != E; ++I)
 1010   assert(V.size() == T->getNumElements() &&
 1025   for (unsigned i = 0, e = V.size(); i != e; ++i) {
 1052   unsigned VecSize = V.size();
 1070   assert((T->isOpaque() || V.size() == T->getNumElements()) &&
 1076   assert((ST->isOpaque() || ST->getNumElements() == V.size()) &&
 1087       for (unsigned i = 0, e = V.size(); i != e; ++i) {
 1105   assert(V.size() == T->getNumElements() &&
 1113   VectorType *Ty = VectorType::get(V.front()->getType(), V.size());
 1119   VectorType *T = VectorType::get(V.front()->getType(), V.size());
 1128     for (unsigned i = 1, e = V.size(); i != e; ++i)
 1239   assert(Ops.size() == getNumOperands() && "Operand count mismatch!");
 2042   ArgVec.reserve(1 + Idxs.size());
 2044   for (unsigned i = 0, e = Idxs.size(); i != e; ++i) {
 2412                        (IdxList.size() + 1),
 2413                    IdxList.size() + 1),
 2418   for (unsigned i = 0, E = IdxList.size(); i != E; ++i)
 2562   Type *Ty = ArrayType::get(Type::getHalfTy(Context), Elts.size());
 2564   return getImpl(StringRef(Data, Elts.size() * 2), Ty);
 2568   Type *Ty = ArrayType::get(Type::getFloatTy(Context), Elts.size());
 2570   return getImpl(StringRef(Data, Elts.size() * 4), Ty);
 2574   Type *Ty = ArrayType::get(Type::getDoubleTy(Context), Elts.size());
 2576   return getImpl(StringRef(Data, Elts.size() * 8), Ty);
 2596   Type *Ty = VectorType::get(Type::getInt8Ty(Context), Elts.size());
 2598   return getImpl(StringRef(Data, Elts.size() * 1), Ty);
 2601   Type *Ty = VectorType::get(Type::getInt16Ty(Context), Elts.size());
 2603   return getImpl(StringRef(Data, Elts.size() * 2), Ty);
 2606   Type *Ty = VectorType::get(Type::getInt32Ty(Context), Elts.size());
 2608   return getImpl(StringRef(Data, Elts.size() * 4), Ty);
 2611   Type *Ty = VectorType::get(Type::getInt64Ty(Context), Elts.size());
 2613   return getImpl(StringRef(Data, Elts.size() * 8), Ty);
 2616   Type *Ty = VectorType::get(Type::getFloatTy(Context), Elts.size());
 2618   return getImpl(StringRef(Data, Elts.size() * 4), Ty);
 2621   Type *Ty = VectorType::get(Type::getDoubleTy(Context), Elts.size());
 2623   return getImpl(StringRef(Data, Elts.size() * 8), Ty);
 2633   Type *Ty = VectorType::get(Type::getHalfTy(Context), Elts.size());
 2635   return getImpl(StringRef(Data, Elts.size() * 2), Ty);
 2639   Type *Ty = VectorType::get(Type::getFloatTy(Context), Elts.size());
 2641   return getImpl(StringRef(Data, Elts.size() * 4), Ty);
 2645   Type *Ty = VectorType::get(Type::getDoubleTy(Context), Elts.size());
 2647   return getImpl(StringRef(Data, Elts.size() * 8), Ty);

  245     GetElementPtrConstantExpr *Result = new (IdxList.size() + 1)
  393     if (Operands.size() != C->getNumOperands())
  395     for (unsigned I = 0, E = Operands.size(); I != E; ++I)
  408     return new (Operands.size()) ConstantClass(Ty, Operands);
  510     if (Ops.size() != CE->getNumOperands())
  514     for (unsigned I = 0, E = Ops.size(); I != E; ++I)

 2967     return CE->getIndices().size();

  613   for (unsigned i = 0, e = Elements.size(); i != e; ++i) {

   30   assert((MDs.size() == 1 || MDs.size() == 2) &&
   30   assert((MDs.size() == 1 || MDs.size() == 2) &&
  278   return storeImpl(new (DwarfOps.size() + 1) GenericDINode(

  813     unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
  818     unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
  824     unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
  830     unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
  836     unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
  842     unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
  848     unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
  853     unsigned short ArgNo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
  854     unsigned short RefNo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
  876     unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
  882     unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
  888     unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
  900     unsigned ArgInfo = (NextElt == Infos.size() ? 0 : Infos[NextElt++]);
  942   while (NextElt != IITEntries.size() && IITEntries[NextElt] != 0)
 1377   if (Infos.size() != 1)

  588   Args.push_back(B.getInt32(CallArgs.size()));
  591   Args.push_back(B.getInt32(TransitionArgs.size()));
  593   Args.push_back(B.getInt32(DeoptArgs.size()));

  388   assert(getNumOperands() == Args.size() + CountBundleInputs(Bundles) + 1 &&
  393   assert((Args.size() == FTy->getNumParams() ||
  394           (FTy->isVarArg() && Args.size() > FTy->getNumParams())) &&
  397   for (unsigned i = 0; i != Args.size(); ++i)
  405   auto It = populateBundleOperandInfos(Bundles, Args.size());
  723              ComputeNumOperands(Args.size(), CountBundleInputs(Bundles)) &&
  730   assert(((Args.size() == FTy->getNumParams()) ||
  731           (FTy->isVarArg() && Args.size() > FTy->getNumParams())) &&
  734   for (unsigned i = 0, e = Args.size(); i != e; i++)
  742   auto It = populateBundleOperandInfos(Bundles, Args.size());
  791              ComputeNumOperands(Args.size(), IndirectDests.size(),
  791              ComputeNumOperands(Args.size(), IndirectDests.size(),
  794   NumIndirectDests = IndirectDests.size();
  801   assert(((Args.size() == FTy->getNumParams()) ||
  802           (FTy->isVarArg() && Args.size() > FTy->getNumParams())) &&
  805   for (unsigned i = 0, e = Args.size(); i != e; i++)
  813   auto It = populateBundleOperandInfos(Bundles, Args.size());
  815   assert(It + 2 + IndirectDests.size() == op_end() && "Should add up!");
 1076   assert(getNumOperands() == 1 + Args.size() && "NumOperands not set up?");
 1599   assert(getNumOperands() == 1 + IdxList.size() &&
 1638   for (; CurIdx != IdxList.size(); ++CurIdx) {
 1645   return CurIdx == IdxList.size() ? Agg : nullptr;
 1920   for (int i = 0, NumMaskElts = Mask.size(); i < NumMaskElts; ++i) {
 1937   return isSingleSourceMaskImpl(Mask, Mask.size());
 1943   for (int i = 0, NumMaskElts = Mask.size(); i < NumMaskElts; ++i) {
 1955   return isIdentityMaskImpl(Mask, Mask.size());
 1961   for (int i = 0, NumElts = Mask.size(); i < NumElts; ++i) {
 1973   for (int i = 0, NumElts = Mask.size(); i < NumElts; ++i) {
 1986   for (int i = 0, NumElts = Mask.size(); i < NumElts; ++i) {
 2003   int NumElts = Mask.size();
 2036   if (NumSrcElts <= (int)Mask.size())
 2041   for (int i = 0, e = Mask.size(); i != e; ++i) {

  234     if (Ops.size() != RHS->getNumOperands() - Offset)

   43   assert(Weights.size() >= 1 && "Need at least one branch weights!");
   45   SmallVector<Metadata *, 4> Vals(Weights.size() + 1);
   49   for (unsigned i = 0, e = Weights.size(); i != e; ++i)
  202   SmallVector<Metadata *, 4> Vals(Fields.size() * 3);
  204   for (unsigned i = 0, e = Fields.size(); i != e; ++i) {
  216   SmallVector<Metadata *, 4> Ops(Fields.size() * 2 + 1);
  219   for (unsigned i = 0, e = Fields.size(); i != e; ++i) {
  251   SmallVector<Metadata *, 4> Ops(3 + Fields.size() * 3);
  256   for (unsigned I = 0, E = Fields.size(); I != E; ++I) {

  505     : Metadata(ID, Storage), NumOperands(Ops1.size() + Ops2.size()),
  505     : Metadata(ID, Storage), NumOperands(Ops1.size() + Ops2.size()),
  826   return storeImpl(new (MDs.size()) MDTuple(Context, Storage, Hash, MDs),
  885       if (N->getNumOperands() == Ops.size() && N == N->getOperand(0)) {
  886         for (unsigned I = 1, E = Ops.size(); I != E; ++I)
 1480       std::vector<uint64_t> Elements(OrigElements.size() + 2);

   34   return getSummaryList().size() &&
   43   return getSummaryList().size() &&
   57   for (I = Refs.size() - 1; I >= 0 && Refs[I].isWriteOnly(); --I)
   88   assert((!PerModuleIndex || VI.getSummaryList().size() == 1) &&
  207       if (V.getSummaryList().size())

  290   for (unsigned i = 0, e = Params.size(); i != e; ++i) {
  297   NumContainedTys = Params.size() + 1; // + 1 for result type
  316         sizeof(FunctionType) + sizeof(Type *) * (Params.size() + 1),
  380   NumContainedTys = Elements.size();

 2995       Assert(BU.Inputs.size() == 1,
 3004       Assert(BU.Inputs.size() == 1,

  670   return input->getDependentLibraries().size();

   54     if (V.getSummaryList().size()) {
   63     if (!V.getSummaryList().size())

  761   unsigned Index = FileNames.size() + 1;

  220       CurrentOffset += File.Checksum.size();
  232     OS.EmitIntValue(static_cast<uint8_t>(File.Checksum.size()), 1);
  629   for (size_t I = 0, E = Frag.getRanges().size(); I != E;) {

  503   MCOS->EmitIntValue(StandardOpcodeLengths.size() + 1, 1);

  520   for (ReadCount = 0; ReadCount < Buf.size(); ++ReadCount) {

 2395   unsigned NParameters = Parameters.size();
 2397   if ((!IsDarwin || NParameters != 0) && NParameters != A.size())
 2439         OS << A.size();
 2446         if (Index >= A.size())
 4509   unsigned NParameters = Parameters.size();

   91   if (Vec.size() <= 1)
   99   size_t J = Vec.size();

  682   encodeULEB128(Signatures.size(), W.OS);
  708   encodeULEB128(Imports.size(), W.OS);
  750   encodeULEB128(Functions.size(), W.OS);
  764   encodeULEB128(Events.size(), W.OS);
  780   encodeULEB128(Exports.size(), W.OS);
  805   encodeULEB128(TableElems.size(), W.OS);
  832   encodeULEB128(Functions.size(), W.OS);
  938   if (SymbolInfos.size() != 0) {
  940     encodeULEB128(SymbolInfos.size(), W.OS);
  987     encodeULEB128(InitFuncs.size(), W.OS);

   43   assert(Masks.size() == SM.getNumProcResourceKinds() &&

  513   if (InfoBytes.size() < sizeof(*PDBInfo) + 1)
  518                           InfoBytes.size());
 1770   Relocs.reserve(OrigRelocs.size());
 1836     if (Offset + Entry.DataSize > Contents.size())

   96   size_t Size = Buffer.size();

  359   if (ContentsOrErr->size() < 4 || Cur[0] != 'A' || Cur[1] != 'P' ||

   63                                       SymTab.symbols().size());

  130   Mod.End = Syms.size() + Msymtab.symbols().size();

   89   if (ListOffset + sizeof(T) * ListSize < Stream->size())
  105       Offset + Size > Data.size())

  290   Ctx.End = Ctx.Start + Sec.Content.size();
  559         if (Offset + Size > DataSegments[Index].Data.Content.size())
  757   uint32_t EndOffset = Section.Content.size();
 1424   return S.Content.size();

  175   EndianCorrectedSrc.resize(Src.size() + 1);
  666   FileSize += Data.size() * COFF::Symbol16Size; // 1 symbol per resource.
  688       Data.size() * COFF::RelocationSize; // one relocation for each resource.
  736   Header->NumberOfSymbols = Data.size() + 5;
  754   SectionOneHeader->NumberOfRelocations = Data.size();
  823   Aux->NumberOfRelocations = Data.size();
  850   for (unsigned i = 0; i < Data.size(); i++) {
  939   RelocationAddresses.resize(Data.size());
  976   for (unsigned i = 0; i < Data.size(); i++) {

   49   assert(DebugH.size() >= 8);
   50   assert((DebugH.size() - 8) % 8 == 0);

  195   return A.size() * sizeof(T);
  467   for (size_t I = 0; I < Symbols.size(); ++I)
  470   return Symbols.size();
  494   Ret.resize(Symbols.size() + 1);
 1111     for (size_t I = 0, S = V.size(); I < S; ++I) {

   43         Data.size(), [Data](raw_ostream &OS) { OS << toStringRef(Data); });
   54                           sizeof(T) * Data.size()});

  554   Streams.reserve(File.streams().size());

   42     OS.write((const char *)Data.data(), Data.size());
   45   for (unsigned I = 0, N = Data.size(); I != N; I += 2) {
   57     OS.write((const char *)Data.data(), Data.size());

  402   unsigned Index = 0, End = ArgArr.size();

  144     if (C.getExpressionID() >= Expressions.size())
  170     if (C.getCounterID() >= CounterValues.size())
  174     if (C.getExpressionID() >= Expressions.size())
  229     Counts.assign(Record.MappingRegions.size(), 0);
  240   if (Record.MappingRegions.size() == 1 &&
  487         const bool Skipped = (CR.index() + 1) == Regions.size();
  492       if (CR.index() + 1 == Regions.size() ||
  750   for (unsigned I = 0; I < LineSegments.size() && MinRegionCount < 2; ++I)

  260     if (auto Err = readIntMax(FilenameIndex, TranslationUnitFilenames.size()))

   38   encodeULEB128(Filenames.size(), OS);
   58     AdjustedExpressionIDs.resize(Expressions.size(), 0);
  147   encodeULEB128(VirtualFileMapping.size(), OS);
  154   encodeULEB128(MinExpressions.size(), OS);
  215   assert(CurrentFileID == (VirtualFileMapping.size() - 1));

  387                  .count(getInstrProfNameSeparator()) == (NameStrs.size() - 1) &&

  432     Record.Counts.reserve(RawCounts.size());
  875   for (unsigned I = 0, E = Data.size(); I < E; ++I) {
  903   if (RecordIndex >= Data.size()) {

  328   uint32_t NumEntries = ProfileSummaryBuilder::DefaultCutoffs.size();

  126   static size_t size(IO &io, ArrayRef<T> &seq) { return seq.size(); }

 2086   assert(dstPartsCount <= parts.size() && "Integer too big");
 2198     assert(dstPartsCount <= parts.size() && "Integer too big");

  100     unsigned words = std::min<unsigned>(bigVal.size(), getNumWords());

  702   while (Offset < Section.size()) {
  712     if (SectionLength == 0 || (SectionLength + Offset) > Section.size()) {

   33   Offset += Buffer.size();
   82     StringRef S(reinterpret_cast<const char *>(Buffer.begin()), Buffer.size());
  126   Dest = StringRef(reinterpret_cast<const char *>(Bytes.begin()), Bytes.size());

   74                           Data.size()) {}
   98   if (Buffer.size() > MaxLength)
  114                           0, Data.size()) {}
  119   if (auto EC = checkOffsetForWrite(Offset, Data.size()))

   31   Offset += Buffer.size();

 1037   return (S.size() >= 3 && S[0] == '\xef' && S[1] == '\xbb' && S[2] == '\xbf');
 1063     Str = StringRef(BufRef.data() + 3, BufRef.size() - 3);

   81   return (S.size() >= 2 &&
   90   if (SrcBytes.size() % 2)
  116   Out.resize(SrcBytes.size() * UNI_MAX_UTF8_BYTES_PER_CODE_POINT + 1);
  139       Src.size() * sizeof(UTF16)), Out);

   83   unsigned long Size = Data.size();
  193   unsigned long Size = Data.size();

  471       std::memset(ToRead.data(), 0, ToRead.size());

   36   int InitialDigits = ((Buffer.size() - 1) % 3) + 1;
   38   S.write(ThisGroup.data(), ThisGroup.size());
   41   assert(Buffer.size() % 3 == 0);

   35   assert(Redirects.empty() || Redirects.size() == 3);
   56   assert(Redirects.empty() || Redirects.size() == 3);
   70   StringRefArgs.reserve(Args.size());

   25   if (Data.size() > 16)
   42     OS << " (" << format_bytes(Data, None, Data.size(), 1, 0, true) << ")\n";

  197     for (unsigned i = 0, e = Ranges.size(); i != e; ++i) {

 1004       sys::RetryAfterSignal(-1, ::read, FD, Buf.data(), Buf.size());
 1014       sys::RetryAfterSignal(-1, ::pread, FD, Buf.data(), Buf.size(), Offset);

  212       assert(Redirects.size() == 3);

  408   const size_t Size = Bytes.size();
  441     for (size_t I = 0; I < Line.size(); ++I, CharsPrinted += 2) {
  466     Bytes = Bytes.drop_front(Line.size());
  467     LineIndex += Line.size();

  137   return xxHash64({(const char *)Data.data(), Data.size()});

   37   for (unsigned i = 1; i < Loc.size(); ++i)

  152   ID.AddInteger(Classes.size());
  336   ID.AddInteger(Range.size());
  352   void *Mem = Allocator.Allocate(totalSizeToAlloc<Init *>(Range.size()),
  354   BitsInit *I = new(Mem) BitsInit(Range.size());
  393   SmallVector<Init *, 16> NewBits(Bits.size());
  395   for (unsigned i = 0, e = Bits.size(); i != e; ++i) {
  506   SmallVector<Init *, 16> NewBits(Bits.size());
  508   for (unsigned i = 0, e = Bits.size(); i != e; ++i) {
  563   ID.AddInteger(Range.size());
  583   void *Mem = Allocator.Allocate(totalSizeToAlloc<Init *>(Range.size()),
  585   ListInit *I = new(Mem) ListInit(Range.size(), EltTy);
  604     Elements.reserve(getValues().size());
  628   Vals.reserve(Elements.size());
 1422   NewBits.reserve(Bits.size());
 1454   if (Elements.size() == 1)
 1458   ListInits.reserve(Elements.size());
 1586   ID.AddInteger(Args.size());
 1603   void *Mem = Allocator.Allocate(totalSizeToAlloc<Init *>(Args.size()),
 1605   VarDefInit *I = new(Mem) VarDefInit(Class, Args.size());
 1632     for (unsigned i = 0, e = TArgs.size(); i != e; ++i) {
 1750   assert(CondRange.size() == ValRange.size() &&
 1750   assert(CondRange.size() == ValRange.size() &&
 1772   assert(CondRange.size() == ValRange.size() &&
 1772   assert(CondRange.size() == ValRange.size() &&
 1783   void *Mem = Allocator.Allocate(totalSizeToAlloc<Init *>(2*CondRange.size()),
 1785   CondOpInit *I = new(Mem) CondOpInit(CondRange.size(), Ty);
 1790                           I->getTrailingObjects<Init *>()+CondRange.size());
 1905   void *Mem = Allocator.Allocate(totalSizeToAlloc<Init *, StringInit *>(ArgRange.size(), NameRange.size()), alignof(BitsInit));
 1905   void *Mem = Allocator.Allocate(totalSizeToAlloc<Init *, StringInit *>(ArgRange.size(), NameRange.size()), alignof(BitsInit));
 1906   DagInit *I = new(Mem) DagInit(V, VN, ArgRange.size(), NameRange.size());
 1906   DagInit *I = new(Mem) DagInit(V, VN, ArgRange.size(), NameRange.size());
 2076     SCs = SCs.drop_back(1 + SC->getSuperClasses().size());

  189     Init *BI = V->getCastTo(BitsRecTy::get(BitList.size()));
  196     for (unsigned i = 0, e = BitList.size(); i != e; ++i) {
  238   if (TArgs.size() < SubClass.TemplateArgs.size())
  246   for (unsigned i = 0, e = TArgs.size(); i != e; ++i) {
  311   if (SMCTArgs.size() < SubMultiClass.TemplateArgs.size())
  318   for (unsigned i = 0, e = SMCTArgs.size(); i != e; ++i) {
 1847     if (ExpectedArgs.size() < Args.size()) {
 1853     for (unsigned i = 0, e = ExpectedArgs.size(); i != e; ++i) {
 2344       if (ArgN >= TArgs.size()) {
 3082     if (TArgs.size() < TemplateVals.size())
 3082     if (TArgs.size() < TemplateVals.size())
 3087     for (unsigned i = 0, e = TArgs.size(); i != e; ++i) {
 3088       if (i < TemplateVals.size()) {

  277     assert(VRegs.size() == SplitEVTs.size() &&

  307     assert(Cond.size() == 1 && "Unknown Cond array format");

  275     assert(Cond.size() == 1 && "Unknown Cond array format");
  287     assert(Cond.size() == 3 && "Unknown Cond array format");
  292     assert(Cond.size() == 3 && "Unknown Cond array format");

 1104   if (Regs.size() == 1)
 1107   assert(Regs.size() >= 2 && Regs.size() <= 4);
 1107   assert(Regs.size() >= 2 && Regs.size() <= 4);
 1115       CurDAG->getTargetConstant(RegClassIDs[Regs.size() - 2], DL, MVT::i32));
 1118   for (unsigned i = 0; i < Regs.size(); ++i) {

 6660   if (M.size() != static_cast<size_t>(NumInputElements))
 8789   assert(Shuffles.size() == Indices.size() &&
 8789   assert(Shuffles.size() == Indices.size() &&
 8856     for (unsigned i = 0; i < Shuffles.size(); i++) {

  382     if (Cond.size() > 3)
  509   unsigned ExtraCondLat = Cond.size() != 1;
  547   switch (Cond.size()) {
 2420   unsigned NumRegs = Indices.size();
 2444   unsigned NumRegs = Indices.size();
 3231   if (MI.isCopy() && Ops.size() == 1 &&

  232   if (Args.size() != 2 ||

  930     for (unsigned i = 0; i != AllowedModifiers.size(); ++i) {

  260   if (Bytes.size() < 4)

  386   assert(Offset + NumBytes <= Data.size() && "Invalid fixup offset!");
  400     assert((Offset + FulleSizeInBytes) <= Data.size() && "Invalid fixup size!");
  566     for (size_t i = 0, e = Instrs.size(); i != e; ++i) {

  334     for (uint64_t Byte = 0, End = PltContents.size(); Byte + 7 < End;

  223   assert(DstRegs.size() > 1 && "Nothing to unpack");
  236     for (int i = 0, e = DstRegs.size(); i != e; ++i)
  255   for (unsigned i = 0, e = DstRegs.size(); i != e; ++i, Offset += PartSize)
  473       OrigArgRegs.size() == 1
  479     if (OrigArgRegs.size() > 1)
  623         for (int I = 0, E = VRegs[Idx].size(); I != E; ++I)

  133     PN = PHINode::Create(F.getReturnType(), ReturningBlocks.size(),

 5388   for (auto Idx = TokCount; Idx < Tokens.size(); ++Idx)

  235   assert(Bytes.size() >= sizeof(T));
  276   unsigned MaxInstBytesNum = std::min((size_t)TargetMaxInstBytes, Bytes_.size());
  286     if (Bytes.size() >= 8) {
  336     if (Bytes.size() < 4) break;
  350     if (Bytes.size() < 4) break;
  364   if (Res && (MaxInstBytesNum - Bytes.size()) == 12 && (!HasLiteral ||
  391       if (Bytes.size() < 4 * NSAWords) {
  427   Size = Res ? (MaxInstBytesNum - Bytes.size())
  428              : std::min((size_t)4, Bytes_.size());
  801     if (Bytes.size() < 4) {
  803                         Twine(Bytes.size()));

  339   Res.reserve(Schedule.size() * 2);

  149   assert(Offset + NumBytes <= Data.size() && "Invalid fixup offset!");

  300   AllSGPR128s = AllSGPR128s.slice(std::min(static_cast<unsigned>(AllSGPR128s.size()), NumPreloaded));
  339   if (NumPreloaded > AllSGPRs.size())
  360   if (AllSGPRs.size() < ReservedRegCount)
  764     assert(Spill.size() == 1);
  868     assert(Spill.size() == 1);

 1569   for (unsigned I = 0, E = Ins.size(), PSInputNum = 0; I != E; ++I) {
 1657   if (RegIdx == ArgVGPRs.size()) {
 1679   if (RegIdx == ArgSGPRs.size())
 5159   if (Elts.size() == 1) {
 5162   } else if (Elts.size() == 2) {
 5165   } else if (Elts.size() <= 4) {
 5168   } else if (Elts.size() <= 8) {
 5172     assert(Elts.size() <= 16);
 5178   for (unsigned i = 0; i < Elts.size(); ++i) {
 5184   for (unsigned i = Elts.size(); i < NumElts; ++i)
11008         if (Indices.size() == 1 && Indices[0] == 1) {

  707   for (unsigned Idx = 0; Idx < SubIndices.size(); ++Idx) {
  712       SubIdx = SubIndices[SubIndices.size() - Idx - 1];
  728     bool UseKill = KillSrc && Idx == SubIndices.size() - 1;
  798   for (unsigned Idx = 0; Idx < SubIndices.size(); ++Idx) {
  826   if (Cond.size() == 1) {
  836   } else if (Cond.size() == 2) {
 2059   if(Cond.size() == 1 && Cond[0].isReg()) {

 1298     unsigned Degree = Block->getSuccs().size();
 1498     BlockNumSuccsLeft[i] = Block->getSuccs().size();
 1649     TryCand.NumSuccessors = TryCand.Block->getSuccs().size();

  780   unsigned NumSubRegs = SplitParts.empty() ? 1 : SplitParts.size();
  892   unsigned NumSubRegs = SplitParts.empty() ? 1 : SplitParts.size();

   50   assert(names.size() == altNames.size());
   50   assert(names.size() == altNames.size());
   51   for (unsigned i = 0; i < names.size(); ++i) {
  109   const int Size = getPrinterTable().size();

  379   assert((Cond.size() == 3 || Cond.size() == 0) &&
  379   assert((Cond.size() == 3 || Cond.size() == 0) &&

  303   if (Bytes.size() < 2) {
  312     if (Bytes.size() < 4) {
  317     if (Bytes.size() >= 8) {
  337     if (Bytes.size() >= 6) {

  444   assert((Cond.size() == 2 || Cond.size() == 0) &&
  444   assert((Cond.size() == 2 || Cond.size() == 0) &&
  521   if (Pred1.size() > 2 || Pred2.size() > 2)
  521   if (Pred1.size() > 2 || Pred2.size() > 2)

  208     while (RegIdx % RegAlign != 0 && RegIdx < RegList.size())
  249       if (RegIdx >= RegList.size())

 6720   return VT == MVT::v8i8 && M.size() == 8;
 6725   if (Mask.size() == Elements * 2)
 6757   if (M.size() != NumElts && M.size() != NumElts*2)
 6757   if (M.size() != NumElts && M.size() != NumElts*2)
 6765   for (unsigned i = 0; i < M.size(); i += NumElts) {
 6774   if (M.size() == NumElts*2)
 6789   if (M.size() != NumElts && M.size() != NumElts*2)
 6789   if (M.size() != NumElts && M.size() != NumElts*2)
 6792   for (unsigned i = 0; i < M.size(); i += NumElts) {
 6801   if (M.size() == NumElts*2)
 6821   if (M.size() != NumElts && M.size() != NumElts*2)
 6821   if (M.size() != NumElts && M.size() != NumElts*2)
 6824   for (unsigned i = 0; i < M.size(); i += NumElts) {
 6832   if (M.size() == NumElts*2)
 6851   if (M.size() != NumElts && M.size() != NumElts*2)
 6851   if (M.size() != NumElts && M.size() != NumElts*2)
 6855   for (unsigned i = 0; i < M.size(); i += NumElts) {
 6868   if (M.size() == NumElts*2)
 6892   if (M.size() != NumElts && M.size() != NumElts*2)
 6892   if (M.size() != NumElts && M.size() != NumElts*2)
 6895   for (unsigned i = 0; i < M.size(); i += NumElts) {
 6906   if (M.size() == NumElts*2)
 6925   if (M.size() != NumElts && M.size() != NumElts*2)
 6925   if (M.size() != NumElts && M.size() != NumElts*2)
 6928   for (unsigned i = 0; i < M.size(); i += NumElts) {
 6939   if (M.size() == NumElts*2)
 6977   if (NumElts != M.size())
 6991   if (NumElts != M.size() || (VT != MVT::v8i16 && VT != MVT::v16i8))
16744   assert(Shuffles.size() == Indices.size() &&
16744   assert(Shuffles.size() == Indices.size() &&
16816     for (unsigned i = 0; i < Shuffles.size(); i++) {

  629   unsigned NumRegs = Regs.size();
  835   assert(Regs.size() == 2);

  631   if (Bytes.size() < 4) {
  917   if (Bytes.size() < 2) {
  970   if (Bytes.size() < 4) {

 1047   assert(Offset + NumBytes <= Data.size() && "Invalid fixup offset!");
 1053     assert((Offset + FullSizeBytes) <= Data.size() && "Invalid fixup size!");
 1114   for (size_t i = 0, e = Instrs.size(); i != e; ++i) {

  408   assert((Cond.size() == 1 || Cond.size() == 0) &&
  408   assert((Cond.size() == 1 || Cond.size() == 0) &&

   80   if (Bytes.size() < 2) {
   94   if (Bytes.size() < 4) {

  378   assert(Offset + NumBytes <= Data.size() && "Invalid fixup offset!");

  143   if (Bytes.size() < 8) {
  191     if (Bytes.size() < 16) {

  179     if (Bytes.size() < HEXAGON_INSTR_SIZE)
  296   assert(Bytes.size() >= HEXAGON_INSTR_SIZE);
  524   if (RegNo < Table.size()) {

  133     Node Num = Order.size();
  165   for (unsigned P = 0; P != Order.size(); ++P) {
  175   for (unsigned I = 0; I != Order.size(); ++I) {
  262   for (unsigned I = 0; I != Order.size(); ++I)
  272   for (unsigned I = 0; I != Order.size(); ++I) {
  333     Order.assign(Ord.data(), Ord.data()+Ord.size());
  763     for (unsigned I = 0, E = Mask.size(); I != E; ++I) {
  776     size_t H = Mask.size()/2;
  780     size_t H = Mask.size()/2;
  867   unsigned VecLen = Mask.size();
  868   assert(MaskL.size() == VecLen && MaskR.size() == VecLen);
  868   assert(MaskL.size() == VecLen && MaskR.size() == VecLen);
  885   assert(A.size() > 0 && A.size() >= MaxLen);
  885   assert(A.size() > 0 && A.size() >= MaxLen);
  904   for (int I = 0, E = Mask.size(); I != E; ++I) {
  914   assert(Mask.size() < 0x00007FFF && "Sanity failure");
  921   int N = Mask.size();
 1058   int VecLen = SM.Mask.size();
 1063     for (int I = 0, E = M.Mask.size(); I != E; ++I) {
 1183   int VecLen = SM.Mask.size();
 1213   size_t S = Bytes.size() / 2;
 1221   unsigned VecLen = SM.Mask.size();
 1247   int VecLen = SM.Mask.size();
 1271   int VecLen = SM.Mask.size();
 1311   int VecLen = SM.Mask.size();
 1366   unsigned VecLen = Mask.size();
 1504   int VecLen = SM.Mask.size();
 1628   int VecLen = SM.Mask.size();
 1678   int VecLen = SM.Mask.size();
 1952   int VecLen = SM.Mask.size();
 1994   MVT VecTy = MVT::getVectorVT(MVT::i8, Data.size());

 1914   assert(AM.size() <= 8 && "Unexpected shuffle mask");
 1915   unsigned VecLen = AM.size();
 1936   if (F == AM.size())
 2101   for (unsigned i = 0, e = Values.size(); i != e; ++i) {
 2126   assert(VecTy.getVectorNumElements() == Elem.size());
 2128   SmallVector<ConstantInt*,4> Consts(Elem.size());
 2131   unsigned First, Num = Elem.size();
 2143     assert(Elem.size() == 2);
 2183     assert(Elem.size() == 4);
 2209   assert(VecTy.getVectorNumElements() == Elem.size());
 2211   SmallVector<ConstantInt*,8> Consts(Elem.size());
 2214   unsigned First, Num = Elem.size();
 2510     for (ArrayRef<SDValue> A(Rs); A.size() != 1; A = A.drop_back(A.size()/2)) {
 2510     for (ArrayRef<SDValue> A(Rs); A.size() != 1; A = A.drop_back(A.size()/2)) {
 2511       for (unsigned i = 0, e = A.size()/2; i != e; ++i)

  346   unsigned VecLen = Values.size();
  589   unsigned VecLen = Values.size();

  626       assert((Cond.size() == 3) && "Only supporting rr/ri version of nvjump");
  643       assert((Cond.size() == 2) && "Malformed cond vector");
 4263   assert(Cond.size() == 2);
 4428   return Cond.empty() || (Cond[0].isImm() && (Cond.size() != 1));

  221   if (Indices.size() != Factor || UseMaskForCond || UseMaskForGaps)

  429     assert(Offset + NumBytes <= Data.size() && "Invalid fixup offset!");
  518         << ": Offset=" << Offset << ": Size=" << Data.size() << ": OInst=0x";

   78   if (Bytes.size() < 4) {

  678   assert((Condition.size() == 1) &&

  252     if (Bytes.size() < (Words + 1) * 2) {
  266     if (Bytes.size() < (Words + 1) * 2) {
  307     if (Bytes.size() < (Words + 1) * 2) {
  372   if (Bytes.size() < 2) {

  149   assert(Offset + NumBytes <= Data.size() && "Invalid fixup offset!");

  273   assert((Cond.size() == 1 || Cond.size() == 0) &&
  273   assert((Cond.size() == 1 || Cond.size() == 0) &&

 1164   if (Bytes.size() < 2) {
 1184   if (Bytes.size() < 4) {

   43   for (unsigned i = 0; i < VRegs.size(); ++i)
   64   for (unsigned ArgsIndex = 0, ArgLocsIndex = 0; ArgsIndex < Args.size();
  506     if (ArgRegs.size() == Idx)
  511           (int)(RegSize * (ArgRegs.size() - Idx));
  518     for (unsigned I = Idx; I < ArgRegs.size(); ++I, VaArgOffset += RegSize) {

 4191         (int)((ByValArgRegs.size() - FirstReg) * GPRSizeInBytes);
 4338   if (ArgRegs.size() == Idx)
 4343         (int)(RegSizeInBytes * (ArgRegs.size() - Idx));
 4355   for (unsigned I = Idx; I < ArgRegs.size();
 4406     for (unsigned I = FirstReg; Size > 0 && (I < IntArgRegs.size());

  112   for (unsigned i = 1; i < Cond.size(); ++i) {
  135   assert((Cond.size() <= 3) &&

  190   assert((Cond.size() == 1 || Cond.size() == 0) &&
  190   assert((Cond.size() == 1 || Cond.size() == 0) &&

  330   if (Bytes.size() < 4) {

  329   if (OpList1.size() != OpList2.size()) {
  329   if (OpList1.size() != OpList2.size()) {
  334   for (unsigned i = 0; i < OpList1.size(); ++i) {

  710   assert((Cond.size() == 2 || Cond.size() == 0) &&
  710   assert((Cond.size() == 2 || Cond.size() == 0) &&
  759   if (Cond.size() != 2)
  797   assert(Cond.size() == 2 &&
 1525   assert(Pred1.size() == 2 && "Invalid PPC first predicate");
 1526   assert(Pred2.size() == 2 && "Invalid PPC second predicate");

  327     if (Bytes.size() < 4) {
  336     if (Bytes.size() < 2) {

  301   assert(Offset + NumBytes <= Data.size() && "Invalid fixup offset!");

 1958     if (ArgRegs.size() == Idx) {
 1962       VarArgsSaveSize = XLenInBytes * (ArgRegs.size() - Idx);
 1981     for (unsigned I = Idx; I < ArgRegs.size();

  343   assert((Cond.size() == 3 || Cond.size() == 0) &&
  343   assert((Cond.size() == 3 || Cond.size() == 0) &&

  318   if (Bytes.size() < 4) {

  249   assert((Cond.size() == 1 || Cond.size() == 0) &&
  249   assert((Cond.size() == 1 || Cond.size() == 0) &&

  456   if (Bytes.size() < 2)
  473   if (Bytes.size() < Size)

  107   assert(Offset + Size <= Data.size() && "Invalid fixup offset!");

  489   assert((Cond.size() == 2 || Cond.size() == 0) &&
  489   assert((Cond.size() == 2 || Cond.size() == 0) &&
  541   if (Pred.size() != 2)
  575   assert(Pred.size() == 2 && "Invalid condition");
  720   assert(Pred.size() == 2 && "Invalid condition");
 1006   if (Ops.size() == 2 && Ops[0] == 0 && Ops[1] == 1) {
 1034   if (Ops.size() != 1)

  381   if ((SignedDivRem || UnsignedDivRem) && Args.size() == 2) {
  471     if (Args.size() == 2 && ST->hasMiscellaneousExtensions3()) {

   78   if (Size >= Bytes.size())
   90                                Bytes.data() + Bytes.size(), &Error)
   92                                                     Bytes.data() + Bytes.size(),
  111   if (Size + sizeof(T) > Bytes.size())

  118   assert(Offset + NumBytes <= Data.size() && "Invalid fixup offset!");

  155   for (unsigned I = 0; I < getBlocks().size(); ++I) {

  192   assert(Cond.size() == 2 && "Expected a flag and a successor block");

  190   if (Bytes.size() <= Index)

  115     assert(Fixup.getOffset() + Size <= Data.size() && "Invalid fixup offset!");
  541     for (unsigned i = 0, e = Instrs.size(); i != e; ++i) {

  472   for (uint64_t Byte = 0, End = PltContents.size(); Byte + 6 < End; ) {
  497   for (uint64_t Byte = 0, End = PltContents.size(); Byte + 6 < End; ) {

  308   for (int i = 0, e = RawMask.size(); i < e; ++i) {
  340   assert(RawMask.size() == 16 && "Illegal VPPERM shuffle mask size");
  355   for (int i = 0, e = RawMask.size(); i < e; ++i) {
  502   for (unsigned i = 0, e = RawMask.size(); i < e; ++i) {
  522   assert((NumElts == RawMask.size()) && "Unexpected mask size");
  524   for (unsigned i = 0, e = RawMask.size(); i < e; ++i) {
  562   uint64_t EltMaskSize = RawMask.size() - 1;
  563   for (int i = 0, e = RawMask.size(); i != e; ++i) {
  576   uint64_t EltMaskSize = (RawMask.size() * 2) - 1;
  577   for (int i = 0, e = RawMask.size(); i != e; ++i) {

  204     assert(VRegs.size() == SplitEVTs.size() &&
  351         Arg.hasAttribute(Attribute::Nest) || VRegs[Idx].size() > 1)

 3401       FuncInfo->setVarArgsFPOffset(ArgGPRs.size() * 8 + NumXMMRegs * 16);
 3403           ArgGPRs.size() * 8 + ArgXMMs.size() * 16, 16, false));
 3403           ArgGPRs.size() * 8 + ArgXMMs.size() * 16, 16, false));
 3423     if (!ArgXMMs.empty() && NumXMMRegs != ArgXMMs.size()) {
 5198   unsigned NumElts = Mask.size();
 5204   unsigned NumElts = Mask.size();
 5287   WidenedMask.assign(Mask.size() / 2, 0);
 5288   for (int i = 0, Size = Mask.size(); i < Size; i += 2) {
 5329   assert(WidenedMask.size() == Mask.size() / 2 &&
 5393   assert(Bits.size() == Undefs.getBitWidth() &&
 5407   for (unsigned i = 0, e = Bits.size(); i != e; ++i) {
 7797   unsigned NumElems = Elts.size();
10125   for (int i = 0, Size = Mask.size(); i < Size; ++i) {
10140   int Size = Mask.size();
10163   int Size = Mask.size();
10213   int Size = Mask.size();
10254   if (Mask.size() != ExpectedMask.size())
10254   if (Mask.size() != ExpectedMask.size())
10257   int Size = Mask.size();
10292   int Size = Mask.size();
10293   if (Size != (int)ExpectedMask.size())
10367   MVT EltVT = MVT::getIntegerVT(128 / Mask.size());
10368   MVT VT = MVT::getVectorVT(EltVT, Mask.size());
10390   assert(Mask.size() % 2 == 0 && "Expecting even number of elements in mask");
10391   unsigned HalfSize = Mask.size() / 2;
10408   assert(Mask.size() == 4 && "Only 4-lane shuffle masks");
10437   APInt Zeroable(Mask.size(), 0);
10445   int ScalarSizeInBits = VectorSizeInBits / Mask.size();
10448   for (int i = 0, Size = Mask.size(); i < Size; ++i) {
10517   for (int i = 0, e = Mask.size(); i < e; i++) {
10543   int Size = Mask.size();
10733   int Size = (int)Mask.size();
10777   if (Mask.size() != VT.getVectorNumElements())
10906     MaskVT = MVT::getVectorVT(EltVT, Mask.size());
10915         MVT::getVectorVT(EltVT == MVT::f64 ? MVT::i64 : MVT::i32, Mask.size());
10921   SmallVector<SDValue, 16> VMaskOps(Mask.size(), Zero);
10923   for (int i = 0, Size = Mask.size(); i < Size; ++i) {
10958   for (int i = 0, Size = Mask.size(); i < Size; ++i) {
10986   assert(Mask.size() <= 64 && "Shuffle mask too big for blend mask");
10990   for (int i = 0, Size = Mask.size(); i < Size; ++i) {
11195   SmallVector<int, 32> BlendMask(Mask.size(), -1);
11196   SmallVector<int, 32> PermuteMask(Mask.size(), -1);
11198   for (int i = 0, Size = Mask.size(); i < Size; ++i) {
11231   int NumElts = Mask.size();
11386   SmallVector<int, 32> V1Mask(Mask.size(), -1);
11387   SmallVector<int, 32> V2Mask(Mask.size(), -1);
11388   SmallVector<int, 32> BlendMask(Mask.size(), -1);
11389   for (int i = 0, Size = Mask.size(); i < Size; ++i)
11429   int NumElts = Mask.size();
11562   assert(Mask.size() <= 16 &&
11625   unsigned NumElts = Mask.size();
11701   int Size = Mask.size();
11764   int Size = Mask.size();
11798   int Size = Mask.size();
11854   int Size = Mask.size();
12021     assert(NumElements == (int)Mask.size() && "Unexpected shuffle mask size!");
12116   assert((int)Mask.size() == NumElements && "Unexpected shuffle mask size");
12270       find_if(Mask, [&Mask](int M) { return M >= (int)Mask.size(); }) -
12273   for (int i = 0, Size = Mask.size(); i < Size; ++i)
12284   SDValue V2S = getScalarValueForVectorElement(V2, Mask[V2Index] - Mask.size(),
12300   } else if (Mask[V2Index] != (int)Mask.size() || EltVT == MVT::i8 ||
12342       SmallVector<int, 4> V2Shuffle(Mask.size(), 1);
12415   assert(Mask.size() == 4 && "Unsupported mask size!");
12500   unsigned NumElts = Mask.size();
12519   assert(BroadcastIdx < (int)Mask.size() && "We only expect to be called with "
12686   assert(Mask.size() == 4 && "Unexpected mask size for v4 shuffle!");
12802   assert(Mask.size() >= 2 && "Single element masks are invalid.");
12804   int Size = Mask.size();
12914   assert(Mask.size() == 2 && "Unexpected mask size for v2 shuffle!");
12998   assert(Mask.size() == 2 && "Unexpected mask size for v2 shuffle!");
13183   assert(Mask.size() == 4 && "Unexpected mask size for v4 shuffle!");
13279   assert(Mask.size() == 4 && "Unexpected mask size for v4 shuffle!");
13407   assert(Mask.size() == 8 && "Shuffle mask length doesn't match!");
13531     assert((AToAInputs.size() == 3 || AToAInputs.size() == 1) &&
13531     assert((AToAInputs.size() == 3 || AToAInputs.size() == 1) &&
13533     assert((BToAInputs.size() == 1 || BToAInputs.size() == 3) &&
13533     assert((BToAInputs.size() == 1 || BToAInputs.size() == 3) &&
13535     assert(AToAInputs.size() + BToAInputs.size() == 4 &&
13535     assert(AToAInputs.size() + BToAInputs.size() == 4 &&
13538     bool ThreeAInputs = AToAInputs.size() == 3;
13564     if (BToBInputs.size() == 2 && AToBInputs.size() == 2) {
13564     if (BToBInputs.size() == 2 && AToBInputs.size() == 2) {
13612               BToAInputs.size() == 3 ? TripleNonInputIdx : OneInput;
13664     if (InPlaceInputs.size() == 1) {
13679     assert(InPlaceInputs.size() == 2 && "Cannot handle 3 or 4 inputs!");
13764     if (IncomingInputs.size() == 1) {
13774     } else if (IncomingInputs.size() == 2) {
13904   int Size = Mask.size();
13966   assert(Mask.size() == 8 && "Unexpected mask size for v8 shuffle!");
14107   int ShuffleModulus = Mask.size() * (IsSingleInput ? 1 : 2);
14118   for (int i = 0, e = Mask.size(); i < e; ++i) {
14174   assert(Mask.size() == 16 && "Unexpected mask size for v16 shuffle!");
14255       for (int i = 0, ie = MovingInputs.size(); i < ie; ++i) {
14520   ArrayRef<int> LoMask = Mask.slice(0, Mask.size() / 2);
14521   ArrayRef<int> HiMask = Mask.slice(Mask.size() / 2);
14644   int Size = Mask.size();
14764   int Size = Mask.size();
14922   int NumElts = Mask.size();
14962       assert(M1.size() == M2.size() && "Unexpected mask size");
14962       assert(M1.size() == M2.size() && "Unexpected mask size");
14963       for (int i = 0, e = M1.size(); i != e; ++i)
14970       assert(Mask.size() == MergedMask.size() && "Unexpected mask size");
14970       assert(Mask.size() == MergedMask.size() && "Unexpected mask size");
14971       for (int i = 0, e = MergedMask.size(); i != e; ++i) {
15085   assert((Mask.size() == HalfMask.size() * 2) &&
15085   assert((Mask.size() == HalfMask.size() * 2) &&
15094   unsigned HalfNumElts = HalfMask.size();
15288   int Size = Mask.size();
15550   if (Zeroable.countLeadingOnes() < (Mask.size() - 8))
15581   assert(Mask.size() == 4 && "Unexpected mask size for v4 shuffle!");
15689   assert(Mask.size() == 4 && "Unexpected mask size for v4 shuffle!");
15787   assert(Mask.size() == 8 && "Unexpected mask size for v8 shuffle!");
15886   assert(Mask.size() == 8 && "Unexpected mask size for v8 shuffle!");
15997   assert(Mask.size() == 16 && "Unexpected mask size for v16 shuffle!");
16097   assert(Mask.size() == 32 && "Unexpected mask size for v32 shuffle!");
16360   assert(Mask.size() == 8 && "Unexpected mask size for v8 shuffle!");
16414   assert(Mask.size() == 16 && "Unexpected mask size for v16 shuffle!");
16467   assert(Mask.size() == 8 && "Unexpected mask size for v8 shuffle!");
16530   assert(Mask.size() == 16 && "Unexpected mask size for v16 shuffle!");
16599   assert(Mask.size() == 32 && "Unexpected mask size for v32 shuffle!");
16652   assert(Mask.size() == 64 && "Unexpected mask size for v64 shuffle!");
16725   int NumElts = Mask.size();
16775   int NumElts = Mask.size();
16814   int Size = Mask.size();
16854   int NumElts = Mask.size();
16974   int NumElements = Mask.size();
17012       for (int i = 0, Size = Mask.size(); i < Size; ++i)
17021         for (int i = 0, Size = Mask.size(); i < Size; ++i)
17080   int MaskUpperLimit = OrigMask.size() * (V2IsUndef ? 1 : 2);
31819   unsigned NumMaskElts = Mask.size();
31951   unsigned NumMaskElts = Mask.size();
31982       ShuffleVT = MVT::getVectorVT(MVT::f64, Mask.size());
31984       for (int i = 0, e = Mask.size(); i != e; ++i) {
32136   unsigned NumMaskElts = Mask.size();
32294   assert((Inputs.size() == 1 || Inputs.size() == 2) &&
32294   assert((Inputs.size() == 1 || Inputs.size() == 2) &&
32299   bool UnaryShuffle = (Inputs.size() == 1);
32314   unsigned NumBaseMaskElts = BaseMask.size();
32816   unsigned NumMaskElts = BaseMask.size();
32817   unsigned NumInputs = Inputs.size();
32921   unsigned NumMaskElts = Mask.size();
32923   unsigned NumOps = Ops.size();
33029   assert(RootMask.size() > 0 && (RootMask.size() > 1 || RootMask[0] == 0) &&
33029   assert(RootMask.size() > 0 && (RootMask.size() > 1 || RootMask[0] == 0) &&
33087   assert(((RootMask.size() > OpMask.size() &&
33088            RootMask.size() % OpMask.size() == 0) ||
33089           (OpMask.size() > RootMask.size() &&
33090            OpMask.size() % RootMask.size() == 0) ||
33091           OpMask.size() == RootMask.size()) &&
33097   assert(isPowerOf2_32(RootMask.size()) && "Non-power-of-2 shuffle mask sizes");
33099   unsigned RootMaskSizeLog2 = countTrailingZeros(RootMask.size());
33102   unsigned MaskWidth = std::max<unsigned>(OpMask.size(), RootMask.size());
33104   unsigned OpRatio = std::max<unsigned>(1, RootMask.size() >> OpMaskSizeLog2);
33801   unsigned Size = Mask.size();
34121   SmallVector<int, 8> HalfMask(Mask.size() / 2);
44330     unsigned NumOps = Ops.size();
45186   assert(SrcVT.getVectorNumElements() == ShuffleMask.size() &&

 1678     size_t NumElts = Mask.size();

 2777   assert((Cond.size() == 1 || Cond.size() == 0) &&
 2777   assert((Cond.size() == 1 || Cond.size() == 0) &&
 2836   if (Cond.size() != 1)
 2873   assert(Cond.size() == 1 && "Invalid Cond array");
 4610   unsigned NumAddrOps = MOs.size();
 4620     assert(MOs.size() == 5 && "Unexpected memory operand list length");
 4857   if (MOs.size() == X86::AddrNumOperands &&
 5031   if (Ops.size() == 2 && Ops[0] == 0 && Ops[1] == 1) {
 5048   } else if (Ops.size() != 1)
 5256   if (Ops.size() == 2 && Ops[0] == 0 && Ops[1] == 1) {
 5268   } else if (Ops.size() != 1)

  260   for (unsigned i = 0; i < Mask.size(); i++)
  262   for (unsigned i = 0; i < Mask.size(); i++)
  691   assert(Matrix.size() == 4 && "Invalid matrix size");
  753     for (unsigned i = 0, e = Shuffles.size(); i < e; ++i)
  812   assert(Shuffles.size() == Indices.size() &&
  812   assert(Shuffles.size() == Indices.size() &&

  221     if (Args.size() == 2 && ISD == ISD::MUL && LT.second == MVT::v4i32) {
 3496   if (Indices.size() && Indices.size() != Factor)
 3496   if (Indices.size() && Indices.size() != Factor)
 3658         Indices.size() ? Indices.size() : Factor;
 3658         Indices.size() ? Indices.size() : Factor;

   48   if (Bytes.size() < 2) {
   60   if (Bytes.size() < 4) {

  279   assert((Cond.size() == 2 || Cond.size() == 0) &&
  279   assert((Cond.size() == 2 || Cond.size() == 0) &&
  297   assert(Cond.size() == 2 && "Unexpected number of components!");

  446       if (SuspendResultTys.size() != ResumeTys.size()) {
  446       if (SuspendResultTys.size() != ResumeTys.size()) {
  453       for (size_t I = 0, E = ResumeTys.size(); I != E; ++I) {

  227             CalleeSummaryList.size() > 1 &&

  277     LLVM_DEBUG(dbgs() << "Applying bonus for: " << Region.size()
  279     Penalty -= Region.size();

  282         totalSizeToAlloc<MDNode *>(Types.size()), alignof(GlobalTypeMember)));
  284     GTM->NTypes = Types.size();
  315         Alloc.Allocate(totalSizeToAlloc<GlobalTypeMember *>(Targets.size()),
  319     Call->NTargets = Targets.size();
  869   for (unsigned I = 0; I != Globals.size(); ++I) {
 1357   AsmArgs.reserve(Functions.size() * 2);
 1361   for (unsigned I = 0; I != Functions.size(); ++I)
 1485   for (unsigned I = 0; I != Functions.size(); ++I)
 1495       ArrayType::get(getJumpTableEntryType(), Functions.size());
 1506     for (unsigned I = 0; I != Functions.size(); ++I) {
 1593   for (unsigned I = 0; I != TypeIds.size(); ++I)
 1598   std::vector<std::set<uint64_t>> TypeMembers(TypeIds.size());
 1629   GlobalLayoutBuilder GLB(Globals.size());
 1636   std::vector<GlobalTypeMember *> OrderedGTMs(Globals.size());

  179     if (VTUsed.size() > Offset)
  188         if (I < B.size())
  200         while ((I + Byte) < B.size() && Byte < (Size / 8)) {
  717     assert(VI.getSummaryList().size() == 1 &&
  846     assert(P.VTableVI.getSummaryList().size() == 1 ||
  985   auto Size = TheFn.getSummaryList().size();
 1036   if (TargetsForSlot.size() > ClThreshold)
 1167     if (Target.Fn->arg_size() != Args.size() + 1)
 1174     for (unsigned I = 0; I != Args.size(); ++I) {

 1182       if (ITy->isVectorTy() && Mask.size() > ITy->getVectorNumElements())
 1198       for (int i = 0, e = Mask.size(); i != e; ++i) {
 1236       assert(NewOps.size() == 2 && "binary operator with #ops != 2");
 1252       assert(NewOps.size() == 2 && "icmp with #ops != 2");
 1256       assert(NewOps.size() == 2 && "fcmp with #ops != 2");
 1273       assert(NewOps.size() == 1 && "cast with #ops != 1");
 1296     return UndefValue::get(VectorType::get(EltTy, Mask.size()));
 1299     return ConstantAggregateZero::get(VectorType::get(EltTy, Mask.size()));
 1303     for (int i = 0, e = Mask.size(); i != e; ++i) {
 1347       bool NeedsRebuild = (Mask.size() != I->getType()->getVectorNumElements());
 1373       for (int e = Mask.size(); Index != e; ++Index) {

 2042   assert(ExtendedGlobals.size() == MetadataInitializers.size());
 2042   assert(ExtendedGlobals.size() == MetadataInitializers.size());
 2045   for (size_t i = 0; i < ExtendedGlobals.size(); i++) {
 2067   assert(ExtendedGlobals.size() == MetadataInitializers.size());
 2067   assert(ExtendedGlobals.size() == MetadataInitializers.size());
 2069   SmallVector<GlobalValue *, 16> MetadataGlobals(ExtendedGlobals.size());
 2070   for (size_t i = 0; i < ExtendedGlobals.size(); i++) {
 2125   assert(ExtendedGlobals.size() == MetadataInitializers.size());
 2125   assert(ExtendedGlobals.size() == MetadataInitializers.size());
 2131   SmallVector<GlobalValue *, 16> LivenessGlobals(ExtendedGlobals.size());
 2133   for (size_t i = 0; i < ExtendedGlobals.size(); i++) {
 2182   assert(ExtendedGlobals.size() == MetadataInitializers.size());
 2182   assert(ExtendedGlobals.size() == MetadataInitializers.size());
 2183   unsigned N = ExtendedGlobals.size();
 2845   copyToShadow(ShadowMask, ShadowBytes, 0, ShadowMask.size(), IRB, ShadowBase);
 2852   assert(ShadowMask.size() == ShadowBytes.size());
 2852   assert(ShadowMask.size() == ShadowBytes.size());

 1004     for (int j : llvm::seq<int>(0, CountersBySP.size())) {
 1025     int CountersSize = CountersBySP.size();

  226                     << " Num_targets: " << ValueDataRef.size()

  195     for (unsigned i = 0, e = ExitBlocks.size(); i != e; ++i) {

   92   if (Ops.size() == 0)
   95   for (; i < Ops.size() && isConstantFalse(Ops[i]); i++) {}
   96   if (i == Ops.size())
   99   for (; i < Ops.size(); i++)

  669   size_t N = AllBlocks.size();
  698         AllBlocks.size(), F, Int32Ty, SanCovGuardsSectionName);
  702         AllBlocks.size(), F, Int8Ty, SanCovCountersSectionName);
  713   for (size_t i = 0, N = AllBlocks.size(); i < N; i++)

  256         assert(Ops.size() == 1 && "FNeg is a unary operator!");
  267         assert(Ops.size() == 2 && "its a binary operator!");
  280         assert(Ops.size() == 1 && "FPTo[US]I is a unary operator!");
  290         assert(Ops.size() == 2 && "FCmp is a binary operator!");

 1786   if (L->getBlocks().size() >= LoopSizeCutoff) {

 2126   Updates.reserve((2 * Preds.size()) + NewBBs.size());

  246   if (SubLoop->getBlocks().size() != 1) {

 1003                     << loopHeader->getName() << " [" << L->getBlocks().size()
 1237                     << loopHeader->getName() << " [" << L->getBlocks().size()

  574     if (Comparisons.size() == 1)
  587     Scratch.reserve(size + Comparisons.size() - 1);
  592     for (int I = 1, E = Comparisons.size(); I < E; ++I) {
  624   LLVM_DEBUG(dbgs() << "Merging " << Comparisons.size() << " comparisons -> "
  626   if (Comparisons.size() == 1) {

  986   unsigned NumOps = PHIOperands.size();

 1208   for (size_t i = 0; i < records.size(); i++) {
 1280     assert(Index < LiveVec.size() && "Bug in std::find?");
 1307   for (unsigned i = 0; i < LiveVariables.size(); i++) {
 1703   PromotableAllocas.reserve(Live.size());
 1864   assert(PromotableAllocas.size() == Live.size() + NumRematerializedValues &&
 1920   for (size_t i = 0; i < records.size(); i++) {

  978   NewBlocks.reserve(L.getNumBlocks() + ExitBlocks.size());
 1218   ClonedExitsInLoops.reserve(ExitBlocks.size());
 1684   ExitsInLoops.reserve(ExitBlocks.size());
 1916     assert(Invariants.size() == 1 &&
 2212     bool ReplaceUnswitched = FullUnswitch || (Invariants.size() == 1);
 2734         TI, /*FullUnswitch*/ !BI || (Invariants.size() == 1 &&

  563   LLVM_DEBUG(dbgs() << "  Speculating around " << SpecPNs.size() << " PHIs!\n");
  564   NumPHIsSpeculated += SpecPNs.size();

   98   assert(Dead.size() == BBs.size() && "Duplicating blocks?");
  576         PHINode::Create(PN->getType(), Preds.size(), PN->getName() + ".ph", BI);
  629   for (unsigned i = 0, e = Preds.size(); i != e; ++i) {
  684   for (unsigned i = 0, e = Preds.size(); i != e; ++i) {

  126         PN.getType(), Preds.size(), "split",
  128     for (unsigned i = 0, e = Preds.size(); i != e; ++i)

  188     if (int Res = cmpNumbers(OBL.Inputs.size(), OBR.Inputs.size()))
  188     if (int Res = cmpNumbers(OBL.Inputs.size(), OBR.Inputs.size()))
  590     if (int Res = cmpNumbers(LIndices.size(), RIndices.size()))
  590     if (int Res = cmpNumbers(LIndices.size(), RIndices.size()))
  592     for (size_t i = 0, e = LIndices.size(); i != e; ++i) {
  601     if (int Res = cmpNumbers(LIndices.size(), RIndices.size()))
  601     if (int Res = cmpNumbers(LIndices.size(), RIndices.size()))
  603     for (size_t i = 0, e = LIndices.size(); i != e; ++i) {

 1759           MergedDeoptArgs.reserve(ParentDeopt->Inputs.size() +
 1760                                   ChildOB.Inputs.size());

  206   if (L->getBlocks().size() == 1)

  309   for (unsigned i = 0; i != L->getBlocks().size(); ++i) {

  124   assert(InitArgs.size() == InitArgTypes.size() &&
  124   assert(InitArgs.size() == InitArgTypes.size() &&

   79     if (DT->isReachableFromEntry(BB) && PredCache.get(BB).size()) {

 5535   uint64_t NumCases = Values.size();

 1022   WE.AppendingGVNumNewMembers = NewMembers.size();

  558     if (NumFound == Chain.size()) {
  588   unsigned SizeBytes = ElementSizeBytes * Chain.size();
  590   if (NumLeft == Chain.size()) {
  719   for (unsigned ChainLen = Chain.size(); ChainIdx < ChainLen; ++ChainIdx) {
  870   LLVM_DEBUG(dbgs() << "LSV: Vectorizing " << Instrs.size()
  877   for (int i = 0, e = Instrs.size(); i < e; ++i) {
  962   unsigned ChainSize = Chain.size();
  976   if (NewChain.size() == 1) {
  984   ChainSize = Chain.size();
  995                             Chain.size() * VecStoreTy->getNumElements());
  997     VecTy = VectorType::get(StoreTy, Chain.size());
 1049     for (unsigned I = 0, E = Chain.size(); I != E; ++I) {
 1064     for (unsigned I = 0, E = Chain.size(); I != E; ++I) {
 1085   NumScalarsVectorized += Chain.size();
 1113   unsigned ChainSize = Chain.size();
 1127   if (NewChain.size() == 1) {
 1135   ChainSize = Chain.size();
 1145                             Chain.size() * VecLoadTy->getNumElements());
 1147     VecTy = VectorType::get(LoadTy, Chain.size());
 1203     for (unsigned I = 0, E = Chain.size(); I != E; ++I) {
 1229     for (unsigned I = 0, E = Chain.size(); I != E; ++I) {
 1248   NumScalarsVectorized += Chain.size();

 5378   SmallVector<RegisterUsage, 8> RUs(VFs.size());
 5379   SmallVector<SmallMapVector<unsigned, unsigned, 4>, 8> MaxUsages(VFs.size());
 5408     for (unsigned j = 0, e = VFs.size(); j < e; ++j) {
 5457   for (unsigned i = 0, e = VFs.size(); i < e; ++i) {

  186   for (int i = 1, e = VL.size(); i < e; i++) {
  210   for (unsigned i = 1, e = VL.size(); i < e; ++i)
  272   for (unsigned I = 0, E = VL.size(); I < E; ++I) {
  377   for (int Cnt = 0, E = VL.size(); Cnt < E; Cnt++) {
  412   for (int i = 1, e = VL.size(); i < e; i++)
  888       assert((empty() || VL.size() == getNumLanes()) &&
  893       unsigned NumLanes = VL.size();
 1199       if (VL.size() == Scalars.size())
 1201       return VL.size() == ReuseShuffleIndices.size() &&
 1401       for (int i = 0, e = VL.size(); i != e; ++i) {
 1413       assert((!Bundle.getValue() || Lane == VL.size()) &&
 2281   if (NumUniqueScalarValues == VL.size()) {
 2319       for (unsigned j = 0; j < VL.size(); ++j)
 2365         Op0.assign(VL.size(), VL0->getOperand(0));
 2388         Op0.assign(VL.size(), VL0->getOperand(0));
 2418       SmallVector<Value *, 4> PointerOps(VL.size());
 2451         if (Diff && Diff->getAPInt().getZExtValue() == (VL.size() - 1) * Size) {
 2668       for (unsigned i = 0, e = VL.size() - 1; i < e; ++i)
 2854     if (!LI || !LI->isSimple() || !LI->hasNUses(VL.size()))
 2860   if (NElts != VL.size())
 2865   unsigned E = VL.size();
 2915   VectorType *VecTy = VectorType::get(ScalarTy, VL.size());
 2921         IntegerType::get(F->getContext(), MinBWs[VL[0]].first), VL.size());
 3005         for (unsigned i = 0, e = VL.size(); i < e; ++i) {
 3051         ReuseShuffleCost -= (ReuseShuffleNumbers - VL.size()) * ScalarEltCost;
 3055       int ScalarCost = VL.size() * ScalarEltCost;
 3057       VectorType *SrcVecTy = VectorType::get(SrcTy, VL.size());
 3073         ReuseShuffleCost -= (ReuseShuffleNumbers - VL.size()) * ScalarEltCost;
 3075       VectorType *MaskTy = VectorType::get(Builder.getInt1Ty(), VL.size());
 3116       for (unsigned i = 0, e = VL.size(); i < e; ++i) {
 3140         ReuseShuffleCost -= (ReuseShuffleNumbers - VL.size()) * ScalarEltCost;
 3156         ReuseShuffleCost -= (ReuseShuffleNumbers - VL.size()) * ScalarEltCost;
 3169         ReuseShuffleCost -= (ReuseShuffleNumbers - VL.size()) * ScalarEltCost;
 3187         ReuseShuffleCost -= (ReuseShuffleNumbers - VL.size()) * ScalarEltCost;
 3210         ReuseShuffleCost -= (ReuseShuffleNumbers - VL.size()) * ScalarEltCost;
 3259         VectorType *Src0Ty = VectorType::get(Src0SclTy, VL.size());
 3260         VectorType *Src1Ty = VectorType::get(Src1SclTy, VL.size());
 3524   VectorType *VecTy = VectorType::get(ScalarTy, VL.size());
 3531   for (unsigned I = VL.size(); I > 0; --I) {
 3656         if (VL.size() == E->Scalars.size() && !E->ReuseShuffleIndices.empty()) {
 3683   if (VL.size() > 2) {
 3693     if (UniqueValues.size() == VL.size() || UniqueValues.size() <= 1 ||
 3699   VectorType *VecTy = VectorType::get(ScalarTy, VL.size());
 3716   const unsigned E = Indices.size();
 5336   const unsigned ChainLen = Chain.size();
 5416   int E = Stores.size();
 5504   if (VL.size() < 2)
 5508                     << VL.size() << ".\n");
 5519   unsigned MaxVF = std::max<unsigned>(PowerOf2Floor(VL.size()), MinVF);
 5550   unsigned NextInst = 0, MaxInst = VL.size();
 5589         assert(Ops.size() == 2);
 6414       if (Order && Order->size() == VL.size()) {
 6414       if (Order && Order->size() == VL.size()) {
 6416         SmallVector<Value *, 4> ReorderedOps(VL.size());
 7061       for (int I = 0, E = GEPList.size(); I < E && Candidates.size() > 1; ++I) {

  802             Phi->getNumIncomingValues() == Masks.size()) &&

  130       if (LoadsSeen == Operands.size())

  357     return Args.size();
  473     return Attributes.size();
  669     return Args.size();
  682     if (Args.size() > 0) {
  848     return Position.size();
  932     return Lines.size();

 2342   size_t param_size() const { return parameters().size(); }
 2932     assert(chain().size() >= 2);
 2937     assert(chain().size() >= 2);
 4060   size_t param_size() const { return parameters().size(); }

 1241   size_t size() const { return Single ? 1 : Result.size(); }

 3442         InstantiatedFrom(InstantiatedFrom), NumExpansions(UsingDecls.size()) {
 3787         NumBindings(Bindings.size()) {

   88         UnsupportedFriend(false), NumTPLists(FriendTypeTPLists.size()) {

  267   unsigned clauselist_size() const { return Clauses.size(); }

  217             (assert(N == Params.size()),
  257       : Arguments(Args.data()), NumArguments(Args.size()) {}
  598     ID.AddInteger(TemplateArgs.size());
 1891     ID.AddInteger(TemplateArgs.size());
 2287       : Decl(Decl::FriendTemplate, DC, Loc), NumParams(Params.size()),
 2733     ID.AddInteger(TemplateArgs.size());

 4132         Length(Length ? *Length : PartialArgs.size()), Pack(Pack) {

  214     assert(VL.size() == NumVars &&
 4354     assert(UDs.size() == NumUniqueDeclarations &&
 4378     assert(DNLs.size() == NumUniqueDeclarations &&
 4404     assert(CLSs.size() == NumComponentLists &&
 4430     assert(Components.size() == NumComponents &&
 4432     assert(CLSs.size() == NumComponentLists &&
 4448     assert(Declarations.size() == ComponentLists.size() &&
 4448     assert(Declarations.size() == ComponentLists.size() &&
 4450     assert(Declarations.size() == NumComponentLists &&
 4501         PrevSize += C.size();
 4544     assert(DMDs.size() == OMPVarListClause<T>::varlist_size() &&
 4608       assert(UniqueDecls.size() == DeclsListNum.size() &&
 4608       assert(UniqueDecls.size() == DeclsListNum.size() &&
 4881     assert(llvm::array_lengthof(MapTypeModifiers) == MapModifiers.size() &&
 4886                MapModifiersLoc.size() &&

 1775     AttributedStmtBits.NumAttrs = Attrs.size();

  221     this->Args.NumArgs = Args.size();

 5502     setNumProtocols(protocols.size());
 5503     assert(getNumProtocols() == protocols.size() &&
 5507              protocols.size() * sizeof(ObjCProtocolDecl*));

  952     return this->getTypePtr()->getTypeArgsAsWritten().size();

  283     return VTableIndices.size();
  297       return vtable_components().size();
  301     size_t nextIndex = (i + 1 == VTableIndices.size())
  302                            ? vtable_components().size()

  896   if (List.size() <= N)
  915   return internal::getTemplateSpecializationArgs(Node).size() == N;
 3982   return (N < Node.parameters().size()

 1384   if (InnerMatchers.size() == 1) {

 1544   size_t numSuccessors() const { return successors().size(); }

  153   size_t param_size() const { return parameters().size(); }

  218     return ID >= (Builtin::FirstTSBuiltin + TSRecords.size());
  223   unsigned getAuxBuiltinID(unsigned ID) const { return ID - TSRecords.size(); }

  171     NumParameters = List.size();
  172     ParameterList = PPAllocator.Allocate<IdentifierInfo *>(List.size());
  509         NumOverrides(Overrides.size()) {

 1323     EnterTokenStream(Toks.data(), Toks.size(), DisableMacroExpansion, false,

 1054       assert((Conversions.empty() || Conversions.size() == NumConversions) &&

  202           totalSizeToAlloc<ParsedTemplateArgument>(TemplateArgs.size())))
  231           NumArgs(TemplateArgs.size()) {

  101       assert(Index < TemplateArgumentLists[getNumLevels() - Depth - 1].size());
  115       if (Index >= TemplateArgumentLists[getNumLevels() - Depth - 1].size())
  125       assert(Index < TemplateArgumentLists[getNumLevels() - Depth - 1].size());

  601     for (unsigned I = 0, N = Path.size(); I != N; ++I) {
  793   LVal.resizePath(Path.size());
  794   memcpy(LVal.getPath(), Path.data(), Path.size() * sizeof(LValuePathEntry));
  839   MPD->resizePath(Path.size());
  840   memcpy(MPD->getPath(), Path.data(), Path.size()*sizeof(const CXXRecordDecl*));

 3760   size_t NumArgs = ArgArray.size();
 3878       EPI.ExceptionSpec.Type, EPI.ExceptionSpec.Exceptions.size());
 4225                        sizeof(TemplateArgument) * Args.size() +
 4248   unsigned NumArgs = Args.size();
 4409   unsigned NumArgs = Args.size();
 4532   for (unsigned i = 1; i != Protocols.size(); ++i)
 4603       canonTypeArgsVec.reserve(effectiveTypeArgs.size());
 4629   size += typeArgs.size() * sizeof(QualType);
 4630   size += protocols.size() * sizeof(ObjCProtocolDecl *);
 4737   size += protocols.size() * sizeof(ObjCProtocolDecl *);
 8348   if (lhsArgs.size() != rhsArgs.size())
 8348   if (lhsArgs.size() != rhsArgs.size())
 8352   for (unsigned i = 0, n = lhsArgs.size(); i != n; ++i) {
 9184   size_t E = FirstHasInfo ? FirstFnType->getExtParameterInfos().size()
 9185                           : SecondFnType->getExtParameterInfos().size();

  241   for (unsigned I = 0, E = QualTypeVals.size(); I != E; ++I) {
  272   for (unsigned i = 0, e = PrevArgs.size(); i != e; ++i) {

  697   if (Error Err = ImportTemplateArguments(TemplArgs.data(), TemplArgs.size(),
 5819   SmallVector<const Attr *, 1> ToAttrs(FromAttrs.size());
 7045         E->getPartialArguments().size(),

  727   ParamVarDocs.resize(ParamVars.size(), nullptr);
  981   for (unsigned i = 0, e = ParamVars.size(); i != e; ++i) {
 1048   for (unsigned i = 0, e = ParamVars.size(); i != e; ++i)

 1925     TemplParamLists = new (Context) TemplateParameterList *[TPLists.size()];
 1926     NumTemplParamLists = TPLists.size();
 3194   assert(NewParamInfo.size() == getNumParams() && "Parameter count mismatch!");
 3198     ParamInfo = new (C) ParmVarDecl*[NewParamInfo.size()];
 4472     NumParams = NewParamInfo.size();
 4473     ParamInfo = new (getASTContext()) ParmVarDecl*[NewParamInfo.size()];
 4481   this->NumCaptures = Captures.size();
 4693       ChainingSize(CH.size()) {
 4844   assert(getNumModuleIdentifiers(Imported) == IdentifierLocs.size());
 4860               additionalSizeToAlloc<SourceLocation>(IdentifierLocs.size()))

 1359     for (unsigned I = 0, N = Decls.size(); I != N; ++I)
 1362     Skip.push_back(Decls.size());
 1366     for (unsigned I = 0, N = Decls.size(); I != N; ++I) {

 2904   size_t Extra = additionalSizeToAlloc<NamedDecl *>(UsingDecls.size());
 3025   size_t Extra = additionalSizeToAlloc<BindingDecl *>(Bindings.size());

   58           FriendTypeTPLists.size());

  866   NumParams = Params.size();
  874                   sizeof(SourceLocation) * SelLocs.size();
 1427     : NumParams(typeParams.size()) {
 1439       ctx.Allocate(totalSizeToAlloc<ObjCTypeParamDecl *>(typeParams.size()),

   33       new (C, DC, additionalSizeToAlloc<Expr *>(VL.size()))
   35   D->NumVars = VL.size();
   50   assert(VL.size() == NumVars &&
   65       C, DC, additionalSizeToAlloc<Expr *, OMPClause *>(VL.size(), CL.size()))
   65       C, DC, additionalSizeToAlloc<Expr *, OMPClause *>(VL.size(), CL.size()))
   67   D->NumVars = VL.size();
   69   D->NumClauses = CL.size();
   86   assert(VL.size() == NumVars &&
   92   assert(CL.size() == NumClauses &&
  108       new (C, DC, additionalSizeToAlloc<OMPClause *>(CL.size()))
  110   D->NumClauses = CL.size();
  124   assert(CL.size() == NumClauses &&
  204   size_t NumClauses = CL.size();
  213   assert(CL.size() == Clauses.size() &&
  213   assert(CL.size() == Clauses.size() &&

   52       NumParams(Params.size()), ContainsUnexpandedParameterPack(false),
   84                              Params.size(), RequiresClause ? 1u : 0u),
  570       ExpandedParameterPack(true), NumExpandedTypes(ExpandedTypes.size()) {
  598                   ExpandedTypes.size()))
  648       ExpandedParameterPack(true), NumExpandedParams(Expansions.size()) {
  670               additionalSizeToAlloc<TemplateParameterList *>(Expansions.size()))
  709       NumArguments(Args.size()) {
  717   void *Mem = Context.Allocate(totalSizeToAlloc<TemplateArgument>(Args.size()));

 1343   NumArgs = std::max<unsigned>(Args.size(), MinNumArgs);
 1344   unsigned NumPreArgs = PreArgs.size();
 1360   for (unsigned I = 0; I != Args.size(); ++I) {
 1364   for (unsigned I = Args.size(); I != NumArgs; ++I) {
 1385   unsigned NumArgs = std::max<unsigned>(Args.size(), MinNumArgs);
 1554       totalSizeToAlloc<OffsetOfNode, Expr *>(comps.size(), exprs.size()));
 1554       totalSizeToAlloc<OffsetOfNode, Expr *>(comps.size(), exprs.size()));
 1577     NumComps(comps.size()), NumExprs(exprs.size())
 1577     NumComps(comps.size()), NumExprs(exprs.size())
 1579   for (unsigned i = 0; i != comps.size(); ++i) {
 1583   for (unsigned i = 0; i != exprs.size(); ++i) {
 2223     InitExprs(C, initExprs.size()),
 2227   for (unsigned I = 0; I != initExprs.size(); ++I) {
 3125   for (unsigned I = 0; I < Exprs.size(); ++I)
 4105      BuiltinLoc(BLoc), RParenLoc(RP), NumExprs(args.size())
 4107   SubExprs = new (C) Stmt*[args.size()];
 4108   for (unsigned i = 0; i != args.size(); i++) {
 4125   this->NumExprs = Exprs.size();
 4127   memcpy(SubExprs, Exprs.data(), sizeof(Expr *) * Exprs.size());
 4142       NumAssocs(AssocExprs.size()), ResultIndex(ResultIndex),
 4144   assert(AssocTypes.size() == AssocExprs.size() &&
 4144   assert(AssocTypes.size() == AssocExprs.size() &&
 4167       NumAssocs(AssocExprs.size()), ResultIndex(ResultDependentIndex),
 4169   assert(AssocTypes.size() == AssocExprs.size() &&
 4169   assert(AssocTypes.size() == AssocExprs.size() &&
 4189   unsigned NumAssocs = AssocExprs.size();
 4203   unsigned NumAssocs = AssocExprs.size();
 4245     NumDesignators(Designators.size()), NumSubExprs(IndexExprs.size() + 1) {
 4245     NumDesignators(Designators.size()), NumSubExprs(IndexExprs.size() + 1) {
 4295   assert(IndexIdx == IndexExprs.size() && "Wrong number of index expressions");
 4304   void *Mem = C.Allocate(totalSizeToAlloc<Stmt *>(IndexExprs.size() + 1),
 4422   ParenListExprBits.NumExprs = Exprs.size();
 4424   for (unsigned I = 0, N = Exprs.size(); I != N; ++I) {
 4447   void *Mem = Ctx.Allocate(totalSizeToAlloc<Stmt *>(Exprs.size()),
 4488   assert(semantics.size() && "no semantic expressions!");
 4496     assert(resultIndex < semantics.size());
 4502   void *buffer = C.Allocate(totalSizeToAlloc<Expr *>(semantics.size() + 1),
 4513   PseudoObjectExprBits.NumSubExprs = semantics.size() + 1;
 4516   for (unsigned i = 0, e = semantics.size() + 1; i != e; ++i) {
 4564     NumSubExprs(args.size()), BuiltinLoc(BLoc), RParenLoc(RP), Op(op)
 4566   assert(args.size() == getNumSubExprs(op) && "wrong number of subexpressions");
 4567   for (unsigned i = 0; i != args.size(); i++) {

  193   CXXNewExprBits.NumPlacementArgs = PlacementArgs.size();
  219   for (unsigned I = 0; I != PlacementArgs.size(); ++I) {
  267   unsigned NumPlacementArgs = PlacementArgs.size();
  640   unsigned NumArgs = Args.size();
  699   unsigned NumArgs = std::max<unsigned>(Args.size(), MinNumArgs);
  939   unsigned NumArgs = Args.size();
 1041   unsigned SizeOfTrailingObjects = sizeOfTrailingObjects(Args.size());
 1076   unsigned SizeOfTrailingObjects = sizeOfTrailingObjects(Args.size());
 1104       NumArgs(Args.size()) {
 1114   for (unsigned I = 0, N = Args.size(); I != N; ++I) {
 1182       NumCaptures(Captures.size()), CaptureDefault(CaptureDefault),
 1185   assert(CaptureInits.size() == Captures.size() && "Wrong number of arguments");
 1185   assert(CaptureInits.size() == Captures.size() && "Wrong number of arguments");
 1198   for (unsigned I = 0, N = Captures.size(); I != N; ++I) {
 1207   for (unsigned I = 0, N = CaptureInits.size(); I != N; ++I)
 1224   unsigned Size = totalSizeToAlloc<Stmt *>(Captures.size() + 1);
 1326   ExprWithCleanupsBits.NumObjects = objects.size();
 1327   for (unsigned i = 0, e = objects.size(); i != e; ++i)
 1334   void *buffer = C.Allocate(totalSizeToAlloc<CleanupObject>(objects.size()),
 1368   CXXUnresolvedConstructExprBits.NumArgs = Args.size();
 1370   for (unsigned I = 0; I != Args.size(); ++I) {
 1381   void *Mem = Context.Allocate(totalSizeToAlloc<Expr *>(Args.size()));
 1602       Context.Allocate(totalSizeToAlloc<TemplateArgument>(PartialArgs.size()));
 1645   return new (Context.Allocate(totalSizeToAlloc<VarDecl *>(Params.size())))
 1646       FunctionParmPackExpr(T, ParamPack, NameLoc, Params.size(), Params.data());
 1687   TypeTraitExprBits.NumArgs = Args.size();
 1691   for (unsigned I = 0, N = Args.size(); I != N; ++I) {
 1709   void *Mem = C.Allocate(totalSizeToAlloc<TypeSourceInfo *>(Args.size()));
 1735   unsigned NumArgs = std::max<unsigned>(Args.size(), MinNumArgs);
 1768       NumTemplateArgs(ConvertedArgs.size()) {
 1781   assert(Converted.size() == NumTemplateArgs);
 1818                                 ConvertedArgs.size()));

  204     for (unsigned I = 0, N = Path.size(); I != N; ++I) {
 5053        PathLength <= Path.size(); ++PathLength) {
 5157   for (unsigned I = 1; I != Path.size(); ++I) {
 5437     ForbiddenNullArgs.resize(Args.size());
 5445           if (ASTIdx >= Args.size())
 5451   for (unsigned Idx = 0; Idx < Args.size(); Idx++) {
 5477   ArgVector ArgValues(Args.size());
 5737   ArgVector ArgValues(Args.size());
 9231       assert(V.size() == E->getType()->castAs<VectorType>()->getNumElements());
 9233       Result = APValue(V.data(), V.size());
14349   ArgVector ArgValues(Args.size());

   30       NumElements(Elements.size()), Range(SR), ArrayWithObjectsMethod(Method) {
   32   for (unsigned I = 0, N = Elements.size(); I != N; ++I) {
   48   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(Elements.size()));
   64       NumElements(VK.size()), HasPackExpansions(HasPackExpansions), Range(SR),
   99       VK.size(), HasPackExpansions ? VK.size() : 0));
   99       VK.size(), HasPackExpansions ? VK.size() : 0));
  183   setNumArgs(Args.size());
  185   for (unsigned I = 0; I != Args.size(); ++I) {
  217     Mem = alloc(Context, Args.size(), 0);
  236     Mem = alloc(Context, Args.size(), 0);
  255     Mem = alloc(Context, Args.size(), 0);
  278       (SelLocsK == SelLoc_NonStandard) ? SelLocs.size() : 0;
  279   return alloc(C, Args.size(), NumStoredSelLocs);

  120     return LHS.Bindings.size() == RHS.Bindings.size() &&
  120     return LHS.Bindings.size() == RHS.Bindings.size() &&

 4188                        CSE->getTemplateArguments().size());

  917     ID.AddInteger(TypeArgs.size());
  923     ID.AddInteger(Protocols.size());
  941     ID.AddInteger(Protocols.size());

   55     ArgsData.reserve(Args.size());
   68     if (ArgIndex < Args.size())

  317   assert(VL.size() == varlist_size() &&
  327   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(2 * VL.size()));
  329       new (Mem) OMPPrivateClause(StartLoc, LParenLoc, EndLoc, VL.size());
  342   assert(VL.size() == varlist_size() &&
  348   assert(VL.size() == varlist_size() &&
  358   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(3 * VL.size()));
  360       new (Mem) OMPFirstprivateClause(StartLoc, LParenLoc, EndLoc, VL.size());
  375   assert(PrivateCopies.size() == varlist_size() &&
  381   assert(SrcExprs.size() == varlist_size() && "Number of source expressions is "
  388   assert(DstExprs.size() == varlist_size() && "Number of destination "
  395   assert(AssignmentOps.size() == varlist_size() &&
  407   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(5 * VL.size()));
  409       new (Mem) OMPLastprivateClause(StartLoc, LParenLoc, EndLoc, VL.size());
  430   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(VL.size()));
  432       new (Mem) OMPSharedClause(StartLoc, LParenLoc, EndLoc, VL.size());
  443   assert(PL.size() == varlist_size() &&
  449   assert(IL.size() == varlist_size() &&
  455   assert(UL.size() == varlist_size() &&
  461   assert(FL.size() == varlist_size() &&
  468       UE.size() == varlist_size() + 1 &&
  482       C.Allocate(totalSizeToAlloc<Expr *>(5 * VL.size() + 2 + VL.size() + 1));
  482       C.Allocate(totalSizeToAlloc<Expr *>(5 * VL.size() + 2 + VL.size() + 1));
  484       StartLoc, LParenLoc, Modifier, ModifierLoc, ColonLoc, EndLoc, VL.size());
  490   std::fill(Clause->getInits().end(), Clause->getInits().end() + VL.size(),
  492   std::fill(Clause->getUpdates().end(), Clause->getUpdates().end() + VL.size(),
  522   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(VL.size() + 1));
  524       OMPAlignedClause(StartLoc, LParenLoc, ColonLoc, EndLoc, VL.size());
  537   assert(SrcExprs.size() == varlist_size() && "Number of source expressions is "
  544   assert(DstExprs.size() == varlist_size() && "Number of destination "
  551   assert(AssignmentOps.size() == varlist_size() &&
  562   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(4 * VL.size()));
  564       new (Mem) OMPCopyinClause(StartLoc, LParenLoc, EndLoc, VL.size());
  578   assert(SrcExprs.size() == varlist_size() && "Number of source expressions is "
  585   assert(DstExprs.size() == varlist_size() && "Number of destination "
  592   assert(AssignmentOps.size() == varlist_size() &&
  603   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(4 * VL.size()));
  605       new (Mem) OMPCopyprivateClause(StartLoc, LParenLoc, EndLoc, VL.size());
  620   assert(Privates.size() == varlist_size() &&
  627       LHSExprs.size() == varlist_size() &&
  634       RHSExprs.size() == varlist_size() &&
  640   assert(ReductionOps.size() == varlist_size() && "Number of reduction "
  653   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(5 * VL.size()));
  655       StartLoc, LParenLoc, EndLoc, ColonLoc, VL.size(), QualifierLoc, NameInfo);
  673   assert(Privates.size() == varlist_size() &&
  680       LHSExprs.size() == varlist_size() &&
  687       RHSExprs.size() == varlist_size() &&
  693   assert(ReductionOps.size() == varlist_size() && "Number of task reduction "
  706   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(5 * VL.size()));
  708       StartLoc, LParenLoc, EndLoc, ColonLoc, VL.size(), QualifierLoc, NameInfo);
  726   assert(Privates.size() == varlist_size() &&
  733       LHSExprs.size() == varlist_size() &&
  740       RHSExprs.size() == varlist_size() &&
  746   assert(ReductionOps.size() == varlist_size() && "Number of in reduction "
  754   assert(TaskgroupDescriptors.size() == varlist_size() &&
  768   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(6 * VL.size()));
  770       StartLoc, LParenLoc, EndLoc, ColonLoc, VL.size(), QualifierLoc, NameInfo);
  794   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(VL.size()));
  796                                              ColonLoc, EndLoc, VL.size());
  812   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(VL.size() + 1));
  814       new (Mem) OMPFlushClause(StartLoc, LParenLoc, EndLoc, VL.size());
  830   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(VL.size() + NumLoops));
  832       OMPDependClause(StartLoc, LParenLoc, EndLoc, VL.size(), NumLoops);
  909   Sizes.NumVars = Vars.size();
  911   Sizes.NumComponentLists = ComponentLists.size();
  960   Sizes.NumVars = Vars.size();
  962   Sizes.NumComponentLists = ComponentLists.size();
 1007   Sizes.NumVars = Vars.size();
 1009   Sizes.NumComponentLists = ComponentLists.size();
 1051   assert(VL.size() == varlist_size() &&
 1057   assert(VL.size() == varlist_size() &&
 1068   Sizes.NumVars = Vars.size();
 1070   Sizes.NumComponentLists = ComponentLists.size();
 1117   Sizes.NumVars = Vars.size();
 1119   Sizes.NumComponentLists = ComponentLists.size();

   65   return Index < Args.size() ? getArgLoc(Args[Index]) : SourceLocation();
   75   for (i = 0; i != SelLocs.size(); ++i) {
   80   if (i == SelLocs.size())
   84   for (i = 0; i != SelLocs.size(); ++i) {

  306   CompoundStmtBits.NumStmts = Stmts.size();
  312   assert(CompoundStmtBits.NumStmts == Stmts.size() &&
  321       C.Allocate(totalSizeToAlloc<Stmt *>(Stmts.size()), alignof(CompoundStmt));
  359   void *Mem = C.Allocate(totalSizeToAlloc<const Attr *>(Attrs.size()),
  787               numinputs, clobbers.size()), LBraceLoc(lbraceloc),
  788               EndLoc(endloc), NumAsmToks(asmtoks.size()) {
  801   assert(NumAsmToks == asmtoks.size());
  802   assert(NumClobbers == clobbers.size());
  804   assert(exprs.size() == NumOutputs + NumInputs);
  805   assert(exprs.size() == constraints.size());
  805   assert(exprs.size() == constraints.size());
  809   Exprs = new (C) Stmt*[exprs.size()];
  812   AsmToks = new (C) Token[asmtoks.size()];
  815   Constraints = new (C) StringRef[exprs.size()];
 1216   : Stmt(CapturedStmtClass), NumCaptures(Captures.size()),
 1256   assert(CaptureInits.size() == Captures.size() && "wrong number of arguments");
 1256   assert(CaptureInits.size() == Captures.size() && "wrong number of arguments");
 1258   unsigned Size = sizeof(CapturedStmt) + sizeof(Stmt *) * (Captures.size() + 1);
 1262     Size += sizeof(Capture) * Captures.size();

   27   const size_t Size = totalSizeToAlloc<Stmt *>(handlers.size() + 1);
   41     : Stmt(CXXTryStmtClass), TryLoc(tryLoc), NumHandlers(handlers.size()) {
   89       CoroutineBodyStmt::FirstParamMove + Args.ParamMoves.size());
  110     : Stmt(CoroutineBodyStmtClass), NumParams(Args.ParamMoves.size()) {

   20   assert(Clauses.size() == getNumClauses() &&
   45   assert(A.size() == getCollapsedNumber() &&
   51   assert(A.size() == getCollapsedNumber() && "Number of loop private counters "
   58   assert(A.size() == getCollapsedNumber() &&
   64   assert(A.size() == getCollapsedNumber() &&
   70   assert(A.size() == getCollapsedNumber() &&
   77       A.size() == getCollapsedNumber() &&
   83   assert(A.size() == getCollapsedNumber() &&
   89   assert(A.size() == getCollapsedNumber() &&
  100       C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
  102       new (Mem) OMPParallelDirective(StartLoc, EndLoc, Clauses.size());
  126       C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
  129       OMPSimdDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size());
  169       C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
  172       new (Mem) OMPForDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size());
  222       C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
  225       OMPForSimdDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size());
  273       C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
  275       new (Mem) OMPSectionsDirective(StartLoc, EndLoc, Clauses.size());
  320       C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
  322       new (Mem) OMPSingleDirective(StartLoc, EndLoc, Clauses.size());
  363       C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
  365       new (Mem) OMPCriticalDirective(Name, StartLoc, EndLoc, Clauses.size());
  387   void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
  391       OMPParallelForDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size());
  440       Size + sizeof(OMPClause *) * Clauses.size() +
  443       StartLoc, EndLoc, CollapsedNum, Clauses.size());
  491       C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
  493       new (Mem) OMPParallelSectionsDirective(StartLoc, EndLoc, Clauses.size());
  516       C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
  518       new (Mem) OMPTaskDirective(StartLoc, EndLoc, Clauses.size());
  581                                     sizeof(OMPClause *) * Clauses.size(),
  585       new (Mem) OMPTaskgroupDirective(StartLoc, EndLoc, Clauses.size());
  627                                     sizeof(OMPClause *) * Clauses.size(),
  631       new (Mem) OMPCancelDirective(StartLoc, EndLoc, Clauses.size());
  653   void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size());
  655       new (Mem) OMPFlushDirective(StartLoc, EndLoc, Clauses.size());
  677       C.Allocate(Size + sizeof(Stmt *) + sizeof(OMPClause *) * Clauses.size());
  679       new (Mem) OMPOrderedDirective(StartLoc, EndLoc, Clauses.size());
  701   void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
  704       new (Mem) OMPAtomicDirective(StartLoc, EndLoc, Clauses.size());
  734       C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
  736       new (Mem) OMPTargetDirective(StartLoc, EndLoc, Clauses.size());
  758       C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
  760       new (Mem) OMPTargetParallelDirective(StartLoc, EndLoc, Clauses.size());
  783       Size + sizeof(OMPClause *) * Clauses.size() +
  786       StartLoc, EndLoc, CollapsedNum, Clauses.size());
  834       sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
  836       new (Mem) OMPTargetDataDirective(StartLoc, EndLoc, Clauses.size());
  856       sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
  858       new (Mem) OMPTargetEnterDataDirective(StartLoc, EndLoc, Clauses.size());
  878       sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
  880       new (Mem) OMPTargetExitDataDirective(StartLoc, EndLoc, Clauses.size());
  903       C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
  905       new (Mem) OMPTeamsDirective(StartLoc, EndLoc, Clauses.size());
  928       C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
  931       OMPTaskLoopDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size());
  979   void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
  983       OMPTaskLoopSimdDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size());
 1031       Size + sizeof(OMPClause *) * Clauses.size() +
 1034       StartLoc, EndLoc, CollapsedNum, Clauses.size());
 1083       C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
 1087       StartLoc, EndLoc, CollapsedNum, Clauses.size());
 1137       Size + sizeof(OMPClause *) * Clauses.size() +
 1141       StartLoc, EndLoc, CollapsedNum, Clauses.size());
 1191   void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
 1195       OMPDistributeDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size());
 1242       C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
 1244       new (Mem) OMPTargetUpdateDirective(StartLoc, EndLoc, Clauses.size());
 1267       Size + sizeof(OMPClause *) * Clauses.size() +
 1272                                                   CollapsedNum, Clauses.size());
 1338       Size + sizeof(OMPClause *) * Clauses.size() +
 1343                                             Clauses.size());
 1408       Size + sizeof(OMPClause *) * Clauses.size() +
 1412       StartLoc, EndLoc, CollapsedNum, Clauses.size());
 1462       Size + sizeof(OMPClause *) * Clauses.size() +
 1467                                                   CollapsedNum, Clauses.size());
 1518   void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
 1522       OMPTargetSimdDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size());
 1562       Size + sizeof(OMPClause *) * Clauses.size() +
 1565       StartLoc, EndLoc, CollapsedNum, Clauses.size());
 1614       C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
 1619                                                 Clauses.size());
 1669       C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
 1675                                                  Clauses.size());
 1742       Size + sizeof(OMPClause *) * Clauses.size() +
 1747                                              Clauses.size());
 1812       C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
 1814       new (Mem) OMPTargetTeamsDirective(StartLoc, EndLoc, Clauses.size());
 1837       Size + sizeof(OMPClause *) * Clauses.size() +
 1842                                                   Clauses.size());
 1895       Size + sizeof(OMPClause *) * Clauses.size() +
 1901            StartLoc, EndLoc, CollapsedNum, Clauses.size());
 1971       Size + sizeof(OMPClause *) * Clauses.size() +
 1977            StartLoc, EndLoc, CollapsedNum, Clauses.size());
 2044       Size + sizeof(OMPClause *) * Clauses.size() +
 2049                                             Clauses.size());

 1863     ID.AddInteger(Args.size());

  677   ObjCObjectTypeBits.NumTypeArgs = typeArgs.size();
  678   assert(getTypeArgsAsWritten().size() == typeArgs.size() &&
  678   assert(getTypeArgsAsWritten().size() == typeArgs.size() &&
  682            typeArgs.size() * sizeof(QualType));
 1597   assert(typeArgs.size() == typeParams->size());
 2709   DependentTemplateSpecializationTypeBits.NumArgs = Args.size();
 2964   FunctionTypeBits.NumParams = params.size();
 2965   assert(getNumParams() == params.size() && "NumParams overflow!");
 2974     ExtraBits.NumExceptionType = epi.ExceptionSpec.Exceptions.size();
 3445   TemplateSpecializationTypeBits.NumArgs = Args.size();
 3514   ID.AddInteger(typeArgs.size());
 3517   ID.AddInteger(protocols.size());
 3533   ID.AddInteger(protocols.size());

 2203   if (VTableIndices.size() <= 1)
 2204     assert(VTableIndices.size() == 1 && VTableIndices[0] == 0);

  265   if (InnerMatchers.size() != 1)

  143       if (Index < Args.size()) {

  378   ArgT **InnerArgs = new ArgT *[Args.size()]();
  381   for (size_t i = 0, e = Args.size(); i != e; ++i) {
  398                                                            Args.size())));
  401   for (size_t i = 0, e = Args.size(); i != e; ++i) {
  518   CHECK_ARG_COUNT(0);
  529   CHECK_ARG_COUNT(1);
  542   CHECK_ARG_COUNT(2);
  673     if (Args.size() < MinCount || MaxCount < Args.size()) {
  673     if (Args.size() < MinCount || MaxCount < Args.size()) {
  679           << ("(" + Twine(MinCount) + ", " + MaxStr + ")") << Args.size();
  684     for (size_t i = 0, e = Args.size(); i != e; ++i) {

  409                                    AllParams.size() - 1)]

  279   if (X.getRanges().size() != Y.getRanges().size())
  279   if (X.getRanges().size() != Y.getRanges().size())
  280     return X.getRanges().size() < Y.getRanges().size();
  280     return X.getRanges().size() < Y.getRanges().size();
  284   for (unsigned i = 0, n = X.getRanges().size(); i < n; ++i) {
  897   for (int I = 0, Last = TAList.size() - 1; I != Last; ++I) {
  901   describeTemplateParameter(Out, TAList[TAList.size() - 1], LO);

   35           (TSRecords.size() + AuxTSRecords.size())) &&
   35           (TSRecords.size() + AuxTSRecords.size())) &&
   99   for (unsigned i = 0, e = TSRecords.size(); i != e; ++i)
  104   for (unsigned i = 0, e = AuxTSRecords.size(); i != e; ++i)
  106         .setBuiltinID(i + Builtin::FirstTSBuiltin + TSRecords.size());

  417   if (getNumArgs() != Names.size())
  419   for (unsigned I = 0, E = Names.size(); I != E; ++I) {

  472       return n < Names.size();
  486       if (AN == Name && ARN.RegNum < Names.size())
  515       assert(n < Names.size() && "Out of bounds register number!");
  527       if (AN == Name && ARN.RegNum < Names.size())
  633   for (Index = 0; Index != OutputConstraints.size(); ++Index)
  663         if (i >= OutputConstraints.size()) return false;

  507   assert(Types.size() > 0 && "Empty list of types.");
 5850   int PairPos = 0, End = Ops.size() - 1;
 9465   assert((Ops.size() & (Ops.size() - 1)) == 0 &&
 9465   assert((Ops.size() & (Ops.size() - 1)) == 0 &&
 9468   for (unsigned i = 0, e = Ops.size(); i != e && AllConstants; ++i)
 9474     for (unsigned i = 0, e = Ops.size(); i != e; ++i)
 9481     llvm::UndefValue::get(llvm::VectorType::get(Ops[0]->getType(), Ops.size()));
 9483   for (unsigned i = 0, e = Ops.size(); i != e; ++i)
 9708   assert((Ops.size() == 2 || Ops.size() == 4) &&
 9708   assert((Ops.size() == 2 || Ops.size() == 4) &&
 9734   if (Ops.size() == 4)
 9779   assert(Ops.size() == 2);
 9893   if (Ops.size() > 4)
 9914   if (Ops.size() > 3) {

  259   for (unsigned I = 0, N = Path.size(); I != N; ++I) {

  161   assert(ExtInfos.size() == FPT->getNumParams());
  803   assert(paramInfos.empty() || paramInfos.size() == argTypes.size());
  803   assert(paramInfos.empty() || paramInfos.size() == argTypes.size());
  805          required.getNumRequiredArgs() <= argTypes.size());
  809                                   argTypes.size() + 1, paramInfos.size()));
  809                                   argTypes.size() + 1, paramInfos.size()));
  826   FI->NumArgs = argTypes.size();
  829   for (unsigned i = 0, e = argTypes.size(); i != e; ++i)
  831   for (unsigned i = 0, e = paramInfos.size(); i != e; ++i)
 1469       IRArgs.NumberOfArgs = AI.getCoerceAndExpandTypeSequence().size();
 3407   assert((int)ArgTypes.size() == (ArgRange.end() - ArgRange.begin()));
 3455   for (unsigned I = 0, E = ArgTypes.size(); I != E; ++I) {

 1749   for (unsigned i = 0, e = TAList.size(); i != e; ++i) {
 1998         VFTLayout.vtable_components().size() - CGM.getLangOpts().RTTIData;

  712     for (unsigned i = 0, e = Decls.size(); i != e; ++i)

 3010   assert(Checked.size() > 0);
 3018   for (int i = 0, n = Checked.size(); i < n; ++i) {
 3045   for (int i = 1, n = Checked.size(); i < n; ++i) {
 3068     Args.reserve(DynamicArgs.size() + 1);
 3069     ArgTypes.reserve(DynamicArgs.size() + 1);
 3083     for (size_t i = 0, n = DynamicArgs.size(); i != n; ++i) {
 3442                                                         indices.size() - 1,

  409     for (size_t I = 0; I != Elems.size(); ++I) {
  459     for (size_t I = 0; I != Elems.size(); ++I) {

 3699   assert(Args.size() == 3 && "Expected 3 argument here!");

 1169     MethodList.addInt(IntTy, Methods.size());
 1330         Protocols.size());
 1336     ProtocolBuilder.addInt(SizeTy, Protocols.size());
 2777   MethodList.addInt(Int32Ty, Methods.size());
 2848   IvarList.addInt(IntTy, (int)IvarNames.size());
 2856   for (unsigned int i = 0, e = IvarNames.size() ; i < e ; i++) {
 2991   MethodList.addInt(IntTy, Methods.size());
 3011   ProtocolList.addInt(LongTy, Protocols.size());
 3186   int bitCount = bits.size();

 2347       for (unsigned i = 0, e = buffer.size(); i < e; i++)
 2493   for (unsigned i = 0, e = RecFields.size(); i != e; ++i) {
 3326                                              MethodTypes.size());
 3942     values.addInt(ObjCTypes.IntTy, methods.size());
 3959   values.addInt(ObjCTypes.IntTy, methods.size());
 6053   unsigned NumClasses = Container.size();
 6708   values.addInt(ObjCTypes.IntTy, methods.size());

  974   ClausesData.reserve(Shareds.size());
  975   SharedAddresses.reserve(Shareds.size());
  976   Sizes.reserve(Shareds.size());
  977   BaseDecls.reserve(Shareds.size());
 3063         CGF.Builder.getInt32(CapturedVars.size()), // Number of captured vars
 3324   for (unsigned I = 0, E = AssignmentOps.size(); I < E; ++I) {
 3350   assert(CopyprivateVars.size() == SrcExprs.size() &&
 3350   assert(CopyprivateVars.size() == SrcExprs.size() &&
 3351          CopyprivateVars.size() == DstExprs.size() &&
 3351          CopyprivateVars.size() == DstExprs.size() &&
 3352          CopyprivateVars.size() == AssignmentOps.size());
 3352          CopyprivateVars.size() == AssignmentOps.size());
 3386     llvm::APInt ArraySize(/*unsigned int numBits=*/32, CopyprivateVars.size());
 3393     for (unsigned I = 0, E = CopyprivateVars.size(); I < E; ++I) {
 5598   for (unsigned I = 0, E = ReductionOps.size(); I < E; ++I, ++IPriv, ++Idx) {
 5736   auto Size = RHSExprs.size();
 5750   for (unsigned I = 0, E = RHSExprs.size(); I < E; ++I, ++IPriv, ++Idx) {
 5789       CGF.Builder.getInt32(RHSExprs.size()), // i32 <n>
 9909       CGF.Builder.getInt32(CapturedVars.size()), // Number of captured vars
10794     assert(CallArgs.size() == DoacrossFinArgs);
10830   llvm::APInt Size(/*numBits=*/32, NumIterations.size());
10838   for (unsigned I = 0, E = NumIterations.size(); I < E; ++I) {
10861       llvm::ConstantInt::getSigned(CGM.Int32Ty, NumIterations.size()),
10955     assert(CallArgs.size() == CleanupArgs &&

 2555           llvm::ConstantInt::get(CGM.SizeTy, CapturedVars.size())};
 2977   unsigned Size = Privates.size();
 3779   for (unsigned I = 0, E = Privates.size(); I < E; ++I, ++IPriv, ++Idx) {
 3979   for (unsigned I = 0, E = Privates.size(); I < E; ++I, ++IPriv, ++Idx) {
 4291   auto Size = RHSExprs.size();
 4305   for (unsigned I = 0, E = RHSExprs.size(); I < E; ++I, ++IPriv, ++Idx) {
 4339                            CGF.Builder.getInt32(RHSExprs.size()),
 4352     llvm::SmallVector<const ValueDecl *, 4> PrivatesReductions(Privates.size());
 4512   TargetArgs.reserve(Args.size());
 4514   for (unsigned I = 0, E = Args.size(); I < E; ++I) {

 1587                   E = C->getLoopNumIterations().size();
 5199                         E = C->getLoopNumIterations().size();

  705     } else if (nextVTableThunkIndex < layout.vtable_thunks().size() &&
 1117     for (unsigned I = 0; I != Comps.size(); ++I) {

 1028   if (Weights.size() < 2)
 1040   ScaledWeights.reserve(Weights.size());

  253   auto type = llvm::ArrayType::get(eltTy, elts.size());

 2561   for (unsigned I = 0; I != CXXThreadLocalInits.size(); ++I) {

 2317   for (size_t I = 0, E = CXXThreadLocalInitVars.size(); I != E; ++I) {
 2759     assert(DerivedToBasePath.size() == MemberPointerPath.size());

 3811     assert(ElementNum <= ActionInfo.size() && "Invalid number of elements.");
 3830     if (ActionInfo.size() < 3 || !canCollapseAssembleAction())
 3862     if (ActionInfo.size() < 2 || !canCollapseAssembleAction())
 3885     if (ActionInfo.size() < 2)
 3898     for (size_t i = 1; i < ActionInfo.size(); i++)
 4928   while (CurDigit < Digits.size()) {

  228   for (size_t i = 0, e = Args.size(); i < e; ++i) {
  311   Environment.reserve(NewEnvironment.size() + 1);

 6385   for (unsigned I = 0; I < DepInfo.size(); ++I) {

  341       for (size_t i = 0, e = Styles.size(); i < e; ++i) {

  302   if (Tokens.size() < Kinds.size())
  306       Tokens.end() - Kinds.size();
  310   for (unsigned i = 1; i < Kinds.size(); ++i) {
  316   Tokens.resize(Tokens.size() - Kinds.size() + 1);

 1857   if (Path.size() > 1) {
 1858     for (unsigned I = 1, N = Path.size(); I != N; ++I) {

 6293   if (SuperProtocols.size() > 0) {
 6295     Write_protocol_list_t_TypeDecl(Result, SuperProtocols.size());
 6299     Result += "\t"; Result += utostr(SuperProtocols.size()); Result += ",\n";
 6300     for (unsigned i = 0, e = SuperProtocols.size(); i < e; i++) {
 6318   if (Methods.size() > 0) {
 6320     Write_method_list_t_TypeDecl(Result, Methods.size());
 6325     Result += "\t"; Result += utostr(Methods.size()); Result += ",\n";
 6326     for (unsigned i = 0, e = Methods.size(); i < e; i++) {
 6358   if (Properties.size() > 0) {
 6360     Write__prop_list_t_TypeDecl(Result, Properties.size());
 6365     Result += "\t"; Result += utostr(Properties.size()); Result += ",\n";
 6366     for (unsigned i = 0, e = Properties.size(); i < e; i++) {
 6427   if (baseMethods.size() > 0) {
 6439   if (!metaclass && baseProtocols.size() > 0) {
 6447   if (!metaclass && ivars.size() > 0) {
 6457   if (!metaclass && Properties.size() > 0) {
 6639   if (InstanceMethods.size() > 0) {
 6648   if (ClassMethods.size() > 0) {
 6657   if (RefedProtocols.size() > 0) {
 6666   if (ClassProperties.size() > 0) {
 6695   if (Methods.size() == 0)
 6702   for (unsigned i = 0, e = Methods.size(); i < e; i++) {
 6734   for (unsigned i =0, e = Ivars.size(); i < e; i++) {
 6765   if (OriginalIvars.size() > 0) {
 6771     for (unsigned i = 0, e = OriginalIvars.size(); i < e; i++) {

  411   FinalRelations.reserve(Relations.size()+1);

 1483   for (unsigned i = 1; i != StringToks.size(); ++i) {
 1539   for (unsigned i = 0, e = StringToks.size(); i != e; ++i) {

   36     if ((*Entry)->NumUnexpArgTokens >= UnexpArgTokens.size() &&
   41       if ((*Entry)->NumUnexpArgTokens == UnexpArgTokens.size())
   52         llvm::safe_malloc(totalSizeToAlloc<Token>(UnexpArgTokens.size())))
   53         MacroArgs(UnexpArgTokens.size(), VarargsElided, MI->getNumParams());
   58     Result->NumUnexpArgTokens = UnexpArgTokens.size();

  245       sizeof(ModuleMacro) + sizeof(ModuleMacro *) * Overrides.size(),

  161   CachedTokens.erase(CachedTokens.begin() + CachedLexPos - 1 + NewToks.size());
  162   CachedLexPos += NewToks.size() - 1;

 1575   for (size_t I = 0, N = Path.size(); I != N; ++I) {

 1030   bool cacheNeedsToGrow = tokens.size() >

  346   return Tokens.size() == MI->getNumTokens() &&
 1137     auto ToksCopy = std::make_unique<Token[]>(Toks.size());
 1139     EnterTokenStream(std::move(ToksCopy), Toks.size(),

  755     return TokenStream.size() == CurIdx;

 1110     if (Toks.size() > 2)

   53     assert(AsmToks.size() == AsmTokOffsets.size());
   53     assert(AsmToks.size() == AsmTokOffsets.size());
  159   for (unsigned i = FirstTokIndex, e = AsmTokOffsets.size(); i != e; ++i) {
  185   if (TokIndex < AsmToks.size()) {
  306   for (unsigned i = 0, e = AsmToks.size(); i < e; ++i) {
  348   assert(TokOffsets.size() == AsmToks.size());

  251     for (unsigned i = 0, NumToks = Toks.size(); i != NumToks; ++i) {
  265     if (Toks.size() == 1 && Toks[0] == tok::eof &&

  270     I.Fun.NumExceptionsOrDecls = DeclsInPrototype.size();
  272     I.Fun.DeclsInPrototype = new NamedDecl *[DeclsInPrototype.size()];
  273     for (size_t J = 0; J < DeclsInPrototype.size(); ++J)
  288   BindingGroup.NumBindings = Bindings.size();
  296   if (Bindings.size()) {
  298         Bindings.size() <= llvm::array_lengthof(InlineBindings)) {
  304           new DecompositionDeclarator::Binding[Bindings.size()];

   49   DD.AvailabilityData.SelectorLocs = new SourceLocation[Locs.size()];
   51          sizeof(SourceLocation) * Locs.size());
   52   DD.AvailabilityData.NumSelectorLocs = Locs.size();

  822   for (unsigned I = 0, E = ToScopes.size(); I != E; ++I)

  645       OS << (I.index() == Rules.size() - 1 ? ", and " : ", ");

 4229         if (IdxAST >= Args.size())
 4232           NonNullArgs.resize(Args.size());
 4254           NonNullArgs.resize(Args.size());
 4283             NonNullArgs.resize(Args.size());
 4317       CheckedVarArgs.resize(Args.size());
 4336     for (unsigned ArgIdx = NumParams; ArgIdx < Args.size(); ++ArgIdx) {
 4673   if (Args.size() < AdjustedNumArgs) {
 4675         << 0 << AdjustedNumArgs << static_cast<unsigned>(Args.size())
 4678   } else if (Args.size() > AdjustedNumArgs) {
 4681         << 0 << AdjustedNumArgs << static_cast<unsigned>(Args.size())
 4965     auto *Scope = Args[Args.size() - 1];
 7139   if (format_idx >= Args.size()) {
 7169     assert(ArgIdx < Args.size() && "ArgIdx outside bounds");
 7192   if (Args.size() == firstDataArg) {
 8790   const unsigned numDataArgs = Args.size() - firstDataArg;
11400   if (TypeArgs.size() != 1)
11429   if (TypeArgs.size() != 2)
14543   if (TypeTagIdxAST >= ExprArgs.size()) {
14563   if (ArgumentIdxAST >= ExprArgs.size()) {

 5036   if (Args.size() && !Args.data())
 5039   for (unsigned I = 0; I != Args.size(); ++I)
 5100       SemaRef, CurrentArg, Candidates.data(), Candidates.size(), OpenParLoc);
 5185         if (!TooManyArguments(FP->getNumParams(), Args.size(),
 5196       ProduceSignatureHelp(*this, S, Results, Args.size(), OpenParLoc);
 5236   return ProduceSignatureHelp(*this, S, Results, Args.size(), OpenParLoc);
 5578   for (unsigned I = 0, E = Initializers.size(); I != E; ++I) {
 6133   unsigned NumSelIdents = SelIdents.size();
 6213       R.StartParameter = SelIdents.size();
 6571       if (I > SelIdents.size())
 6574       if (I < SelIdents.size())
 6577       else if (NeedSuperKeyword || I > SelIdents.size()) {
 6793         R.StartParameter = SelIdents.size();
 6826         getPreferredArgumentTypeForMessageSend(Results, SelIdents.size());
 6968         R.StartParameter = SelIdents.size();
 6983         getPreferredArgumentTypeForMessageSend(Results, SelIdents.size());
 7049       if (I == SelIdents.size()) {
 8363         unsigned NumSelIdents = SelIdents.size();
 8382       R.StartParameter = SelIdents.size();

 5586         TemplateParamLists.size() != 0) {
 5686       (TemplateParamLists.size() == 0 || R->isFunctionType()))
 5698     if (TemplateParamLists.size()) {
 6760           TemplateParamLists.size() > 0
 6802     if (TemplateParamLists.size() > VDTemplateParamLists)
 8689         if (TemplateParamLists.size() > 1) {
 8697         if (TemplateParamLists.size() > 0)
 8725       if (TemplateParamLists.size() > 0)
11174   if (DeduceInits.size() > 1) {
11700     for (size_t Idx = 0; Idx < Args.size(); ++Idx) {
12813   for (unsigned i = 0, e = Group.size(); i != e; ++i) {
12875   if (Group.size() > 1) {
12878     for (unsigned i = 0, e = Group.size(); i != e; ++i) {
12906       DeclGroupRef::Create(Context, Group.data(), Group.size()));
12924   if (Group.size() >= 2) {
14712   assert(TemplateParameterLists.size() == 0 || TUK != TUK_Reference);
14725   if (TemplateParameterLists.size() > 0 ||
14747             /*FriendLoc*/ SourceLocation(), TemplateParameterLists.size() - 1,
15493       if (TemplateParameterLists.size() > 0) {
17356     for (unsigned i = 0, e = Elements.size(); i != e; ++i) {
17383   for (unsigned i = 0, e = Elements.size(); i != e; ++i) {

 7991           assert(SelectorSlotNames.size() == Locs.size());
 7992           for (unsigned I = 0; I < Locs.size(); ++I) {

  877   if ((int64_t)Bindings.size() != NumElems) {
  879         << DecompType << (unsigned)Bindings.size() << NumElems.toString(10)
  880         << (NumElems < Bindings.size());
 1121   if ((int64_t)Bindings.size() != TupleSize) {
 1123         << DecompType << (unsigned)Bindings.size() << TupleSize.toString(10)
 1124         << (TupleSize < Bindings.size());
 1346     assert(Bindings.size() != NumFields);
 1348         << DecompType << (unsigned)Bindings.size() << NumFields
 1349         << (NumFields < Bindings.size());
 1369     if (I >= Bindings.size())
 1409   if (I != Bindings.size())
 2638   for (unsigned idx = 0; idx < Bases.size(); ++idx) {
 2662       if (Bases.size() > 1)
 3296     if (TemplateParameterLists.size()) {
 4949       Constructor->setNumCtorInitializers(Initializers.size());
 4951         new (Context) CXXCtorInitializer*[Initializers.size()];
 4953              Initializers.size() * sizeof(CXXCtorInitializer*));
 4974   for (unsigned i = 0; i < Initializers.size(); i++) {
 5152   for (unsigned InitIndex = 0; InitIndex != Inits.size(); ++InitIndex) {
 5193   for (unsigned InitIndex = 0; InitIndex != Inits.size(); ++InitIndex) {
 5327   for (unsigned i = 0; i < MemInits.size(); i++) {
 5345       if (MemInits.size() != 1) {
10990                         TemplateParamLists.size()
11022   if (TemplateParamLists.size()) {
11026     if (TemplateParamLists.size() != 1) {
11029          TemplateParamLists[TemplateParamLists.size()-1]->getRAngleLoc());
13399   switch (Args.size()) {
13642   unsigned NumArgs = ArgsPtr.size();
14616                                 FriendLoc, TempParamLists.size() - 1,
14629   for (unsigned I = TempParamLists.size(); I-- > 0; ) {
14783   if (TempParams.size() && !T->isElaboratedTypeSpecifier()) {
16047     for (unsigned I = 0, N = Args.size(); I != N; ++I) {
16065     Exceptions.reserve(DynamicExceptions.size());
16066     for (unsigned ei = 0, ee = DynamicExceptions.size(); ei != ee; ++ei) {

  777       typeParamsIn.size());
 1423     assert(numProtocolsResolved == identifiers.size() && "Unresolved protocols");
 1515     assert(protocols.size() == identifierLocs.size());
 1519   for (unsigned i = 0, n = identifiers.size(); i != n; ++i) {
 1527   if (numProtocolsResolved == identifiers.size())
 1537   for (unsigned i = 0, n = identifiers.size(); i != n; ++i) {
 1614     assert(numTypeDeclsResolved == identifiers.size() && "Unresolved type decl");
 1616     for (unsigned i = 0, n = identifiers.size(); i != n; ++i) {
 1633   if (numTypeDeclsResolved == identifiers.size())
 1640   for (unsigned i = 0, n = identifiers.size(); i != n; ++i) {
 1733   if (numProtocolsResolved == identifiers.size())
 1737   assert(numTypeDeclsResolved == identifiers.size() && "Not all types?");
 2094   DeclsInGroup.reserve(Decls.size() + 1);
 2096   for (unsigned i = 0, e = Decls.size(); i != e; ++i) {
 3910   for (unsigned i = 0, e = allMethods.size(); i != e; i++ ) {
 4101     for (unsigned i = 0, e = allTUVars.size(); i != e; i++) {
 4112   for (unsigned i = 0, e = allTUVars.size(); i != e; i++) {
 4691             assert(ObjCMethod->parameters().size() ==
 4692                        IMD->parameters().size() &&

  395   if (Args.size() < numFormalParams + numArgsAfterSentinel + 1) {
  402   Expr *sentinelExpr = Args[Args.size() - numArgsAfterSentinel - 1];
 1426   unsigned NumAssocs = ArgTypes.size();
 1427   assert(NumAssocs == ArgExprs.size());
 1452   unsigned NumAssocs = Types.size();
 1453   assert(NumAssocs == Exprs.size());
 1605   assert(Args.size() <= 2 && "too many arguments for literal operator");
 1608   for (unsigned ArgIdx = 0; ArgIdx != Args.size(); ++ArgIdx) {
 1620   if (S.LookupLiteralOperator(Scope, R, llvm::makeArrayRef(ArgTy, Args.size()),
 4988   FunctionCallCCC CCC(S, FuncName.getAsIdentifierInfo(), Args.size(), ME);
 5050   if (Args.size() < NumParams) {
 5051     if (Args.size() < MinArgs) {
 5059                                         << static_cast<unsigned>(Args.size())
 5071             << FnKind << MinArgs << static_cast<unsigned>(Args.size())
 5088   if (Args.size() > NumParams) {
 5097                                         << static_cast<unsigned>(Args.size())
 5106             << static_cast<unsigned>(Args.size()) << Fn->getSourceRange()
 5114             << FnKind << NumParams << static_cast<unsigned>(Args.size())
 5157     if (ArgIx < Args.size()) {
 5379   for (size_t i = 0, e = args.size(); i != e; i++) {
 5410       ArgExprs.size() < FT->getNumParams())
 5482   if (S.TooManyArguments(Callee->getNumParams(), ArgExprs.size(),
 5486   if (Callee->getMinRequiredArguments() > ArgExprs.size())
 5885     TheCall->shrinkNumArgs(Args.size());
 5902     if (CorrectedTypos && Args.size() < NumParams) {
 5912     TheCall->setNumArgsUnsafe(std::max<unsigned>(Args.size(), NumParams));
 5960       if (FDecl->hasBody(Def) && Args.size() != Def->param_size()) {
 5962        if (!Proto || !(Proto->isVariadic() && Args.size() >= Def->param_size()))
 5964           << (Args.size() > Def->param_size()) << FDecl << Fn->getSourceRange();
 5974     for (unsigned i = 0, e = Args.size(); i != e; i++) {
 6157   for (unsigned I = 0, E = InitArgList.size(); I != E; ++I) {
 6222   for (unsigned I = 0, E = InitArgList.size(); I != E; ++I) {

 1014   for (int I = FunctionScopes.size();
 1340           (Exprs.size() == 1 && isa<InitListExpr>(Exprs[0]))) &&
 1346       Exprs.size()
 1371   if (Exprs.size() == 1 && !ListInitialization &&
 2363   AllocArgs.reserve((PassAlignment ? 2 : 1) + PlaceArgs.size());
 2779       if (Func->getNumParams() == Params.size()) {
 4964     ArgExprs.reserve(Args.size() - 1);
 4965     for (unsigned I = 1, N = Args.size(); I != N; ++I) {
 5037   for (unsigned I = 0, N = Args.size(); I != N; ++I) {
 5056   ConvertedArgs.reserve(Args.size());
 5058   for (unsigned I = 0, N = Args.size(); I != N; ++I) {
 6680   unsigned SkipStart = OperatorArrows.size(), SkipCount = 0;
 6683   if (OperatorArrows.size() > Limit) {
 6686     SkipCount = OperatorArrows.size() - (Limit - 1);
 6689   for (unsigned I = 0; I < OperatorArrows.size(); /**/) {

   43   if (Strings.size() != 1) {
  880   for (unsigned I = 0, N = Elements.size(); I != N; ++I) {
 1567     for (unsigned i = 0, e = Args.size(); i != e; i++) {
 1645   if (Args.size() < NumNamedArgs) {
 1647       << 2 << NumNamedArgs << static_cast<unsigned>(Args.size());
 1729     for (unsigned i = NumNamedArgs, e = Args.size(); i < e; ++i) {
 1740     if (Args.size() != NumNamedArgs) {
 1743           << 2 /*method*/ << NumNamedArgs << static_cast<unsigned>(Args.size())
 1754       Method, SelLoc, makeArrayRef(Args.data(), Args.size()));
 2474     unsigned NumArgs = ArgsIn.size();
 2528   unsigned NumArgs = ArgsIn.size();
 2717       unsigned NumArgs = ArgsIn.size();
 3021   unsigned NumArgs = ArgsIn.size();

 3899         (IsListInit && Args.size() == 1 && isa<InitListExpr>(Args[0]) &&
 3916                                Args.size() == 1 &&
 3936   if (S.getLangOpts().CPlusPlus17 && Args.size() == 1 &&
 3993           (Args.size() == 1 && isa<InitListExpr>(Args[0]))) &&
 4021       UnwrappedArgs.size() == 1 && UnwrappedArgs[0]->isRValue() &&
 5599   for (unsigned I = 0, E = Args.size(); I != E; ++I)
 5629   if (Args.size() == 1) {
 5659     if (Args.size() != 1)
 5835   assert(Args.size() >= 1 && "Zero-argument case handled above");
 5838   if (Args.size() > 1) {
 6364   unsigned NumArgs = Args.size();
 6397       Kind.AllowExplicit() && !Kind.isCopyInit() && Args.size() == 1 &&
 6885                 N = std::min<unsigned>(Callee->getNumParams(), Args.size());
 7774         Args.size() == 1) {
 7826       Args.size() == 1 && isa<InitListExpr>(Args[0]) &&
 7844       Entity.getKind() == InitializedEntity::EK_Variable && Args.size() > 0) {
 7898     assert(Args.size() == 1);
 8239       assert(Args.size() == 1 && "expected a single argument for list init");
 8698   if (Args.size() == 1) {
 8952       assert(Args.size() > 1 && "Expected multiple initializers!");
 8984     if (Args.size())
 8989       assert(Args.size() == 1 &&
 9636                                  Candidate.Conversions.size() > 0;
 9723       (Inits.size() == 1 && Kind.getKind() != InitializationKind::IK_Direct)

   70   unsigned CurScopeIndex = FunctionScopes.size() - 1;
  130   assert(CurScopeIndex < (FunctionScopes.size() - 1));
  186   assert(((IndexOfCaptureReadyLambda != (FunctionScopes.size() - 1)) ||
  533   LSI->NumExplicitTemplateParams = TParams.size();

 2993   for (unsigned ArgIdx = 0; ArgIdx != Args.size(); ++ArgIdx) {
 3414       else if (FD->getNumParams() == ArgTys.size()) {
 3416         for (unsigned ArgIdx = 0; ArgIdx != ArgTys.size(); ++ArgIdx) {
 3484         << R.getLookupName() << (int)ArgTys.size() << ArgTys[0]
 3485         << (ArgTys.size() == 2 ? ArgTys[1] : QualType()) << AllowRaw
 5394   if (Modules.size() > 1) {
 5399       if (++N == 5 && N != Modules.size()) {

  368   for (unsigned I = 0, N = Path.size(); I != N; ++I) {