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

References

  246     return str().substr(Start, N);

  627       return substr(0, find_if_not(F));
  634       return substr(0, find_if(F));
  642       return substr(N);
  650       return substr(0, size()-N);
  657       return substr(find_if_not(F));
  664       return substr(find_if(F));

   32       return Data.substr(Offset, End - Offset);

  453     return getBlock().getContent().substr(Offset, Size);

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

  483       return Name.substr(1);

  218     return hasFlag(Feature) ? Feature.substr(1) : Feature;

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

  514           Cand = Cand.substr(0, It);

  208     Stream << S.substr(0, N);

   32   Name = Name.substr(Name.find(Key));

 3574   Str = Str.substr(Slice.Offset);
 3580     Str = Str.substr(0, Str.find('\0'));

  198       if (Magic.substr(off).startswith(

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

  119   Cursor C = Cursor(Value.substr(1, Value.size() - 2));

 2657   StringRef V = S.substr(2);

 4010     if (S == 8 && Constraint.substr(1, 6) == "memory") // "{memory}"

 1859   StringRef RefStepString = In.substr(Position + 1);
 1891       Override = Override.substr(0, RefPos);
 1917       RecipType = RecipType.substr(0, RefPos);
 1922       RecipType = RecipType.substr(1);
 1953     Override = Override.substr(0, RefPos);
 1973     RecipType = RecipType.substr(0, RefPos);

 1562       Name = Name.substr(
 1611       RelSecName = RelSecName.substr(

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

  354     StringRef Str = Data.getData().substr(*OffsetPtr, Value.uval);

   71     StringRef Name = ConstantPoolStrings.substr(

  189         LocSectionData = LocSectionData.substr(C->Offset, C->Length);

   63     DataExtractor InfoData(Data.getData().substr(Offset, InfoLength),

  192     StrTab.Data = MemBuffer->getBuffer().substr(Hdr->StrtabOffset,
  252   DataExtractor Data(MemBuffer->getBuffer().substr(AddrInfoOffset), Endian, 4);

  254     Name = Name.substr(Name.find_first_not_of("._"));
  496       SymbolName = SymbolName.substr(0, AtPos);

  163                       EHFrameContent.substr(RecordOffset, RecordLength));
  360       RecordAddress, EHFrameContent.substr(RecordOffset, RecordLength),

  293     DemangledName = DemangledName.substr(1);

  266       GV.setName("__" + GV.getName().substr(1) + "." + Twine(NextId++));

   43     StringRef LHSExpr = Expr.substr(0, EQIdx).rtrim();
   54     StringRef RHSExpr = Expr.substr(EQIdx + 1).ltrim();
  125       Token = Expr.substr(0, TokLen);
  159       return std::make_pair(BinOpToken::ShiftLeft, Expr.substr(2).ltrim());
  161       return std::make_pair(BinOpToken::ShiftRight, Expr.substr(2).ltrim());
  182     return std::make_pair(Op, Expr.substr(1).ltrim());
  212     return std::make_pair(Expr.substr(0, FirstNonSymbol),
  213                           Expr.substr(FirstNonSymbol).ltrim());
  225     StringRef RemainingExpr = Expr.substr(1).ltrim();
  237     RemainingExpr = RemainingExpr.substr(1).ltrim();
  247     RemainingExpr = RemainingExpr.substr(1).ltrim();
  293     StringRef RemainingExpr = Expr.substr(1).ltrim();
  305     RemainingExpr = RemainingExpr.substr(1).ltrim();
  331     StringRef RemainingExpr = Expr.substr(1).ltrim();
  337     StubContainerName = RemainingExpr.substr(0, ComaIdx).rtrim();
  338     RemainingExpr = RemainingExpr.substr(ComaIdx).ltrim();
  343     RemainingExpr = RemainingExpr.substr(1).ltrim();
  351     RemainingExpr = RemainingExpr.substr(1).ltrim();
  368     StringRef RemainingExpr = Expr.substr(1).ltrim();
  374     FileName = RemainingExpr.substr(0, ComaIdx).rtrim();
  375     RemainingExpr = RemainingExpr.substr(ComaIdx).ltrim();
  380     RemainingExpr = RemainingExpr.substr(1).ltrim();
  388     RemainingExpr = RemainingExpr.substr(1).ltrim();
  456     return std::make_pair(Expr.substr(0, FirstNonDigit),
  457                           Expr.substr(FirstNonDigit));
  485         evalComplexExpr(evalSimpleExpr(Expr.substr(1).ltrim(), PCtx), PCtx);
  491     RemainingExpr = RemainingExpr.substr(1).ltrim();
  501     StringRef RemainingExpr = Expr.substr(1).ltrim();
  506     RemainingExpr = RemainingExpr.substr(1).ltrim();
  516     RemainingExpr = RemainingExpr.substr(1).ltrim();
  592     RemainingExpr = RemainingExpr.substr(1).ltrim();
  603     RemainingExpr = RemainingExpr.substr(1).ltrim();
  614     RemainingExpr = RemainingExpr.substr(1).ltrim();
  721       DidAllTestsPass &= check(Line.substr(RulePrefix.size()));

  400   Name = Name.substr(4);
  420     if (Name.substr(11) == "c")
  422     if (Name.substr(11) == "z")
  424     if (Name.substr(11) == "nzc")
  497   Name = Name.substr(5); // Strip off "llvm."
  517                                "llvm.ctlz." + Name.substr(14), F->getParent());
  738       Name = Name.substr(5);
 1395   Name = Name.substr(12); // Remove avx512.mask.
 1659     Name = Name.substr(5);
 1663       Name = Name.substr(4);
 1666       Name = Name.substr(5);
 2181         Name = Name.substr(9); // strip off "xop.vpcom"
 4058     return OS.str().substr(1);

  259     Tok = Tok.substr(1);
  407       Tok = Tok.substr(1);

  144     Name = Name.substr(1);

   42     OS << Name.substr(1);

  234   StringRef Prefix = PassID.substr(0, prefix_pos);

  244         NameRef.substr(0, std::max(1u, (unsigned)NonGlobalValueMaxNameSize));

 2161                        F.getName().substr(0, 5) == "llvm.";

  507       Name = Name.substr(strlen("__imp_"));

  736              : Name.substr(0, DotPos);

 1286     StringRef Prefix = AliasName.substr(0, Pos);
 1287     StringRef Rest = AliasName.substr(Pos);
 1290       Tail = Rest.substr(Symbol.isUndefined() ? 2 : 1);

  379     OS << MAI->getCommentString() << ' ' << Comments.substr(0, Position) <<'\n';
  381     Comments = Comments.substr(Position+1);
  940     Data = Data.substr(0, Data.size()-1);
 2002     String = String.substr(0, String.size()-1);

  154     FormattedOS << CommentBegin << ' ' << Comments.substr(0, Position);
  156     Comments = Comments.substr(Position+1);

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

  374     if (Result.substr(2).getAsInteger(2, Value))

 2315   Filename = Filename.substr(1, Filename.size() - 2);
 2517     Body = Body.substr(Pos);
 4583     Body = Body.substr(Pos);

 1258         Name = Name.substr(strlen(".custom_section."));
 1536               .substr(PrefixLength + 1)

  156     if (Name.substr(1).rtrim(' ').getAsInteger(10, StringOffset)) {
  159       OS.write_escaped(Name.substr(1).rtrim(' '));
  194     if (Name.substr(3).rtrim(' ').getAsInteger(10, NameLength)) {
  197       OS.write_escaped(Name.substr(3).rtrim(' '));
  378     if (Name.substr(3).rtrim(' ').getAsInteger(10, NameSize)) {
  381       OS.write_escaped(Name.substr(3).rtrim(' '));

  115     From = From.substr(1);
  116     To = To.substr(1);
  126   return (Twine(S.substr(0, Pos)) + To + S.substr(Pos + From.size())).str();
  126   return (Twine(S.substr(0, Pos)) + To + S.substr(Pos + From.size())).str();

  117       std::tie(S, Buf) = Buf.substr(1).split('"');
  122       StringRef Word = Buf.substr(0, End);

   91     Str = Str.substr(1);
 1068       if (decodeBase64StringEntry(Name.substr(2), Offset))
 1072       if (Name.substr(1).getAsInteger(10, Offset))

   40   SectionData = SectionData.substr(4);
   46   SectionData = SectionData.substr(8);
   71   SectionData = SectionData.substr(HdrSize);

 1950   return arrayRefFromStringRef(getData().substr(Offset, Size));
 4611   return getData().substr(S.stroff, S.strsize);

   72     ObjectData = ParentData.substr(Header.offset, Header.size);
   75     ObjectData = ParentData.substr(Header64.offset, Header64.size);
   92     ObjectData = ParentData.substr(Header.offset, Header.size);
   94     ObjectData = ParentData.substr(Header64.offset, Header64.size);

  250   Header.Magic = getData().substr(0, 4);

  370   return S.substr(0, SuffixPos);

  185       StringRef Rest = Str.substr(Prefix.size());

 1759     Pipeline.push_back({Text.substr(0, Pos), {}});
 1766     Text = Text.substr(Pos + 1);

   65   Data = Data.substr(N);
   90   Result = Data.substr(0, Length);
   91   Data = Data.substr(Length);
  372   return Data.substr(Pointer - Address, Size);
  627   Data = Data.substr(StringRef(TestingFormatMagic).size());
  634   Data = Data.substr(N);
  641   Data = Data.substr(N);
  645   if (Error E = ProfileNames.create(Data.substr(0, ProfileNamesSize), Address))
  647   StringRef CoverageMapping = Data.substr(ProfileNamesSize);
  654   CoverageMapping = CoverageMapping.substr(Pad);

  237   return PathNameStr.substr(LastPos);
 1122         MemOPSizeRange.substr(0, Pos).getAsInteger(10, RangeStart);
 1124         MemOPSizeRange.substr(Pos + 1).getAsInteger(10, RangeLast);

  160   StringRef Str = (Line)->substr(1);

   75   FName = Input.substr(0, n1);
   76   if (Input.substr(n1 + 1, n2 - n1 - 1).getAsInteger(10, NumSamples))
   78   if (Input.substr(n2 + 1).getAsInteger(10, NumHeadSamples))
  107   StringRef Loc = Input.substr(Depth, n1 - Depth);
  114     if (Loc.substr(0, n2).getAsInteger(10, LineOffset))
  116     if (Loc.substr(n2 + 1).getAsInteger(10, Discriminator))
  120   StringRef Rest = Input.substr(n1 + 2);
  128       if (Rest.substr(0, n3).getAsInteger(10, NumSamples))
  144       n3 += Rest.substr(n3).find_first_not_of(' ');
  145       Rest = Rest.substr(n3);
  154         StringRef AfterColon = Rest.substr(n3 + 1);
  156         Target = Rest.substr(0, n3);
  160         StringRef WordAfterColon = Rest.substr(n3 + 1, n4 - n3 - 1);
  181     CalleeName = Rest.substr(0, n3);
  182     if (Rest.substr(n3 + 1).getAsInteger(10, NumSamples))

  148     StringRef ArchExtBase(ArchExt.substr(2));

  294     if (A.substr(offset, 3) == "_be")
  299   if (offset != StringRef::npos && A.substr(offset, 2) == "eb")
  303     A = A.substr(0, A.size() - 2);
  306     A = A.substr(offset);
  446     Name = Name.substr(2);

  530   auto I = Sub.OptionsMap.find(Arg.substr(0, EqualPos));
  538   Value = Arg.substr(EqualPos + 1);
  539   Arg = Arg.substr(0, EqualPos);
  618       if (Handler->addOccurrence(pos, ArgName, Val.substr(0, Pos), MultiArg))
  621       Val = Val.substr(Pos + 1);
  717     Name = Name.substr(0, Name.size() - 1); // Chop off the last character.
  749         (Length < Arg.size()) ? Arg.substr(Length) : StringRef();
  750     Arg = Arg.substr(0, Length);
  762       Value = MaybeValue.substr(1);
 1410         ArgName = ArgName.substr(1);
 1424         ArgName = ArgName.substr(1);

   97   Str = Str.substr(I);
  278     DefExpr = Expr.substr(0, DefEnd);
  279     Expr = Expr.substr(DefEnd + 1);
  331       PatternStr = PatternStr.substr(0, PatternStr.size() - 1);
  392       if (AddRegExToRegEx(PatternStr.substr(2, End - 2), CurParen, SM))
  396       PatternStr = PatternStr.substr(End + 2);
  410       StringRef UnparsedPatternStr = PatternStr.substr(2);
  414       StringRef MatchStr = UnparsedPatternStr.substr(0, End);
  426       PatternStr = UnparsedPatternStr.substr(End + 2);
  441         size_t SpacePos = MatchStr.substr(0, VarEndIdx).find_first_of(" \t");
  579     RegExStr += Regex::escape(PatternStr.substr(0, FixedMatchEnd));
  580     PatternStr = PatternStr.substr(FixedMatchEnd);
  716   StringRef BufferPrefix = Buffer.substr(0, ExampleString.size());
  804     unsigned Distance = computeMatchDistance(Buffer.substr(i));
  872       Str = Str.substr(2);
  891       Str = Str.substr(1);
 1089     StringRef Skipped = Buffer.substr(0, Loc);
 1152         CmdLine->getBuffer().substr(Prefix.size(), PatternString.size());
 1210       Buffer = Buffer.substr(Buffer.find_first_not_of(" \t"));
 1220     if (P.parsePattern(Buffer.substr(0, EOL), UsedPrefix, SM, Req))
 1232     Buffer = Buffer.substr(EOL);
 1354   Buffer = Buffer.substr(Buffer.find_first_not_of(" \t\n\r"));
 1408     Range = Range.substr(Range.find_first_of("\n\r"));
 1417       Range = Range.substr(1);
 1418     Range = Range.substr(1);
 1450     StringRef MatchBuffer = Buffer.substr(LastMatchEnd);
 1477     StringRef MatchBuffer = Buffer.substr(LastPos);
 1478     StringRef SkippedRegion = Buffer.substr(LastPos, MatchPos);
 1636       StringRef MatchBuffer = Buffer.substr(MatchPos);
 1818     StringRef CmdlineDef = CmdlineDefsDiagRef.substr(CmdlineDefIndices.first,
 1832       StringRef CmdlineDefExpr = CmdlineDef.substr(1);
 1955       CheckRegion = Buffer.substr(0, MatchLabelPos + MatchLabelLen);
 1956       Buffer = Buffer.substr(MatchLabelPos + MatchLabelLen);
 1981       CheckRegion = CheckRegion.substr(MatchPos + MatchLen);

   98       return std::make_pair(ReplacementItem{Fmt.substr(0, BO)}, Fmt.substr(BO));
   98       return std::make_pair(ReplacementItem{Fmt.substr(0, BO)}, Fmt.substr(BO));
  106       StringRef Middle = Fmt.substr(BO, NumEscapedBraces);
  126       return std::make_pair(ReplacementItem{Fmt.substr(0, BO2)},
  127                             Fmt.substr(BO2));
  130     StringRef Right = Fmt.substr(BC + 1);

   42       S = S.substr(1);
   54     S = S.substr(3);
   70     S = S.substr(1);
   75     S = S.substr(1);
   85     StringRef Chars = S.substr(1, End - 1);
   86     S = S.substr(End + 1);
   88       Expected<BitVector> BV = expand(Chars.substr(1), Original);
   98     S = S.substr(1);
  103     S = S.substr(1);
  167         if (matchOne(Pats, S.substr(I)))
  176     S = S.substr(1);

  160       Implementer = Lines[I].substr(15).ltrim("\t :");
  162       Hardware = Lines[I].substr(8).ltrim("\t :");
  178         return StringSwitch<const char *>(Lines[I].substr(8).ltrim("\t :"))
  203         return StringSwitch<const char *>(Lines[I].substr(8).ltrim("\t :"))
  222         return StringSwitch<const char *>(Lines[I].substr(8).ltrim("\t :"))
  233         return StringSwitch<const char *>(Lines[I].substr(8).ltrim("\t :"))

   65   PIDStr = PIDStr.substr(PIDStr.find_first_not_of(" "));

   73         return path.substr(0, 2);
   81       return path.substr(0, end);
   86       return path.substr(0, 1);
   90     return path.substr(0, end);
  263       Component = Path.substr(Position, 1);
  307   I.Component = Path.substr(0, 0);
  331   size_t start_pos = filename_pos(Path.substr(0, end_pos), S);
  356         return path.substr(0, b->size() + pos->size());
  414   return path.substr(root.size());
  436       StringRef c = component.substr(loc);
  471     return path.substr(0, end_pos);
  515   StringRef RelPath = OrigPath.substr(OldPrefix.size());
  577       return fname.substr(0, pos);
  590       return fname.substr(pos);
  681     Path = Path.substr(2);
  683       Path = Path.substr(1);

  168       Repl = Repl.substr(1);
  174       Repl = Repl.substr(1);
  178       Repl = Repl.substr(1);
  186       Repl = Repl.substr(Ref.size());

   26     if (s1.substr(i, N).equals_lower(s2))
   45   return std::make_pair(Source.slice(Start, End), Source.substr(End));

  182   StringRef This = substr(From);
  213     if (substr(i, N).equals(Str))
  225     if (substr(i, N).equals_lower(Str))
  378     if (substr(i, N).equals(Str))
  388     Str = Str.substr(2);
  393     Str = Str.substr(2);
  398     Str = Str.substr(2);
  403     Str = Str.substr(1);
  446     Str2 = Str2.substr(1);
  523     Str = Str.substr(1);
  577     Str = Str.substr(1);

  140   Prefix = Path.substr(0, Sep);
  141   Name = Path.substr(Sep + 1);

 1024     Str = Str.substr(1);
 1046       Name = Name.substr(1);
 1055     EnvironmentName = EnvironmentName.substr(EnvironmentTypeName.size());
 1066     OSName = OSName.substr(OSTypeName.size());

  589   StringRef Remainder = PathStr.substr(Expr.size() + 1);

   44   input = input.substr(1);
   53     input = input.substr(1);
   75   input = input.substr(1);
   87   input = input.substr(1);
   99   input = input.substr(1);

 1985       assert(RPath.substr(0, OverlayDirLen) == OverlayDir &&
 2007         assert(RPath.substr(0, OverlayDirLen) == OverlayDir &&

 1814       Ret += Raw.substr(1);
 1818       Ret += Raw.substr(2);
 1821       StringRef TagHandle = Raw.substr(0, Raw.find_last_of('!') + 1);
 1832       Ret += Raw.substr(Raw.find_last_of('!') + 1);
 1881     StringRef UnquotedValue = Value.substr(1, Value.size() - 2);
 1889     StringRef UnquotedValue = Value.substr(1, Value.size() - 2);
 1899         UnquotedValue = UnquotedValue.substr(i + 2);
 1922     UnquotedValue = UnquotedValue.substr(i);
 1933         UnquotedValue = UnquotedValue.substr(1);
 1934       UnquotedValue = UnquotedValue.substr(1);
 1940       UnquotedValue = UnquotedValue.substr(1);
 1953           UnquotedValue = UnquotedValue.substr(1);
 2014           if (UnquotedValue.substr(1, 2).getAsInteger(16, UnicodeScalarValue))
 2018           UnquotedValue = UnquotedValue.substr(2);
 2026           if (UnquotedValue.substr(1, 4).getAsInteger(16, UnicodeScalarValue))
 2030           UnquotedValue = UnquotedValue.substr(4);
 2038           if (UnquotedValue.substr(1, 8).getAsInteger(16, UnicodeScalarValue))
 2042           UnquotedValue = UnquotedValue.substr(8);
 2046       UnquotedValue = UnquotedValue.substr(1);
 2310     return new (NodeAllocator) AliasNode(stream.CurrentDoc, T.Range.substr(1));
 2337                                            , AnchorInfo.Range.substr(1)
 2344                   , AnchorInfo.Range.substr(1)
 2351                  , AnchorInfo.Range.substr(1)
 2358                   , AnchorInfo.Range.substr(1)
 2365                  , AnchorInfo.Range.substr(1)
 2372                 , AnchorInfo.Range.substr(1)
 2380         BlockScalarNode(stream.CurrentDoc, AnchorInfo.Range.substr(1),
 2387                  , AnchorInfo.Range.substr(1)
 2428   T = T.substr(T.find_first_of(" \t")).ltrim(" \t");
 2430   StringRef TagHandle = T.substr(0, HandleEnd);
 2431   StringRef TagPrefix = T.substr(HandleEnd).ltrim(" \t");

   43     printLine(OS, Prefix + Desc.substr(Pos, Length), ' ', Suffix);

 5139       Name = Name.substr(2);
 5175     Name = Name.substr(2);
 5241       Name = Name.substr(2);

  498   StringRef Res = mangledName.substr(0, Len);

  117     StringRef CurFmt = Fmt.substr(PrevFmtSpecifierIdx,

 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);
 6473     DimId = DimId.substr(12);

10649       bool Failed = Constraint.substr(2).getAsInteger(10, Idx);

 4906       unsigned Flag = StringSwitch<unsigned>(IFlagsStr.substr(i, 1).lower())
 4990       unsigned Flag = StringSwitch<unsigned>(Flags.substr(i, 1))
 6263     unsigned CC = ARMCondCodeFromString(Mnemonic.substr(Mnemonic.size()-2));
 6294       StringSwitch<unsigned>(Mnemonic.substr(Mnemonic.size()-2, 2))
 6311     unsigned CC = ARMVectorCondCodeFromString(Mnemonic.substr(Mnemonic.size()-1));
 7031             Mnemonic = Mnemonic.substr(0, 4);
11769     Name = Name.substr(2);

  390         getLexer().getTok().getString().substr(0, 1), S));
  392         getLexer().getTok().getString().substr(1, 1), S));

  947   StringRef IndexPattern = AccessPattern.substr(FirstDollar + 1);
  948   StringRef RelocKindStr = AccessPattern.substr(FirstColon + 1,
  950   StringRef PatchImmStr = AccessPattern.substr(SecondColon + 1,

  857           getContext(), String.substr(HeadTail.first.size(), 1), Loc));
 1131           getContext(), Token.getString().substr(0, 1), Token.getLoc()));
 1133           getContext(), Token.getString().substr(1, 1), Token.getLoc()));

 1043     Mnemonic = Name.substr(0, Name.size() - 2);
 1054         LPCC::suffixToLanaiCondCode(Mnemonic.substr(1, Next));
 1082         Mnemonic = Mnemonic.substr(0, Next + 1);
 1084         Mnemonic = Mnemonic.substr(0, Next);

 5904     StringRef NumString = Name.substr(1);
 5917     StringRef NumString = Name.substr(3);
 5930     StringRef NumString = Name.substr(2);
 6255             matchAnyRegisterNameWithoutDollar(Operands, DefSymbol.substr(1), S);

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

 1186                !Name.substr(1).getAsInteger(10, IntVal) && IntVal < 32) {
 1189                !Name.substr(1).getAsInteger(10, IntVal) && IntVal < 32) {
 1192                !Name.substr(2).getAsInteger(10, IntVal) && IntVal < 64) {
 1195                !Name.substr(1).getAsInteger(10, IntVal) && IntVal < 32) {
 1198                !Name.substr(1).getAsInteger(10, IntVal) && IntVal < 32) {
 1201                !Name.substr(2).getAsInteger(10, IntVal) && IntVal < 8) {

 1009     if (name.substr(0, 3).equals_lower("asr")
 1010         && !name.substr(3).getAsInteger(10, intVal)
 1080     if (name.substr(0, 3).equals_lower("fcc")
 1081         && !name.substr(3).getAsInteger(10, intVal)
 1090     if (name.substr(0, 1).equals_lower("g")
 1091         && !name.substr(1).getAsInteger(10, intVal)
 1098     if (name.substr(0, 1).equals_lower("o")
 1099         && !name.substr(1).getAsInteger(10, intVal)
 1105     if (name.substr(0, 1).equals_lower("l")
 1106         && !name.substr(1).getAsInteger(10, intVal)
 1112     if (name.substr(0, 1).equals_lower("i")
 1113         && !name.substr(1).getAsInteger(10, intVal)
 1120     if (name.substr(0, 1).equals_lower("f")
 1121         && !name.substr(1, 2).getAsInteger(10, intVal) && intVal < 32) {
 1127     if (name.substr(0, 1).equals_lower("f")
 1128         && !name.substr(1, 2).getAsInteger(10, intVal)
 1137     if (name.substr(0, 1).equals_lower("r")
 1138         && !name.substr(1, 2).getAsInteger(10, intVal) && intVal < 31) {
 1145     if (name.substr(0, 1).equals_lower("c")
 1146         && !name.substr(1).getAsInteger(10, intVal)

 3297     if (name.substr(0, 1).equals("r")
 3298         && !name.substr(1).getAsInteger(10, intVal) && intVal <= 31) {
 3307     if (name.substr(0, 1).equals("f") &&
 3308         !name.substr(1).getAsInteger(10, intVal) && intVal <= 63) {

  713   if (Name.substr(1).getAsInteger(10, Reg.Num))

 2397         ParseConditionCode(PatchedName.substr(1)) != X86::COND_INVALID))) {
 2415     PatchedName = PatchedName.substr(0, Name.size()-1);

45209   S = S.substr(S.find_first_not_of(" \t")); // Skip leading whitespace.
45215     S = S.substr(Piece.size());
45220     S = S.substr(Pos);
45281       SplitString(StringRef(ConstraintsStr).substr(5), AsmPieces, ",");
45295       SplitString(StringRef(ConstraintsStr).substr(5), AsmPieces, ",");

 1736       StringRef NewName = OrigName.substr(0, pos);

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

   43     return Name.substr(1);

 2403       OldName = OldName.substr(LastSROAPrefix + strlen(".sroa."));
 2408         OldName = OldName.substr(IndexEnd + 1);
 2412           OldName = OldName.substr(OffsetEnd + 1);
 2416     OldName = OldName.substr(0, OldName.find(".sroa_"));

  495     StringRef SubStr1 = Str1.substr(0, Length);
  496     StringRef SubStr2 = Str2.substr(0, Length);
  922   Str = Str.substr(0, LenC->getZExtValue());

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

  315       I->setName(I->getName().substr(1));

 1345     MethodName = STRefMethodName.substr(len);
 1354   std::string ClassNamePostfix = LoweredClassName.substr(Ix);

  434   return file.substr(locInfo.second).startswith(text);

 4056     Comp = Comp.substr(1);
 4059     if (Comp.substr(i + 1).find(Comp[i]) != StringRef::npos)
 4071     Comp = Comp.substr(1);

10724         Str = Str.substr(Off);
10728           Str = Str.substr(0, Pos);

  701   Out << FunctionEncodingStream.str().substr(EncodingPositionStart);

  143           StringRef MaskType = MatchedStr.substr(sizeof("mask.") - 1);

  314     OS << "OMP" << ClauseName.substr(/*Start=*/0, /*N=*/1).upper()
 1481         OS << "OMP" << ClauseName.substr(/*Start=*/0, /*N=*/1).upper()

  118       Result.Text = Code.substr(0, 1);
  123       Result.Text = Code.substr(0, 1);
  128       Result.Text = Code.substr(0, 1);
  133       Result.Text = Code.substr(0, 1);
  160             Result.Text = Code.substr(0, TokenLength);
  176           Result.Text = Code.substr(0, TokenLength);
  181         Result.Text = Code.substr(0, 1);
  215     Result->Text = Code.substr(0, Length);
  262         Result->Text = Code.substr(0, Length + 1);
  263         Result->Value = Code.substr(1, Length - 1);

  129     StringRef suffix = functionName.substr(it - start);

   56       return s.substr(0, i);

  453     FName = FName.substr(FName.startswith("CGCF") ? 4 : 2);
  504   FName = FName.substr(FName.find_first_not_of('_'));
  721   FName = FName.substr(FName.find_first_not_of('_'));
 1095       if (Slot.substr(Slot.size() - 8).equals_lower("delegate")) {

   14     Name = Name.substr(2, Name.size() - 4);

  124     DirName = DirName.substr(0, DirName.size()-1);

  529     name = name.substr(1);

   62   StringRef runtimeName = input.substr(0, dash);
   88     StringRef verString = input.substr(dash + 1);

  409     setFeatureEnabled(Features, Name.substr(1), Enabled);
  441     Name = Name.substr(1);

  473     Constraint = Constraint.substr(1);

  142       if (!SpecialRegs.count(S.substr(0, E)))

 1042     Constraint = Constraint.substr(1);
 1125   Builder.defineMacro("_M_ARM", Triple.getArchName().substr(Offset));

 1733     Constraint = Constraint.substr(1);

   50     URL = URL.substr(Start + 4);
   68     URL = URL.substr(Start);

  101         Opt = Opt.substr(3);
  142           Specifier = Opt.substr(6);
  170           Specifier = Opt.substr(13);
  204       if (!IsPositive) Opt = Opt.substr(3);

   43     name = name.substr(1);

  482       return (Twine(Entry.second) + Path.substr(Entry.first.size())).str();
 3583     Name = Name.substr(1);
 3684     Name = Name.substr(1);

 2760     FnName = FnName.substr(1);
 2890       FilenameString = FilenameString.substr(I - E);
 2899             FilenameString.substr(I - llvm::sys::path::begin(FilenameString));

 4930     assert(Section.substr(0, 2) == "__" &&
 4932     return Section.substr(2).str();
 4934     assert(Section.substr(0, 2) == "__" &&
 4936     return ("." + Section.substr(2) + "$B").str();

  436     Message = Message.substr(7);
 1035     Msg = Msg.substr(7);

 2226         ReqFeatures.push_back(StringRef(F).substr(1));

  966         return Target.multiVersionSortPriority(LHS.substr(1)) >
  967                Target.multiVersionSortPriority(RHS.substr(1));
  981     Out << Feat.substr(1);
 2973                     [](StringRef Str) { return Str.substr(1); });
 5718         Int8Ty, Uuid.substr(Field3ValueOffsets[Idx], 2), 16);
 5721     llvm::ConstantInt::get(Int32Ty, Uuid.substr(0,  8), 16),
 5722     llvm::ConstantInt::get(Int16Ty, Uuid.substr(9,  4), 16),
 5723     llvm::ConstantInt::get(Int16Ty, Uuid.substr(14, 4), 16),
 5871                             StringRef{Feat}.substr(1));

  145       StringRef LookupName = LineRef.substr(0, Pos);
  149       StringRef FileName = LineRef.substr(Pos + 1);

   30         Version = llvm::StringSwitch<Distro::DistroType>(Line.substr(17))

 1787       llvm::outs() << Suffix.substr(1) << "\n";
 4492     SmallString<128> Suffixed(BaseName.substr(0, End));

   94       OS << "@" << Flag.substr(1);
  102     llvm::StringMap<int>::iterator SI = FlagSet.find(Flag.substr(1));
  107       FlagSet[Flag.substr(1)] = I;
  147       Opposite.flags().push_back(("-" + Flag.substr(1)).str());
  250     FlagSet[Flag.substr(1)] = isFlagEnabled(Flag);
  254       llvm::StringMap<bool>::const_iterator SI = FlagSet.find(Flag.substr(1));

   49       CPU = Value.substr(6);
   51       Arch = Value.substr(7);
  351     CPUName = StringRef(WaCPU->getValue()).substr(6);
  361     ArchName = StringRef(WaArch->getValue()).substr(7);
  396     getARMFPUFeatures(D, WaFPU, Args, StringRef(WaFPU->getValue()).substr(6),
  420                         StringRef(WaHDiv->getValue()).substr(8), Features);

   59   In = In.substr(Major.size());
   65     In = In.substr(Major.size());
  122     StringRef Name(Ext.substr(Type.size()));
  157       auto Next =  Name.substr(Pos);
  158       Name = Name.substr(0, Pos);
  252   StringRef Exts = MArch.substr(5);
  260     OtherExts = Exts.substr(Pos);
  261     Exts = Exts.substr(0, Pos);

  163     StringRef RefStep = In.substr(Position + 1);
  236       Val = Val.substr(1);
 3509     Triple.getArchName().substr(Offset).getAsInteger(10, Version);

   80     Name = Name.substr(1);
   84       Name = Name.substr(3);
  117             Args.MakeArgString(std::string(ArgName) + Dirs.substr(0, Delim)));
  120         CmdArgs.push_back(Args.MakeArgString(Dirs.substr(0, Delim)));
  123     Dirs = Dirs.substr(Delim + 1);

   38   V = V.substr(strlen("CUDA Version "));

  819     Arch = Arch.substr(0, 5);
  822     Arch = Arch.substr(0, 5);
  825     Arch = Arch.substr(0, 5);

 1702       GoodVersion.PatchSuffix = MinorStr.substr(EndNumber);
 1728       GoodVersion.PatchSuffix = PatchText.substr(EndNumber);

  582     return CPU.substr(sizeof("hexagon") - 1);

  337   return file.substr(Offs.getOffset()).startswith(text);

  700         text = text.substr(0, text.size()-suff.size());

   59         LongestPrefix = Comment.substr(0, PrefixLength);
   84         encoding::columnWidthWithTabs(Text.substr(MaxSplitBytes, BytesInChar),
   95     if (kNumberedListRegexp->match(Text.substr(SpaceOffset).ltrim(Blanks)))
  126     StringRef BeforeCut = Text.substr(0, SpaceOffset).rtrim(Blanks);
  127     StringRef AfterCut = Text.substr(SpaceOffset);
  158           Text.substr(0, Advance), UsedColumns + Chars, TabWidth, Encoding);
  172     Text = Text.substr(Advance);
  189   StringRef Content = Token.TokenText.substr(2).ltrim();
  225          encoding::columnWidthWithTabs(Line.substr(Offset, StringRef::npos),
  242   Line = Tok.TokenText.substr(
  249   return getStringSplit(Line.substr(TailOffset), ContentStartColumn,
  278   return getCommentSplit(Content[LineIndex].substr(TailOffset),
  286   StringRef Text = Content[LineIndex].substr(TailOffset);
  345   TokenText.substr(2, TokenText.size() - 4)
  388       Decoration = Decoration.substr(0, Decoration.size() - 1);
  422     Content[i] = Content[i].substr(DecorationSize);
  465   return getCommentSplit(Content[LineIndex].substr(TailOffset),
  493   StringRef Whitespace = Lines[LineIndex].substr(0, StartOfLine);
  497   Content[LineIndex - 1] = Lines[LineIndex - 1].substr(
  499   Content[LineIndex] = Lines[LineIndex].substr(StartOfLine);
  512       encoding::columnWidthWithTabs(Content[LineIndex].substr(Offset, Length),
  522     if (Content[LineIndex].substr(Offset, StringRef::npos).empty()) {
  558     ContentWithNoDecoration = ContentWithNoDecoration.substr(1).ltrim(Blanks);
  560   StringRef FirstWord = ContentWithNoDecoration.substr(
  571   StringRef Text = Content[LineIndex].substr(TailOffset);
  622          Lines[0].substr(1).find_first_not_of(Blanks) != StringRef::npos;
  654       size_t BreakLength = Lines[0].substr(1).find_first_not_of(Blanks);
  674       Prefix = Prefix.substr(0, 1);
  679       Prefix = Prefix.substr(0, 1);
  701     StringRef Line = Content.back().substr(TailOffset);
  715     IndentContent = Lines[LineIndex].ltrim(Blanks).substr(1);
  772       Content[i] = Lines[i].substr(IndentPrefix.size());
  787       Content[i] = Content[i].substr(0, EndOfLine);
  815       Content[LineIndex].substr(Offset, Length), StartColumn, Style.TabWidth,
  829   StringRef Text = Content[LineIndex].substr(TailOffset);
  963     IndentContent = Lines[LineIndex].substr(2);

  157   size_t LParenPos = TokenText.substr(0, 19).find_first_of('(');
  160   StringRef Delimiter = TokenText.substr(2, LParenPos - 2);
  166   if (!TokenText.substr(RParenPos + 1).startswith(Delimiter))
 1496     return encoding::columnWidthWithTabs(Text.substr(LastNewlinePos),
 1517       Current.TokenText.substr(OldPrefixSize).drop_back(OldSuffixSize);
 1827         CommentPragmasRegex.match(Current.TokenText.substr(2)) ||

   69     TotalWidth += columnWidth(Tail.substr(0, TabPos), Encoding);
   72     Tail = Tail.substr(TabPos + 1);

 1959       replaceCRLF(Code.substr(IncludesBeginOffset, IncludesBlockSize)))
 2005         Code.substr(Prev, (Pos != StringRef::npos ? Pos : Code.size()) - Prev);
 2128       replaceCRLF(Code.substr(Imports.front().Offset, ImportsBlockSize)))
 2164         Code.substr(Prev, (Pos != StringRef::npos ? Pos : Code.size()) - Prev);

  467                                 : LiteralText.substr(0, FirstBreak);
  475         LiteralText.substr(LastBreak + 1, LiteralText.size()), StartColumn,
  499   HashToken->TokenText = Lex->getBuffer().substr(From, Len);
  573     LineStart = Buffer.substr(LineOffset);
  575     LineStart = Buffer.substr(LineOffset, FirstSpace - LineOffset);
  717         FormatTok->TokenText = FormatTok->TokenText.substr(0, BackslashPos + 1);
  745     FormatTok->TokenText = FormatTok->TokenText.substr(SkippedWhitespace);
  776     FormatTok->TokenText = FormatTok->TokenText.substr(0, 1);
  781     FormatTok->TokenText = FormatTok->TokenText.substr(0, 1);
  801         Text.substr(0, FirstNewlinePos), Column, Style.TabWidth, Encoding);
  806         Text.substr(Text.find_last_of('\n') + 1), 0, Style.TabWidth, Encoding);

  238     return FileContents.substr(SM.getFileOffset(Begin),
  342           Current->TokenText.substr(1, Current->TokenText.size() - 2);
  356           Current->TokenText.substr(1, Current->TokenText.size() - 2);

 2510     IndentContent = FormatTok.TokenText.substr(2);

 2117                               llvm::StringRef(A->getValue()).substr(1));
 3297         Value.substr(0, Comma).getAsInteger(10, Bytes) ||
 3298         Value.substr(Comma + 1).getAsInteger(10, EndOfLine))

  120       FileName = FileName.substr(SysRoot.size());

   50     MacroBody = MacroBody.substr(0, End);

   26   return S.substr(0, Offset).str();
   62         LineStr = LineStr.substr(Pos + strlen("struct "));
   64         LineStr = LineStr.substr(Pos + strlen("class "));
   66         LineStr = LineStr.substr(Pos + strlen("union "));
   80       LineStr = LineStr.substr(Pos + strlen(" Size:"));
   92       LineStr = LineStr.substr(Pos + strlen("Alignment:"));
  104       LineStr = LineStr.substr(Pos + strlen("sizeof="));
  114         LineStr = LineStr.substr(Pos + strlen("align="));
  130     LineStr = LineStr.substr(Pos + strlen("FieldOffsets: ["));
  138       (void)LineStr.substr(0, Idx).getAsInteger(10, Offset);
  143       LineStr = LineStr.substr(Idx + 1);
  145         LineStr = LineStr.substr(1);

   76       StringRef Message = Blob.substr(0, Record[0]);

   53     Str = Str.substr(Pos + 1);
  642       applyTemplateHighlighting(OS, Str.substr(WordStart, WordLength),
  652     applyTemplateHighlighting(OS, Str.substr(WordStart, WordLength),
  659   applyTemplateHighlighting(OS, Str.substr(Length), TextNormal, Bold);

  449       DToken = DToken.substr(0, DToken.size()-3);
  470     DToken = DToken.substr(0, DToken.size()-DType.size());
  620       D.Text += Content.substr(CPos, FPos-CPos);
  774       C2 += C.substr(last);
  777     C2 += C.substr(last, loc-last);
 1141       RegexStr += llvm::Regex::escape(S.substr(0, VerbatimMatchLength));

 1109     Result << S.substr(0, Pos);

  502     HS.LookupFrameworkCache(Filename.substr(0, SlashPos));
 1056       *FrameworkMap.insert(std::make_pair(Filename.substr(0, SlashPos),

  972   return file.substr(beginInfo.second, EndOffs - beginInfo.second);
 1019   return ExpansionBuffer.substr(ExpansionInfo.second, MacroTokenLength);
 1044   return ExpansionBuffer.substr(ExpansionInfo.second, MacroTokenLength);
 1085   StringRef Rest = Buffer.substr(Line - Buffer.data());
 2823   auto RestOfBuffer = StringRef(CurPtr, BufferEnd - CurPtr).substr(TermLen);
 2829       RestOfBuffer = RestOfBuffer.substr(Pos+TermLen);

 1627         StringRef BeforeCRLF = RemainingTokenSpan.substr(0, CRLFPos);
 1628         StringRef AfterCRLF = RemainingTokenSpan.substr(CRLFPos);
 1636         RemainingTokenSpan = AfterCRLF.substr(1);

  516       StringRef Sub = Directive.substr(2);
  528       StringRef Sub = Directive.substr(1);
 1541   Buffer = Buffer.substr(1, Buffer.size()-2);
 1829     StringRef FrameworkName = OriginalFilename.substr(0, SlashPos);
 1834         << OriginalFilename.substr(SlashPos + 1) << FrameworkName

  211         Result = FilePath.substr(Path.size());

 1100     Feature = Feature.substr(2, Feature.size() - 4);
 1127     Extension = Extension.substr(2, Extension.size() - 4);

 1225     StringRef Group = StringRef(WarningName).substr(2);

  118     LineBuf = LineBuf.substr(0, TotalOffset);

  276       indentSpace = MB.substr(lineOffs, i-lineOffs);
  341   return ReplaceText(start, origLength, MB.substr(newOffs, newLength));
  383     parentSpace = MB.substr(parentLineOffs, i-parentLineOffs);
  388     startSpace = MB.substr(startLineOffs, i-startLineOffs);
  395   StringRef indent = startSpace.substr(parentSpace.size());
  404     StringRef origIndent = MB.substr(offs, i-offs);

 8800       StrRef.substr(0, TypeSize).find('\0') == StringRef::npos) {
13651   while (!str.empty() && str.front() == '_') str = str.substr(1);
13653     str = str.substr(3);
13658     str = str.substr(3);

 9680     auto BareFeat = StringRef{Feat}.substr(1);

 3923         !Str.substr(1, VectorStringLength).getAsInteger(10, VectorSize) &&
 3925       parseModeAttrArg(*this, Str.substr(VectorStringLength + 1), DestWidth,
 4836     AliasName = AliasName.substr(6);

  622           &S.Context.Idents.get(setterName->getName().substr(3));

  607       MacroBody = MacroBody.substr(0, End);

 1983         s1StrRef = s1StrRef.substr(0, (size_t)len->getZExtValue());
 1984         s2StrRef = s2StrRef.substr(0, (size_t)len->getZExtValue());
 1996         s1StrRef = s1StrRef.substr(0, s1Term);
 2000         s2StrRef = s2StrRef.substr(0, s2Term);

  140     Name = Name.substr(10);
  749     Name = Name.substr(10);

  799             << "') starts with '" << StringRef(FuncName).substr(0, 3) << "'";

  134     CheckerName = CheckerName.substr(0, Pos);

   92       return HadLeadingColonColon ? NewName : NewName.substr(2);
  100       return NewName.substr(NS.size());
  142   StringRef TrimmedQName = QName.substr(2);
  209     return Pos != StringRef::npos ? ReplacementString.substr(Pos + 2)

  388       StringRef Head = TextRef.substr(0, R.getOffset() + Delta - Offset);
  389       StringRef Tail = TextRef.substr(REnd - Offset);
  395       StringRef Tail = RText.substr(End - R.getOffset());

   81     StringRef V = Prefix ? Value.first.substr(0, Key.size()) : Value.first;
   85     StringRef V = Prefix ? Value.first.substr(0, Key.size()) : Value.first;
   95       types::lookupTypeForExtension(path::extension(Filename).substr(1));
  389       Prefix = Filename.substr(0, Dir - DirEnd);

   99   Code.substr(StartPos, EndPos - StartPos).split(Lines, '\n');

  539         ReplacedName = NewName.substr(LastColonPos + 1);
  569       if (NewName.startswith("::") && NewName.substr(2) == ReplacedName)

  163       if (ToTemplate.substr(Index, 2) == "$$") {
  167       } else if (ToTemplate.substr(Index, 2) == "${") {
  172                   ToTemplate.substr(Index),
  176             ToTemplate.substr(Index + 2, EndOfIdentifier - Index - 2);
  183                 ToTemplate.substr(Index),
  190                           ToTemplate.substr(Index, NextIndex - Index)});

  119   return Text.substr(Begin, length());

  230     RelativePath = RelativePath.substr(strlen("./"));

  260     outs() << Text.substr(From, Index - From);
  279   outs() << Text.substr(From);

  391     return NameOrErr->substr(sizeof(OFFLOAD_BUNDLER_MAGIC_STR) - 1);

  324         Source.substr(Tok.getLocation().getRawEncoding(), Tok.getLength());

  150       RootGroup = RootGroup.substr(2);

  110       GetStableCStr(SavedStrings, Edit.substr(1));
  115       GetStableCStr(SavedStrings, Edit.substr(1));
  120     StringRef MatchPattern = Edit.substr(2).split('/').first;
  121     StringRef ReplPattern = Edit.substr(2).split('/').second;
  136     auto Option = Edit.substr(1);

   74       Result.push_back(Text.substr(Start, End - Start).lower());

   28   StringRef RemappingFilePath = Text.substr(Pos + std::strlen(IWYUPragma));

   58         DB = Arg.substr(strlen("-db="));
   60         Input = Arg.substr(strlen("-input="));

   79              CaseStr.substr(0, WordCompletionPos) ==
   80                  Word.substr(0, WordCompletionPos))
   82           (CaseStr.substr(WordCompletionPos) + " ").str(), CaseStr));

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

   52       Message = Message.substr(0, Message.size() - CheckNameInMessage.size());
  279           Line.substr(BracketIndex, BracketEndIndex - BracketIndex);

   20     GlobList = GlobList.substr(1);
   29   StringRef UntrimmedGlob = GlobList.substr(0, GlobList.find(','));
   31   GlobList = GlobList.substr(UntrimmedGlob.size() + 1);

   62                (llvm::Twine(NewFuncName.substr(2)) + "(" +
   77                (llvm::Twine(NewFuncName.substr(2)) + "(" +

  180          Mock->getName() == Expect->getName().substr(strlen("gmock_"));

   89   const StringRef StrLenBegin = StrLenText.substr(0, StrLenText.find(Arg0Text));
   90   const StringRef StrLenEnd = StrLenText.substr(

  725                                           : "wcs" + CC.Name.substr(3).str());

   53                  Decl->getName().substr(1).str();

  122     Replacement += RHSString.substr(Func->getName().size());

  854     IteratorName = ContainerName.substr(0, Len - 1);
  861     IteratorName = ContainerName.substr(0, Len - 2);

   47     NewName.replace(0, Index - 1, Name.substr(0, Index - 1).lower());
   91   auto Prefix = PropertyName.substr(0, Start);
   96   return RegexExp.match(PropertyName.substr(Start + 1));

   68         OverrideOptions.Checks = Arg.substr(strlen("-checks="));

  304         Substr = Substr.substr(Groups[0].size());
  307         Substr = Substr.substr(Groups[0].size() - Groups[4].size());
  310         Substr = Substr.substr(Groups[0].size() - Groups[6].size());
  342       Fixup += Word.substr(0, 1).upper();
  343       Fixup += Word.substr(1).lower();
  352         Fixup += Word.substr(0, 1).upper();
  353         Fixup += Word.substr(1).lower();
  362       Fixup += Word.substr(0, 1).upper();
  363       Fixup += Word.substr(1).lower();
  371         Fixup += Word.substr(0, 1).upper();
  373         Fixup += Word.substr(0, 1).lower();
  375       Fixup += Word.substr(1).lower();

   65   return HeaderFileExtensions.count(extension.substr(1)) > 0;

  145     EndIfStr = EndIfStr.substr(EndIfStr.find_first_not_of("#endif \t"));

   21       return Str.substr(0, Str.size() - Suffix.size());

   67       return Line.substr(I, Marker.size());
   80   return Code.substr(Rest.size());
  131   StringRef Trailing = firstLine(Code.substr(Cursor));
  139   StringRef NextLine = firstLine(Code.substr(Cursor + Trailing.size() + 1));

   30     R += Input.substr(From, Next - From);
   48     R += Input.substr(From, Next - From);

  258         std::string Spelling = (Code.substr(B, E - B) + "::").str();

  176       RegStream << llvm::Regex::escape(Glob.substr(I, 1));

  174       Code.substr(StartOfLine).take_until([](char C) { return C == '\n'; });
  189   llvm::StringRef Before = Code.substr(0, Offset);
  195   Pos.character = lspLength(Before.substr(StartOfLine));
  210     auto LineSoFar = Code.substr(Offset - ColumnInBytes, ColumnInBytes);
  575   return Buf->getBuffer().substr(BeginOffset, EndOffset - BeginOffset);
  599   llvm::StringRef Before = Code.substr(0, Offset);
  610   return {QName.substr(0, Pos + 2), QName.substr(Pos + 2)};
  610   return {QName.substr(0, Pos + 2), QName.substr(Pos + 2)};

  171   auto SchemeStr = Uri.substr(0, Pos);
  176   Uri = Uri.substr(Pos + 1);
  179     U.Authority = percentDecode(Uri.substr(0, Pos));
  180     Uri = Uri.substr(Pos);

  750             ("#define " + Buffer.substr(StartOffset, EndOffset - StartOffset))

  210       types::lookupTypeForExtension(llvm::sys::path::extension(Path).substr(1));

   54     auto SubPath = Header.substr(It->data() - Header.begin());

 1057     P.Offsets.first = lspLength(llvm::StringRef(Label).substr(0, Range.Begin));
 1058     P.Offsets.second = lspLength(llvm::StringRef(Label).substr(1, Range.End));

  562         AnnotatedCode += Code.substr(NextCodeChar, Offset - NextCodeChar);
  568     AnnotatedCode += Code.substr(NextCodeChar);

   91     Result += Input.substr(NextChar, StartOffset - NextChar);
   93                             Input.substr(StartOffset, EndOffset - StartOffset));
   96   Result += Input.substr(NextChar);

   24     Sym.Name = QName.substr(Pos + 2);
   25     Sym.Scope = QName.substr(0, Pos + 2);
   48     Sym.Name = QName.substr(Pos + 2);
   49     Sym.Scope = QName.substr(0, Pos + 2);
   50     USR += "@N@" + replace(QName.substr(0, Pos), "::", "@N@"); // ns:: -> @N@ns

  144     Cases.push_back((Code.substr(0, Offset) + "^" + Code.substr(Offset)).str());
  144     Cases.push_back((Code.substr(0, Offset) + "^" + Code.substr(Offset)).str());
  149     Cases.push_back((Code.substr(0, Begin) + "[[" +
  150                      Code.substr(Begin, End - Begin) + "]]" + Code.substr(End))
  150                      Code.substr(Begin, End - Begin) + "]]" + Code.substr(End))

  306     HeaderName = HeaderName.substr(PathBuf.size() + 1);

  460     Tmp = Tmp2.substr(2);

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

 6670   return cxstring::createDup(Buffer.substr(LocInfo.second, CXTok.int_data[2]));

   31   return s.startswith("c:") ? s.substr(2) : "";

  174     else if (StringRef(*I).substr(1) == Flag.substr(1))
  174     else if (StringRef(*I).substr(1) == Flag.substr(1))

   84         llvm::sys::path::extension(EntryFile).substr(1))));

   94   StringRef Before = Code.substr(0, Offset);

  152     AttrSpelling = AttrSpelling.substr(2, AttrSpelling.size() - 4);

 1088       Sub->Name = Text.substr(0, NameSize).str();

  192       return OptionName.substr(0, I - OptionName.begin());

  724   Name.substr(0, I).getAsInteger(10, T.ElementBitwidth);
  738     Name.substr(0, I).getAsInteger(10, NumLanes);
  752     Name.substr(0, I).getAsInteger(10, T.NumVectors);

   24   StringRef Archive = Filename.substr(0, Filename.rfind('('));
   25   StringRef Object = Filename.substr(Archive.size() + 1).drop_back();
   38     StringRef ObjData = FatData.substr(It->getOffset(), It->getSize());

  546     SectionName = SectionName.substr(SectionName.find_first_not_of("._"));
 1548   SmallString<40> DIECopy(Data.getData().substr(Offset, NextOffset - Offset));
 2033       StringRef CIEData = FrameData.substr(EntryOffset, InitialLength + 4);
 2084                       FrameData.substr(InputOffset, FDERemainingBytes));

   39     SectionName = SectionName.substr(SectionName.find_first_not_of("._"));
  445       StringRef Input = InputSec.Data.substr(Offset, Length);

  344     ArchName = ("arm" + Arch.substr(5)).str();

  225       mcpu = opt.substr(strlen("mcpu="));
  227       extra_library_path = opt.substr(strlen("extra_library_path="));
  229       triple = opt.substr(strlen("mtriple="));
  231       obj_path = opt.substr(strlen("obj-path="));
  246       thinlto_linked_objects_file = opt.substr(strlen("thinlto-index-only="));
  250       thinlto_prefix_replace = opt.substr(strlen("thinlto-prefix-replace="));
  255           opt.substr(strlen("thinlto-object-suffix-replace="));
  260       cache_dir = opt.substr(strlen("cache-dir="));
  262       cache_policy = opt.substr(strlen("cache-policy="));
  271       if (opt.substr(strlen("lto-partitions="))
  277       sample_profile = opt.substr(strlen("sample-profile="));
  281       cs_profile_path = opt.substr(strlen("cs-profile-path="));
  287       dwo_dir = opt.substr(strlen("dwo_dir="));
  289       RemarksFilename = opt.substr(strlen("opt-remarks-filename="));
  291       RemarksPasses = opt.substr(strlen("opt-remarks-passes="));
  295       RemarksFormat = opt.substr(strlen("opt-remarks-format="));
  297       stats_file = opt.substr(strlen("stats-file="));

  707   return (outFile.substr(0, outFile.rfind('.')) + ".map").str();
  887   StringRef path = arg.substr(1);
  962     binaryExtension = binaryExtension.substr(1); // %_EXT% does not include '.'.
  976       buf.append(altPath.substr(cursor));
  982     buf.append(altPath.substr(cursor, firstMark - cursor));
  983     StringRef var = altPath.substr(firstMark, secondMark - firstMark + 1);
 1385         StringRef optLevel = s.substr(7);
 1389         StringRef jobs = s.substr(11);
 1394         StringRef n = s.substr(17);

  257   arg = arg.substr(strlen("embed"));
  262   arg = arg.substr(strlen(",id="));
  279       arg = arg.substr(strlen("level="));
  284       arg = arg.substr(strlen("uiaccess="));
  572       if (tok.substr(1).getAsInteger(0, ord))
  596   return sym.startswith("_") ? sym.substr(1) : sym;
  605   sym = sym.substr(0, sym.find('@', 1));
  613   sym = sym.substr(1);
  870       exports.push_back(tok.substr(strlen("/export:")));

  825     return s.substr(1);
  855     extName = extName.substr(0, extName.find('@'));

  108   libName = libName.substr(0, libName.rfind('.'));
  142   libName = libName.substr(0, libName.rfind('.'));

  378       Symbol *imp = find(name.substr(strlen("__imp_")));
  427       Symbol *imp = find(name.substr(strlen("__imp_")));
  772   if (Symbol *s = findByPrefix("@" + name.substr(1) + "@"))
  775   if (Symbol *s = findByPrefix(name.substr(1) + "@@"))
  778   return findByPrefix("?" + name.substr(1) + "@@Y");

  639   return s.substr(0, s.find('.', 1));

   38     res = root.substr(2);

   55     StringRef b = s.substr(0, 2);
   56     s = s.substr(2);

  688     return {BuildIdKind::Hexstring, parseHex(s.substr(2))};
 1330       ret.insert(s.substr(0, pos));
 1331       s = s.substr(pos + 1);

  210     path::append(s, config->sysroot, path1.substr(1), path2);
  242     return findFromSearchPaths(name.substr(1));

  233     name = saver.save("." + name.substr(2));
 1238     pieces.emplace_back(off, xxHash64(s.substr(0, size)), !isAlloc);
 1239     s = s.substr(size);

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

  437   x = x.substr(6);
  438   y = y.substr(6);
  459   if (!to_integer(s.substr(pos + 1), v, 10))

  730     std::string newName = (name.substr(0, i) + "0" + name.substr(i)).str();
  730     std::string newName = (name.substr(0, i) + "0" + name.substr(i)).str();
  757     newName = (name.substr(0, i) + name.substr(i + 1)).str();
  757     newName = (name.substr(0, i) + name.substr(i + 1)).str();

   49     s = s.substr(pos + 1);
   50   return s.substr(0, s.find_first_of("\r\n"));
   57   return s.substr(0, tok.data() - s.data()).count('\n') + 1;
  105         size_t lineno = begin.substr(0, s.data() - begin.data()).count('\n');
  111       s = s.substr(e + 1);
  119       vec.push_back(s.substr(0, 2));
  120       s = s.substr(2);
  134     vec.push_back(s.substr(0, pos));
  135     s = s.substr(pos);
  150       s = s.substr(e + 2);
  157       s = s.substr(e + 1);
  192       ret.push_back(s.substr(0, e));
  196     if (s.substr(e).startswith("!=") || s.substr(e).startswith("==") ||
  196     if (s.substr(e).startswith("!=") || s.substr(e).startswith("==") ||
  197         s.substr(e).startswith(">=") || s.substr(e).startswith("<=") ||
  197         s.substr(e).startswith(">=") || s.substr(e).startswith("<=") ||
  198         s.substr(e).startswith("<<") || s.substr(e).startswith(">>")) {
  198         s.substr(e).startswith("<<") || s.substr(e).startswith(">>")) {
  199       ret.push_back(s.substr(e, 2));
  200       s = s.substr(e + 2);
  202       ret.push_back(s.substr(e, 1));
  203       s = s.substr(e + 1);

  136     return s.substr(1, s.size() - 2);
  292       driver->addFile(s.substr(1), /*withLOption=*/false);
  294       driver->addFile(saver.save(config->sysroot + "/" + s.substr(1)),
  297     driver->addLibrary(s.substr(2));
 1061     if (!to_integer(tok.substr(2), val, 16))
 1306     phdrs.push_back((tok.size() == 1) ? next() : tok.substr(1));

  210   StringRef verstr = s.substr(pos + 1);
  225     verstr = verstr.substr(1);

  126       if (Optional<std::string> s = findFile(dir, name.substr(1)))
  205       add("-entry:" + s.substr(1));

  837       abi2className += sym.substr(17);
  840       abi2metaclassName += sym.substr(17);

 1272       if (partialStr.substr(0, n).equals(edgeStr.substr(0, n))) {
 1272       if (partialStr.substr(0, n).equals(edgeStr.substr(0, n))) {
 1279         StringRef abEdgeStr = edgeStr.substr(0,n).copy(allocator);
 1280         StringRef bcEdgeStr = edgeStr.substr(n).copy(allocator);

  763           StringRef name = stabSym.name.substr(0, colonIdx);

  161         llvm::StringRef bp_id_str = tmp_str.substr(0, pos);

  564       raw_command_string = raw_command_string.substr(alias_command.size());
  567         raw_command_string = raw_command_string.substr(pos);
 1117       std::string regex(regex_sed.substr(first_separator_char_pos + 1,
 1120       std::string subst(regex_sed.substr(second_separator_char_pos + 1,

 1881   llvm::StringRef key = format_str.substr(0, sep_pos);
 1890             format_str.substr(sep_pos + (entry_def->keep_separator ? 0 : 1));
 2004       parent_entry.AppendText(format.substr(0, non_special_chars));
 2291           variable_name = format_str.substr(0, percent_pos);
 2293             format_str.substr(percent_pos + 1, paren_pos - (percent_pos + 1));
 2296       variable_name = format_str.substr(0, paren_pos);
 2299     format_str = format_str.substr(paren_pos + 1);
 2375   llvm::StringRef partial_variable(str.substr(dollar_pos + 2));

   45   s << line.substr(0, column);
   47   options.selected.Apply(s, line.substr(column, 1));
   49   s << line.substr(column + 1U);

 2381         llvm::StringRef next_separator = temp_expression.substr(next_sep_pos);
 2540                 temp_expression.substr(close_bracket_position + 1); // skip ]
 2594                   temp_expression.substr(close_bracket_position + 1); // skip ]
 2623                 temp_expression.substr(close_bracket_position + 1); // skip ]
 2658                 temp_expression.substr(close_bracket_position + 1); // skip ]

  522       llvm::StringRef dwarf_name(name.substr(name_idx));

   52     release = release.substr(0, release.find_first_not_of("0123456789."));

 1242       std::string cmd_word = command_string.substr(start, end - start);
 1275   command_string = command_string.substr(end);
 2503     llvm::StringRef this_line = help_text.substr(0, line_width_max);
 2514     this_line = this_line.substr(0, std::min(first_newline, last_space));

  137           key = key.substr(1, key.size() - 2);
  142               key = key.substr(1, key.size() - 2);

   91         value_str = trimmed_value_str.substr(1, trimmed_len - 2);

  686     StringRef existing_command = existing.substr(0, pos);

  151     m_arguments = full.substr(arg_start, arg_end - arg_start + 1);
  153       m_qualifiers = full.substr(arg_end + 1).ltrim();
  161       m_basename = full.substr(0, basename_end);
  164         m_context = full.substr(context_start, context_end - 1 - context_start);
  166       m_basename = full.substr(basename_begin, basename_end - basename_begin);

  206     llvm::StringRef tok_str = line.substr(start, token.getLength());

 2037           name_strref.substr(ivar_prefix.size());
 2069           name_strref.substr(class_prefix.size());

 1532   return symbol_name.substr(0, pos);
 2218     llvm::StringRef symbol_bare = symbol_ref.substr(0, version_pos);
 2224       llvm::StringRef suffix = symbol_ref.substr(version_pos);

   96           llvm::StringRef(response.GetStringRef()).substr(1));

  487         llvm::StringRef(m_bytes).substr(1, hash_mark_idx - 1));

  757       error_str = response.GetStringRef().substr(1);

  145   llvm::StringRef piece = name.substr(0, dot_pos);
  154   return result.ResolveName(name.substr(dot_pos + 1));
  177   PythonObject parent = ResolveName(name.substr(0, dot_pos));
  182   return parent.ResolveName(name.substr(dot_pos + 1));

  674     auto action = rule_text.substr(0, action_end_pos);
  693     auto attribute = rule_text.substr(action_end_pos + 1,
  705     auto operation = rule_text.substr(
  711                                rule_text.substr(operation_end_pos + 1), error);

  580   llvm::StringRef archive = path_with_object.substr(0, path_with_object.rfind('('));
  583   llvm::StringRef object = path_with_object.substr(archive.size() + 1).drop_back();

  625         PrivateAutoComplete(frame, partial_path.substr(1), "*", compiler_type,
  632         PrivateAutoComplete(frame, partial_path.substr(1), std::string("&"),
  645             PrivateAutoComplete(frame, partial_path.substr(2),
  669             PrivateAutoComplete(frame, partial_path.substr(1),
  698         remaining_partial_path = partial_path.substr(pos);

  541   ConstString name_const_string(var_expr.substr(0, separator_idx));
  666       ConstString child_name(var_expr.substr(0, var_expr.find_first_of(".-[")));

  809   llvm::StringRef cpu_str = triple_str.substr(0, pos);
  810   llvm::StringRef remainder = triple_str.substr(pos + 1);

   31     result += quoted.substr(0, regular);
   32     quoted = quoted.substr(regular);
   99     arg += command.substr(0, regular);
  100     command = command.substr(regular);
  145         arg += command.substr(0, quoted);
  146         command = command.substr(quoted);

   24   llvm::StringRef partial_command(command_line.substr(0, raw_cursor_pos));

  337       absolute_path.substr(1, 2) == R"(:\)")

  347   view = view.substr(m_index);

   26         auto err_string = packet_ref.substr(4);

   30   tmp_scheme = uri.substr(0, pos);
   34     tmp_path = uri.substr(path_pos);
   38   auto host_port = uri.substr(
   49     tmp_hostname = host_port.substr(1, pos - 1);

  353       OS << Cmd.substr(0, pos);
  354       Cmd = Cmd.substr(pos);

  935                                      {expression.substr(1)});

  245     DyLibComponents.push_back(DyLibComponentsStr.substr(Offset, NextOffset-Offset));

   67       OS << Str.substr(0, Width);
   70       OS << Str.substr(0, Width - 3) << "...";

  510     Snippets.push_back(Line.substr(Start, Len));

  119         << Line.substr(Col - 1, End - Col);
  135       << Line.substr(Col - 1, Line.size() - Col + 1);
  168   Str = Str.substr(0, std::min(Str.size(), (size_t)LineNumberColumnWidth));

  214     StringRef SymContents = SecContents.substr(SymOffset, SymSize);
  329             SymContents.substr(SymOffI, BytesInAddress).data();

  174     if (percent > 0) out << format.substr(0, percent);
  183     format = format.substr(percent+2);

   44   if (Name.startswith("@")) Name = Name.substr(1);

  213   return Section.substr(Off->Offset, Off->Length);
  238     Out.EmitBytes(Types.substr(
  275       Out.EmitBytes(Types.substr(PrevOffset, C.Length));
  387   Name = Name.substr(2); // Drop ".z"
  422   Name = Name.substr(Name.find_first_not_of("._"));

   55   return Str.substr(Offset, StrLen);

  646     StringRef Name = AbsDefStmt.substr(0, EqIdx).trim();
  647     StringRef AddrStr = AbsDefStmt.substr(EqIdx + 1).trim();

   87       Str = Str.substr(Pos);
   93         Str = Str.substr(Str.find_first_of('\n'));
  111     StringRef Value = Str.substr(0, Next);
  119       Str = Str.substr(Str.find('\n'));
  127     Str = Str.substr(Next);

  690     Name = Name.substr(1);

  283   size_t DataLen = checkedGetHex<uint8_t>(Line.substr(1, 2));
  289   Rec.Addr = checkedGetHex<uint16_t>(Line.substr(3, 4));
  290   Rec.Type = checkedGetHex<uint8_t>(Line.substr(7, 2));
  291   Rec.HexData = Line.substr(9, DataLen * 2);

  243       MachOObj.getData().substr(LDC.dataoff, LDC.datasize));
  254       MachOObj.getData().substr(LDC.dataoff, LDC.datasize));

  212     std::string ThumbName = (Twine("thumb") + TT.getArchName().substr(3)).str();
 1160   const char *loh = O->getData().substr(LohLC.dataoff, 1).data();
 7172     FormattedOS << CommentBegin << ' ' << Comments.substr(0, Position);
 7174     Comments = Comments.substr(Position + 1);
 8001   StringRef PageEncodings = PageData.substr(EncodingsStart, StringRef::npos);
 8193       printRegularSecondLevelUnwindPage(Contents.substr(Pos, 4096));
 8195       printCompressedSecondLevelUnwindPage(Contents.substr(Pos, 4096),

  719   *FS << Buffer.substr(BITMAPFILEHEADER_size);

  990     StringRef Contents = Data.substr(0, SubSectionSize);
 1095             StringRef Stmt = FrameFunc.substr(0, EqOrEnd);

  602     std::string SectionIDStr = Mapping.substr(0, EqualsIdx);
  615     std::string NewAddrStr = Mapping.substr(EqualsIdx + 1);
  888         Dyld.getSectionContent(SI.SectionID).substr(SI.Offset));

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

  745       OS << llvm::StringRef(Str).substr(0, OpenPos + 1) << "\n ";
  749     OS << llvm::StringRef(Str).substr(OpenPos + 1, ClosePos - OpenPos - 2);

  139   EXPECT_EQ("lo", Str.substr(3));
  140   EXPECT_EQ("", Str.substr(100));
  141   EXPECT_EQ("hello", Str.substr(0, 100));
  142   EXPECT_EQ("o", Str.substr(4, 10));

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

   22   Struct->setName(Struct->getName().substr(0, 3));

  179   EXPECT_EQ(VarName, OrigVarName.substr(1));
  186   EXPECT_EQ(VarName, OrigVarName.substr(1));

  301   EXPECT_TRUE(BufData.substr(0x0000,8).equals("12345678"));
  302   EXPECT_TRUE(BufData.substr(0x0FF8,8).equals("12345678"));
  303   EXPECT_TRUE(BufData.substr(0x1000,8).equals("abcdefgh"));
  304   EXPECT_TRUE(BufData.substr(0x2FF8,8).equals("abcdefgh"));
  305   EXPECT_TRUE(BufData.substr(0x3000,8).equals("ABCDEFGH"));
  306   EXPECT_TRUE(BufData.substr(0x3FF8,8).equals("ABCDEFGH"));
  316   EXPECT_TRUE(BufData2.substr(0x0000,8).equals("12345678"));
  317   EXPECT_TRUE(BufData2.substr(0x17F8,8).equals("12345678"));
  318   EXPECT_TRUE(BufData2.substr(0x1800,8).equals("abcdefgh"));
  319   EXPECT_TRUE(BufData2.substr(0x2FF8,8).equals("abcdefgh"));
  352     EXPECT_EQ("0123456789abcdef", MB.getBuffer().substr(i, 0x10)) << "i: " << i;

  197   ParsedString = ParsedString.substr(1, ParsedString.size() - 2);

   39   return OS.str().substr(StartIndex);

  903   StringRef RegName = Tok.substr(RegisterPrefix.size());
 1048     addAsmOperand(String.substr(Prev), IsIsolatedToken);
 1600         OperandName = Token.substr(2, Token.size() - 3);
 1602         OperandName = Token.substr(1);

  965             Cond = ("!STI.getFeatureBits()[" + Namespace + "::" + Op.substr(1) +

  268   std::string LHSOpName = StringRef(CStr).substr(start, wpos - start);
  276   std::string RHSOpName = StringRef(CStr).substr(wpos);
  501     Cur = Cur.substr(VariantsEnd + 1);

  105       StringRef Prefix = Original.substr(0, FirstMeta);
  106       StringRef PatStr = Original.substr(FirstMeta);
  123             (!Regexpr || Regexpr->match(InstName.substr(Prefix.size())))) {
  150         if (!Regexpr || Regexpr->match(InstName.substr(Prefix.size()))) {

   32     OS << Current.substr(0, Pos);
   33     Current = Current.substr(Pos);

  629                                  "::" + Op.substr(1) + "]")

  135         Cond = Cond.substr(1);

   75     Ret += StringRef(Tag).substr(18);