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

References

26954       return strncmp(getName(), RHS.data(), RHS.size()) < 0;
31814       return strncmp(getName(), RHS.data(), RHS.size()) < 0;

  262   switch (Name.size()) {
 7799   switch (Name.size()) {

   39   switch (RuleIdentifier.size()) {

  205   switch (Mnemonic.size()) {
 4421   switch (Name.size()) {

  188   switch (Name.size()) {
  681   switch (Mnemonic.size()) {
 6128   switch (Name.size()) {

   78   switch (Name.size()) {
  294   switch (Name.size()) {
  696   switch (Name.size()) {

   52   switch (Name.size()) {
  397   switch (Name.size()) {

   66   switch (Name.size()) {
  928   switch (Name.size()) {
 3287   switch (Name.size()) {

   60   switch (Name.size()) {
  571   switch (Name.size()) {

   52   switch (Name.size()) {
  105   switch (Name.size()) {

 2104   switch (Name.size()) {

   72       switch (Mnemonic.size()) {
   87   switch (Mnemonic.size()) {
 3223   switch (Name.size()) {

   97   switch (Name.size()) {
  292   switch (Name.size()) {
  544       switch (Mnemonic.size()) {
  583   switch (Mnemonic.size()) {
 1225   switch (Name.size()) {

   94       switch (Mnemonic.size()) {
  230   switch (Mnemonic.size()) {
 1862   switch (Name.size()) {

   59   switch (Name.size()) {
  952       switch (Mnemonic.size()) {
 1652       switch (Mnemonic.size()) {
 1901   switch (Mnemonic.size()) {
 5441   switch (Name.size()) {

  479         char *Mem = new (Ctx, 1) char[Ref.size()];
  480         std::memcpy(Mem, Ref.data(), Ref.size());
  481         tags_[I] = StringRef(Mem, Ref.size());
  792               , aliaseeLength(Aliasee.size()),aliasee(new (Ctx, 1) char[aliaseeLength])
  809     aliaseeLength = S.size();
 1284               , annotationLength(Annotation.size()),annotation(new (Ctx, 1) char[annotationLength])
 1301     annotationLength = S.size();
 1744               , labelLength(Label.size()),label(new (Ctx, 1) char[labelLength])
 1755               , labelLength(Label.size()),label(new (Ctx, 1) char[labelLength])
 1773     labelLength = S.size();
 2120               , messageLength(Message.size()),message(new (Ctx, 1) char[messageLength])
 2122               , replacementLength(Replacement.size()),replacement(new (Ctx, 1) char[replacementLength])
 2171     messageLength = S.size();
 2188     replacementLength = S.size();
 3286               , nameLength(Name.size()),name(new (Ctx, 1) char[nameLength])
 3314     nameLength = S.size();
 3488               , nameLength(Name.size()),name(new (Ctx, 1) char[nameLength])
 3505     nameLength = S.size();
 4147               , messageLength(Message.size()),message(new (Ctx, 1) char[messageLength])
 4148               , replacementLength(Replacement.size()),replacement(new (Ctx, 1) char[replacementLength])
 4175     messageLength = S.size();
 4188     replacementLength = S.size();
 4330               , messageLength(Message.size()),message(new (Ctx, 1) char[messageLength])
 4346               , messageLength(Message.size()),message(new (Ctx, 1) char[messageLength])
 4370     messageLength = S.size();
 4531               , messageLength(Message.size()),message(new (Ctx, 1) char[messageLength])
 4552     messageLength = S.size();
 4785               , languageLength(Language.size()),language(new (Ctx, 1) char[languageLength])
 4786               , definedInLength(DefinedIn.size()),definedIn(new (Ctx, 1) char[definedInLength])
 4815     languageLength = S.size();
 4828     definedInLength = S.size();
 5545               , resolverLength(Resolver.size()),resolver(new (Ctx, 1) char[resolverLength])
 5562     resolverLength = S.size();
 5653               , sectionLength(Section.size()),section(new (Ctx, 1) char[sectionLength])
 5670     sectionLength = S.size();
 7930         char *Mem = new (Ctx, 1) char[Ref.size()];
 7931         std::memcpy(Mem, Ref.data(), Ref.size());
 7932         sanitizers_[I] = StringRef(Mem, Ref.size());
 8945         char *Mem = new (Ctx, 1) char[Ref.size()];
 8946         std::memcpy(Mem, Ref.data(), Ref.size());
 8947         implVendors_[I] = StringRef(Mem, Ref.size());
10446               , metadataNameLength(MetadataName.size()),metadataName(new (Ctx, 1) char[metadataNameLength])
10463     metadataNameLength = S.size();
11631               , nameLength(Name.size()),name(new (Ctx, 1) char[nameLength])
11648     nameLength = S.size();
11691               , nameLength(Name.size()),name(new (Ctx, 1) char[nameLength])
11708     nameLength = S.size();
11751               , nameLength(Name.size()),name(new (Ctx, 1) char[nameLength])
11768     nameLength = S.size();
11811               , nameLength(Name.size()),name(new (Ctx, 1) char[nameLength])
11828     nameLength = S.size();
11871               , nameLength(Name.size()),name(new (Ctx, 1) char[nameLength])
11888     nameLength = S.size();
12960               , nameLength(Name.size()),name(new (Ctx, 1) char[nameLength])
12985     nameLength = S.size();
13368         char *Mem = new (Ctx, 1) char[Ref.size()];
13369         std::memcpy(Mem, Ref.data(), Ref.size());
13370         diagnosticIdentifiers_[I] = StringRef(Mem, Ref.size());
13630               , modelLength(Model.size()),model(new (Ctx, 1) char[modelLength])
13647     modelLength = S.size();
13690               , featuresStrLength(FeaturesStr.size()),featuresStr(new (Ctx, 1) char[featuresStrLength])
13707     featuresStrLength = S.size();
14507               , messageLength(Message.size()),message(new (Ctx, 1) char[messageLength])
14518               , messageLength(Message.size()),message(new (Ctx, 1) char[messageLength])
14544     messageLength = S.size();
14727               , guidLength(Guid.size()),guid(new (Ctx, 1) char[guidLength])
14744     guidLength = S.size();
15042               , messageLength(Message.size()),message(new (Ctx, 1) char[messageLength])
15076     messageLength = S.size();
15205               , aliaseeLength(Aliasee.size()),aliasee(new (Ctx, 1) char[aliaseeLength])
15229     aliaseeLength = S.size();
15272               , importModuleLength(ImportModule.size()),importModule(new (Ctx, 1) char[importModuleLength])
15289     importModuleLength = S.size();
15332               , importNameLength(ImportName.size()),importName(new (Ctx, 1) char[importNameLength])
15349     importNameLength = S.size();

  137   switch (Name.size()) {

   11   switch (Name.size()) {

   10   switch (Name.size()) {

   10   switch (Name.size()) {
   73   switch (Name.size()) {

   11   switch (Name.size()) {
 1596   switch (Name.size()) {
 1806   switch (Name.size()) {
 1814   switch (Name.size()) {
 3366   switch (Name.size()) {
 4075   switch (Name.size()) {
 4378   switch (Name.size()) {

12697   switch (Name.size()) {

16643       arg3 = str.size();

   40       : P(S.data()), Size(S.size()), Hash(Hash) {
   41     assert(S.size() <= std::numeric_limits<uint32_t>::max());
  105       : P(new char[S.size()]), Size(S.size()), Hash(Hash) {
  105       : P(new char[S.size()]), Size(S.size()), Hash(Hash) {
  106     memcpy(P, S.data(), S.size());

  144   size_t Length = Input.size();
  175   Output.reserve((Input.size() + 1) / 2);
  176   if (Input.size() % 2 == 1) {
  181   assert(Input.size() % 2 == 0);
  319   size_t Len = (std::distance(Begin, End) - 1) * Separator.size();
  321     Len += (*Begin).size();
  352   return Str.size();

  180     size_t KeyLength = Key.size();

  331           return size() - S.size();
  331           return size() - S.size();
  608       if (N >= size())
  610       return drop_back(size() - N);
  618       if (N >= size())
  620       return drop_front(size() - N);
  641       assert(size() >= N && "Dropping more elements than exist");
  649       assert(size() >= N && "Dropping more elements than exist");
  650       return substr(0, size()-N);
  673       *this = drop_front(Prefix.size());
  683       *this = drop_back(Suffix.size());
  735       return std::make_pair(slice(0, Idx), slice(Idx + Separator.size(), npos));
  753       return std::make_pair(slice(0, Idx), slice(Idx + Separator.size(), npos));
  909     return buffer.append(string.data(), string.size());

 1036                     << std::string(F.getName().size(), '=') << "\n");

  364     Strings.push_back(std::unique_ptr<char[]>(new char[S.size()]));
  365     memcpy(&Strings.back()[0], S.data(), S.size());
  366     return StringRef(&Strings.back()[0], S.size());

  299     unsigned BlobLen = (unsigned) Blob.size();
  364           assert(Blob.size() == BlobLen && "BlobLen got changed");
  403     emitBlob(makeArrayRef((const uint8_t *)Bytes.data(), Bytes.size()),

  586     assert(GuidStr.size() == 16 && "guid isn't 16 bytes");

   59   size_t size() const { return Section == nullptr ? 0 : Section->Data.size(); }

  109           Offset >= Expr->Data.getData().size() ||
  115       Offset = Op.isError() ? Expr->Data.getData().size() : Op.EndOffset;
  117           Offset >= Expr->Data.getData().size() ||
  136   iterator end() const { return iterator(this, Data.getData().size()); }

  258                      dwarf::RangeListEncodingString(Entry.EntryKind).size());

   30     if (Offset < Data.size()) {
   42   const size_t Size = S.Data.size();
   46     Offset += Str.size() + 1;

  159         Size(Content.size()), Ordinal(Ordinal) {
  205     Size = Content.size();

  140     if (auto Err = serializeSeq(C, static_cast<uint64_t>(S.size())))
  142     return C.appendBytes((const char *)S.data(), S.size());

   82         : ContentPtr(Content.data()), Size(Content.size()),
   99       Size = Content.size();

  665     return Str.substr(0, Str.size()-1);

  622   unsigned getLength() const { return (unsigned)getString().size(); }

   92     return Str.slice(1, Str.size() - 1);

   92     return BaseReg.size();
   95     return IndexReg.size();

   40   if (Object.size() < ELF::EI_NIDENT)
  111   size_t getBufSize() const { return Buf.size(); }
  406       Offset + Size > Buf.size())
  497   if (sizeof(Elf_Ehdr) > Object.size())
  498     return createError("invalid buffer: the size (" + Twine(Object.size()) +
  514   const uint64_t FileSize = Buf.size();
  572   if (Pos + sizeof(T) > Buf.size())
  696   if (Offset >= DotShstrtab.size())

  250   if (Offset >= StrTab.size())
  255                              Offset, StrTab.size());

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

  748     PipelineName = PipelineName.substr(11, PipelineName.size() - 12);
  757     PipelineName = PipelineName.substr(8, PipelineName.size() - 9);

  200     if (Buffer->getBuffer().size() < Cursor + 4) {
  226     if (Buffer->getBuffer().size() < Cursor + Len) {

  513         if (Dit == It + Suffix.size() - 1)

 1209     assert((MF != Grouping || O.ArgStr.size() == 1) &&

  537   bool eof(const Cursor &C) const { return Data.size() == C.Offset; }
  544   bool isValidOffset(uint64_t offset) const { return Data.size() > offset; }

  278   size_t getBufferSize() const { return Buffer.size(); }

   41                              Str.size()));

  299                           Value.size());
  314                           Value.size());

   34   Name = Name.drop_front(Key.size());

  541         std::min(Input.find_first_not_of("0123456789"), Input.size()));
  564     return S.size() > 2 &&
  568     return S.size() > 2 && S.drop_front(2).find_first_not_of(
  579        (S.size() > 1 && std::strchr("0123456789", S[1]) == nullptr)))

  181     size_t Size = Str.size();

 1797       for (size_t I = 0, E = Rec.size(); I != E; ++I, ++Len) {
 1845       if (LHSPart.second.size() != RHSPart.second.size())
 1845       if (LHSPart.second.size() != RHSPart.second.size())
 1846         return LHSPart.second.size() < RHSPart.second.size();
 1846         return LHSPart.second.size() < RHSPart.second.size();

   51     return lookupName(Name.data(), Name.size());

  390     void *Ptr = Allocator.Allocate(String.size(), 1);
  391     memcpy(Ptr, String.data(), String.size());
  392     return StringRef(reinterpret_cast<const char *>(Ptr), String.size());

  655     size_t StrLen = Str.size();
 1535     if (Name.size() < 12 || Name[1] != '_')

  165   if (Read != Asm.size()) {

   35   if (Magic.size() < 4)
   43       if (Magic.size() < MinSize)
   54     if (Magic.size() >= sizeof(COFF::WinResMagic) &&
   87     if (startswith(Magic, "\177ELF") && Magic.size() >= 18) {
  115       if (Magic.size() >= 8 && Magic[7] < 43)
  135       if (Magic.size() >= MinSize)
  145       if (Magic.size() >= MinSize)
  195     if (startswith(Magic, "MZ") && Magic.size() >= 0x3c + 4) {

  102   size_t Size = s.size();

  527     if (Strings.size() < Size)
  964             for (unsigned i = 0, e = Blob.size(); i != e; ++i)
  973               O->OS << "unprintable, " << Blob.size() << " bytes.";

  476   if (Record[0] + Record[1] > Strtab.size())

 1936   if (StringsOffset > Blob.size())
 1951     if (Strings.size() < Size)

  588   for (unsigned i = 0, e = Str.size(); i != e; ++i) {
 1098     Vals.push_back(C->getName().size());
 1269     Vals.push_back(GV.getName().size());
 1298       Vals.push_back(GV.getPartition().size());
 1314     Vals.push_back(F.getName().size());
 1337     Vals.push_back(F.getPartition().size());
 1350     Vals.push_back(A.getName().size());
 1361     Vals.push_back(A.getPartition().size());
 1373     Vals.push_back(I.getName().size());
 1381     Vals.push_back(I.getPartition().size());
 4573     Vals.push_back(GV.getName().size());
 4587     Vals.push_back(F.getName().size());
 4601     Vals.push_back(A.getName().size());
 4615     Vals.push_back(I.getName().size());

 2332   for (unsigned i = 1, e = Data.size(); i != e; ++i)

  118     Str = Str.substr(0, Str.size()-1);

 1096         assert(Str.data()[Str.size()] == '\0' && "non-nullterminated MDString");
 1097         OS.EmitBytes(StringRef(Str.data(), Str.size() + 1));

  617   return S.size() + 1;

   35     NumBytes += Str.size() + 1;

   44     End = Ptr + Str.size();
  119   Cursor C = Cursor(Value.substr(1, Value.size() - 2));
  122   Str.reserve(C.remaining().size());
  288   unsigned StringOffset = PrefixLength + Number.size(); // Drop '%bb.<id>'
  308   if (!C.remaining().startswith(Rule) || !isdigit(C.peek(Rule.size())))
  311   C.advance(Rule.size());
  321   if (!C.remaining().startswith(Rule) || !isdigit(C.peek(Rule.size())))
  324   C.advance(Rule.size());
  329   unsigned StringOffset = Rule.size() + Number.size();
  329   unsigned StringOffset = Rule.size() + Number.size();
  363   return lexName(C, Token, MIToken::SubRegisterIndex, Rule.size(),
  372   if (isdigit(C.peek(Rule.size())))
  374   return lexName(C, Token, MIToken::NamedIRBlock, Rule.size(), ErrorCallback);
  382   if (isdigit(C.peek(Rule.size())))
  384   return lexName(C, Token, MIToken::NamedIRValue, Rule.size(), ErrorCallback);
  477   C.advance(Rule.size());
  483     StringRef String = Start.upto(C).drop_front(Rule.size());
  504   StringRef String = Start.upto(R).drop_front(Rule.size());
  551   if (StrVal.size() <= PrefLen)

  538   assert(Loc >= Source.data() && Loc <= (Source.data() + Source.size()));
 1522     if (SizeStr.size() == 0 || !llvm::all_of(SizeStr, isdigit))
 1566   if (SizeStr.size() == 0 || !llvm::all_of(SizeStr, isdigit))
 1601   if (SizeStr.size() == 0 || !llvm::all_of(SizeStr, isdigit))
 2658   APInt A(V.size()*4, V, 16);

  458   char *Dest = Allocator.Allocate<char>(Name.size() + 1);
  460   Dest[Name.size()] = 0;

  689       size_t e = CFI.getValues().size() - 1;

 3976   unsigned S = Constraint.size();
 4124   StringRef RegName(Constraint.data() + 1, Constraint.size() - 2);

   72                  MAI.getCommentString().size()) == 0;

 1862   if (RefStepString.size() == 1) {

  206     auto NullTerminatedString = StringRef(Value.data(), Value.size() + 1);
  209     incrStreamedLen(NullTerminatedString.size());

   54     StringSize += S.size() + 1; // +1 for '\0'

  155       size_t BytesNeeded = Name.size() + UniqueName.size() + 2;
  155       size_t BytesNeeded = Name.size() + UniqueName.size() + 2;
  160         size_t DropN = std::min(N.size(), BytesToDrop / 2);
  161         size_t DropU = std::min(U.size(), BytesToDrop - DropN);
  487       NamesLen += Name.size() + 1;

  140   uint64_t SectionSize = StringOffsetsSection.Data.size();
  222     uint64_t size = StringOffsetsSection.Data.size();
  740   LocDWO->parse(LocData, 0, LocData.getData().size(), 4 /* Version */);
  864   if (stmtOffset >= U->getLineSection().Data.size())

  126   if (Data && CUAbbrOffset < Data->getData().size()) {

  412         for (unsigned i = 0, e = AugmentationString.size(); i != e; ++i) {

  132   while (Offset < data.getData().size()) {
  238                  MaxEncodingStringLength - EncodingString.size() + 1, '(');
  311                    dwarf::LocListEncodingString(Entry.Kind).size());

   36     while (Offset < Sec.Data.size()) {

  195                  MaxEncodingStringLength - EncodingString.size() + 1, ']');

  144   OS << TagStr.substr(7, TagStr.size() - 12) << " ";

  293       while (FailOffset < Data.getData().size())
  311     if (Op.getEndOffset() < Data.getData().size())

  213   if (AddrOffsetSection->Data.size() < Offset + getAddressByteSize())
  227   if (StringOffsetSection.Data.size() < Offset + ItemSize)
  469     if (RangeSection->Data.size()) {
  899             {0, StringOffsetSection.Data.size(), 4, DWARF32})};

  454       if (*SectionOffset >= DObj.getRangesSection().Data.size())
  463       if (*SectionOffset >= DObj.getLineSection().Data.size())
  570       if (*RefVal >= DieCU->getInfoSection().Data.size()) {
  586     if (SecOffset && *SecOffset >= DObj.getStrSection().size()) {
  613     if (DObj.getStrOffsetsSection().Data.size() < Offset + ItemSize) {
  622     if (StringOffset >= DObj.getStrSection().size()) {
  669     if (LineTableOffset < DCtx.getDWARFObj().getLineSection().Data.size()) {

  119   size_t LS = S1.size();
  120   size_t RS = S2.size();

   22   uint32_t Size = Str.size();

   94   Expected<uint32_t> ExpectedIndex = allocateNamedStream(Name, Data.size());

 1171     memcpy(Addr, Data.data(), Data.size());

  194                  << B->getContent().size() << " bytes, from "
  198         memcpy(BlockDataPtr, B->getContent().data(), B->getContent().size());
  214         B->setContent(StringRef(BlockDataPtr, B->getContent().size()));
  217         LastBlockEnd = BlockDataPtr + B->getContent().size();

   36   if (Data.size() < 4) {

  146         if (DataOffset + NSec.Size > Obj.getData().size())

   62           G.addAnonymousSymbol(B, 0, RecordContent.size(), false, false);
   84           G.addAnonymousSymbol(B, 0, RecordContent.size(), false, false);

  238             BlockToFix->getAddress() + BlockToFix->getContent().size())

  246             BlockToFix->getAddress() + BlockToFix->getContent().size())

  212                     (*Name).size() - HasGlobalPrefix);

 1077     if (Name.size() == 0) {

  450         FirstNonDigit = Expr.size();
  454         FirstNonDigit = Expr.size();
  667     ArrayRef<uint8_t> SymbolBytes(SymbolMem.bytes_begin(), SymbolMem.size());
  721       DidAllTestsPass &= check(Line.substr(RulePrefix.size()));

  405     for (unsigned i = 0, e = Name.size(); i != e; ++i) {
 3148     for (unsigned i = 1, e = Name.size(); i != e; ++i) {

  495   if (Name.size() <= 8 || !Name.startswith("llvm."))
 2818                          (Name.size() > 18 && Name[18] == 'i');
 2886                          (Name.size() > 18 && Name[18] == 'i');
 2954                          (Name.size() > 18 && Name[18] == 'i');
 3171         if (Name[Name.size()-5] == 's')
 3226         if (Name[Name.size()-5] == 's')
 4096       C, (Twine("llvm.loop.vectorize.") + OldTag.drop_front(OldPrefix.size()))

 2583     return get(Context, makeArrayRef(Data, Str.size()));

  176   *Length = S.size();
  183   *Length = S.size();
  342     Result[i].KeyLen = ModuleFlag.Key->getString().size();
  821   *Length = V->getName().size();
 1116       *Length = S->getString().size();
 1174   *NameLen = NamedNode->getName().size();
 1238   *Length = S.size();
 1262   *Length = S.size();
 1393   *Length = Str.size();
 2335   *NameLength = Str.size();

  427       if (Rest.size() > 1)

  913   *Len = Dir.size();
  919   *Len = Name.size();
  925     *Len = Src->size();
 1230   *Length = Str.size();

  561   assert(Name.size() >= MatchSize && "Expected either exact or prefix match");
  562   bool IsExactMatch = Name.size() == MatchSize;

   74   while (CmpEnd < Name.size() && High - Low > 0) {
   77     CmpEnd = CmpEnd == StringRef::npos ? Name.size() : CmpEnd;
   91       (Name.startswith(NameFound) && Name[NameFound.size()] == '.'))

  421     unsigned NameSize = Name.size();

  242   if (NameRef.size() > NonGlobalValueMaxNameSize && !isa<GlobalValue>(this))

 1039     AssertDI(Checksum->Value.size() == Size, "invalid checksum length", &N);
 2160   bool isLLVMdotName = F.getName().size() >= 5 &&

  432     MangledName.reserve(GV.getName().size() + 1);

  464   assert(NameRef.data()[NameRef.size()] == '\0');
  676   *size = S.size();

  274     if (TheTriple.isOSBinFormatMachO() && Name.size() > 0 && Name[0] == '_')
 1032         Modules[LeftIndex]->getSingleBitcodeModule().getBuffer().size();
 1034         Modules[RightIndex]->getSingleBitcodeModule().getBuffer().size();

  796     if (STTypePrefix.size()== ST->getName().size())
  796     if (STTypePrefix.size()== ST->getName().size())

  859   if (Size <= Magic.size() + sizeof(Size) + CompressedContents.size())

  407     ExplicitCommentToEmit.append(c.slice(2, c.size()).str());
  409     size_t p = 2, len = c.size() - 2;
  428     ExplicitCommentToEmit.append(c.slice(1, c.size()).str());
  885   for (unsigned i = 0, e = Data.size(); i != e; ++i) {
  922   if (Data.size() == 1 ||
  940     Data = Data.substr(0, Data.size()-1);
  952   for (size_t I = 0, EI = alignTo(Data.size(), Cols); I < EI; I += Cols) {
  953     size_t J = I, EJ = std::min(I + Cols, Data.size());
 1563     size_t e = Values.size() - 1;
 1949   if (Comments.size() && Comments.back() != '\n')
 2002     String = String.substr(0, String.size()-1);

  662       size_t RecordSize = FixedSizePortion.size() +

  194       NewName.resize(Name.size());

 1222     Name = Name.substr(1, Name.size()-1);

  536   if (CommentString.size() == 1)
  543   return strncmp(Ptr, CommentString.data(), CommentString.size()) == 0;

 1198       if (Split.first.size() != IDVal.size()) {
 1198       if (Split.first.size() != IDVal.size()) {
 1391   for (size_t Pos = 0; Pos < AltMacroStr.size(); Pos++) {
 1833         Info.AsmRewrites->emplace_back(AOK_Label, IDLoc, IDVal.size(),
 2202     return parseDirectiveMSEmit(IDLoc, Info, IDVal.size());
 2315   Filename = Filename.substr(1, Filename.size() - 2);
 2404     std::size_t End = Body.size(), Pos = 0;
 2512           Pos += 1 + Argument.size();
 2877         StringRef(PrefixLoc.getPointer(), getTok().getIdentifier().size() + 1);
 2910   for (unsigned i = 0, e = Str.size(); i != e; ++i) {
 2924       size_t length = Str.size();
 4521     std::size_t End = Body.size(), Pos = 0;
 4579         Pos += 1 + Argument.size();
 5658   for (std::size_t I = 0, End = Values.size(); I != End; ++I) {
 5845         AsmStrRewrites.emplace_back(AOK_Output, Start, SymName.size());
 5850         AsmStrRewrites.emplace_back(AOK_Input, Start, SymName.size());

  259       CurSize = getTok().getIdentifier().size() + 2;
  262       CurSize = getTok().getIdentifier().size();
  265       CurSize = getTok().getString().size();
  800   getStreamer().EmitIntValue(Data.size()+1, 4); // namesz.

   32   return SMLoc::getFromPointer(Str.data() + Str.size());

   88   assert(Segment.size() <= 16 && Section.size() <= 16 &&
   88   assert(Segment.size() <= 16 && Section.size() <= 16 &&
   91     if (i < Segment.size())
   96     if (i < Section.size())
  203   if (Segment.empty() || Segment.size() > 16)
  212   if (Section.size() > 16)

  165   assert(Size >= Str.size());
  167   W.OS.write_zeros(Size - Str.size());

   69       memcpy(Buf + P.second, Data.data(), Data.size());
   82   if (Pos >= S.size())
   84   return (unsigned char)S[S.size() - Pos - 1];
  147         size_t Pos = Size - S.size() - (K != RAW);
  157       Size += S.size();

  306     encodeULEB128(Str.size(), W.OS);
 1531     if (WS.getSectionName().size() > PrefixLength) {

  378   return SymbolName.size() > XCOFF::NameSize;

  149     if (Name.size() == 1) // Linker member.
  151     if (Name.size() == 2 && Name[1] == '/') // String table.
  170     if (StringOffset >= Parent->getStringTable().size()) {
  219   if (Name[Name.size() - 1] != '/')
  323     : Parent(Parent), Header(Parent, Data.data(), Data.size(), nullptr),
  331                ? Parent->getData().size() - (Start - Parent->getData().data())
  401   return Data.size() - StartOfFile;
  457   size_t SpaceToSkip = Data.size();

  178   uint64_t PosAfterHeader = Pos + 60 + Name.size();
  181   unsigned NameWithPadding = Name.size() + Pad;
  191   return Thin || Name.size() >= 16 || Name.contains('/');
  246   unsigned Size = Names.size();
  306   Size += StringTable.size();
  337     Pos += M.Header.size() + M.Data.size() + M.Padding.size();
  337     Pos += M.Header.size() + M.Data.size() + M.Padding.size();
  342     printNBits(Out, Kind, StringTable.size());
  468         isDarwin(Kind) ? offsetToAlignment(Data.size(), Align(8)) : 0;
  470         offsetToAlignment(Data.size() + MemberPadding, Align(2));
  497     Pos += Header.size() + Data.size() + Padding.size();
  497     Pos += Header.size() + Data.size() + Padding.size();
  579       MaxOffset += M.Header.size() + M.Data.size() + M.Padding.size();
  579       MaxOffset += M.Header.size() + M.Data.size() + M.Padding.size();

  126   return (Twine(S.substr(0, Pos)) + To + S.substr(Pos + From.size())).str();
  195           (ImportName.size() + 1)),
  219        u32(ImportName.size() + 1),
  250   Buffer.resize(S + ImportName.size() + 1);
  251   memcpy(&Buffer[S], ImportName.data(), ImportName.size());
  252   Buffer[S + ImportName.size()] = '\0';
  466   size_t ImpSize = ImportName.size() + Sym.size() + 2; // +2 for NULs
  466   size_t ImpSize = ImportName.size() + Sym.size() + 2; // +2 for NULs
  483   memcpy(P, Sym.data(), Sym.size());
  484   P += Sym.size() + 1;
  485   memcpy(P, ImportName.data(), ImportName.size());
  560       sizeof(uint32_t) + Sym.size() + Prefix.size() + 1;
  560       sizeof(uint32_t) + Sym.size() + Prefix.size() + 1;

   70   assert(Str.size() <= 6 && "String too long, possible overflow.");
   71   if (Str.size() > 6)

   43   if (SectionData.size() < 8)
   55   if (SectionData.size() < HdrSize)

   80       if (Contents->size() <= 1)

   96     S.Size = Value.size();
  383       BFC.Symtab.size() < sizeof(storage::Header))
  398   FC.TheReader = {{BFC.Symtab.data(), BFC.Symtab.size()},
  399                   {BFC.StrtabForSymtab.data(), BFC.StrtabForSymtab.size()}};

  109   assert(Offset <= O.getData().size());
  222   if (sizeof(T) > Obj.getData().size()) {
  285     uint64_t FileSize = Obj.getData().size();
  414   uint64_t FileSize = Obj.getData().size();
  473   uint64_t FileSize = Obj.getData().size();
  607   uint64_t FileSize = Obj.getData().size();
  645   uint64_t FileSize = Obj.getData().size();
  832   uint64_t FileSize = Obj.getData().size();
  913   uint64_t FileSize = Obj.getData().size();
 1202   uint64_t FileSize = Obj.getData().size();
 1787   if (NValue >= StringTable.size())
 1940   uint64_t FileSize = getData().size();
 2322   if (Idx != Foo.npos && Foo.size() >= 2) {
 2336   F = Name.slice(Idx, Idx + Foo.size());
 2337   DotFramework = Name.slice(Idx + Foo.size(),
 2338                             Idx + Foo.size() + sizeof(".framework/")-1);
 2358   F = Name.slice(Idx, Idx + Foo.size());
 2359   DotFramework = Name.slice(Idx + Foo.size(),
 2360                             Idx + Foo.size() + sizeof(".framework/")-1);
 2401   if (Lib.size() >= 3) {
 2402     Dot = Lib.slice(Lib.size()-2, Lib.size()-1);
 2402     Dot = Lib.slice(Lib.size()-2, Lib.size()-1);
 2404       Lib = Lib.slice(0, Lib.size()-2);
 2418   if (Lib.size() >= 3) {
 2419     Dot = Lib.slice(Lib.size()-2, Lib.size()-1);
 2419     Dot = Lib.slice(Lib.size()-2, Lib.size()-1);
 2421       Lib = Lib.slice(0, Lib.size()-2);
 2449       if (D.dylib.name+Name.size() >= D.cmdsize)

  141   if (Buf.size() < MinSize) {
  151     if (bigSize > Buf.size()) {

  147     MangledName.reserve(GV.getName().size() + 1);

  260   Ctx.End = Ctx.Start + getData().size();

  439             Contents.size()));
  723   assert(Src.size() <= COFF::NameSize &&

   77       if (Name.size() <= COFF::NameSize) {
  115       if (Name.size() <= COFF::NameSize) {
  290           (i->File.size() + CP.getSymbolSize() - 1) / CP.getSymbolSize();
  563           (i->File.size() + SymbolSize - 1) / SymbolSize;
  565       uint32_t NumZeros = NumberOfAuxBytes - i->File.size();
  566       OS.write(i->File.data(), i->File.size());

  149   if (Scalar.size() != 38)

   73     OS.write(Str.data(), Str.size());
  128     OS.write(Entry.Name.data(), Entry.Name.size());
  185     OS.write(String.data(), String.size());
  205   OS.write(File.Name.data(), File.Name.size());
  231       OS.write(IncludeDir.data(), IncludeDir.size());
  342   virtual void onValue(const StringRef String) { Length += String.size() + 1; }

 1063       support::endian::write<uint32_t>(OS, NE.Name.size() + 1,

  337       OS.write(Opcode.Symbol.data(), Opcode.Symbol.size());
  463     OS.write(Str.data(), Str.size());

   44   size_t CopySize = 16 >= Scalar.size() ? 16 : Scalar.size();
   44   size_t CopySize = 16 >= Scalar.size() ? 16 : Scalar.size();
   47   if (Scalar.size() < 16) {
   48     memset((void *)&Val[Scalar.size()], 0, 16 - Scalar.size());
   48     memset((void *)&Val[Scalar.size()], 0, 16 - Scalar.size());
   64   for (size_t Idx = 0; Idx < Scalar.size(); ++Idx) {

  187     if (Scalar.size() < 2 * N)
  189     if (Scalar.size() > 2 * N)
  222     if (Scalar.size() < N)
  224     if (Scalar.size() > N)

  112   encodeULEB128(Str.size(), OS);

   29   if (Scalar.size() % 2 != 0)
   33   for (unsigned I = 0, N = Scalar.size(); I != N; ++I)

  178   if (Cur.size() == LHS.size() + RHS.size() &&
  178   if (Cur.size() == LHS.size() + RHS.size() &&
  178   if (Cur.size() == LHS.size() + RHS.size() &&
  272       BaseArgs.getArgString(Index) + Opt.getName().size(), BaseArg));

  185       StringRef Rest = Str.substr(Prefix.size());
  190         return Prefix.size() + StringRef(I->Name).size();
  190         return Prefix.size() + StringRef(I->Name).size();
  264     if (CandidateName.empty() || CandidateName.size() < MinimumLength)
  290       if (Option.find(Last) == LHS.size())

   63   if (N > Data.size())
   81   if (Result > Data.size())
  370   if (Offset + Size > Data.size())
  578   for (const char *Buf = Data.data(), *End = Buf + Data.size(); Buf < End;) {
  627   Data = Data.substr(StringRef(TestingFormatMagic).size());
  632   if (N > Data.size())
  639   if (N > Data.size())
  642   if (Data.size() < ProfileNamesSize)
  652   if (CoverageMapping.size() < Pad)

   40     encodeULEB128(Filename.size(), OS);

  281     PGOFuncName = PGOFuncName.drop_front(FileName.size() + 1);
 1123       if (Pos < MemOPSizeRange.size() - 1)

  661     Out.reserve(OrigName.size() + Replacement.size() - ExtractedName.size());
  661     Out.reserve(OrigName.size() + Replacement.size() - ExtractedName.size());
  661     Out.reserve(OrigName.size() + Replacement.size() - ExtractedName.size());

  118     offset_type N = K.size();

  208     Size += Str.size() + 1;

  159         n4 = (n4 != StringRef::npos) ? n3 + n4 + 1 : Rest.size();
  173       if (n4 == Rest.size())
  313   if (Data + Str.size() + 1 > End) {
  319   Data += Str.size() + 1;

   37   return unwrap(String)->size();

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

   36     SerializedSize += KV.first->first().size() + 1; // +1 for the '\0'

   65   if (Buf.size() < 1 || !Buf.consume_front(StringRef("\0", 1)))
   72   if (Buf.size() < sizeof(uint64_t))
   89   if (Buf.size() < sizeof(uint64_t))
  101   if (Buf.size() < StrTabSize)

   22   if (Arch.size() >= 2 && Arch[0] == 'v' && std::isdigit(Arch[1]))

 2621   size_t slen = str.size();

  499   size_t slen = str.size();
 2100   size_t slen = str.size();

   24   unsigned NumBits = ((Str.size() * 64) / 19) + 2;

  303     A = A.substr(0, A.size() - 2);
  315     if (A.size() >= 2 && (A[0] != 'v' || !std::isdigit(A[1])))

   56   StringRef NumStr = Duration.slice(0, Duration.size()-1);

   63   for (unsigned I = 0; I < Style.size(); ++I) {
   64     if (Style[I] == '%' && Style.size() > I + 1) switch (Style[I + 1]) {

   96   size_t Len = ArgName.size();
   98     return Len + ArgPrefix.size() + ArgHelpPrefix.size();
   98     return Len + ArgPrefix.size() + ArgHelpPrefix.size();
   99   return Len + ArgPrefixLong.size() + ArgHelpPrefix.size();
   99   return Len + ArgPrefixLong.size() + ArgHelpPrefix.size();
  103   if (ArgName.size() == 1)
  442   if (ArgStr.size() == 1)
  716   while (OMI == OptionsMap.end() && Name.size() > 1) {
  717     Name = Name.substr(0, Name.size() - 1); // Chop off the last character.
  724     Length = Name.size();
  738   if (Arg.size() == 1)
  749         (Length < Arg.size()) ? Arg.substr(Length) : StringRef();
  813   for (size_t I = 0, E = Src.size(); I != E; ++I) {
  888   size_t E = Src.size();
  916   for (size_t I = 0, E = Src.size(); I != E; ++I) {
 1684     Len += getValueStr(O, ValName).size() + FormattingLen;
 1712   outs().indent(GlobalWidth - O.ArgStr.size());
 1832 static size_t OptionPrefixesSize = OptionPrefix.size() + ArgHelpPrefix.size();
 1832 static size_t OptionPrefixesSize = OptionPrefix.size() + ArgHelpPrefix.size();
 1844         argPlusPrefixesSize(O.ArgStr) + EqValue.size();
 1849       size_t NameSize = Name.empty() ? EmptyOption.size() : Name.size();
 1849       size_t NameSize = Name.empty() ? EmptyOption.size() : Name.size();
 1856       BaseSize = std::max(BaseSize, getOption(i).size() + 8);
 1882                          EqValue.size() +
 1889       assert(GlobalWidth >= OptionName.size() + OptionPrefixesSize);
 1890       size_t NumSpaces = GlobalWidth - OptionName.size() - OptionPrefixesSize;
 1894         assert(NumSpaces >= EmptyOption.size());
 1895         NumSpaces -= EmptyOption.size();
 1907       Option::printHelpStr(getDescription(i), GlobalWidth, Option.size() + 8);
 1921   outs().indent(GlobalWidth - O.ArgStr.size());
 1929     size_t L = getOption(i).size();
 1981   size_t NumSpaces = MaxOptWidth > V.size() ? MaxOptWidth - V.size() : 0;
 1981   size_t NumSpaces = MaxOptWidth > V.size() ? MaxOptWidth - V.size() : 0;

   30       memcpy(ResultPtr, Source.data(), Source.size());
   31       ResultPtr += Source.size();
   40         &sourceStart, sourceStart + Source.size(),
   41         &targetStart, targetStart + Source.size(), flags);
   53         &sourceStart, sourceStart + Source.size(),
   54         &targetStart, targetStart + Source.size(), flags);
  161   DstUTF16.resize(SrcUTF8.size()+1);
  190   Result.resize(Source.size() + 1);

  176   assert(*offset_ptr <= Data.size());
  185       reinterpret_cast<const uint8_t *>(Data.data() + Data.size()), &error);
  196   assert(*offset_ptr <= Data.size());
  202       reinterpret_cast<const uint8_t *>(Data.data() + Data.size()), &error);

   33     Option::printHelpStr(HelpStr, GlobalWidth, ArgStr.size() + 6);

  116     ssize_t written = ::write(2, MessageStr.data(), MessageStr.size());

   86   for (unsigned E = Str.size(); I != E; ++I) {
  331       PatternStr = PatternStr.substr(0, PatternStr.size() - 1);
  355       (PatternStr.size() < 2 || (PatternStr.find("{{") == StringRef::npos &&
  617     return Buffer.size();
  622     MatchLen = FixedStr.size();
  700   MatchLen = FullMatch.size() - MatchStartSkip;
  716   StringRef BufferPrefix = Buffer.substr(0, ExampleString.size());
  793   for (size_t i = 0, e = std::min(size_t(4096), Buffer.size()); i != e; ++i) {
  988   if (Buffer.size() <= Prefix.size())
  988   if (Buffer.size() <= Prefix.size())
  991   char NextChar = Buffer[Prefix.size()];
  993   StringRef Rest = Buffer.drop_front(Prefix.size() + 1);
 1043   while (Loc < Str.size() && IsPartOfWord(Str[Loc]))
 1086            Prefix.data() < Buffer.data() + Buffer.size() &&
 1111     Buffer = Buffer.drop_front(SkipWord(Buffer, Prefix.size()));
 1181            AfterSuffix.data() < Buffer.data() + Buffer.size() &&
 1189     Buffer = AfterSuffix.empty() ? Buffer.drop_front(UsedPrefix.size())
 1358       SM, Loc, Pat.getCheckTy(), Buffer, 0, Buffer.size(), Diags);
 1415     if (Range.size() > 1 && (Range[1] == '\n' || Range[1] == '\r') &&
 1804           std::make_pair(CmdlineDefsDiag.size(), CmdlineDef.size()));

  292                                OS.write(Buffer.data(), Buffer.size());

   87   unsigned Size =  String.size();

   34   if (Spec.size() > 1) {
   94   while (From < Fmt.size() && From != StringRef::npos) {
  104     if (Braces.size() > 1) {
  105       size_t NumEscapedBraces = Braces.size() / 2;

   32     if (S.size() < 3)
  166       for (size_t I = 0, E = S.size(); I < E; ++I)

  251       if (Str.size() == 2 && P->Demangler.consumeIf("St"))

  538   if (LLVM_LIKELY(isLegalUTF8String(&Rest, Data + S.size())))
  548   std::vector<UTF32> Codepoints(S.size()); // 1 codepoint per byte suffices.
  551   ConvertUTF8toUTF32(&In8, In8 + S.size(), &Out32, Out32 + Codepoints.size(),

  228   ArrayRef<uint8_t> SVal((const uint8_t *)Str.data(), Str.size());

   61     memcpy(Memory, Data.data(), Data.size());
   62   Memory[Data.size()] = 0; // Null terminate string.
   76   char *Mem = static_cast<char *>(operator new(N + NameRef.size() + 1));
  127   auto Buf = WritableMemoryBuffer::getNewUninitMemBuffer(InputData.size(), BufferName);
  130   memcpy(Buf->getBufferStart(), InputData.data(), InputData.size());
  282   size_t AlignedStringLen = alignTo(sizeof(MemBuffer) + NameRef.size() + 1, 16);

   71       if (path.size() >= 2 &&
   77     if ((path.size() > 2) && is_separator(path[0], style) &&
   96     if (str.size() > 0 && is_separator(str[str.size() - 1], style))
   96     if (str.size() > 0 && is_separator(str[str.size() - 1], style))
   97       return str.size() - 1;
   99     size_t pos = str.find_last_of(separators(style), str.size() - 1);
  103         pos = str.find_last_of(':', str.size() - 2);
  117       if (str.size() > 2 && str[1] == ':' && is_separator(str[2], style))
  122     if (str.size() > 3 && is_separator(str[0], style) && str[0] == str[1] &&
  128     if (str.size() > 0 && is_separator(str[0], style))
  141         path.size() > 0 && is_separator(path[end_pos], style);
  236   i.Position  = path.size();
  241   assert(Position < Path.size() && "Tried to increment past end!");
  244   Position += Component.size();
  247   if (Position == Path.size()) {
  254   bool was_net = Component.size() > 2 && is_separator(Component[0], S) &&
  268     while (Position != Path.size() && is_separator(Path[Position], S)) {
  273     if (Position == Path.size() && Component != "/") {
  298   I.Position = Path.size();
  322   if (Position == Path.size() && !Path.empty() &&
  350         b->size() > 2 && is_separator((*b)[0], style) && (*b)[1] == (*b)[0];
  356         return path.substr(0, b->size() + pos->size());
  356         return path.substr(0, b->size() + pos->size());
  376         b->size() > 2 && is_separator((*b)[0], style) && (*b)[1] == (*b)[0];
  393         b->size() > 2 && is_separator((*b)[0], style) && (*b)[1] == (*b)[0];
  414   return path.substr(root.size());
  492   if (ext.size() > 0 && ext[0] != '.')
  510   if (OldPrefix.size() == NewPrefix.size()) {
  510   if (OldPrefix.size() == NewPrefix.size()) {
  515   StringRef RelPath = OrigPath.substr(OldPrefix.size());
  573     if ((fname.size() == 1 && fname == ".") ||
  574         (fname.size() == 2 && fname == ".."))
  586     if ((fname.size() == 1 && fname == ".") ||
  587         (fname.size() == 2 && fname == ".."))
  680   while (Path.size() > 2 && Path[0] == '.' && is_separator(Path[1], style)) {
  682     while (Path.size() > 0 && is_separator(Path[0], style))

   43   Data.resize(2 + Salt.size());

   98   pm[0].rm_eo = String.size();
  154       if (Repl.size() != Split.first.size() &&
  154       if (Repl.size() != Split.first.size() &&
  186       Repl = Repl.substr(Ref.size());
  217   for (unsigned i = 0, e = String.size(); i != e; ++i) {

  278   memcpy(Arr.data(), S.data(), S.size());

  316            I->getText().size());
  319     unsigned LastColumnModified = HintCol + I->getText().size();
  342   for (unsigned i = 0, e = LineContents.size(), OutCol = 0; i != e; ++i) {

  148       Section = I->slice(1, I->size() - 1);

   22   size_t N = s2.size(), M = s1.size();
   22   size_t N = s2.size(), M = s1.size();
   61   for (unsigned i = 0, e = Name.size(); i != e; ++i) {

   98       makeArrayRef(data(), size()),
   99       makeArrayRef(Other.data(), Other.size()),
  108   std::string Result(size(), char());
  109   for (size_type i = 0, e = size(); i != e; ++i) {
  116   std::string Result(size(), char());
  117   for (size_type i = 0, e = size(); i != e; ++i) {
  140   size_t N = Str.size();
  183   while (This.size() >= Str.size()) {
  183   while (This.size() >= Str.size()) {
  208   size_t N = Str.size();
  220   size_t N = Str.size();
  238   for (size_type i = 0; i != Chars.size(); ++i)
  263   for (size_type i = 0; i != Chars.size(); ++i)
  279   for (size_type i = 0; i != Chars.size(); ++i)
  304   for (size_type i = 0, e = Chars.size(); i != e; ++i)
  332     S = S.slice(Idx + Separator.size(), npos);
  374   size_t N = Str.size();
  402   if (Str[0] == '0' && Str.size() > 1 && isDigit(Str[1])) {
  451   if (Str.size() == Str2.size())
  451   if (Str.size() == Str2.size())
  536   unsigned BitWidth = Log2Radix * Str.size();

   14   char *P = Alloc.Allocate<char>(S.size() + 1);
   16     memcpy(P, S.data(), S.size());
   17   P[S.size()] = '\0';
   18   return StringRef(P, S.size());

   71   int Len = Key.size() + Val.size() + 3; // +3 for " ", "=" and "\n"
   71   int Len = Key.size() + Val.size() + 3; // +3 for " ", "=" and "\n"
  128   if (Path.size() < sizeof(UstarHeader::Name)) {
  137   if (Path.size() - Sep - 1 >= sizeof(UstarHeader::Name))
  150   memcpy(Hdr.Name, Name.data(), Name.size());
  153   memcpy(Hdr.Prefix, Prefix.data(), Prefix.size());
  184     writeUstarHeader(OS, Prefix, Name, Data.size());
  187     writeUstarHeader(OS, "", "", Data.size());

  122     Width = std::max(Width, Targets.back().first.size());
  129     OS.indent(Width - Targets[i].first.size()) << " - "

   94   for (size_t I = 0; I < Query.size(); I++) {

 1055     EnvironmentName = EnvironmentName.substr(EnvironmentTypeName.size());
 1066     OSName = OSName.substr(OSTypeName.size());

  345   for (size_t i = 0, e = Text.size(); i < e; i += Length) {
  347     if (Length <= 0 || i + Length > Text.size())

  589   StringRef Remainder = PathStr.substr(Expr.size() + 1);
  854     if ((Name.size() == 1 && Name[0] == '.') ||
  855         (Name.size() == 2 && Name[0] == '.' && Name[1] == '.'))

  482   size_t ArgLength = Program.size() + 1;
  489     if (Arg.size() >= (32 * 4096))
  492     ArgLength += Arg.size() + 1;

 1440     size_t RootPathLen = sys::path::root_path(Trimmed).size();
 1441     while (Trimmed.size() > RootPathLen &&
 1443       Trimmed = Trimmed.slice(0, Trimmed.size() - 1);
 1923   return Path.slice(Parent.size() + 1, StringRef::npos);
 1984       unsigned OverlayDirLen = OverlayDir.size();
 1987       RPath = RPath.slice(OverlayDirLen, RPath.size());
 2006         unsigned OverlayDirLen = OverlayDir.size();
 2009         RPath = RPath.slice(OverlayDirLen, RPath.size());

   68     if (Input.size() >= 4) {
   77     if (Input.size() >= 2 && Input[1] != 0)
   81     if (  Input.size() >= 4
   87     if (Input.size() >= 2 && uint8_t(Input[1]) == 0xFE)
   91     if (Input.size() >= 2 && uint8_t(Input[1]) == 0xFF)
   95     if (  Input.size() >= 3
  103   if (Input.size() >= 4 && Input[1] == 0 && Input[2] == 0 && Input[3] == 0)
  106   if (Input.size() >= 2 && Input[1] == 0)
 1881     StringRef UnquotedValue = Value.substr(1, Value.size() - 2);
 1889     StringRef UnquotedValue = Value.substr(1, Value.size() - 2);
 1894       Storage.reserve(UnquotedValue.size());
 1916   Storage.reserve(UnquotedValue.size());
 1931       if (   UnquotedValue.size() > 1
 1937       if (UnquotedValue.size() == 1)
 1951         if (   UnquotedValue.size() > 1
 2010           if (UnquotedValue.size() < 3)
 2022           if (UnquotedValue.size() < 5)
 2034           if (UnquotedValue.size() < 9)

  692   unsigned End = S.size();
  751   Column += s.size();
  811   if (key.size() < strlen(spaces))
  812     Padding = &spaces[key.size()];

  352   if (FS.Str.size() >= FS.Width || FS.Justify == FormattedString::JustifyNone) {
  356   const size_t Difference = FS.Width - FS.Str.size();

   72   size_t Len = Data.size();

 1164         Val.replace(found, LHSs->getValue().size(), MHSs->getValue());
 1165         idx = found + MHSs->getValue().size();

   24   assert((Prefix.str().size() + Suffix.size() <= MAX_LINE_LEN) &&
   27   for (size_t i = (size_t)OS.tell() - Pos, e = MAX_LINE_LEN - Suffix.size();
   38   size_t PSLen = Prefix.size() + Suffix.size();
   38   size_t PSLen = Prefix.size() + Suffix.size();
   42     size_t Length = std::min(Desc.size() - Pos, MAX_LINE_LEN - PSLen);
   45   } while (Pos < Desc.size());

 5908   if (Constraint.size() == 1) {
 5977   if (Constraint.size() == 1) {
 6033     unsigned Size = Constraint.size();

 1805     Op->Tok.Length = Str.size();
 1917     Op->Barrier.Length = Str.size();
 1930     Op->SysReg.Length = Str.size();
 1955     Op->Barrier.Length = Str.size();
 1968     Op->PSBHint.Length = Str.size();
 1981     Op->BTIHint.Length = Str.size();
 5228   CurLoc = incrementLoc(CurLoc, CPU.size());
 5266     CurLoc = incrementLoc(CurLoc, Name.size());

  485   size_t const savedSize = s.size();
  491   return s.size() < savedSize ? n : -1;
  496   if (Len <= 0 || static_cast<size_t>(Len) > mangledName.size())
  718     OS.write(S.data(), S.size());
  859   S << "_Z" << static_cast<int>(NameStr.size()) << NameStr;

  285       for (size_t I = 0; I < Str.size(); ++I) {

  914     Res->Tok.Length = Str.size();
 2089     StringRef RegSuffix = Str.substr(RegName.size());
 2196   StringRef RegSuffix = RegName.substr(RI->Name.size());
 4467     return Name.substr(0, Name.size() - 4);
 4470     return Name.substr(0, Name.size() - 4);
 4473     return Name.substr(0, Name.size() - 4);
 4476     return Name.substr(0, Name.size() - 5);
 5546   if (Ctl.size() != BITMASK_WIDTH) {
 5555   for (size_t i = 0; i < Ctl.size(); ++i) {

  438   auto NameSZ = Name.size() + 1;
  471   uint16_t VendorNameSize = VendorName.size() + 1;
  472   uint16_t ArchNameSize = ArchName.size() + 1;

10544   if (Constraint.size() == 1) {
10638   if (Constraint.size() > 1) {
10659   if (Constraint.size() == 1) {

   79   for (unsigned I = 0; I != Blob.size() / sizeof(uint32_t) / 2; ++I)

 3395     SmallVector<uint8_t,16> V(S.size());
15614   unsigned S = Constraint.size();
15677   switch (Constraint.size()) {

  448       else if (ConstraintCode.size() == 2) {

 3444     Op->Tok.Length = Str.size();
 4108   if (Name.size() < 2 || Name[0] != CoprocOp)
 4112   switch (Name.size()) {
 4760     Opt = StringSwitch<unsigned>(OptStr.slice(0, OptStr.size()).lower())
 4905         for (int i = 0, e = IFlagsStr.size(); i != e; ++i) {
 4965     Flags = Mask.slice(Next+1, Mask.size());
 4989     for (int i = 0, e = Flags.size(); i != e; ++i) {
 6263     unsigned CC = ARMCondCodeFromString(Mnemonic.substr(Mnemonic.size()-2));
 6265       Mnemonic = Mnemonic.slice(0, Mnemonic.size() - 2);
 6285     Mnemonic = Mnemonic.slice(0, Mnemonic.size() - 1);
 6294       StringSwitch<unsigned>(Mnemonic.substr(Mnemonic.size()-2, 2))
 6299       Mnemonic = Mnemonic.slice(0, Mnemonic.size()-2);
 6311     unsigned CC = ARMVectorCondCodeFromString(Mnemonic.substr(Mnemonic.size()-1));
 6313       Mnemonic = Mnemonic.slice(0, Mnemonic.size()-1);
 6321     ITMask = Mnemonic.slice(2, Mnemonic.size());
 6326     ITMask = Mnemonic.slice(4, Mnemonic.size());
 6330     ITMask = Mnemonic.slice(3, Mnemonic.size());
 6805     if (ITMask.size() > 3) {
 6811     for (unsigned i = ITMask.size(); i != 0; --i) {
 6859     SMLoc Loc = SMLoc::getFromPointer(NameLoc.getPointer() + Mnemonic.size());
 6866     SMLoc Loc = SMLoc::getFromPointer(NameLoc.getPointer() + Mnemonic.size() +
 6883     SMLoc Loc = SMLoc::getFromPointer(NameLoc.getPointer() + Mnemonic.size() +
 6975                                          Mnemonic.size() - 1 + CarrySetting);
 6990                                          Mnemonic.size() - 1 + CarrySetting);
 7038                                           Mnemonic.size() + CarrySetting);
 7071       Mnemonic = Name.slice(0, Mnemonic.size() + 1);

 1096   const size_t VendorHeaderSize = 4 + CurrentVendor.size() + 1;

 1689   if (Constraint.size() == 1) {
 1860   if (Constraint.size() == 1) {

  178   if (Constraint.size() == 1)

  377   Size += S.size() + 1;
  666   if (!File->getFilename().startswith("/") && File->getDirectory().size())

  422     Op->Tok.Length = Str.size();
  857           getContext(), String.substr(HeadTail.first.size(), 1), Loc));
  939                                    Third.getString().size());
  972                                                 Token.getString().size());
  977                           Lookahead.back().getString().size();
 1001       StringRef DotString (RawString.data() + First, RawString.size() - First);

 2978   if (Constraint.size() == 1) {
 2998   if (Constraint.size() == 1) {

 1741                                MAI.getCommentString().size()) == 0)

  586     Op->Tok.Length = Str.size();
 1043     Mnemonic = Name.substr(0, Name.size() - 2);
 1075       size_t Next = Mnemonic.rfind('.', Name.size());

  239   if (Constraint.size() == 1)

  367   if (Constraint.size() == 1) {
  381   if (Constraint.size() == 1) {

  858     Op->RegIdx.Tok.Length = Str.size();
 1457     Op->Tok.Length = Str.size();

 3770   if (Constraint.size() == 1) {
 3956   if (Constraint.size() == 1) {

   75   for (unsigned I = 0, E = Name.size(); I != E; ++I) {

 4255   if (Constraint.size() == 1) {
 4278   if (Constraint.size() == 1) {

  158     ReflectArg = ReflectArg.substr(0, ReflectArg.size() - 1);

  584     Op->Tok.Length = Str.size();
  598     void *Mem = ::operator new(sizeof(PPCOperand) + Str.size());
  601     Op->Tok.Length = Str.size();
  602     std::memcpy(const_cast<char *>(Op->Tok.Data), Str.data(), Str.size());

14217   if (Constraint.size() == 1) {
14309   if (Constraint.size() == 1) {

  668     Op->SysReg.Length = Str.size();

 2537   if (Constraint.size() == 1) {
 2560   if (Constraint.size() == 1) {
 2671   if (ConstraintCode.size() == 1) {

  381     Op->Tok.Length = Str.size();

 3180   if (Constraint.size() == 1) {
 3258   if (Constraint.size() == 1) {
 3286   } else if (!Constraint.empty() && Constraint.size() <= 5
 3290     StringRef name(Constraint.data()+1, Constraint.size()-2);

  164     Op->Token.Length = Str.size();
  708   if (Name.size() < 2)

  953   if (Constraint.size() == 1) {
 1062         Constraint.slice(2, Constraint.size() - 1).getAsInteger(10, Index);
 1072   if (Constraint.size() == 1) {
 1112   if (Constraint.size() > 0 && Constraint[0] == '{') {

  436     if (ConstraintCode.size() == 1) {

  241       LLVMCreateMemoryBufferWithMemoryRangeCopy(Data.data(), Data.size(), "");

  430     Name = StringRef(NameLoc.getPointer(), Name.size());
  441       Name = StringRef(Name.begin(), Name.size() + Sep.getString().size());
  441       Name = StringRef(Name.begin(), Name.size() + Sep.getString().size());
  448       Name = StringRef(Name.begin(), Name.size() + Id.getString().size());
  448       Name = StringRef(Name.begin(), Name.size() + Id.getString().size());

  263     OutStreamer->EmitULEB128IntValue(F.Name.size());

  479   if (Constraint.size() == 1) {

 1176     if (Tok.getString().size() == 3) {
 1189     } else if (Tok.getString().size() == 4 && Tok.getString()[2] == '1') {
 1596     Loc = SMLoc::getFromPointer(SymName.data() + SymName.size());
 1597     ExprLen = End.getPointer() - (SymName.data() + SymName.size());
 1636   const char *EndPtr = Tok.getLoc().getPointer() + LineBuf.size();
 1655     assert(InternalName.size() && "We should have an internal name here.");
 1657     InstInfo->AsmRewrites->emplace_back(AOK_Label, Loc, Identifier.size(),
 1734   const char *DotExprEndLoc = DotDispStr.data() + DotDispStr.size();
 2191                        Buf[1].getIdentifier().size() + 1);
 2401           NameLoc.getFromPointer(NameLoc.getPointer() + Name.size());
 2408                                           NextTok.size() + 1);
 2415     PatchedName = PatchedName.substr(0, Name.size()-1);
 2426       PatchedName.slice(CCIdx, PatchedName.size() - 2))
 2497       PatchedName.slice(5, PatchedName.size() - SuffixSize))
 2526       PatchedName.slice(5, PatchedName.size() - SuffixSize))

  155     Tok.Length = Value.size();
  583     SMLoc EndLoc = SMLoc::getFromPointer(Loc.getPointer() + Str.size());
  586     Res->Tok.Length = Str.size();

45215     S = S.substr(Piece.size());
45355   if (Constraint.size() == 1) {
45394   else if (Constraint.size() == 2) {
45460     unsigned Size = StringRef(constraint).size();
45793   if (Constraint.size() == 1) {
45932   } else if (Constraint.size() == 2 && Constraint[0] == 'Y') {
45978     if (Constraint.size() == 7 && Constraint[0] == '{' &&

  132           Name = Name.drop_front(HintType.first.size());

  255   Key.reserve(CPU.size() + FS.size());
  255   Key.reserve(CPU.size() + FS.size());
  303   FS = Key.slice(CPU.size(), CPUFSWidth);

 1930   if (Constraint.size() == 1) {

   33   Code.reserve(Text.size());
   57       Text = Text.drop_front(Name->size());

  726       void *Ptr = Allocator.Allocate(String.size(), 1);
  727       memcpy(Ptr, String.data(), String.size());
  728       return StringRef(reinterpret_cast<const char *>(Ptr), String.size());

  224       return (s.size() / 4) + 1;
  230       writeBytes(s.data(), s.size());
  233       assert((unsigned)(4 - (s.size() % 4)) > 0);
  234       assert((unsigned)(4 - (s.size() % 4)) <= 4);
  235       writeBytes("\0\0\0\0", 4 - (s.size() % 4));

  676   StringRef Name = Inc->getName()->getName().substr(NamePrefix.size());

  578                                        return i + Cmp.BB->getName().size();

   95   if (int Res = cmpNumbers(L.size(), R.size()))
   95   if (int Res = cmpNumbers(L.size(), R.size()))

  375                  ? Str.size()
  403                  ? Str.size()
  774   if (HasS2 && S2.size() == 1)
  805       Pos = S1.size();
  825       Pos = S1.size();
  884   if (HasStr2 && ToFindStr.size() == 1) {
 1047     if (Len > LHSStr.size() || Len > RHSStr.size())
 1047     if (Len > LHSStr.size() || Len > RHSStr.size())
 1285         CallerName.size() == (CalleeName.size() + 1) &&
 1285         CallerName.size() == (CalleeName.size() + 1) &&
 2342   if (FormatStr.size() == 1 || FormatStr == "%%")
 2350     if (ChrStr.size() != 1)
 2356   if (FormatStr[FormatStr.size() - 1] == '\n' &&
 2431                                     FormatStr.size() + 1)); // Copy the null byte.
 2432     return ConstantInt::get(CI->getType(), FormatStr.size());
 2437   if (FormatStr.size() != 2 || FormatStr[0] != '%' ||
 2530       return ConstantInt::get(CI->getType(), FormatStr.size());
 2531     else if (N < FormatStr.size() + 1)
 2539                          FormatStr.size() + 1)); // Copy the null byte.
 2540     return ConstantInt::get(CI->getType(), FormatStr.size());
 2545   if (FormatStr.size() == 2 && FormatStr[0] == '%' &&
 2574         return ConstantInt::get(CI->getType(), Str.size());
 2575       else if (N < Str.size() + 1)
 2579                      ConstantInt::get(CI->getType(), Str.size() + 1));
 2582       return ConstantInt::get(CI->getType(), Str.size());
 2620         ConstantInt::get(DL.getIntPtrType(CI->getContext()), FormatStr.size()),
 2626   if (FormatStr.size() != 2 || FormatStr[0] != '%' ||

  220   Name = Name.substr(Prefix().size(), StringRef::npos);

  101   ArrayRef<char> Bytes(D.data(), D.size());
  110   ArrayRef<char> Bytes(D.data(), D.size());
  119   ArrayRef<char> Bytes(D.data(), D.size());

   39   if (Data.size() < 32)
   44   if (Data.size() - 32 == 0 || Data.size() % 32 != 0)
   44   if (Data.size() - 32 == 0 || Data.size() % 32 != 0)
  270   if (Data.size() < 32)

  400                        L.getLocWithOffset(1 + TagName.size()));
  442       return NameLocBegin.getLocWithOffset(Name.size());
  457                      LocBegin, LocBegin.getLocWithOffset(1 + TagName.size()),
  460                      LocBegin.getLocWithOffset(1 + TagName.size())) {
  516                      LocBegin.getLocWithOffset(2 + TagName.size()))
  665                        getBeginLoc().getLocWithOffset(1 + Name.size()));
  871               LocBegin.getLocWithOffset(Text.size())),

  106     IntVal = Text.size();
  117     IntVal = Name.size();
  148     IntVal = Text.size();
  169     IntVal = Text.size();
  180     IntVal = Name.size();
  191     IntVal = Name.size();
  202     IntVal = Str.size();
  213     IntVal = Name.size();

 2472     assert(!str.empty() && str.data()[str.size()] == '\0');

  351   return ss.write(str.data(), str.size());

  558     StartGetterSelectorLoc.getLocWithOffset(GetterSelector.getNameForSlot(0).size());

   49       AfterMacroLoc = I->getLocWithOffset(getARCMTMacroName().size());
   65   if (RelOffs - getARCMTMacroName().size() > 100)

  486   SourceLocation afterText = loc.getLocWithOffset(text.size());

10362         /*Pascal*/ false, getStringLiteralArrayType(CharTy, Key.size()),

   49   if (Typo.size() <= 1)
   61     unsigned MinPossibleEditDistance = abs((int)Name.size() - (int)Typo.size());
   61     unsigned MinPossibleEditDistance = abs((int)Name.size() - (int)Typo.size());
   84   char *Name = Allocator.Allocate<char>(CommandName.size() + 1);
   85   memcpy(Name, CommandName.data(), CommandName.size());
   86   Name[CommandName.size()] = '\0';

   71   for (unsigned i = 0, e = Name.size(); i != e; ++i) {
   81   for (unsigned i = 0, e = Name.size(); i != e; ++i) {

  424                                   Loc.getLocWithOffset(1 + CommandName.size()),
  448                               TextBegin.getLocWithOffset(Text.size()),
 1004       : BestDecl(nullptr), Typo(Typo), MaxEditDistance((Typo.size() + 2) / 3),
 1030   unsigned MinPossibleEditDistance = abs((int)Name.size() - (int)Typo.size());
 1030   unsigned MinPossibleEditDistance = abs((int)Name.size() - (int)Typo.size());
 1032       Typo.size() / MinPossibleEditDistance < 3)

 4522       new (C, DC, additionalSizeToAlloc<char>(Arg.size() + 1))
 4524   memcpy(PCD->getTrailingObjects<char>(), Arg.data(), Arg.size());
 4525   PCD->getTrailingObjects<char>()[Arg.size()] = '\0';
 4542   size_t ValueStart = Name.size() + 1;
 4544       new (C, DC, additionalSizeToAlloc<char>(ValueStart + Value.size() + 1))
 4546   memcpy(PDMD->getTrailingObjects<char>(), Name.data(), Name.size());
 4547   PDMD->getTrailingObjects<char>()[Name.size()] = '\0';
 4549          Value.size());
 4550   PDMD->getTrailingObjects<char>()[ValueStart + Value.size()] = '\0';
 4588   char *Buffer = new (getASTContext(), 1) char[Name.size() + 1];
 4589   memcpy(Buffer, Name.data(), Name.size());
 4590   Buffer[Name.size()] = '\0';

 1036   unsigned ByteLength = Str.size();
 1086                                1, NumConcatenated, Str.size()),
 4058   for (unsigned i = 0, e = Comp.size(); i != e; ++i)

10720       if (Off >= 0 && (uint64_t)Off <= (uint64_t)Str.size() &&
10730         return Success(Str.size(), E);

  370         Out << Tag.size();
  685   size_t EncodingPositionStart = FunctionEncodingStream.str().size();
  932   Out << Parts.second.size() << Parts.second;
 2364   Out << 'U' << name.size() << name;
 3270       QualOS << name.size() << name;
 4123     Out << "v1U" << Kind.size() << Kind;

  290   Out << OS.str().size() << OS.str();

   51     if (MangledName.size() <= 4096) {

  137         I += Matches[0].size();
  144           unsigned Size = MaskType.size();

   27   if ((Comment.size() < MinCommentLength) || Comment[0] != '/')
   32     if (Comment.size() < 3)
   42     assert(Comment.size() >= 4);
   47         Comment[Comment.size() - 2] != '*' ||
   48         Comment[Comment.size() - 1] != '/')
   58   const bool TrailingComment = (Comment.size() > 3) && (Comment[3] == '<');
   63   return (Comment.size() > 3) && (Comment[3] == '<');
  403       WhitespaceLen = TokText.size();

  360   Name = Name.drop_back(Suffix.size());
  530                  FullName.drop_back(Pattern.size()).endswith("::")) {

  164           if (TokenLength == Code.size() || !isAlphanumeric(Code[TokenLength]))
  195     if (Code.size() > 1) {
  201     while (Length < Code.size() && isHexDigit(Code[Length]))
  205     while (Length < Code.size()) {
  251     for (size_t Length = 1, Size = Code.size(); Length != Size; ++Length) {
  270     Code = Code.drop_front(Code.size());
  513     Completions.emplace_back(Completion.TypedText.substr(CompToken.Text.size()),

   54   for (StringRef::size_type i = s.size(); i != 0; --i)
  439   char *FileName_cstr = (char*) Alloc.Allocate(FileName.size(), 1);
  440   memcpy(FileName_cstr, FileName.data(), FileName.size());
  444                                                   FileName.size())));

 1095       if (Slot.substr(Slot.size() - 8).equals_lower("delegate")) {

   13   if (Name.size() >= 4 && Name.startswith("__") && Name.endswith("__"))
   14     Name = Name.substr(2, Name.size() - 4);
   64   if (ShouldNormalize && AttrName.size() >= 4 && AttrName.startswith("__") &&
   66     AttrName = AttrName.slice(2, AttrName.size() - 2);

  599   unsigned BestDistance = Group.size() + 1; // Sanity threshold.

   78   if (llvm::sys::path::is_separator(Filename[Filename.size() - 1]))
  121   if (DirName.size() > 1 &&
  124     DirName = DirName.substr(0, DirName.size()-1);

  502   if (name.size() < word.size()) return false;
  502   if (name.size() < word.size()) return false;
  503   return ((name.size() == word.size() || !isLowercase(name[word.size()])) &&
  503   return ((name.size() == word.size() || !isLowercase(name[word.size()])) &&
  503   return ((name.size() == word.size() || !isLowercase(name[word.size()])) &&

   87     NewLHS += LHS.slice(Pos+1, LHS.size());

   55   if (dash != StringRef::npos && dash + 1 != input.size() &&

  178       Ptr[i] = FillStr[i % FillStr.size()];

   97     if (StringRef(Name).size() > 1)

  135         if (Opt.size() > 5) {  // Specifier must be present.
  136           if ((Opt[5] != '=' && Opt[5] != '-') || Opt.size() == 6) {
  163         if (Opt.size() != 12) {
  164           if ((Opt[12] != '=' && Opt[12] != '-') || Opt.size() == 13) {

 1246       for (unsigned I = 0, E = Item.getMaskType().size(); I < E; ++I)
 3119               makeArrayRef(WideBytes.data(), WideBytes.size()), StrUtf8)) {

  482       return (Twine(Entry.second) + Path.substr(Entry.first.size())).str();

  700     char *Data = DebugInfoNames.Allocate<char>(A.size() + B.size());
  700     char *Data = DebugInfoNames.Allocate<char>(A.size() + B.size());
  702       std::memcpy(Data, A.data(), A.size());
  704       std::memcpy(Data + A.size(), B.data(), B.size());
  704       std::memcpy(Data + A.size(), B.data(), B.size());
  705     return StringRef(Data, A.size() + B.size());
  705     return StringRef(Data, A.size() + B.size());

 2444   assert(Asm->getLabel().size() < 64-Name.size() &&

 1039       unsigned NumU8CodeUnits = Str.size();
 1070       Fields.addInt(Int32Ty, Str.size());
 1072       Fields.addInt(Int32Ty, Str.size());
 1082       for (int i=0,e=Str.size() ; i<e ; ++i) {

 1944   StringLength = String.size();

 1900     for (unsigned i = 0, e = StrVal.size() - 1; i != e; ++i) {

 4586   unsigned NumBytes = String.size();
 4727         Entry.first().size() / 2);
 5706   assert(Uuid.size() == 36);

  447     TDTypeName += llvm::utostr(TypeInfoString.size());
  449         TypeDescriptorTypeMap[TypeInfoString.size()];
  455         llvm::ArrayType::get(CGM.Int8Ty, TypeInfoString.size() + 1)};

 8819     assert(E.State==Recursive && E.Str.size() == Str.size() &&

  860     ArchPrefixLen = CfgFileArch.size();
 1202     for (size_t i = 0, e = ParentProcess.size(); i < e; ++i) {

  159       Pos = ProgName.size() - Suffix.size();
  159       Pos = ProgName.size() - Suffix.size();

   94   if (Split.second.size() && !DecodeAArch64Features(D, Split.second, Features))
  110       (Split.second.size() && !DecodeAArch64Features(D, Split.second, Features)))

  110       (Split.second.size() && !DecodeARMFeatures(
  126       (Split.second.size() && !DecodeARMFeatures(

  122     StringRef Name(Ext.substr(Type.size()));
  206       (MArch.size() < 5)) {

   96   for (unsigned i = 0, e = Target.size(); i != e; ++i) {
  171     if (RefStep.size() != 1) {

  190             LibDeviceName.size(), FileName.find('.', LibDeviceName.size()));
  190             LibDeviceName.size(), FileName.find('.', LibDeviceName.size()));

  932   return PathIntoXcode.take_front(Index + XcodeAppSuffix.size());
 1070       return SDK.slice(0, SDK.size() - 4);
 1528   if (!SDK.size())
 1808     if (SDK.size() > 0) {

 1377   for (size_t I = 0, E = OptStr.size(); I != E; ++I) {
 1504     for (size_t I = 0, E = OptStr.size(); I != E; ++I) {

  336   Len = text.size();

  354   if (end == buffer.size())
  357   assert(begin < buffer.size() && end < buffer.size() && "Invalid range!");
  357   assert(begin < buffer.size() && end < buffer.size() && "Invalid range!");
  368     assert((end + 1 != buffer.size() || buffer.data()[end + 1] == 0) &&

  700         text = text.substr(0, text.size()-suff.size());
  700         text = text.substr(0, text.size()-suff.size());
  748       CharSourceRange::getCharRange(B, B.getLocWithOffset(text.size()));

   79   End = End.getLocWithOffset(Last.TokenText.size());

   55       size_t PrefixLength = KnownPrefix.size();
   56       while (PrefixLength < Comment.size() && Comment[PrefixLength] == ' ')
   58       if (PrefixLength > LongestPrefix.size())
   80        NumChars < MaxSplit && MaxSplitBytes < Text.size();) {
  101              SpaceOffset + 1 < Text.size() && Text[SpaceOffset + 1] == '{')
  129     if (!DecorationEndsWithStar || AfterCut.size() <= 1 || AfterCut[1] != '/')
  131     return BreakableToken::Split(BeforeCut.size(),
  161     if (Chars > MaxSplit || Text.size() <= Advance)
  224   return UnbreakableTailLength + Postfix.size() +
  231   return StartColumn + Prefix.size();
  243       Prefix.size(), Tok.TokenText.size() - Prefix.size() - Postfix.size());
  243       Prefix.size(), Tok.TokenText.size() - Prefix.size() - Postfix.size());
  243       Prefix.size(), Tok.TokenText.size() - Prefix.size() - Postfix.size());
  243       Prefix.size(), Tok.TokenText.size() - Prefix.size() - Postfix.size());
  250                         ColumnLimit - Postfix.size(), Style.TabWidth, Encoding);
  258       Tok, Prefix.size() + TailOffset + Split.first, Split.second, Postfix,
  326   return Content.size() >= 2 && !hasSpecialMeaningPrefix &&
  345   TokenText.substr(2, TokenText.size() - 4)
  388       Decoration = Decoration.substr(0, Decoration.size() - 1);
  417                                   ? Content[i].size()
  418                                   : Decoration.size();
  427   IndentAtLineBreak = std::max<unsigned>(IndentAtLineBreak, Decoration.size());
  477   size_t EndOfPreviousLine = Lines[LineIndex - 1].size();
  491     StartOfLine = Lines[LineIndex].size();
  523       LineLength -= Decoration.size();
  578       Text.size() == Split.first + Split.second) {
  589   assert(LocalIndentAtLineBreak >= Prefix.size());
  634                                      Content[LineIndex - 1].size() -
  685                                      Content[LineIndex - 1].size() -
  692       InPPDirective, /*Newlines=*/1, ContentColumn[LineIndex] - Prefix.size());
  704       return Split(TrimmedLine.size(), Line.size() - TrimmedLine.size());
  704       return Split(TrimmedLine.size(), Line.size() - TrimmedLine.size());
  704       return Split(TrimmedLine.size(), Line.size() - TrimmedLine.size());
  754       if (Lines[i].size() > Prefix[i].size() &&
  754       if (Lines[i].size() > Prefix[i].size() &&
  755           isAlphanumeric(Lines[i][Prefix[i].size()])) {
  772       Content[i] = Lines[i].substr(IndentPrefix.size());
  784         EndOfLine = Content[i].size();
  838                                Prefix[LineIndex].size() -
  839                                OriginalPrefix[LineIndex].size();
  840   assert(IndentAtLineBreak >= Prefix[LineIndex].size());
  844       /*Spaces=*/IndentAtLineBreak - Prefix[LineIndex].size());
  881                       Lines[LineIndex - 1].size() -
  926         (OriginalPrefix[LineIndex].size() - Prefix[LineIndex].size());
  926         (OriginalPrefix[LineIndex].size() - Prefix[LineIndex].size());
  946         tokenAt(LineIndex), OriginalPrefix[LineIndex].size(), 0, "", "",

  150   if (TokenText.size() < 5 // The smallest raw string possible is 'R"()"'.
  163   size_t RParenPos = TokenText.size() - Delimiter.size() - 2;
  163   size_t RParenPos = TokenText.size() - Delimiter.size() - 2;
 1512   unsigned OldPrefixSize = 3 + OldDelimiter.size();
 1513   unsigned OldSuffixSize = 2 + OldDelimiter.size();
 1526   unsigned NewPrefixSize = 3 + NewDelimiter.size();
 1527   unsigned NewSuffixSize = 2 + NewDelimiter.size();
 1599           SourceMgr, PrefixDelimiterStart, OldDelimiter.size(), NewDelimiter));
 1608           Current.Tok.getLocation().getLocWithOffset(Current.TokenText.size() -
 1609                                                      1 - OldDelimiter.size());
 1611           SourceMgr, SuffixDelimiterStart, OldDelimiter.size(), NewDelimiter));

   55   return Text.size();
   99   if (Text.size() < 2)
  109     while (I < Text.size() && isHexDigit(Text[I]))
  116       while (I < Text.size() && I < 4 && isOctDigit(Text[I]))

 1300         for (size_t i = 1; i < Input.size() - 1; i++) {
 1303             if (!Escaped && i + 1 < Input.size() &&
 1849     unsigned End = Start + Includes[Indices[i]].Text.size();
 1900       Includes.back().Offset + Includes.back().Text.size();
 2005         Code.substr(Prev, (Pos != StringRef::npos ? Pos : Code.size()) - Prev);
 2040     if (Pos == StringRef::npos || Pos + 1 == Code.size())
 2079       Imports.back().Offset + Imports.back().Text.size();
 2164         Code.substr(Prev, (Pos != StringRef::npos ? Pos : Code.size()) - Prev);
 2187     } else if (Trimmed.size() > 0 && !ImportsInBlock.empty()) {
 2192     if (Pos == StringRef::npos || Pos + 1 == Code.size())
 2205   return Code.size() > 188 && Code[0] == 0x47 && Code[188] == 0x47;

  468     return Content.size() > 1 &&

  314     AddLength += First[i]->TokenText.size();
  318                                   First[0]->TokenText.size() + AddLength);
  383   const char *RegexBegin = Offset - RegexToken->TokenText.size();
  413   RegexToken->ColumnWidth = RegexToken->TokenText.size();
  441   const char *TmplBegin = Offset - BacktickToken->TokenText.size(); // at "`"
  475         LiteralText.substr(LastBreak + 1, LiteralText.size()), StartColumn,
  491       Lex->getBufferLocation() - HashToken->TokenText.size(); // at "#"
  495     To = Lex->getBuffer().size();
  500   SourceLocation Loc = To < Lex->getBuffer().size()
  525   const char *End = Last->TokenText.data() + Last->TokenText.size();
  657     for (int i = 0, e = Text.size(); i != e; ++i) {
  711       if (BackslashPos + 1 < FormatTok->TokenText.size() &&
  714         Offset -= FormatTok->TokenText.size();
  731   while (FormatTok->TokenText.size() > 1 && FormatTok->TokenText[0] == '\\') {
  733     if (FormatTok->TokenText.size() > 2 &&
  758     TrailingWhitespace = UntrimmedText.size() - FormatTok->TokenText.size();
  758     TrailingWhitespace = UntrimmedText.size() - FormatTok->TokenText.size();

  180     unsigned PreviousSize = getSourceText(InsertionPoint).size();
  342           Current->TokenText.substr(1, Current->TokenText.size() - 2);
  356           Current->TokenText.substr(1, Current->TokenText.size() - 2);

 2424     bool is_short_annotation = Right.TokenText.size() < 10;

 1370         if (FollowedByNewline && (Text.size() >= 5 || FunctionLike) &&

  758         StringRef(OutFile).drop_back(OutputExtension.size());

 1026       if (CoverageVersion.size() != 4) {
 3204         (Major == 3 ? VerParts.second.size() == 1 &&
 3206                     : VerParts.first.size() == Ver.size() ||
 3206                     : VerParts.first.size() == Ver.size() ||

  332     unsigned N = Target.size();
  356     unsigned N = File.size();

  713   bool IsRaw = (Magic.size() >= 4 && Magic[0] == 'C' && Magic[1] == 'P' &&

   44   if (MacroName.size() != Macro.size()) {
   44   if (MacroName.size() != Macro.size()) {

   23   while (Offset < S.size() && isIdentifierBody(S[Offset]))
  134       while (Idx < LineStr.size() && isDigit(LineStr[Idx]))

  404   OS.write(S.begin(), S.size());

  306   if (LocalEOL.size() == 2 &&

  600           Context->CharTy, llvm::APInt(32, Str.size() + 1), nullptr,

  500           Context->CharTy, llvm::APInt(32, Str.size() + 1), nullptr,

  383                                      0 /* For legacy */, Name.size()};
  530   RecordData::value_type Record[] = {RECORD_CATEGORY, category, catName.size()};
  560                                        FlagName.size()};
  652   Record.push_back(Message.size());
  823       Flag ? DiagFlagLookup[Flag] : 0, Message.size()};
  837                                      End.Offset, Text.size()};

  101   assert(*i<SourceLine.size() && "must point to a valid index");
  119   end = begin + (SourceLine.size() - *i);
  206   out.resize(SourceLine.size()+1, -1);
  210   while (i<SourceLine.size()) {
  242   while (i<SourceLine.size()) {
  261     assert(m_byteToColumn.size()==SourceLine.size()+1);
  548   assert(Start < Str.size() && "Invalid start position!");
  552   if (End == Str.size())
  617   const unsigned Length = std::min(Str.find('\n'), Str.size());
 1012   unsigned EndColNo = map.getSourceLine().size();
 1032     while (StartColNo < map.getSourceLine().size() &&
 1038     if (EndColNo > map.getSourceLine().size())
 1039       EndColNo = map.getSourceLine().size();
 1054   assert(StartColNo <= map.getSourceLine().size() && "Invalid range!");
 1055   assert(EndColNo <= map.getSourceLine().size() && "Invalid range!");
 1186     const char *BufEnd = BufStart + BufData.size();
 1208            (LineNo != CaretLineNo || Line.size() > CaretColNo))
 1294   while (i<line.size()) {

  136     PEnd = C + S.size();
  139     return memcmp(P, S.data(), S.size()) == 0;
  186         PEnd = P + S.size();
  231         P += OpenBrace.size();
  235           PEnd = P + CloseBrace.size();
  238         P += CloseBrace.size();
  449       DToken = DToken.substr(0, DToken.size()-3);
  470     DToken = DToken.substr(0, DToken.size()-DType.size());
  470     DToken = DToken.substr(0, DToken.size()-DType.size());
  622       CPos = FPos + NewlineStr.size();
  770   C2.reserve(C.size());
  773     if (loc == StringRef::npos || loc == C.size()) {
  784       if (last < C.size())
 1139         VerbatimMatchLength = S.size();

 1107       Pos = S.size();

  170     while (Last != End && size_t(Last - First) < Terminator.size() &&
  179     if (size_t(Last - First) < Terminator.size())

  649   char *CopyStr = Alloc.Allocate<char>(Str.size()+1);
  651   CopyStr[Str.size()] = '\0';
 1061       CacheLookup.first().size() == FrameworkName.size() &&
 1063              CacheLookup.first().size()) != 0)
 1774       if (NI->size() == 1 && DI->size() == 1 &&
 1774       if (NI->size() == 1 && DI->size() == 1 &&

  491   if (Offset >= Buffer.size())

 1771     memcpy(ResultPtr, Fragment.data(), Fragment.size());
 1772     ResultPtr += Fragment.size();
 1790     Dummy.reserve(Fragment.size() * CharByteWidth);

  346     Buffer.reserve(Buffer.size() + Name.size());
  347     for (unsigned I = 0, N = Name.size(); I != N; ++I) {
 1493     Tok.StringLength = RI.size();

  110   if (Text.size() >= 2 && Text[0] == '_' &&
  177   if (Include.size() > MaxStdHeaderNameLen)
  500     if (!Tok.needsCleaning() && RI.size() < 20) {
 1534   if (Buffer.size() <= 2) {
 1541   Buffer = Buffer.substr(1, Buffer.size()-2);
 2102       Path.reserve(Name.size()+2);
 2112           Path.size() <= Filename.size() ? Filename[Path.size()-1] :

  211         Result = FilePath.substr(Path.size());
  353             const size_t MaxHalfLength = std::max(ControllingMacroName.size(),
  354                                                   DefinedMacroName.size()) / 2;

 1099   if (Feature.startswith("__") && Feature.endswith("__") && Feature.size() >= 4)
 1100     Feature = Feature.substr(2, Feature.size() - 4);
 1126       Extension.size() >= 4)
 1127     Extension = Extension.substr(2, Extension.size() - 4);

   48   char *Memory = (char *)PPRec.Allocate(FileName.size() + 1, alignof(char));
   49   memcpy(Memory, FileName.data(), FileName.size());
   50   Memory[FileName.size()] = 0;
   51   this->FileName = StringRef(Memory, FileName.size());

  485   Tok.setLength(Str.size());
  488   SourceLocation Loc = ScratchBuf->getToken(Str.data(), Str.size(), DestPtr);
  492                                        ExpansionLocEnd, Str.size());
 1055     if (Str.size() >= 2 && Str.front() == '"' && Str.back() == '"')

   27     if (Str.size() == 1)
   32     if (Str[1] == 'R' && Str[0] != 'R' && Str.size() == 2 && CPlusPlus11)
   37       if (Str.size() == 2) return true; // "u8"
   38       if (Str.size() == 3 && Str[2] == 'R') return true; // "u8R"

   73   if (Name.size() >= 4 && Name.startswith("__") && Name.endswith("__"))

  967       Toks[0].setLength(Section.size());

  170   unsigned len = s.size();

  124   AddInsertDelta(OrigOffset, Str.size());
  135   if (OrigLength != NewStr.size())
  136     AddReplaceDelta(OrigOffset, NewStr.size() - OrigLength);
  390   if (parentSpace.size() >= startSpace.size())
  390   if (parentSpace.size() >= startSpace.size())
  395   StringRef indent = startSpace.substr(parentSpace.size());

  351   char *Mem = (char *)Allocate(Ref.size() + 1, 1);
  353   Mem[Ref.size()] = 0;

   43     MessageData = new char [Msg.size()];
   44     memcpy(MessageData, Msg.data(), Msg.size());
   47   DD.AvailabilityData.MessageLen = Msg.size();

 5473     unsigned NumBytes = String.size();
 8789   size_t StrLen = std::min(std::max(TypeSize, size_t(1)) - 1, StrRef.size());
 8799   if (TypeSize <= StrRef.size() &&
 8852   size_t StrLen = std::min(std::max(TypeSize, size_t(1)) - 1, StrRef.size());

 1629   if (AttrName.size() > 4 && AttrName.startswith("__") &&
 3835   switch (Str.size()) {
 3915   if (Str.size() >= 4 && Str[0] == 'V') {
 3917     size_t StrSize = Str.size();
 5333   if (StrRef.size() == 38 && StrRef.front() == '{' && StrRef.back() == '}')
 5337   if (StrRef.size() != 36) {

 3639   unsigned MinPossibleEditDistance = abs((int)MethodName.size() - (int)Typo.size());
 3641       Typo.size() / MinPossibleEditDistance < 1)

 3188   Target.resize(CharByteWidth * (Source.size() + 1));
11237       (LHSStrRef.size() > 1 && LHSStrRef.startswith("0")) ||
11238       (RHSStrRef.size() > 1 && RHSStrRef.startswith("0")) ||

 6719       if (Name.size() >= 2 && Name.front() == '_' &&

 4224   unsigned MinED = abs((int)Name.size() - (int)TypoStr.size());
 4224   unsigned MinED = abs((int)Name.size() - (int)TypoStr.size());
 4225   if (MinED && TypoStr.size() / MinED < 3)
 4230   unsigned UpperBound = (TypoStr.size() + 2) / 3;
 4249   if (TypoStr.size() < 3 &&
 4250       (Name != TypoStr || Correction.getEditDistance(true) > TypoStr.size()))
 4396   unsigned TypoLen = Typo->getName().size();
 5011   unsigned TypoLen = Typo->getName().size();
 5134   if (!ExternalTypo && ED > 0 && Typo->getName().size() / ED < 3)

  602     if (MacroName.size() == Macro.size())
  602     if (MacroName.size() == Macro.size())
 1188                 Blob.size() / 4));
 3150           static_cast<unsigned int>(Blob.size() / 4));
 3480       assert(Blob.size() % sizeof(PPEntityOffset) == 0);
 3481       F.NumPreprocessedEntities = Blob.size() / sizeof(PPEntityOffset);
 3512       assert(Blob.size() % sizeof(PPSkippedRange) == 0);
 3513       F.NumPreprocessedSkippedRanges = Blob.size() / sizeof(PPSkippedRange);
 3780   const unsigned char *DataEnd = Data + F.ModuleOffsetMap.size();
 4727   if (BlockNameLen + UserInfoLen > Blob.size()) return true;
 5958     StringRef FullFileName(FullFileNameStart, Blob.size() - Record[0]);

 1369   for (; Filename[Pos] && Pos < BaseDir.size(); ++Pos)
 1400   Hasher.update(ArrayRef<uint8_t>(Bytes.bytes_begin(), Bytes.size()));
 2019       unsigned KeyLen = key.Filename.size() + 1 + 8 + 8;
 2254                                  Blob.size() - 1};
 2361                                   StringRef(Name.data(), Name.size() + 1));
 2757       Record.push_back(ID->getFileName().size());
 4597   Record.push_back(Str.size());
 5044         LE.write<uint16_t>(Name.size());
 5045         Out.write(Name.data(), Name.size());

  333   Record.push_back(Arg.size());
  345   Record.push_back(Name.size() + 1 + Value.size());
  345   Record.push_back(Name.size() + 1 + Value.size());

  737     unsigned KeyLen = Key.size();
  803     Record.push_back(Name.size());

  607   unsigned n = str.size();

  869     if ((stringValue.trim().size() == 0 && stringValue.size() > 0) ||
  869     if ((stringValue.trim().size() == 0 && stringValue.size() > 0) ||
 1177   if ((Comment.trim().size() == 0 && Comment.size() > 0) || // Is Whitespace
 1177   if ((Comment.trim().size() == 0 && Comment.size() > 0) || // Is Whitespace

 1587   return Snippet.size();

  816     unsigned len = Msg.size();

   81   if (Checker.FullName.size() == PackageName.size())
   81   if (Checker.FullName.size() == PackageName.size())
   85   if (Checker.FullName[PackageName.size()] == PackageSeparator)
  519     size_t NameLength = Checker.FullName.size();

  134   auto UnspelledSpecifier = QName.drop_back(Spelling.size());

  391       Delta += R.getReplacementText().size() - R.getLength();
  397       if (R.getOffset() + RText.size() > End) {
  401         Length += R.getLength() - RText.size();
  403       DeltaFirst += RText.size() - R.getLength();
  539     unsigned Length = R.getReplacementText().size();
  550       Offset += R.getReplacementText().size() - R.getLength();
  554         R.getOffset() + R.getReplacementText().size() <= Position) {
  555       Position = R.getOffset() + R.getReplacementText().size();

   80     Children[Element].insert(NewPath, ConsumedLength + Element.size() + 1);
  120           ConsumedLength + Element.size() + 1);

  253     NextLineOffset = std::min(Code.size(), Offset + Line.size() + 1);
  253     NextLineOffset = std::min(Code.size(), Offset + Line.size() + 1);
  260                       Offset, std::min(Line.size() + 1, Code.size() - Offset))),
  260                       Offset, std::min(Line.size() + 1, Code.size() - Offset))),

   70   size_t Limit = std::min(L.size(), R.size());
   70   size_t Limit = std::min(L.size(), R.size());
   81     StringRef V = Prefix ? Value.first.substr(0, Key.size()) : Value.first;
   85     StringRef V = Prefix ? Value.first.substr(0, Key.size()) : Value.first;
  334         if (Dir->size() > ShortDirectorySegment) // not trivial ones
  387       if (Dir->size() > ShortDirectorySegment)

   96     EndPos = Code.size();
  101     if (Line.size() > ColumnLimit)
  120     int End = Start + R.getReplacementText().size();
  123         R.getOffset() > 0 && R.getOffset() <= Code.size() &&
  128     Offset += R.getReplacementText().size() - R.getLength();
  277                 RE.getExistingReplacement()->getReplacementText().size();

  161   for (size_t Index = 0; Index < ToTemplate.size();) {

  117   assert(Begin <= Text.size());
  118   assert(End <= Text.size());

  311     End = Code.size();

  239     if (ReadChars > FC.size())
  248     if (ReadChars + 8 > FC.size())
  258       if (ReadChars + 8 > FC.size())
  265       if (ReadChars + 8 > FC.size())
  272       if (ReadChars + 8 > FC.size())
  279       if (ReadChars + TripleSize > FC.size())
  286       if (!Offset || Offset + Size > FC.size())
  439     OS.write(Content->data(), Content->size());

   46     unsigned len = it->getKey().size();
   56     unsigned spaces = (maxName + 3) - (it->size());

   81     if (RootGroup.size() > UINT16_MAX) {

  119              Edit.slice(2, Edit.size()-1).find('/') != StringRef::npos) {
  122     ReplPattern = ReplPattern.slice(0, ReplPattern.size()-1);

  818       if (FromDeclNameRef.size() < ReplaceName.size())

  192         assert((Init.second.Name.size() + 1) <= BitCodeConstants::RecordSize);
  272   assert(BlockIdName.data() && BlockIdName.size() && "Unknown BlockId.");
  321   assert(Str.size() < (1U << BitCodeConstants::StringLengthSize));
  322   Record.push_back(Str.size());

   87     if (Scalar.size() != 40)

   79   for (size_t I = 0; I < Text.size(); ++I) {
  113   Flush(Text.size());

   40     assert(Directory.size() <= PathStorage.size());
   41     PathStorage.resize(Directory.size()); // Shrink to parent.

  105       OS << "  " << std::string(prefixText.size() + Source.size(), '=') << '\n';

   43   Line = Line.drop_front(Word.size());
   65     if (P->CompletionPos && P->CompletionPos <= Word.data() + Word.size()) {
   78     else if (CaseStr.size() != 0 && IsCompletion && WordCompletionPos <= CaseStr.size() &&
   78     else if (CaseStr.size() != 0 && IsCompletion && WordCompletionPos <= CaseStr.size() &&

  333     AnalyzerOptions->Config[OptName.substr(AnalyzerPrefix.size())] = Opt.second;

   52       Message = Message.substr(0, Message.size() - CheckNameInMessage.size());
  272   size_t BracketIndex = NolintIndex + NolintDirectiveText.size();
  274   if (BracketIndex < Line.size() && Line[BracketIndex] == '(') {

   31   GlobList = GlobList.substr(UntrimmedGlob.size() + 1);

   49   Path = Path.drop_front(PrefixPosition + AbslPrefix.size());

  131   unsigned UpperBound = (ArgName.size() + 2) / 3 + 1;

   91       StrLenText.find(Arg0Text) + Arg0Text.size(), StrLenText.size());
   91       StrLenText.find(Arg0Text) + Arg0Text.size(), StrLenText.size());

   92                    MatchedDecl->getName().size()),

   36   if (!llvm::isAlpha(FC) || Decl->getName().size() == 1) {

  136   if (!std::strncmp(Data, Port.data(), Port.size()) &&
  137       !isIdentifierBody(Data[Port.size()]))

   41     Guard = Guard.replace(PosLLVMProject, LLVMProject.size(), "/llvm/");

   75         StartLoc.getLocWithOffset(StringRef("cast").size() - 1);
   85         StartLoc.getLocWithOffset(StringRef("cast").size() - 1);
  122     Replacement += RHSString.substr(Func->getName().size());

   63   SourceLocation EndLoc = IoStateLoc.getLocWithOffset(TypeName.size() - 1);

  852   size_t Len = ContainerName.size();

  180     ConstructCallEnd = ConstructCallStart.getLocWithOffset(ExprStr.size());

  197   return !Invalid && std::strspn(Text.data(), " \t\r\n") == Text.size();

   83     int TextLength = Text.size();

   49   if (Index < Name.size()) {
   90   assert(Start != llvm::StringRef::npos && Start + 1 < PropertyName.size());
  115   assert(MatchedDecl->getName().size() > 0);

  302       if (Groups[2].size() > 0) {
  304         Substr = Substr.substr(Groups[0].size());
  305       } else if (Groups[3].size() > 0) {
  307         Substr = Substr.substr(Groups[0].size() - Groups[4].size());
  307         Substr = Substr.substr(Groups[0].size() - Groups[4].size());
  308       } else if (Groups[5].size() > 0) {
  310         Substr = Substr.substr(Groups[0].size() - Groups[6].size());
  310         Substr = Substr.substr(Groups[0].size() - Groups[6].size());

  181               Ifndef, Ifndef.getLocWithOffset(CurHeaderGuard.size())),
  185               Define, Define.getLocWithOffset(CurHeaderGuard.size())),

   21       return Str.substr(0, Str.size() - Suffix.size());
   21       return Str.substr(0, Str.size() - Suffix.size());
  231       Edits[LineNumber].second.append(SourceText.data(), SourceText.size());

  282   return formatCode(Code, File, {tooling::Range(0, Code.size())});

  306               Qualifier.size() < ShortestQualifier.size())
  306               Qualifier.size() < ShortestQualifier.size())
 1343     ReplacedRange.start.character -= HeuristicPrefix.Name.size();
 1710   assert(Offset <= Content.size());
 1718   Result.Name = Content.slice(Rest.size(), Offset);
 1725       Content.slice(Rest.size(), Result.Name.begin() - Content.begin());

  429             Msg.resize(Rest.size());
  470   if (R.size() != Code.size())
  470   if (R.size() != Code.size())

   67       return Line.substr(I, Marker.size());
   80   return Code.substr(Rest.size());
   93                               From.size(), To);
  139   StringRef NextLine = firstLine(Code.substr(Cursor + Trailing.size() + 1));
  143   if (unsigned TrailWS = Trailing.size() - TrailingTrim.size())
  143   if (unsigned TrailWS = Trailing.size() - TrailingTrim.size())
  181       tooling::Range(Leading.data() - Code.data(), Leading.size()));
  213       LengthChange += R.getReplacementText().size() - R.getLength();
  217              ReplacementSplit <= int(R.getReplacementText().size()) &&
  358       Offset += R.getReplacementText().size();
  364       if (PositionWithinReplacement > R.getReplacementText().size()) {
  365         Offset += R.getReplacementText().size();

   28   for (size_t From = 0; From < Input.size();) {
   46   for (size_t From = 0; From < Input.size();) {

   77     : PatN(std::min<int>(MaxPat, Pattern.size())),
  156   assert(Text.size() == Roles.size());
  157   if (Text.size() == 0)
  166   for (unsigned I = 0; I < Text.size() - 1; ++I) {
  175   Roles[Text.size() - 1] = packedLookup<CharRole>(CharRoles, Types);
  182   WordN = std::min<int>(MaxWord, NewWord.size());

  103       return LHS.IncludeHeader.size() < RHS.IncludeHeader.size();
  103       return LHS.IncludeHeader.size() < RHS.IncludeHeader.size();

   39   return Name.size() >= 2 && Name[0] == '_' &&

  164   for (size_t I = 0, E = Glob.size(); I < E; ++I) {

   21   if (Stream.size() < 8)
   28   if (Stream.size() < Len)
   43   llvm::support::endian::write32le(Size, C.Data.size());
   46   if (C.Data.size() % 2)
   57   if (RIFF->Data.size() < 4)
   73     DataLen += 4 + 4 + C.Data.size() + (C.Data.size() % 2);
   73     DataLen += 4 + 4 + C.Data.size() + (C.Data.size() % 2);

  174       bool SelectedAll = Begin == 0 && End >= FileContent.rtrim().size();
  467   if (Buf.size() == 0)
  471   if (Offset == Buf.size())

   59   for (size_t I = 0; I < U8.size();) {
  116   if (Result > U8.size()) {
  118     return U8.size();
  134     Count = Code.size();
  188   Offset = std::min(Code.size(), Offset);
  395   assert(Offset < Buf.size());
  598   Offset = std::min(Code.size(), Offset);
  948   std::vector<CharRole> Roles(Content.size());
  961   for (unsigned I = 0; I < Content.size(); ++I) {
 1106     ER.EligiblePoints.emplace_back(offsetToPosition(Code, Code.size()));

   43     if (Body.size() > 2 && Body[0] == '/' && Body[2] == ':')
   54     if (AbsolutePath.size() > 1 && AbsolutePath[1] == ':')

  748       if (EndOffset <= Buffer.size() && StartOffset < EndOffset)

  190   return Path.drop_back(llvm::sys::path::extension(Path).size());

  168       Index.try_emplace({Sorted[I].data(), Sorted[I].size()}, I);
  188     assert(Index.count({S.data(), S.size()}) && "string not interned");
  189     return Index.find({S.data(), S.size()})->second;

  159     assert(!S.data()[S.size()] && "Visited StringRef must be null-terminated");

   28   assert(Raw.size() == RawSize);
   36   if (Str.size() != RawSize * 2)

   25   std::vector<CharRole> Roles(Identifier.size());
   27                  llvm::makeMutableArrayRef(Roles.data(), Identifier.size()));
   90   if (Query.size() < 3) // short-query trigrams only
   94   std::vector<CharRole> Roles(Query.size());
   95   calculateRoles(Query, llvm::makeMutableArrayRef(Roles.data(), Query.size()));
   99   for (unsigned I = 0; I < Query.size(); ++I) {

   87                                                  ThenCode.size(), ElseCode)))
   91                                                  ElseCode.size(), ThenCode)))

  126     Pending = Pending.drop_front(MatchPos + Matches[0].size());

   25     if (Word.size() == Annotated->size())
  290   std::vector<CharRole> Roles(Text.size());
  293   for (unsigned I = 0; I < Text.size(); ++I)

   46     return Range{Position{}, offsetToPosition(Buffer, Buffer.size())};

  300       HasValue(StartOfFile.getLocWithOffset(Source.code().size())));

   48       Outer.size() >= Wrapping.first.size() + Wrapping.second.size())
   48       Outer.size() >= Wrapping.first.size() + Wrapping.second.size())
   48       Outer.size() >= Wrapping.first.size() + Wrapping.second.size())
   49     return Outer.drop_front(Wrapping.first.size()).drop_back(Wrapping.second.size());
   49     return Outer.drop_front(Wrapping.first.size()).drop_back(Wrapping.second.size());

  240   if (UmbrellaDirName.size())
  355   if (IncludePath.size())
  360     ((IncludePath.size() >= 2) && (IncludePath[1] == ':'))) {

   93   if (ProblemFilesPath.size() != 0) {
  143   if (HeaderPrefix.size() != 0)
  216   if (HeaderPrefix.size() != 0)
  471   if (Extension.size() == 0)

  228   if (HeaderPrefix.size() == 0)
  259   if ((HeaderDirectory.size() == 0) && (HeaderPrefix.size() != 0)) {

  389     Length = MacroName.size();

   55         format::getLLVMStyle(), Code, {tooling::Range(0, Code.size())});

  131     return OldName.substr(0, OldName.size() - 4).str() + "melo";

   81   *out_buffer_ptr = static_cast<char*>(llvm::safe_malloc(Data.size()));
   82   *out_buffer_size = Data.size();
   83   memcpy(*out_buffer_ptr, Data.data(), Data.size());
  143   *out_buffer_ptr = static_cast<char*>(llvm::safe_malloc(Data.size()));
  144   *out_buffer_size = Data.size();
  145   memcpy(*out_buffer_ptr, Data.data(), Data.size());

  399   if (Str.data()[Str.size()] == '\0')
  405   char *buf = IdxCtx.StrScratch.Allocate<char>(Str.size() + 1);
  407   buf[Str.size()] = '\0';

   51     char *mem = Alloc.Allocate<char>(Blob.size() + 1);
   52     memcpy(mem, Blob.data(), Blob.size());
   53     mem[Blob.size()] = '\0';
  324   if (Name.size() > 65536)
  332   if (Name.size() > 65536)
  342   if (Name.size() > 65536)
  368   if (CodeToInsert.size() > 65536)

   87   if (!String.empty() && String.data()[String.size()] != 0)
   98   char *Spelling = static_cast<char *>(llvm::safe_malloc(String.size() + 1));
   99   memmove(Spelling, String.data(), String.size());
  100   Spelling[String.size()] = 0;

  346       Parser::completeExpression(Code, Code.size(), nullptr, &NamedValues);
  353   Comps = Parser::completeExpression(Code, Code.size(), nullptr, &NamedValues);
  358   Comps = Parser::completeExpression(Code, Code.size(), nullptr, &NamedValues);

   39     std::vector<tooling::Range> Ranges(1, tooling::Range(0, Code.size()));

   36     return format(Code, 0, Code.size(), Style);

   42     std::vector<tooling::Range> Ranges(1, tooling::Range(0, Code.size()));

   39     return format(Code, 0, Code.size(), Style);

   36     return format(Code, 0, Code.size(), Style);

   44     std::vector<tooling::Range> Ranges(1, tooling::Range(0, Code.size()));

   36     return format(Code, 0, Code.size(), Style);

   37     std::vector<tooling::Range> Ranges(1, tooling::Range(0, Code.size()));

   36     return format(Code, 0, Code.size(), Style);

   34     return format(Code, 0, Code.size(), Style);

   42         /*Ranges=*/{1, tooling::Range(0, Code.size())}, Style);

   25       Length = Code.size() - Offset;

   13     return std::vector<tooling::Range>(1, tooling::Range(0, Code.size()));

   24     return std::vector<tooling::Range>(1, tooling::Range(0, Code.size()));

   38                                  /*Ranges=*/{1, tooling::Range(0, Code.size())},

   68     assert(SI + S.size() + 1 <= sizeof(File.Bytes));
   71     SI += S.size() + 1;

   97         format::getLLVMStyle(), Code, {tooling::Range(0, Code.size())});

   46   Buf.RemoveText(Pos, RemoveStr.size());
   50   tagRange(Pos, TagStr.size(), "outer", Buf);
   51   tagRange(Pos, TagStr.size(), "inner", Buf);
   91   Buf.RemoveText(Input.find(RemoveStr0), RemoveStr0.size(),
  108   Buf.RemoveText(Input.find(RemoveStr1), RemoveStr1.size());

   93   Offset = std::min(Code.size(), Offset);

 1590                                                   .size(),

   52   const std::vector<Range> Ranges(1, Range(0, Code.size()));

  104               + std::string(type, 0, type.size()-1) + ">(Record.readInt())")
  152     AttrSpelling = AttrSpelling.substr(2, AttrSpelling.size() - 4);
 3959   OS << Name << "\n" << std::string(Name.size(), '=') << "\n";

   81   for (unsigned i = 0, e = Str.size(); i != e; ++i) {

   40   for (size_t i = 0, e = UTF8.size(); i != e; ++i) {

 1012     while (End < Text.size() - 1 && Text[End] == '%' &&
 1653   OS << Str << "\n" << std::string(Str.size(), Kind) << "\n";

  377     for (unsigned I = 1; I < Proto.size(); ++I)
  720   for (I = 0; I < Name.size(); ++I) {
  733     for (I = 0; I < Name.size(); ++I) {
  748     for (I = 0; I < Name.size(); ++I) {

   25   StringRef Object = Filename.substr(Archive.size() + 1).drop_back();

 1431   return Name.size() > 2 && (Name[0] == '-' || Name[0] == '+') &&
 1449   if (!SelectorStart.size())
 1452   StringRef Selector(SelectorStart.data(), SelectorStart.size() - 1);
 1460   if (ClassName[ClassName.size() - 1] == ')') {
 2479   unsigned Size = 4 /* FORM_strp */ + File.size() + 1 +

  471   LineSectionSize += PrologueBytes.size() + 4;
  650     LineSectionSize += Translated.size() + 1;
  662     LineSectionSize += Translated.size() + 1;
  771   FrameSectionSize += CIEBytes.size();
  781   MS->EmitIntValue(FDEBytes.size() + 4 + AddrSize, 4);
  785   FrameSectionSize += FDEBytes.size() + 8 + AddrSize;

  572     if (Name.size() == 0 || Name[0] == '\0')

  540                     EntryRef.getString().size() + 1);

   26     CurrentEndOffset += S.size() + 1;

  263     } else if (opt.size() == 2 && opt[0] == 'O') {

   42   sectionNameSize = sectionName.size();
  658   memcpy(buf, str.data(), str.size());
  659   buf[str.size()] = '\0';

  440   size_t getSize() const override { return str.size() + 1; }

   45     return alignTo(name.size() + 3, 2);
   51     memcpy(buf + 2, name.data(), name.size());

  971   while (cursor < altPath.size()) {

  840   const char *nameStart = buf + sizeof(coff_import_header) + name.size() + 1;

   68     nameSize = nameStr.size();
   69     assert(nameSize == nameStr.size() && "name length truncated");
  100   nameSize = origName.size();

   92         isRuntimePseudoReloc(false), nameSize(n.size()),

  323     assert(!config->debug || name.size() <= COFF::NameSize ||
  326             std::min(name.size(), (size_t)COFF::NameSize));
 1076   assert(str.size() > COFF::NameSize);
 1117   if (name.size() > COFF::NameSize) {
 1122     memcpy(sym.Name.ShortName, name.data(), name.size());
 1147     if (sec->name.size() <= COFF::NameSize)

  102   d = d.slice(s.size() + 1);

   85   size_t bufSize = mb.getBuffer().size();
  826       d += s.size() + 1;
 1017       if (this->stringTable.size() <= eSym.st_name)
 1207       if (val >= this->stringTable.size())
 1212       if (val >= this->stringTable.size())

 1213   for (unsigned i = 0, n = s.size(); i != n; i += entSize) {

  152         usedStartStop.insert(s.substr(prefix.size()));

  728   for (size_t i = 0, e = name.size(); i != e + 1; ++i) {

  156         e = s.size() - 1;
  160     size_t size = s.size();
  162     if (s.size() == size)

  136     return s.substr(1, s.size() - 2);
 1306     phdrs.push_back((tok.size() == 1) ? next() : tok.substr(1));

   60   if (pos != StringRef::npos && pos + 1 < name.size() && name[pos + 1] == '@')

   49   StringRefZ(StringRef s) : data(s.data()), size(s.size()) {}
  177     nameSize = s.size();

   77   return {(const uint8_t *)s.data(), s.size() + 1};
  257   ArrayRef<uint8_t> contents = {(const uint8_t *)s.data(), s.size() + 1};
 1172   this->size = this->size + s.size() + 1;
 1179     memcpy(buf, s.data(), s.size());
 1180     buf[s.size()] = '\0';
 1181     buf += s.size() + 1;

   85   if ((reloff + nreloc*8) > buffer.size())
  100   if ((istOffset + istCount*4) > buffer.size())
  153   if (fileBuffer.size() < 32)

  196   memcpy(s, str.begin(), (str.size() > 16) ? 16: str.size());
  196   memcpy(s, str.begin(), (str.size() > 16) ? 16: str.size());

  398     size += sizeof(dylib_command) + pointerAlign(_file.installName.size() + 1);
  418     size += pointerAlign(sizeof(dylinker_command) + dyldPath().size()+1);
  441     size += sizeof(dylib_command) + pointerAlign(dep.path.size()+1);
  447     size += pointerAlign(sizeof(rpath_command) + path.size() + 1);
  836       uint32_t size = sizeof(dylib_command) + pointerAlign(path.size() + 1);
  846       memcpy(lc + sizeof(dylib_command), path.begin(), path.size());
  847       lc[sizeof(dylib_command) + path.size()] = '\0';
  914       uint32_t size=pointerAlign(sizeof(dylinker_command)+dyldPath().size()+1);
  921       memcpy(lc+sizeof(dylinker_command), dyldPath().data(), dyldPath().size());
  922       lc[sizeof(dylinker_command)+dyldPath().size()] = '\0';
  963       uint32_t size = sizeof(dylib_command) + pointerAlign(dep.path.size()+1);
  973       memcpy(lc+sizeof(dylib_command), dep.path.begin(), dep.path.size());
  974       lc[sizeof(dylib_command)+dep.path.size()] = '\0';
  981       uint32_t size = pointerAlign(sizeof(rpath_command) + path.size() + 1);
  987       memcpy(lc+sizeof(rpath_command), path.begin(), path.size());
  988       lc[sizeof(rpath_command)+path.size()] = '\0';
 1071     memcpy(&_buffer[strOffset], sym.name.begin(), sym.name.size());
 1072     strOffset += sym.name.size();
 1262   StringRef partialStr = entry.name.drop_front(_cummulativeString.size());
 1271     for (int n=edgeStr.size()-1; n > 0; --n) {
 1275         bNodeStr = bNodeStr.drop_back(edgeStr.size()-n).copy(allocator);
 1326   StringRef partialStr = entry.name.drop_front(_cummulativeString.size());
 1343       nodeSize += _importedName.size();
 1356     nodeSize += edge._subString.size() + 1 // String length.
 1376                           + _importedName.size() + 1;
 1477     _symbolStringPoolSize += (sym.name.size()+1);
 1480     _symbolStringPoolSize += (sym.name.size()+1);
 1483     _symbolStringPoolSize += (sym.name.size()+1);
 1486     _symbolStringPoolSize += (sym.name.size()+1);

  877           file.ownedAllocations.Allocate<char>(newDirPath.size() + 2);
  878         memcpy(p, newDirPath.data(), newDirPath.size());
  879         p[newDirPath.size()] = '/';
  880         p[newDirPath.size() + 1] = '\0';
 1483               6 + targ->name().size() + llvm::getULEB128Size(bind.segOffset);

  704   char *strCopy = alloc.Allocate<char>(str.size() + 1);
  705   memcpy(strCopy, str.data(), str.size());
  706   strCopy[str.size()] = '\0';

  492     if (scalar.size() != 3)

  321       lazyOffset += target->name().size() + 12;

   97                                        << newName.size() << ")\n");
  127                                    << ", " << newName.size() << ")\n");
  141                                      << newName2.size() << ")\n");
  150                                         << ", " << atom.name().size() << ")\n");
  167     char *s = _storage.Allocate<char>(str.size());
  168     memcpy(s, str.data(), str.size());
  169     return StringRef(s, str.size());
  673       char *s = _storage.Allocate<char>(str.size());
  674       memcpy(s, str.data(), str.size());
  675       return StringRef(s, str.size());
  767                                         << ", " << _targetName.size() << ")\n");
  851                                    << ", " << _name.size() << ")\n");
 1019                       << _name.size() << ")\n");
 1088                                    << ", " << _name.size() << ")\n");
 1161                                    << ", " << _name.size() << ")\n");

  708     writeUleb128(os, bodyContent.size(), "function size");

   88              msg + " [str[" + Twine(string.size()) + "]: " + string + "]");
   89   encodeULEB128(string.size(), os);
   90   os.write(string.data(), string.size());

   97   void CopyData(llvm::StringRef src) { CopyData(src.data(), src.size()); }

  274   bool HasData(unsigned size) { return size <= m_buffer.size(); }

  109   return ref().GetOutputData().size();
  115   return ref().GetErrorData().size();

  163             tmp_str[pos + 1] == '*' && tmp_str.size() == (pos + 2)) {
  339     llvm::StringRef to = right1.drop_front(specifier_str.size());

  212     Name = Name.drop_front(PartialItem.size());

  564       raw_command_string = raw_command_string.substr(alias_command.size());
 1040           (int)regex_sed.size(), regex_sed.data());
 1044     size_t regex_sed_size = regex_sed.size();
 1049           (int)regex_sed.size(), regex_sed.data());
 1056                                      (int)regex_sed.size(), regex_sed.data());
 1070           (int)(regex_sed.size() - first_separator_char_pos - 1),
 1072           (int)regex_sed.size(), regex_sed.data());
 1083           (int)(regex_sed.size() - second_separator_char_pos - 1),
 1085           (int)regex_sed.size(), regex_sed.data());
 1098             (int)(regex_sed.size() - third_separator_char_pos - 1),
 1105           separator_char, separator_char, separator_char, (int)regex_sed.size(),
 1111           separator_char, separator_char, separator_char, (int)regex_sed.size(),

  324   const std::size_t original_code_size = code.size();
  332   assert(original_code_size >= code.size());
  333   std::size_t raw_start = original_code_size - code.size();

 1503         size_t len = entry.ref().size();
 1577                                buffer.GetString().size(),
 1578                                error) == buffer.GetString().size())

   36   if (permissions.size() != 9)

 1610       if (command.size() != 2U)

  268     : string(s.data(), s.size()), printf_format(), children(),
  287     children.back().string.append(s.data(), s.size());
  918         subpath.size() > close_bracket_index) {
 1135       s.Write(scope_stream.GetString().data(), scope_stream.GetString().size());
 1971           remainder = format_str.drop_front(format_str.size() - 1);
 2129       if (format.size() == 1) {
 2342                        match_prefix.size()) == 0)
 2344             MakeMatch(prefix, def->children[i].name + match_prefix.size()));
 2357   if (dollar_pos == str.size() - 1) {

   34   if (!cursor_pos || *cursor_pos >= line.size()) {

  950       to_add = to_add.substr(request.GetCursorArgumentPrefix().size());
  959       to_add = to_add.substr(request.GetCursorArgumentPrefix().size());
  976         longest_prefix.substr(request.GetCursorArgumentPrefix().size());

   36   if (name.size() + name_offset > sizeof(saddr_un->sun_path))
   42   memcpy(saddr_un->sun_path + name_offset, name.data(), name.size());
   51         offsetof(struct sockaddr_un, sun_path) + name_offset + name.size();

   28   if (options_args.size() < 1)
  143   help_string.Printf("'%*s", (int)command_name.size(), command_name.data());

   33   if (input_str.size() < 2)

 1241         end = command_string.size();
 1266           end >= command_string.size())
 1735     const std::size_t actual_cmd_name_len = cmd_obj->GetCommandName().size();
 2488   size_t line_width_max = max_columns - prefix.size();
 2490     line_width_max = help_text.size() + prefix.size();
 2490     line_width_max = help_text.size() + prefix.size();
 2492   strm.IndentMore(prefix.size());
 2510     if (this_line.size() != help_text.size())
 2510     if (this_line.size() != help_text.size())
 2519     help_text = help_text.drop_front(this_line.size()).ltrim();
 2521   strm.IndentLess(prefix.size());
 2531                        (int)separator.size(), separator.data());
 2539   int indent_size = max_word_len + separator.size() + 2;
 2555     return pos == llvm::StringRef::npos ? S.size() : pos;
 2685   size_t size = str.size();
 2977           actual_cmd_name_len = cmd_obj->GetCommandName().size();
 2982           actual_cmd_name_len += cmd_name.size();
 2997           actual_cmd_name_len = sub_cmd_name.size() + 1;

   39   if (s.size() != 1)

  102   if (index.size() == name.size()) {
  102   if (index.size() == name.size()) {

   51       if (value_str.size() == 0)

  135         if ((key.size() > 2) && (key.back() == ']')) {
  137           key = key.substr(1, key.size() - 2);
  140             if ((key.size() > 2) && (key.back() == quote_char)) {
  142               key = key.substr(1, key.size() - 2);
  221   if (left.size() == name.size()) {
  221   if (left.size() == name.size()) {

   66     if (value.size() > 0) {

   41   dst.reserve(str.size());
   43   for (size_t i = 0, e = str.size(); i != e; ++i) {
   86         const size_t trimmed_len = trimmed_value_str.size();

  628       max_name_len = std::max<size_t>(property->GetName().size(), max_name_len);

   51   if (value.size() > 0) {
   55       if (value.size() <= 1 || value.back() != value.front()) {
   80     if (value.size() > 0) {

 1080         input_line.erase(pos, tmp_arg.size());
 1092           input_line.erase(pos, tmp_arg.size());

  418   if (name.size() == 0 || name[0] != '$')
  438   if (name.size() == 0)

  668     cmd = cmd.drop_front(to_remove.size());

  726   assert(abs_pos <= code.size() && "Absolute position outside code string?");

 1100                                                      decl_name.size());

   89   assert(left_right_chars.size() == 2);
  120   if (basename.size() > 0 && basename[0] == '~')
  123   if (basename.size() <= idx)
  132   while (idx < basename.size()) {
  139   return idx == basename.size();
  152     if (arg_end + 1 < full.size())
  347       Written += Search.size();

  646                      m_text.data(), m_text.data() + m_text.size());

   18   for (size_t i = 0; i < name.size(); i++) {

  714       if (base_str.size() > 2)

   90   if (name.size() > 1 && (name[0] == '+' || name[0] == '-')) {
  102     int name_len = name.size();

 2037           name_strref.substr(ivar_prefix.size());
 2041       if (class_and_ivar.first.size() && class_and_ivar.second.size()) {
 2041       if (class_and_ivar.first.size() && class_and_ivar.second.size()) {
 2069           name_strref.substr(class_prefix.size());

 1226         const ConstString base_kernel(name_ref.drop_back(expand.size()));

  103   if (str.size() <= hex_digits<data_t::uuid_t>() ||
  104       str.size() > hex_digits<data_t>())
  208     if (Str.empty() || ID.SetFromStringRef(Str, Str.size() / 2) != Str.size())
  208     if (Str.empty() || ID.SetFromStringRef(Str, Str.size() / 2) != Str.size())

 1967           name.append(name_slice.data(), name_slice.size());
 3741               symbol_name = symbol_name + g_objc_v2_prefix_class.size();
 3747               symbol_name = symbol_name + g_objc_v2_prefix_metaclass.size();
 3752               symbol_name = symbol_name + g_objc_v2_prefix_ivar.size();
 4213                             symbol_name + g_objc_v2_prefix_class.size();
 4220                             symbol_name + g_objc_v2_prefix_metaclass.size();
 4227                             symbol_name + g_objc_v2_prefix_ivar.size();
 4252                     symbol_name = symbol_name + g_objc_v1_prefix_class.size();
 6252           size_t bytes_written = buffer.GetString().size();

 1176         ::memcpy(developer_dir_path, path_ref.data(), path_ref.size());
 1177         developer_dir_path[path_ref.size()] = '\0';

  277       reg_info.dynamic_size_dwarf_len = dwarf_opcode_string.size() / 2;

  165                 __FUNCTION__, int(payload.size()), payload.data(), send_async);
  184                 __FUNCTION__, int(payload.size()), payload.data(), send_async);
  217         int(payload.size()), payload.data(), response.GetStringRef().data(),
  235             __FUNCTION__, int(payload.size()), payload.data());

  124   packet.Write(payload.data(), payload.size());
  139     const size_t packet_length = packet.size();

 1939           if (extractor.GetHexByteString(arg) * 2 != hex_arg.size()) {
 2248             response.GetStringRef().size())
 2275             response.GetStringRef().size())
 3214       new DataBufferHeap(response.GetStringRef().size() / 2, 0));
 3229       new DataBufferHeap(response.GetStringRef().size() / 2, 0));
 3607   if (result.GetUUID().SetFromStringRef(string, string.size() / 2) !=
 3608       string.size())

 2838   if (xfer_offset >= buffer.size()) {
 2847     if (xfer_length >= buffer.size()) {
 2857     response.PutEscapedBytes(buffer.data(), buffer.size());

  583             size_t dwarf_opcode_len = value.size() / 2;
 1127           if (new_target_triple.getVendorName().size() == 0) {
 1130             if (new_target_triple.getOSName().size() == 0) {
 1133               if (new_target_triple.getEnvironmentName().size() == 0)
 1795             reg_value_extractor.GetStringRef().size() / 2, 0));
 2132                   const size_t byte_size = bytes.GetStringRef().size() / 2;
 2333       } else if (key.size() == 2 && ::isxdigit(key[0]) && ::isxdigit(key[1])) {
 4949   AppendSTDOUT(out.data(), out.size());
 5338       packet.PutBytesAsRawHex8(command.data(), command.size());

  320   PyObject *str = PyString_FromStringAndSize(string.data(), string.size());

 2544       buffer.assign(return_data.data(), return_data.size());
 3052     dest.assign(return_data.data(), return_data.size());
 3163     dest.assign(str_data.data(), str_data.size());

 1782   const auto len = message.size();

   78       if (m_next_line >= m_section_text.size())
   97   assert(m_current_line < m_section_text.size());

  657   if (host.size() == 1 && llvm::isAlpha(host[0]) && path.startswith("\\"))

  182   if (qname.size() < 4 || child.asTag().getUniqueName().size() < 4)
  221   StringView sv(record.UniqueName.begin(), record.UniqueName.size());
  543   StringView name{pub->Name.begin(), pub->Name.size()};

  538   StringView sv(record.UniqueName.begin(), record.UniqueName.size());

  577   size_t len = path_with_object.size();
  583   llvm::StringRef object = path_with_object.substr(archive.size() + 1).drop_back();

   24   if (token.size() != 1)

  223     if (mangled.size() < 3 || !mangled.startswith("_Z"))

  709   if (basename.size() < name.size()) {
  709   if (basename.size() < name.size()) {
  710     scope = name.take_front(name.size() - basename.size());
  710     scope = name.take_front(name.size() - basename.size());

  146           const size_t match_type_scope_size = match_type_scope.size();

  176           const size_t match_type_scope_size = match_type_scope.size();

  638       if (partial_path.size() > 1 && partial_path[1] == '>' &&
  643           if (partial_path.size() > 2 && partial_path[2]) {
  667           if (partial_path.size() > 1 && partial_path[1]) {
  686         const size_t partial_path_len = partial_path.size();

  215     if (orig_ref.size() < prefix_ref.size())
  215     if (orig_ref.size() < prefix_ref.size())

  618       if (var_expr.size() >= 2 && var_expr[1] != '>')
  744       if (var_expr.size() <= 2) {

  161   size_t size = str.size();
  646     std::size_t prev_prefix_length = original_args.size() - arg_string.size();
  646     std::size_t prev_prefix_length = original_args.size() - arg_string.size();
  662       std::size_t prefix_length = original_args.size() - arg_string.size();
  662       std::size_t prefix_length = original_args.size() - arg_string.size();

   19   assert(raw_cursor_pos <= command_line.size() && "Out of bounds cursor?");

   48       return entry.getKey().size();
  142         mem_size += sizeof(StringPoolEntryType) + entry.getKey().size();
  280   m_string = StringPool().GetConstCStringWithLength(s.data(), s.size());

   15   const size_t size = Key.size() + 1 /*=*/ + Value.size() + 1 /*\0*/;
   15   const size_t size = Key.size() + 1 /*=*/ + Value.size() + 1 /*\0*/;

  108   SetBytes(str.data(), str.size());

  100   if (i < path.size())
  336   if (absolute_path.size() > 3 && llvm::isAlpha(absolute_path[0]) &&

   63   bytes_written = Write(str.data(), str.size());
  153   Write(str.data(), str.size());

  261     m_index += str.size();

  109     for (count = 0; count < std::min(prefix.size(), arg.size()); ++count) {

   91   Output.append(Expr.begin() + Left.size(), Expr.end());

  106     return str.size() - rest.size();
  106     return str.size() - rest.size();

   31   auto host_pos = pos + kSchemeSep.size();
   40       ((path_pos != std::string::npos) ? path_pos : uri.size()) - host_pos);

   95       name = name.drop_front(scheme.size() + strlen("://"));

   76       bytes_written = ::send(descriptor.m_socket, str.data(), str.size(), 0);
   78       bytes_written = ::write(descriptor.m_fd, str.data(), str.size());
  150   if (!read_full(log, expected.size(), result))

  145         raw_debug_info.data(), raw_debug_info.size(),

   91       if (Path.size() < S.size() && S.find(Path) == 0) {

   42     return server.Write(packet.data(), packet.size(), status, nullptr) ==
   43            packet.size();

  246       PyByteArray_FromStringAndSize(test_bytes, orig_bytes.size());
  252   EXPECT_EQ(after_bytes.size(), orig_bytes.size());
  253   EXPECT_EQ(0, ::memcmp(orig_bytes.data(), test_bytes, orig_bytes.size()));

  102   m_consumed_bytes+= result.size();

   30   ASSERT_EQ(kInitMiscString.size(), ex.GetBytesLeft());

  208   if (ZeroPad && HexValue.size() < Info.byte_size * 2) {
  209     Storage.insert(Storage.begin(), Info.byte_size * 2 - HexValue.size(), '0');
  214   SmallVector<uint8_t, 64> Bytes(HexValue.size() / 2);
  230   if (Response.size() < 3)
  247     if (Key.size() != 2)

  446   outs().write(Data.data(), Data.size());
  548     file.write(Data.data(), Data.size());
 1104       if (Arg.startswith(expected) && Arg.size() > len && Arg[len] == '=') {

  427         FromEnd = StaticExt.size() + 1;
  429         FromEnd = SharedExt.size() + 1;
  435         Out = Lib.slice(3, Lib.size() - FromEnd);

   51     if (Str.size() <= Width) {
   53         OS.indent(Width - Str.size());
   58       OS.indent(Width - Str.size());
   97     FileReportColumns[0] = std::max(FileReportColumns[0], Filename.size());
  100         std::max(FunctionReportColumns[0], Funcname.size());

  520   Snip(LCol - 1, Line.size() + 1 - LCol);

  115     unsigned End = std::min(S->Col, static_cast<unsigned>(Line.size()) + 1);
  135       << Line.substr(Col - 1, Line.size() - Col + 1);
  168   Str = Str.substr(0, std::min(Str.size(), (size_t)LineNumberColumnWidth));
  169   OS.indent(LineNumberColumnWidth - Str.size()) << Str << '|';

   99   encodeULEB128(ProfileNamesData.size(), OS);

  230           SymContents.size() / sizeof(little32_t));

   89   uint64_t Size = CurStrOffsetSection.size();
  433           (CurEntry.Contributions[Index].Length = Contents.size());

   67           /* each hex digit is 4 bits */ HexValue.size() * 4, HexValue, 16);

  125             << (const void *)(MRI.getContent().data() + MRI.getContent().size())
  126             << " (" << MRI.getContent().size() << " bytes)";

  358     if (BFC.Symtab.size() >= sizeof(irsymtab::storage::Header)) {

   83   if (Position >= Comment.size())
   91     if (Position < Comment.size())
  103   if (Position < Comment.size())

   87       unsigned EncodingSize = Encoding.size();
   92       for (unsigned i = 0, e = Encoding.size(); i != e; ++i)

   52   size_t CRCPos = alignTo(FileName.size() + 1, 4);
   54   memcpy(Data.data(), FileName.data(), FileName.size());

  113     if (S.Name.size() > COFF::NameSize)
  117     if (S.Name.size() > COFF::NameSize)
  124     if (S.Name.size() > COFF::NameSize) {
  128       memcpy(S.Header.Name, S.Name.data(), S.Name.size());
  132     if (S.Name.size() > COFF::NameSize) {
  151           alignTo(S.AuxFile.size(), sizeof(SymbolTy)) / sizeof(SymbolTy);

  180   assert((S.size() & 1) == 0);
  211     if (R.HexData.size() == 0)
  221     if (R.HexData.size() != 4)
  228     if (R.HexData.size() != 8)
  242     if (R.HexData.size() != 4)
  264   for (size_t Pos = 1; Pos < Line.size(); ++Pos)
  275   if (Line.size() < 11)
  277                              "line is too short: %zu chars.", Line.size());
  284   if (Line.size() != getLength(DataLen))
  287                              Line.size(), getLength(DataLen));
  463   assert((HexData.size() & 1) == 0);
 1006   Size = alignTo(FileName.size() + 1, 4) + 4;

  151           Sec.Size = Sec.Content.size();
  162           Sec.Size = Sec.Content.size();

  178   assert(nlist.n_strx < StrTable.size() &&

  236       assert((Sec.Size == Sec.Content.size()) && "Incorrect section size");
  238              Sec.Content.size());

 1776         uint32_t sect_size = BytesStr.size();
 1866       outs() << format("%.*s", BytesStr.size(), sect) << "\n";
 2157   uint64_t size = Buf.size();
 3028           uint64_t object_size = MachOContents.size();
 3049           uint64_t object_size = MachOContents.size();
 3238           uint64_t object_size = MachOContents.size();
 7755   if (Offset + sizeof(T) > Contents.size()) {
 7899   for (unsigned Offset = 0; Offset < Contents.size(); Offset += EntrySize) {
 8185     if (Pos + sizeof(uint32_t) > Contents.size()) {
10073                           SLC.initprot, SLC.nsects, SLC.flags, Buf.size(),
10079                      SLC.cmd, sg_segname, filetype, Buf.size(), verbose);
10087                           SLC_64.nsects, SLC_64.flags, Buf.size(), verbose);
10093                      sg_segname, filetype, Buf.size(), verbose);
10097       PrintSymtabLoadCommand(Symtab, Obj->is64Bit(), Buf.size());
10101       PrintDysymtabLoadCommand(Dysymtab, Symtab.nsyms, Buf.size(),
10106       PrintDyldInfoLoadCommand(DyldInfo, Buf.size());
10140       PrintEncryptionInfoCommand(Ei, Buf.size());
10144       PrintEncryptionInfoCommand64(Ei, Buf.size());
10187       PrintLinkEditDataCommand(Ld, Buf.size());

 1703     MaxWidth = std::max(MaxWidth, Name.size());
 1772     for (std::size_t Addr = 0, End = Contents.size(); Addr < End; Addr += 16) {
 1963   outs().write(ClangASTContents.data(), ClangASTContents.size());

  765     L = std::max(L, Label.size());
  817     LongestNamespace = std::max(LongestNamespace, Scope.size());
  848   LongestNamespace += StringRef(" namespace ''").size();
  858   CD = std::max(CD, CountHeader.size());
  862   SD = std::max(SD, SizeHeader.size());
 1035           if (Module.size() > 32) {
 1941           [](StringRef S1, StringRef S2) { return S1.size() < S2.size(); });
 1941           [](StringRef S1, StringRef S2) { return S1.size() < S2.size(); });

   22   if (MaxLen == 0 || S.size() <= MaxLen || S.size() <= 3)
   22   if (MaxLen == 0 || S.size() <= MaxLen || S.size() <= 3)
   26   uint32_t FinalLen = std::min<size_t>(S.size(), MaxLen - 3);
   32   if (MaxLen == 0 || S.size() <= MaxLen || S.size() <= 3)
   32   if (MaxLen == 0 || S.size() <= MaxLen || S.size() <= 3)
   36   uint32_t FinalLen = std::min<size_t>(S.size(), MaxLen - 3);
   38   StringRef Back = S.take_back(Front.size());
   43   if (MaxLen == 0 || S.size() <= MaxLen || S.size() <= 3)
   43   if (MaxLen == 0 || S.size() <= MaxLen || S.size() <= 3)
   53   uint32_t RequiredExtraChars = Label.size() + 1 + 2;
   54   if (MaxLen == 0 || RequiredExtraChars + Name.size() <= MaxLen)
   64   uint32_t RequiredExtraChars = Label.size() + 1 + 2;
   65   if (MaxLen == 0 || RequiredExtraChars + Name.size() <= MaxLen)

  372   if (Name.size() > 32) {

  646   if (Str.size() == 0 || Str.size() > 2)
  646   if (Str.size() == 0 || Str.size() > 2)
  651     if (Str.size() == 1)
  670   if (Str.size() == 2)
  715   if (Buffer.size() < BITMAPFILEHEADER_size || Buffer[0] != 'B' ||

   24   explicit Filter(StringRef Input) : Data(Input), DataLength(Input.size()) {}

   34   size_t Length = Representation.size();
   87   Tokenizer(StringRef Input) : Data(Input), DataLength(Input.size()) {}

  299          RelocPtr < SectionContents.data() + SectionContents.size() &&
  327   uint64_t OffsetEnd = OffsetStart + Block.size();
  987     if (SubSectionSize > Data.size())
  997     if (NextOffset > SectionContents.size())
 1092               EqOrEnd = FrameFunc.size();
 1936                                          AddrsigContents.size());

  803   if (NameOffset >= StrTab.size())
 2146   if (Value < DynamicStringTable.size())
 5948           StringRef(reinterpret_cast<const char *>(P) + Key.size() + 1);
 5952       P = P + Key.size() + Value.size() + 2;
 5952       P = P + Key.size() + Value.size() + 2;

  134     const uint8_t *SecEnd = SecContent + SectionContent.size();

  661     if (ArgName.size() == 1)

  840         uint64_t SymSize = SecContent.size() - (CSymAddr - SecContent.data());

  395       max_name_len = std::max(max_name_len, name_or_err->size());

   62     if (L.size() < static_cast<size_t>(MinLength))

  306   return (S.size() > n) ? Twine(S.substr(0, n)) + "..." : Twine(S);

   52   while (RemainingTable.size() > 0) {

  341       OpCode += BindOp.Symbol.size() + 1;
  492   while (RemainingTable.size() > 0) {

  541   EXPECT_EQ(LargeValue, Key.size());
  547   EXPECT_EQ(LargeValue, Key.size());

   83   EXPECT_EQ((size_t) 5, StringRef("hello").size());
  939   EXPECT_EQ(StrEmptyc.size(), 0u);
  967   Dropped = Test.drop_front(Test.size());
  970   Dropped = Test.drop_back(Test.size());
  983   Taken = Test.take_front(Test.size());
  986   Taken = Test.take_back(Test.size());

   40   EXPECT_DEATH(Mod = parseAssemblyString(Source.substr(0, Source.size() - 2),

  376   EXPECT_THAT_ERROR(Reader.readFixedString(FStr[1], FStr[0].size()),

  205       B.getContent().size() - Offset);

  126   std::vector<char> ObjContents(ObjBytes.size());
  140       EXPECT_EQ(RPCObjContents.size(), ObjContents.size())

   73     Mutator.mutateModule(*M, Seed, Source.size(), Source.size() + 100);
   73     Mutator.mutateModule(*M, Seed, Source.size(), Source.size() + 100);

  138   unsigned StrLen = Str.size();
  267       LLVMRemarkParserCreateBitstream(Buf.data(), Buf.size());

  380   unsigned StrLen = Str.size();
  491       LLVMRemarkParserCreateYAML(Buf.data(), Buf.size());

  464       reinterpret_cast<const uint8_t *>(Strings.data()), Strings.size());
  815     Length += S.size() + 1;

 1280   size_t ExpectedStrSize = StringRef("    =<empty> - ").size();
 1309   size_t ExpectedStrSize = StringRef("    =<empty> - ").size();

  154   std::vector<UTF32> Decoded(S.size(), 0);
  158       ConvertUTF8toUTF32(&SourceNext, SourceStart + S.size(), &TargetStart,
  171   std::vector<UTF32> Decoded(S.size(), 0);
  175       &SourceNext, SourceStart + S.size(), &TargetStart,

  254   EXPECT_EQ(BufData.size(), 40000U);

  302     EXPECT_EQ(1u, LastComponent.size());
 1076   ASSERT_EQ(write(FD, Data.data(), Data.size()), static_cast<ssize_t>(Data.size()));
 1076   ASSERT_EQ(write(FD, Data.data(), Data.size()), static_cast<ssize_t>(Data.size()));
 1103     mfr.data()[Val.size()] = 0;
 1323   ASSERT_EQ(Data.size(), (size_t)write(FD, Data.data(), Data.size()));
 1323   ASSERT_EQ(Data.size(), (size_t)write(FD, Data.data(), Data.size()));
 1461   Buffer.resize(Data.size());
 1464     ASSERT_EQ((size_t)Result, Data.size());
 1473   int Result = ::write(FD, Data.data(), Data.size());
 1475     ASSERT_EQ((size_t)Result, Data.size());

   97       if (Path.size() < S.size() && S.find(Path) == 0) {

  167   EXPECT_EQ(Value.data()[Value.size()], '\0');
  197   ParsedString = ParsedString.substr(1, ParsedString.size() - 2);

   36   OS.pwrite(Test.data(), Test.size(), 0);
   72   OS.pwrite(Test.data(), Test.size(), 0);
   73   OS.pwrite(Test.data(), Test.size(), 0);
   90   OS.pwrite(Test.data(), Test.size(), 0);
   91   OS.pwrite(Test.data(), Test.size(), 0);

   19   size_t Length = Input.size();

   24   while (LHS.size() > 0 && RHS.size() > 0) {
   24   while (LHS.size() > 0 && RHS.size() > 0) {

  903   StringRef RegName = Tok.substr(RegisterPrefix.size());
  973   for (size_t i = 0, e = String.size(); i != e; ++i) {
 1013       assert(i != String.size() && "Invalid quoted character");
 1027       if (i + 1 == String.size() || String[i + 1] != '{') {
 1047   if (InTok && Prev != String.size())
 1592       if (Token.size() > 1 && isdigit(Token[1])) {
 1600         OperandName = Token.substr(2, Token.size() - 3);
 2882     std::string LenMnemonic = char(II.Mnemonic.size()) + II.Mnemonic.str();
 3326     std::string LenMnemonic = char(MI->Mnemonic.size()) + MI->Mnemonic.str();
 3440       std::string LenMnemonic = char(MI->Mnemonic.size()) + MI->Mnemonic.str();

   43       unsigned Pad = CC->getName().size();
   71   unsigned Pad = CC->getName().size();

  469     for (size_t e = Cur.size(); VariantsStart != e; ++VariantsStart)
  477     if (VariantsStart == Cur.size())
  485     for (size_t e = Cur.size(); VariantsEnd != e; ++VariantsEnd) {
  499     assert(VariantsEnd != Cur.size() &&

  123             (!Regexpr || Regexpr->match(InstName.substr(Prefix.size())))) {
  150         if (!Regexpr || Regexpr->match(InstName.substr(Prefix.size()))) {

 1190       << str.slice(1,str.size()) << "]";

   59       StringRef EndVar = StartVar.drop_front(2 /* ${ */ + Var.size());

   34   OS << std::string(Str.size(), Kind) << "\n" << Str << "\n"
   35      << std::string(Str.size(), Kind) << "\n";
   39   OS << Str << "\n" << std::string(Str.size(), Kind) << "\n";
   44   Result.reserve(Str.size() + 4);

  811     if (PRDef->getName().size() < 15)
  812       OS.indent(15 - PRDef->getName().size());