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

References

79697     retval = result.Str().GetString().str();
80379     output = result.Str().GetString().str();
80407     output = result.Str().GetString().str();
80435     output = result.Str().GetString().str();
80463     output = result.Str().GetString().str();
80491     output = result.Str().GetString().str();

  104       value = std::move(y);
  129         value = std::move(other.value);

  239     entryName = getEntry()->getName();
  247       exitName = getExit()->getName();

  131       CustomNames[F] = Name;

   53     S.Value = Scalar.str();

  438       VReg2Name[Reg] = Name.str();

   72     this->CPU = std::move(CPU);

 1069     Tag = OBU.getTagName();

  274   void setModuleIdentifier(StringRef ID) { ModuleID = ID; }
  277   void setSourceFileName(StringRef Name) { SourceFileName = Name; }
  284   void setTargetTriple(StringRef T) { TargetTriple = T; }
  289     GlobalScopeAsm = Asm;

   67       Msg = EIB.message();

   93   void setCpu(StringRef MCpu) { this->MCpu = MCpu; }
   94   void setAttr(StringRef MAttr) { this->MAttr = MAttr; }

  133   void setCacheDir(std::string Path) { CacheOptions.Path = std::move(Path); }
  189   void setSaveTempsDir(std::string Path) { SaveTempsDir = std::move(Path); }
  196     SavedObjectsDirectoryPath = std::move(Path);
  200   void setCpu(std::string Cpu) { TMBuilder.MCpu = std::move(Cpu); }
  203   void setAttr(std::string MAttr) { TMBuilder.MAttr = std::move(MAttr); }

  544     void setMainFileName(StringRef S) { MainFileName = S; }

  255     CompilationDir = Directory;
  256     RootFile.Name = FileName;
  328     Header.CompilationDir = Directory;
  329     Header.RootFile.Name = FileName;

   45   void setConstraint(StringRef C) { Constraint = C.str(); }

  109   GUIDBuf = std::to_string(Function::getGUID(Name));

 1076     Value = Arg.str();
 1286     DataType::operator=(V);

 1248     FileName = F.str();
 1301   void setBanner(std::string Banner) { this->Banner = std::move(Banner); }

  335   N = N.substr(0, std::min<std::size_t>(N.size(), 140));
  337     Filename = createGraphFilename(N, FD);

  311       V = fixUTF8(std::move(V));
  496       *Owned = fixUTF8(std::move(*Owned));
  563     Out = *S;

   92     ErrorDiagMsg = ErrorMsg.str();

  130     static auto get(F*) -> decltype(std::declval<F &>() = std::declval<F &&>(), std::true_type{});

   48     AggregateString = Str.str();

  161   void setPath(StringRef Path_) { Path = Path_; }
  220   void setInstallName(StringRef InstallName_) { InstallName = InstallName_; }

 5543     ID.StrVal = F.getName();

   46       Message = EIB.message();
   92       Message = EIB.message();

  862   this->ProducerIdentification = ProducerIdentification;
 5682   Wpd.SingleImplName = {Strtab.data() + Record[Slot],

 3135       GroupName = F.getComdat()->getName();

  122         TypeName = TypeIndex::simpleTypeName(TI);
  124         TypeName = TypeTable.getTypeName(TI);
  186     Filepath = Dir;
  198     Filepath = Filename;
  200     Filepath = (Dir + "\\" + Filename).str();
 1005     FuncName = getFullyQualifiedName(SP->getScope(), SP->getName());
 1009     FuncName = GlobalValue::dropLLVMManglingEscape(GV->getName());

  155       S->Name = Name;

   79   StringValueStorage = std::move(StrVal);

 3040   Result = Token.stringValue();

  393       YamlObject.Name.Value =

  267     Name = (getParent()->getName() + ":").str();

   26   Key = MKey;

  801     BlockName =

  213   NodeGraphAttrs[N] = std::string("color=") + Color;

 1646         COMDATSymName = "__real@" + scalarConstantToHexString(C);
 1651         COMDATSymName = "__real@" + scalarConstantToHexString(C);
 1657         COMDATSymName = "__xmm@" + scalarConstantToHexString(C);
 1662         COMDATSymName = "__ymm@" + scalarConstantToHexString(C);

  535       Banner = std::string("After ") + std::string(P->getPassName());

 1052     Result = FileName;
 1076   Result = FilePath.str();

  294         File = '"' + File + '"';

   54   ObjFileName = Name;

   98   NamedStreamData[*ExpectedIndex] = Data;

   36   Result.FunctionName = getFunctionName(Address.Address, Specifier.FNKind);
   59     Result.FileName = SourceFile->getFileName();

   51           EnvWorkingDir = Env->getValue();
   55           EnvSrc = Env->getValue();

   77     Filename = llvm::sys::path::filename(Filename);

  236   Name = SymbolIterator->second.str();

   57     LineInfo.FunctionName = DemangleName(LineInfo.FunctionName, Info);
  111       Frame->FunctionName = DemangleName(Frame->FunctionName, Info);
  139     Global.Name = DemangleName(Global.Name, Info);
  208     Result = DebugPath.str();
  215     Result = DebugPath.str();
  237     Result = DebugPath.str();
  438       BinaryName = ModuleName.substr(0, ColonPos);

  226     V = Name;
  272     V = Name;

   40       Msg = EIB.message();

  133     ErrorStr = toString(std::move(Err));

  149       *ErrMsg = ec.message();
  159       *ErrMsg = ec.message();

   83     FeaturesStr = Features.getString();

 1480   TargetDepAttrs[A] = V;

  232   StringRepresentation = Desc;

  175     Val = GlobalValue::dropLLVMManglingEscape(V->getName());
  218     Val = (Loc->getFilename() + ":" + Twine(Loc.getLine()) + ":" +

  287   It->second = std::move(GCName);

  514       GlobalRes.IRName = Sym.getIRName();
  522       GlobalRes.IRName = Sym.getIRName();

   84         PathPrefix = M.getModuleIdentifier() + ".";
  114     Path = OutputFileName + "index.dot";
  330     TM->Options.MCOptions.SplitDwarfFile = DwoFile.str().str();

  344     TripleStr = sys::getDefaultTargetTriple();
  361   FeatureStr = Features.getString();

  203     TripleStr = sys::getDefaultTargetTriple();
  254           name = (".objc_class_name_" + ca->getAsCString()).str();
  664   outErr = std::string(path) +

  927           ProducedBinaryFiles[count] =
 1068               ProducedBinaryFiles[count] = writeGeneratedObject(
 1125         ProducedBinaryFiles[count] = writeGeneratedObject(

  203     this->HistoryPath = getDefaultHistoryPath(ProgName);

   70     MainFileName =

  631   File.Name = FileName;

 3622   Checksum = fromHex(Checksum);

  232     E.Name = Tok.Value;
  239       E.Name = Tok.Value;
  288         E.AliasTarget = Tok.Value;
  318       *Out = Tok.Value;

  184       Name = C->getName();

  735     Feature.Name = readString(Ctx);

  885       UnknownFlagsHolder = std::to_string(*Original);

  289       NormalizedName = LHS;
  315         NearestString = (Candidate + RHS).str();

  688     CoveragePath =

  324     Parser->ExternalFilePrependPath = *ExternalFilePrependPath;

  367     Description = std::string(Strings[Value]);
  369     Description = std::string("8-byte alignment, ") + utostr(1ULL << Value)
  388     Description = std::string(Strings[Value]);
  390     Description = std::string("8-byte stack alignment, ") +

  595           NearestString = Name;
  597           NearestString = (Twine(Name) + "=" + RHS).str();
 1274   ProgramName = sys::path::filename(StringRef(argv[0]));

   54     SymlinkMap[Directory] = RealPath.str();

  188       *Error = EC.message();
  196       *Error = EC.message();

  269       StartArg =

 1094   this->Path = PathStr.str();
 1125   TmpName = std::move(Other.TmpName);

  193         *Error = ("invalid backreference string '" + Twine(Ref) + "'").str();

   50     IncludedFile =
  193     LineStr = std::string(LineStart, LineEnd);

   48   Regexp = (Twine("^(") + StringRef(Regexp) + ")$").str();
  104       Error = (Twine("can't open file '") + Path + "': " + EC.message()).str();
  109       Error = (Twine("error parsing file '") + Path + "': " + ParseError).str();
  143         Error = (Twine("malformed section header on line ") + Twine(LineNo) +
  153         Error =
  167       Error = (Twine("malformed line ") + Twine(LineNo) + ": '" +
  181         Error = (Twine("malformed section ") + Section + ": '" + REError).str();
  192       Error = (Twine("malformed regex in line ") + Twine(LineNo) + ": '" +

   36       Error = "error: invalid target '" + ArchName + "'.\n";
   52       Error = ": error: unable to get target for '"
   74     Error = "No available targets are compatible with triple \"" + TT + "\"";
   80     Error = std::string("Cannot choose between targets \"") + I->Name +

  945       NormalizedEnvironment = Twine("android", AndroidVersion).str();

  104     File = *Path;
  182       *ErrMsg = std::string("Executable \"") + Program.str() +
  216           RedirectsStorage[I] = *Redirects[I];
  408         *ErrMsg = llvm::sys::StrError(ENOENT);

   69   *ErrMsg = prefix + ": " + llvm::sys::StrError(errnum);

  963     WorkingDirectory = Path.str();
 1067   WorkingDirectory = AbsolutePath.str();
 1103   ExternalContentsPrefixDir = PrefixDir.str();
 1337           Name = Path.str();
 1339           Name = Value;
 1399         ExternalContentsPath = FullPath.str();

 1637   T.Value = Str.str().str();
 1813       Ret = Doc->getTagMap().find("!")->second;
 1817       Ret = Doc->getTagMap().find("!!")->second;
 1825         Ret = It->second;

  349   Tag = CurrentNode->_node->getVerbatimTag();
  886   Val = Scalar.str();

  807   case CAST: Result = "!cast<" + getType()->getAsString() + ">"; break;
 1152         Val = MHSv->getName();
 2090           Type =

  194       Format = SI->getValue();

  214       InitType = (Twine("' of type bit initializer with length ") +
  217       InitType = (Twine("' of type '") + TI->getType()->getAsString()).str();
 2486       Type = (Twine("' of type '") + TI->getType()->getAsString()).str();

  805       Name = std::string(PRCTX->Name);
  817       Name = std::string(IC->Name);
  829       Name = std::string(DC->Name);
  840       Name = std::string(AT->Name);
  852     Name = std::string(TLBI->Name);

  558         Comment = std::string(DisasmLineMaxLen - DisasmLines[i].size(), ' ');

  291     Attrs.mVecTypeHint = getTypeName(
  296     Attrs.mRuntimeHandle =
  370   Arg.mName = Name;
  371   Arg.mTypeName = TypeName;
  477   Kernel.mName = Func.getName();
  478   Kernel.mSymbolName = (Twine(Func.getName()) + Twine("@kd")).str();

  615   Name = Name + "_" + std::to_string(Size);

  344   void setName(StringRef N) { Name = N; }
  441     Name = FName;

 6462     Token = getLexer().getTok().getString();

  607       ArchFS = (Twine(ArchFS) + "," + FS).str();
  609       ArchFS = FS;

15572     AsmStr = AsmPieces[0];

  181       ArchFS = (Twine(ArchFS) + "," + FS).str();
  183       ArchFS = FS;

  347       Item->StringValue = Value;
  369       Item->StringValue = StringValue;

  141     ARMArchFeature = (ARMArchFeature + "+" + ARM::getArchName(ArchID)).str();
  169       ArchFS = (Twine(ArchFS) + "," + FS).str();
  171       ArchFS = FS;

  734       TypeName = Ty->getName();
  785         TypeName = CTy->getName();
  832   AccessKey = TypeName + ":" + std::to_string(InfoKind) + ":" +

  667     FileName = File->getDirectory().str() + "/" + File->getFilename().str();
  669     FileName = File->getFilename();

 1464           myCharStr = StringRef(".gnu.linkonce.l4.CONST_00000000")
 1470           myCharStr = StringRef(".gnu.linkonce.l8.CONST_0000000000000000")

  192        ImmString = utohexstr(Value);
  196        ImmString = utohexstr(static_cast<uint32_t>(Value));

  328   Result.first = Hexagon_MC::selectHexagonCPU(CPU);
  329   Result.second = selectHexagonFS(Result.first, FS);

  364     MFName = FunctionName;

   36   TargetName = CPU.empty() ? "sm_20" : CPU;

 1563     NewOpcode = Name;
 1568     NewOpcode = Name;

  165       FullFS = "+64bit," + FullFS;
  172       FullFS = "+crbits," + FullFS;
  179       FullFS = "+invariant-function-descriptors," + FullFS;

 3312         newConstraint = "{f" + utostr(intVal) + "}";
 3314         newConstraint = "{d" + utostr(intVal / 2) + "}";
 3316         newConstraint = "{q" + utostr(intVal / 4) + "}";

  182     FU = FU.substr(FU.find("_") + 1);

  295       ArchFS = (Twine(ArchFS) + "," + FS).str();
  297       ArchFS = FS;

  239       FullFS = "+sse2," + FullFS;
  246         FullFS = "+64bit," + FullFS;
  255       FullFS = "+sahf," + FullFS;

   66     Iter->second = Parent;
   80     Iter->second = UUID;

 1104   File->ErrorMessage = ("malformed file\n" + Message).str();
 1110   Ctx.Path = InputBuffer.getBufferIdentifier();
 1130   Ctx.Path = File.getPath();

  215   Value.second = UUID;

  173       E.Name = E.Name.substr(0, E.Name.find('@', 1));

  248         LibMachineSource =
  314     LibMachineSource =

  729       WPDRes->second.SingleImplName = ModuleSummaryIndex::getGlobalNameForLocal(
  967   Res->SingleImplName = TheFn->getName();
 1012       Res->SingleImplName = ModuleSummaryIndex::getGlobalNameForLocal(
 1016       Res->SingleImplName = TheFn.name();
 1019     Res->SingleImplName = TheFn.name();

  801     FunctionName = "__msan_maybe_store_origin_" + itostr(AccessSize);

  587     FuncName = getPGOFuncName(F);
  681   FuncName = Twine(FuncName + "." + Twine(FunctionHash)).str();

  365   CurModuleUniqueId = getUniqueModuleId(CurModule);

  139   void SetNamePrefix(const Twine &P) { Prefix = P.str(); }

   58     TheHash = Result.str();

   59   ProtoName = Name;

  354       Source = Value->getValue(ValueStorage);
  360       Target = Value->getValue(ValueStorage);
  362       Transform = Value->getValue(ValueStorage);
  366       Undecorated = Value->getValue(ValueStorage);
  423       Source = Value->getValue(ValueStorage);
  429       Target = Value->getValue(ValueStorage);
  431       Transform = Value->getValue(ValueStorage);
  486       Source = Value->getValue(ValueStorage);
  492       Target = Value->getValue(ValueStorage);
  494       Transform = Value->getValue(ValueStorage);

  401   void setName(const Twine &newName) { Name = newName.str(); }
 1223   void setName(const Twine &newName) { Name = newName.str(); }
 1279   void bumpIndent(int b) { Indent = std::string((Depth += b) * TabWidth, ' '); }

   47     CurrentRecord.Data = R.data();
   62     CurrentRecord.Data = R.data();
   78     CurrentRecord.Data = R.data();

  314     BitcodeFile = UniqueFilename.str();
  329     OutputFile = OutputPrefix + "-execution-output-%%%%%%%";
  339   OutputFile = UniqueFile.str();

  144   OutputFilename = UniqueFilename.str();

  225     Message = "Found lli: " + *LLIPath + "\n";
  228     Message = LLIPath.getError().message() + "\n";
  390     Message = std::string("Cannot find '") + Command +
  396   Message = "Found command in: " + CmdPath + "\n";
  445   OutputAsmFile = UniqueFile.str();
  515     Message = LLCPath.getError().message() + "\n";
  524   Message = "Found llc: " + *LLCPath + "\n";
  596     Message = "Found lli: " + *LLIPath + "\n";
  599     Message = LLIPath.getError().message() + "\n";
  775   OutputFile = UniqueFilename.str();
  847     Message = "Cannot find `" + CCBinary + "' in PATH: " +
  856       Message = "Cannot find `" + RemoteClient + "' in PATH: " +
  863   Message = "Found CC: " + *CCPath + "\n";

  199     Clang.getHeaderSearchOpts().ResourceDir =

  564   void setCallStackMessage(StringRef st) { CallStackMessage = st; }

   98     Hint.CodeToInsert = Code;
  133     Hint.CodeToInsert = Code;
 1148     DiagObj->DiagArgumentsStr[NumArgs++] = S;
 1170   void addFlagValue(StringRef V) const { DiagObj->FlagValue = V; }

  289     DiagStorage->DiagArgumentsStr[DiagStorage->NumDiagArgs++] = V;

  316   void setTitle(std::string Value) { DriverTitle = std::move(Value); }
  332     InstalledDir = Value;

   41       PSL.FileName = LineSplit.first;

   69     DwarfDebugFlags = Value;

   47   void setPrefix(std::string Value) { Prefix = std::move(Value); }

  305     (*IncludeAliases)[Source] = Dest;
  324     ModuleCachePath = CachePath;

 1157   void setPredefines(StringRef P) { Predefines = P; }

 9203     CurrOpenCLExtension = Ext;

   59     OverlayFiles[FilePath] = Content;

   51   AtomicChange &operator=(AtomicChange &&) = default;
   73   void setError(llvm::StringRef Error) { this->Error = Error; }

  536     PropertyNameString = PropertyNameStringRef;
  997       ClassString  = IDecl->getName();
 1345     MethodName = STRefMethodName.substr(len);
 2156         Entry.Text = Val;

  295         S = "'" + S + "' (aka '" + akaStr + "')";
  315   S = "'" + S + "'";
 1708       FromName = FromTD->getQualifiedNameAsString();
 1709       ToName = ToTD->getQualifiedNameAsString();

  590         ResultMessage = Deprecated->getMessage();
  598         *Message = Unavailable->getMessage();

  638     Proto = GuideDecl->getDeducedTemplate()->getDeclName().getAsString();
  647     Proto = '(' + Proto + ')';

  845       Proto = "auto " + Proto;

 2170       IndicesMap[VTableIndex] = MethodName + " [complete]";
 2171       IndicesMap[VTableIndex + 1] = MethodName + " [deleting]";
 3618       IndicesMap[I.second] = MethodName + " [scalar deleting]";

  153   DelayedDiagArg1 = Arg1.str();
  154   DelayedDiagArg2 = Arg2.str();

  453   UFE->RealPathName = AbsPath.str();

  110   CPU = llvm::ARM::getDefaultCPU(ArchName);
  366     ArchFeature = ("+" + llvm::ARM::getArchName(CPUArch)).str();
 1022     R = std::string("^") + std::string(Constraint, 2);
 1026     R = std::string("r");

   87       HVXVersion = F.substr(std::string("+hvxv").length());

  271         R = std::string("^") + std::string(Constraint, 2);

  298       R = std::string("^") + std::string(Constraint, 2);

  725       PMBuilder.PGOInstrGen = DefaultProfileGenName;
 1441   Conf.SampleProfile = std::move(SampleProfile);
 1452   Conf.ProfileRemapping = std::move(ProfileRemapping);

 1144       LibCallName = std::string("__opencl") +

  203     descName = getBlockDescriptorName(blockInfo, CGM);
 1886       FuncStr = CodeGenFunction::getNonTrivialDestructorStr(
 1891       FuncStr = CodeGenFunction::getNonTrivialCopyConstructorStr(

  214     DeviceSideName = Out.str();
  216     DeviceSideName = ND->getIdentifier()->getName();

  542     MainFileDir = MainFile->getDir()->getName();
  546       MainFileName = llvm::sys::path::remove_leading_dotslash(MainFileDirSS);
  556       MainFileName = CGM.getModule().getName().str();

  206     ContextName = CGM.getMangledName(FD);
  208     ContextName = CGM.getBlockMangledName(GlobalDecl(), BD);
  210     ContextName = OMD->getSelector().getAsString();
  233     Name = getMangledName(&D);
  235     Name = getStaticDeclName(*this, D);
 1109       Name = getMangledName(&D).str() + ".const";
 1111       Name = ("__const." + FunctionName(DC) + "." + D.getName()).str();

  565       PrioritySuffix = std::string(6-PrioritySuffix.size(), '0')+PrioritySuffix;

 3382     SuperClassName = SuperClassDecl->getNameAsString();

 2021     OutputConstraint = SimplifyConstraint(OutputConstraint.c_str() + 1,
 2027     OutputConstraint = AddVariableConstraints(OutputConstraint, *OutExpr,
 2151     InputConstraint = SimplifyConstraint(InputConstraint.c_str(), getTarget(),
 2154     InputConstraint = AddVariableConstraints(

 2166             FirstMissing = Feature.str();

 1099       MangledName = getCUDARuntime().getDeviceStubName(MangledName);
 1350           typeName = ty.getCanonicalType()
 1355           typeName = ty.getUnqualifiedType().getAsString(Policy);
 1364           baseTypeName = ty.getCanonicalType()
 1370           baseTypeName =

   35   FuncName = llvm::getPGOFuncName(

 1360       FilenameStrs[I] = normalizeFilename(Entry.first->getName());
 1384     FilenameStrs[I] = normalizeFilename(Entry.first->getName());

 1198   AsmString = std::move(OS.str());
 8009         AttrVal = AttrVal + "," + llvm::utostr(Max);
 8097       Name = Twine(Twine(Name) + Twine("-")).str();
 8099     Name = Twine(Twine(Name) + Twine("one-as")).str();
 8827   E.Str = Str.str();

  152       Result[LookupName] = FilePath.str().str();

  139   Name = llvm::sys::path::filename(ClangExecutable);
  140   Dir = llvm::sys::path::parent_path(ClangExecutable);
  151   ResourceDir = GetResourcesPath(ClangExecutable, CLANG_RESOURCE_DIR);
  764   ConfigFile = CfgFileName.str();
  800           SystemConfigDir = std::string(CfgDir.begin(), CfgDir.end());
  811           UserConfigDir = std::string(CfgDir.begin(), CfgDir.end());
  851     CfgFileName = ClangNameParts.TargetPrefix + '-' + ClangNameParts.ModeSuffix;

  361       *ErrMsg = EC.message();

   47     Segment = "/" + seg.str();
   49     Segment = seg;
   63   GCCSuffix = S;
   69   OSSuffix = S;
   75   IncludeSuffix = S;

   37     CPU = Mcpu.split("+").first.lower();
  141     MtuneLowerCase = llvm::sys::getHostCPUName();

  612     MArch = Arch;
  614     MArch = Triple.getArchName();
  615   MArch = StringRef(MArch).split("+").first.lower();
  628         MArch = std::string("arm") + Suffix.str();

   58   Major = In.take_while(isDigit);
   64     Minor = In.take_while(isDigit);

 3469       NormalizedTriple = C.getSingleOffloadToolChain<Action::OFK_Host>()
 3474       NormalizedTriple =

  131     BinPath = InstallPath + "/bin";
  132     IncludePath = InstallPath + "/include";
  133     LibDevicePath = InstallPath + "/nvvm/libdevice";
  149       LibPath = InstallPath + "/lib64";
  151       LibPath = InstallPath + "/lib";
  191         LibDeviceMap[GpuArch] = FilePath.str();
  196           LibDeviceMap["sm_20"] = FilePath;
  197           LibDeviceMap["sm_21"] = FilePath;
  198           LibDeviceMap["sm_32"] = FilePath;
  200           LibDeviceMap["sm_30"] = FilePath;
  202             LibDeviceMap["sm_50"] = FilePath;
  203             LibDeviceMap["sm_52"] = FilePath;
  204             LibDeviceMap["sm_53"] = FilePath;
  206           LibDeviceMap["sm_60"] = FilePath;
  207           LibDeviceMap["sm_61"] = FilePath;
  208           LibDeviceMap["sm_62"] = FilePath;
  210           LibDeviceMap["sm_35"] = FilePath;
  211           LibDeviceMap["sm_37"] = FilePath;
  214             LibDeviceMap["sm_50"] = FilePath;
  215             LibDeviceMap["sm_52"] = FilePath;
  216             LibDeviceMap["sm_53"] = FilePath;

  233       TmpPathName =
  237       TmpPathName = D.GetTemporaryDirectory("thinlto");
 1284     OSVersion = S;
 1534     Version = SDKInfo->getVersion().getAsString();
 1541       Version = SDK.slice(StartVer, EndVer + 1);

  499         P = ToolChain.GetFilePath(crtbegin);
  617           P = ToolChain.GetFilePath(crtend);
 1696   GoodVersion.MajorStr = First.first.str();
 1702       GoodVersion.PatchSuffix = MinorStr.substr(EndNumber);
 1708   GoodVersion.MinorStr = MinorStr.str();
 1728       GoodVersion.PatchSuffix = PatchText.substr(EndNumber);
 2409       GCCInstallPath = (LibDir + "/" + LibSuffix + "/" + VersionText).str();
 2410       GCCParentLibPath = (GCCInstallPath + "/../" + Suffix.ReversePath).str();
 2490           GCCParentLibPath = GentooPath + std::string("/../../..");

  207     BundlerTargetArg = BundlerTargetArg + ",hip-amdgcn-amd-amdhsa-" +
  209     BundlerInputArg = BundlerInputArg + "," + II.getFilename();

  390   if (getVFS().exists(InstallRelDir = InstalledDir + "/../target"))

  502   Path = (InstallDir + "/../../../../sysroot" + Multilib.osSuffix()).str();
  535       ArchName = Triple.getArchName().str();
  578     LibDir = "lib" + tools::mips::getMipsABILibSuffix(Args, Triple);
  608     Loader = ("ld-linux-riscv32-" + ABIName + ".so.1").str();
  614     Loader = ("ld-linux-riscv64-" + ABIName + ".so.1").str();
  881         MaxVersionString = VersionText;

   78     Path = std::move(*VCToolsInstallDir);
   88     Path = std::move(*VCInstallDir);
  131           Path = ParentPath;
  137           Path = ParentPath;
  166         Path = ToolChainPath;
  285       Path = VCPath.str();
 1049       SDKVersion = CandidateName;
 1132   path = libPath.str();
 1171   Path = LibPath.str();

  314     Ver = VersionText;
  326     Arch = Archs[0].str();
  334         Arch = CandidateArch;
  363       Arch = CandidateSubdir;
  380     Base = llvm::sys::path::parent_path(TargetSubdir.get());
  382     Base = llvm::sys::path::parent_path(
  385     Base = llvm::sys::path::parent_path(getDriver().getInstalledDir());

   36   LibSuffix = tools::mips::getMipsABILibSuffix(Args, Triple);
  100       Path = getDriver().getInstalledDir() + Path + "/c++/v1";

  251   NaClArmMacrosPath = GetFilePath("nacl-arm-macros.s");

  385     PrefixDir = PS4SDKDir.str();

  227         AllNamespaceNames = "::" + NamespaceName + AllNamespaceNames;
  232       AllNamespaceNames = std::string();

  134         this->Output = Output.str();
  741     *ErrorStr = Buffer.getError().message();
  787   AST->HSOpts->ModuleFormat = PCHContainerRdr.getFormat();
  850   AST->OriginalSourceFile = AST->Reader->getOriginalSourceFile();
 1134   OriginalSourceFile = Clang->getFrontendOpts().Inputs[0].getFile();
 1263   OutDiag.Message = InDiag.getMessage();
 1269   OutDiag.Filename = SM.getFilename(FileLoc);
 1535     CI->getHeaderSearchOpts().ResourceDir = ResourceFilesPath;
 1567   AST->OriginalSourceFile = Clang->getFrontendOpts().Inputs[0].getFile();
 1770   CI->getHeaderSearchOpts().ResourceDir = ResourceFilesPath;
 1776     CI->getHeaderSearchOpts().ModuleFormat = ModuleFormat.getValue();
 2168   FrontendOpts.CodeCompletionAt.FileName = File;
 2188   OriginalSourceFile = Clang->getFrontendOpts().Inputs[0].getFile();

  716     OutFile = OutputPath;
  722     OutFile = Path.str();
  777       OSFile = TempFile = TempPath.str();
  924     TO->Triple = llvm::Triple::normalize(getFrontendOpts().AuxTriple);
 1075   Invocation->getLangOpts()->CurrentModule = ModuleName;
 1091   FrontendOpts.OutputFile = ModuleFileName.str();
 1095   FrontendOpts.OriginalModuleMap = OriginalModuleMapFile;
 1683       ModuleFileName =
 1691       ModuleFileName = PP->getHeaderSearchInfo().getCachedModuleFileName(Module);
 2039     BuiltModules[ModuleName] = ModuleFileName.str();

  310   Opts.DumpExplodedGraphTo = Args.getLastArgValue(OPT_analyzer_dump_egraph);
  317   Opts.AnalyzeSpecificFunction = Args.getLastArgValue(OPT_analyze_function);
  375       Opts.Config[key] = val;
  764   Opts.SplitDwarfFile = Args.getLastArgValue(OPT_split_dwarf_file);
  765   Opts.SplitDwarfOutput = Args.getLastArgValue(OPT_split_dwarf_output);
  805   Opts.DwarfDebugFlags = Args.getLastArgValue(OPT_dwarf_debug_flags);
  806   Opts.RecordCommandLine = Args.getLastArgValue(OPT_record_command_line);
  822   Opts.SampleProfileFile = Args.getLastArgValue(OPT_fprofile_sample_use_EQ);
  834   Opts.InstrProfileOutput =
  836   Opts.ProfileInstrumentUsePath =
  840   Opts.ProfileRemappingFile =
  860   Opts.DebugPass = Args.getLastArgValue(OPT_mdebug_pass);
  892   Opts.FloatABI = Args.getLastArgValue(OPT_mfloat_abi);
  896   Opts.LimitFloatPrecision = Args.getLastArgValue(OPT_mlimit_float_precision);
  946   Opts.ThreadModel = Args.getLastArgValue(OPT_mthread_model, "posix");
  951   Opts.TrapFuncName = Args.getLastArgValue(OPT_ftrap_function_EQ);
  986     Opts.ThinLTOIndexFile = Args.getLastArgValue(OPT_fthinlto_index_EQ);
  989     Opts.SaveTempsFilePrefix =
  994   Opts.ThinLinkBitcodeFile = Args.getLastArgValue(OPT_fthin_link_bitcode_EQ);
 1001   Opts.PreferVectorWidth = Args.getLastArgValue(OPT_mprefer_vector_width_EQ);
 1003   Opts.MainFileName = Args.getLastArgValue(OPT_main_file_name);
 1013     Opts.CoverageDataFile = Args.getLastArgValue(OPT_coverage_data_file);
 1014     Opts.CoverageNotesFile = Args.getLastArgValue(OPT_coverage_notes_file);
 1018     Opts.ProfileFilterFiles =
 1020     Opts.ProfileExcludeFiles =
 1135   Opts.DebugCompilationDir = Args.getLastArgValue(OPT_fdebug_compilation_dir);
 1287   Opts.OptRecordFile = Args.getLastArgValue(OPT_opt_record_file);
 1359   Opts.CudaGpuBinaryFileName =
 1411   Opts.SymbolPartition = Args.getLastArgValue(OPT_fsymbol_partition_EQ);
 1418   Opts.OutputFile = Args.getLastArgValue(OPT_dependency_file);
 1424   Opts.HeaderIncludeOutputFile = Args.getLastArgValue(OPT_header_include_file);
 1437   Opts.DOTOutputFile = Args.getLastArgValue(OPT_dependency_dot);
 1438   Opts.ModuleDependencyOutputDir =
 1512   Opts.DiagnosticLogFile = Args.getLastArgValue(OPT_diagnostic_log_file);
 1646   Opts.WorkingDir = Args.getLastArgValue(OPT_working_directory);
 1664   BlockName = Args[0];
 1669     UserInfo = Args[4];
 1837   Opts.OutputFile = Args.getLastArgValue(OPT_o);
 1856   Opts.ASTDumpFilter = Args.getLastArgValue(OPT_ast_dump_filter);
 1885     = Args.getLastArgValue(OPT_foverride_record_layout_EQ);
 1886   Opts.AuxTriple = Args.getLastArgValue(OPT_aux_triple);
 1887   Opts.StatsFile = Args.getLastArgValue(OPT_stats_file);
 1906   Opts.MTMigrateDir = Args.getLastArgValue(OPT_mt_migrate_directory);
 1908     = Args.getLastArgValue(OPT_arcmt_migrate_report_output);
 1943   Opts.ObjCMTWhiteListPath = Args.getLastArgValue(OPT_objcmt_whitelist_dir_path);
 2040   Opts.Sysroot = Args.getLastArgValue(OPT_isysroot, "/");
 2047   Opts.ResourceDir = Args.getLastArgValue(OPT_resource_dir);
 2058   Opts.ModuleCachePath = P.str();
 2060   Opts.ModuleUserBuildPath = Args.getLastArgValue(OPT_fmodules_user_build_path);
 2118       Path = Buffer.str();
 2669     Opts.OverflowHandler =
 2841   Opts.ObjCConstantStringClass =
 2875   Opts.ModuleName = Args.getLastArgValue(OPT_fmodule_name_EQ);
 3276   Opts.ImplicitPCHInclude = Args.getLastArgValue(OPT_include_pch);
 3280   Opts.PCHThroughHeader = Args.getLastArgValue(OPT_pch_through_header_EQ);
 3387   Opts.CodeModel = getCodeModel(Args, Diags);
 3388   Opts.ABI = Args.getLastArgValue(OPT_target_abi);
 3403   Opts.CPU = Args.getLastArgValue(OPT_target_cpu);
 3404   Opts.FPMath = Args.getLastArgValue(OPT_mfpmath);
 3406   Opts.LinkerVersion = Args.getLastArgValue(OPT_target_linker_version);
 3407   Opts.Triple = Args.getLastArgValue(OPT_triple);
 3410     Opts.Triple = llvm::sys::getDefaultTargetTriple();
 3411   Opts.Triple = llvm::Triple::normalize(Opts.Triple);

  276   InputFile = Literal.GetString().str();
  727           PPOpts.ImplicitPCHInclude = Dir->path();

  209     CI.getFrontendOpts().OutputFile =
  449     Entry.Kind = toString(Inst.Kind);
  457         Entry.DefinitionLocation = std::string(DefLoc.getFilename()) + ":" +
  464       Entry.PointOfInstantiation = std::string(PoiLoc.getFilename()) + ":" +

  358         BaseSDKPath = P.str();

   71       CurrentType = parseName(LineStr);

  123         MainFilename = FE->getName();
  132   DE.WarningOption = DiagnosticIDs::getWarningOptionForDiag(DE.DiagnosticID);
  137   DE.Message = MessageStr.str();
  152           DE.Filename = FE->getName();

  173     SymLinkMap[Dir] = RealPath.str();

  272   FrontendOpts.OutputFile = StoreInMemory ? getInMemoryPreamblePath()
  729     PreprocessorOpts.ImplicitPCHInclude = PCHFile.getFilePath();
  753     PreprocessorOpts.ImplicitPCHInclude = PCHPath;

 1704       elementTypeAsString = ElementType.getAsString(Context->getPrintingPolicy());
 1720       elementTypeAsString = VD->getType().getAsString(Context->getPrintingPolicy());
 4068       ParamStr = (*AI)->getNameAsString();
 4091     Name = TypeString + Name;
 4230         FieldName = TypeString + FieldName;
 4231         ArgName = TypeString + ArgName;
 4441   Name = IFace->getName();
 5091   Name = ND->getNameAsString();
 5237     FuncName = CurFunctionDef->getNameAsString();
 5241     FuncName = std::string(GlobalVarDecl->getNameAsString());

 1495       elementTypeAsString = ElementType.getAsString(Context->getPrintingPolicy());
 1511       elementTypeAsString = VD->getType().getAsString(Context->getPrintingPolicy());
 3278       ParamStr = (*AI)->getNameAsString();
 3301     Name = TypeString + Name;
 3440         FieldName = TypeString + FieldName;
 3441         ArgName = TypeString + ArgName;
 3628   Name = IFace->getName();
 4239   Name = ND->getNameAsString();
 4390     FuncName = CurFunctionDef->getNameAsString();
 4394     FuncName = std::string(GlobalVarDecl->getNameAsString());

 1250       SourceLine = ' ' + SourceLine;
 1251       CaretLine = ' ' + CaretLine;

  221       Clang->getFrontendOpts().ActionName = it->getName();

 1108   Mod->UmbrellaAsWritten = NameAsWritten.str();
 1119   Mod->UmbrellaAsWritten = NameAsWritten.str();
 2286   Header.FileName = Tok.getString();
 2529   ActiveModule->ExportAsModule = Tok.getString();
 2681   Conflict.Message = Tok.getString().str();

 1339   String = Literal.GetString();

 2289           Name = Id.Identifier->getName();

  659     Expansion = "<span class='macro_popup'>" + Expansion + "</span></span>";

  751   Saved = Name.getAsString();

  285   CSec->SectionName = SecName;

 2539             SuperType = ID->getSuperClass()->getNameAsString();
 2756       Result = Param->getIdentifier()->getName();
 2763       Result =
 2795       Result = Param->getIdentifier()->getName();
 2800       Result = Type.getAsString(Policy);
 2804         Result = "(" + Quals + " " + Result + ")";
 2870     Result = Result + " (^";
 2877     Result = '^' + Result;
 3006         PlaceholderStr = NTTP->getIdentifier()->getName();
 3480         Arg = FormatFunctionParameter(Policy, *P, true,
 3486         Arg = "(" + formatObjCParamQualifiers((*P)->getObjCDeclQualifier(),
 3621       Placeholder = FormatFunctionParameter(Policy, Param);
 3626       Placeholder = Prototype->getParamType(P).getAsString(Policy);

 2726     SuitableSpelling =
 2729     SuitableSpelling = S.PP.getLastMacroWithSpelling(
 2736     SuitableSpelling = S.PP.getLastMacroWithSpelling(

11224     RHSStr = "-" + RHSStr;
11226     RHSStr = "+" + RHSStr;

  204       s = " = " + s;

11620       Values = getListOfPossibleValues(OMPC_schedule, /*First=*/0,
11624       Values = getListOfPossibleValues(OMPC_schedule, /*First=*/0,

 9709     Description = S.getTemplateArgumentBindingsText(

 2047     Description = SemaRef.getTemplateArgumentBindingsText(

  513         SuggestedModifier = "%" + SuggestedModifier + Piece.getString();

  617         Name = std::string(" '") + Parm->getName().str() + "'";

 2248   R.Filename = Blob;
 2753         F.BaseDirectory = isysroot.empty() ? "/" : isysroot;
 2802           ImportedFile = PP.getHeaderSearchInfo().getPrebuiltModuleFileName(
 2808           ImportedFile = ReadPath(BaseDirectoryAsWritten, Record, Idx);
 2844       F.ActualOriginalSourceFileName = Blob;
 2854       F.OriginalDir = Blob;
 2858       F.ModuleName = Blob;
 2897         F.BaseDirectory = M->Directory->getName();
 2899         F.BaseDirectory = Blob;
 3866   F.ModuleMapPath = ReadPath(F, Record, Idx);
 4319         Conflict.Message = Unresolved.String.str();
 4729   Metadata.BlockName = std::string(Blob.data(), Blob.data() + BlockNameLen);
 4730   Metadata.UserInfo = std::string(Blob.data() + BlockNameLen,
 5208       ModuleDir = Blob;
 5661       CurrentModule->ExportAsModule = Blob.str();
 5697   LangOpts.CurrentModule = ReadString(Record, Idx);
 5711   LangOpts.OMPHostIRFile = ReadString(Record, Idx);
 5722   TargetOpts.Triple = ReadString(Record, Idx);
 5723   TargetOpts.CPU = ReadString(Record, Idx);
 5724   TargetOpts.ABI = ReadString(Record, Idx);
 5757   FSOpts.WorkingDir = ReadString(Record, Idx);
 5766   HSOpts.Sysroot = ReadString(Record, Idx);
 5786   HSOpts.ResourceDir = ReadString(Record, Idx);
 5787   HSOpts.ModuleCachePath = ReadString(Record, Idx);
 5788   HSOpts.ModuleUserBuildPath = ReadString(Record, Idx);
 5828   PPOpts.ImplicitPCHInclude = ReadString(Record, Idx);

 1534     BaseDirectory = isysroot;

  149   NewModule->FileName = FileName.str();
  192       ErrorStr = Buf.getError().message();

   30   ErrorText = "Double nonblocking on request " +

  155     SuggestedApi =

  619   ChOpts.IgnoredRecordsWithFieldPattern =

   99       DeclName = ND->getQualifiedNameAsString();
  106       DeclName = GetSignature(dyn_cast_or_null<FunctionDecl>(ND));
  111       DeclName = ND->getQualifiedNameAsString();

  673       ArrayIndices = (llvm::Twine("[") + Idx.str() + "]" + ArrayIndices).str();
  680         ArrayIndices = (llvm::Twine("[") + Idx + "]" + ArrayIndices).str();

  365     ContextPrefix = Namespace->getQualifiedNameAsString();
  367     ContextPrefix = Record->getQualifiedNameAsString();
  370       ContextPrefix = Tag->getQualifiedNameAsString();
  375     Val = Val.substr(ContextPrefix.size() + 1);

  101   ErrorMessage = ErrorStream.str();
  115     ErrorMessage = ("Could not auto-detect compilation database for file \"" +
  129     ErrorMessage = ("Could not auto-detect compilation database from directory \"" +
  368     ErrorMsg = "Error while opening fixed database: " + Result.message();
  391   Result[0].Filename = FilePath;

   28   FilePath = Sources.getFilename(Loc);

  174       Disambiguated = "::" + Disambiguated;
  176       Disambiguated = (UnspelledScopes.back() + "::" + Disambiguated).str();

  126   this->FilePath = Entry ? Entry->getName() : InvalidLocation;
  128   this->ReplacementText = ReplacementText;
  390       Text = (Head + R.getReplacementText() + Tail).str();
  396       Text = (Text + Tail).str();

   60     CWD = Path.str();
  118     FileMgr->getFileSystemOpts().WorkingDir = WorkingDirectory;

   66       Path = NewPath;

  341     NewInclude = "\n" + NewInclude;

  205     Result.Filename = Filename;
  233     Result.Heuristic = "inferred from " + Cmd.Filename;

  203     ErrorMessage = "Error while opening JSON database: " + Result.message();
  397         ErrorMessage = ("Unknown key: \"" +

  203   FilePath = FE->getName();
  204   Key = FilePath + ":" + std::to_string(FileIDAndOffset.second);

  539         ReplacedName = NewName.substr(LastColonPos + 1);
  544           ReplacedName = tooling::replaceNestedName(
  564             ReplacedName = "::" + NewName.str();
  570         ReplacedName = NewName.str();

  483       InitialWorkingDir = std::move(*CWD);

   51     T.Replacement = std::move(*Replacement);

   86     CurrentFileName =

  199   Inv->getTargetOpts().Triple = llvm::sys::getDefaultTargetTriple();

  608     BundleStartString =
  610     BundleEndString =
  924   BundlerExecutable = sys::fs::getMainExecutable(argv[0], &BundlerExecutable);

  193               ErrorMessage = DiagText.str().str();

  230     Clang->getHeaderSearchOpts().ResourceDir =

  208   Opts.Triple = llvm::Triple::normalize(Args.getLastArgValue(OPT_triple));
  209   Opts.CPU = Args.getLastArgValue(OPT_target_cpu);
  214     Opts.Triple = llvm::sys::getDefaultTargetTriple();
  240   Opts.DwarfDebugFlags = Args.getLastArgValue(OPT_dwarf_debug_flags);
  241   Opts.DwarfDebugProducer = Args.getLastArgValue(OPT_dwarf_debug_producer);
  242   Opts.DebugCompilationDir = Args.getLastArgValue(OPT_fdebug_compilation_dir);
  243   Opts.MainFileName = Args.getLastArgValue(OPT_main_file_name);
  262   Opts.OutputPath = Args.getLastArgValue(OPT_o);
  263   Opts.SplitDwarfOutput = Args.getLastArgValue(OPT_split_dwarf_output);
  291   Opts.RelocationModel = Args.getLastArgValue(OPT_mrelocation_model, "pic");
  292   Opts.TargetABI = Args.getLastArgValue(OPT_target_abi);
  340     Error = EC.message();

  258     Code = ("namespace " + NsSplitted.back() + " {\n" + Code +
  365   DiffOldNamespace = joinNamespaces(OldNsSplitted);
  366   DiffNewNamespace = joinNamespaces(NewNsSplitted);
  384     Prefix = (StringRef(FullOldNs).drop_back(DiffOldNamespace.size()) +
  764   InsertFwd.ForwardDeclText = Insertion.getReplacementText().str();
  819         ReplaceName = FromDeclNameRef;
  865           ReplaceName = FromDecl->getNameAsString();
  882     ReplaceName = "::" + ReplaceName;

  407       Access = Access + " ";
  725     InfoTitle = ("namespace " + I.Name).str();
  764   InfoTitle = (getTagType(I.TagType) + " " + I.Name).str();

  289   this->SourceRoot = SourceRootDir.str();

  368         Namespace = N->getNameAsString();

  222           TypoScopeString = ND->getNameAsString() + "::" + TypoScopeString;
  266     QueryString = ExtendNestedNameSpecifier(Range);
  272     QueryString = ExtendNestedNameSpecifier(Range);
  275     QueryString = Typo.getAsString();

   95   void setFilePath(StringRef FilePath) { this->FilePath = FilePath; }

   46     StrippedQualifiers =

  254     Filename = SM->getFileEntryForID(SM->getMainFileID())->getName();

   32     HeaderMappingTable[OrignalHeaderPath] = MappingHeaderPath;

   93     QualifiedName = Context.second + "::" + QualifiedName;

   77   void SetFilePath(llvm::StringRef Path) { FilePath = Path; }

  379     GuardName = StringRef(GuardName).upper();

  601   TUD.MainSourceFile = MainFilePath;

   61   Options[NamePrefix + LocalName.str()] = Value;

  174   CurrentFile = File;
  204   ProfilePrefix = Prefix;

  157     CurrentBuildDirectory = BuildDirectory;

   36   StoreFilename = llvm::Twine(FinalPrefix + "-" +

  107     FixItMsg = " : " + FixItMsg;

   29     Guard = Guard.substr(PosInclude + std::strlen("include/"));
   34     Guard = Guard.substr(PosToolsClang + std::strlen("tools/"));
   46     Guard = Guard.substr(PosLLVM);
   54     Guard = "LLVM_" + Guard;

  132       StaticAssertMSG = (Twine(", \"") + AssertMSG->getString() + "\"").str();

  115     LeftText = "*" + LeftText;
  117     RightText = "*" + RightText;
  121     RightText = "std::move(" + RightText + ")";

  534     VarName = AliasVar->getName().str();
  571     VarName = Namer.createIndexName();
  580         ReplaceText = Usage.Kind == Usage::UK_MemberThroughArrow ? VarName + "."
  605         ReplaceText =
  751   Descriptor.ContainerString = getContainerString(Context, Loop, ContainerExpr);

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

  282     ArraySizeExpr = Lexer::getSourceText(CharSourceRange::getTokenRange(

   92     NewName = "std::" + NewName;

   65       ReplacementText =
   71       ReplacementText = Lexer::getSourceText(

  121     Message = (llvm::Twine(Redundant) +
  174       ReplacementText = " " + OverrideSpelling;
  195           ReplacementText = " " + OverrideSpelling + " ";
  202       ReplacementText = " " + OverrideSpelling;

  131     BufferTypeName = Builtin->getName(LO);
  162     BufferTypeName = (llvm::Twine(Builtin->getName(LO)) + " _Complex").str();
  195     BufferTypeName =
  222     BufferTypeName = Typedef->getDecl()->getName();

  232     PartialReserveStmt = "." + MutableFieldName +
  250     ReserveSize = (RangeInitExpName + ".size()").str();
  256     ReserveSize = LoopEndSource;

  179     NewFnName = ("std::" + OldFnName).str();
  182     NewFnName = (OldFnName + "f").str();

  144       Message = (Twine("'") + Old + "' can be replaced by " + New).str();
  145       Message = llvm::Regex("\\$std").sub(Std, Message);
  146       Message =
  149       Message = (Twine("'") + Old + "' is a non-portable " +

  119     ReplacementText = "(" + ReplacementText + ")";
  128       ReplacementText = "!" + ReplacementText;
  186       ReplacementText = "!" + ReplacementText;

  876       Failure.Fixup = std::move(Fixup);
  877       Failure.KindName = std::move(KindName);
  911     Failure.Fixup = std::move(Fixup);
  912     Failure.KindName = std::move(KindName);

  238     Decls[I - 1] = Twine(Snippets[0])

  163       Message =

  166     IncludeStmt = '\n' + IncludeStmt;

   53     AddedAliases[Function][Namespace.str()] = ExistingAlias->getName().str();

   63   CA.command->command = Command::CLANGD_APPLY_TWEAK;
  853         SI.containerName = ParentName ? "" : *ParentName;
  894     Cmd.command = Command::CLANGD_APPLY_FIX_COMMAND;
  901     Cmd.title = "Apply fix: " + Cmd.title;
 1085                         R.contents.value = (*H)->present().renderAsPlainText();
 1088                         R.contents.value = (*H)->present().renderAsMarkdown();

  170   Inputs.Contents = Contents;

  264       Completion.Name = llvm::StringRef(SemaCCS->getTypedText());
  270               Completion.Scope =
  294         Completion.Scope = C.IndexResult->Scope;
  298         Completion.Name = C.IndexResult->Name;
  309         Completion.RequiredQualifier = ShortestQualifier;
  316       Completion.Name = C.IdentifierResult->Name;
  368       S.ReturnType = getReturnType(*SemaCCS);
  370       S.Signature = C.IndexResult->Signature;
  371       S.SnippetSuffix = C.IndexResult->CompletionSnippetSuffix;
  372       S.ReturnType = C.IndexResult->ReturnType;
  376         Completion.Documentation = C.IndexResult->Documentation;
  378         Completion.Documentation = getDocComment(*ASTCtx, *C.SemaResult,
  384     Completion.ReturnType = summarizeReturnType();
  385     Completion.Signature = summarizeSignature();
  386     Completion.SnippetSuffix = summarizeSnippet();
  862           FetchedDocs[S.ID] = S.Documentation;
  928     Info.labelString = ChunkText;
  966     Signature.documentation = formatDocumentation(CCS, DocComment);
 1057   ParseInput.Contents = Input.Contents;
 1072   FrontendOpts.CodeCompletionAt.FileName = Input.FileName;
 1170   CachedReq.Query = HeuristicPrefix.Name;
 1481     Req.Query = Filter->pattern();
 1803   LSP.label = ((InsertInclude && InsertInclude->Insertion)
 1816   LSP.sortText = sortText(Score.Total, Name);
 1828       LSP.textEdit->newText = FixIt.newText + LSP.textEdit->newText;

  132           *RequiredQualifiers = std::move(*Signature);

  137   D.File = SM.getFileEntryForID(SM.getMainFileID())->getName().str();
  148   N.File = FE->getName();
  153   D.Message = llvm::Twine("in included file: ", D.Message).str();
  350   Main.message = mainMessage(D, Opts);
  362       RelInfo.message = noteMessage(D, Note, Opts);
  375       Res.message = noteMessage(D, Note, Opts);
  407         Diag.Name = ("-W" + Warning).str();
  413         Diag.Name = Name;
  421         Diag.Name = std::move(TidyDiag);
  483   D.Message = Message.str();
  485   D.Category = DiagnosticIDs::getCategoryNameFromID(
  527     D.File = SM.getFilename(Info.getLocation());

   39   Drafts[File] = Contents;
  100     NewContents = Contents.substr(0, *StartIndex);
  104     Contents = std::move(NewContents);

   22   this->MainFilePath = MainFileCanonical.str();

   76   Req.Query = Names.second;
  158   SI.name = printName(Ctx, ND);

  341     FinalCode =

  101   C.Contents = std::move(Code);
  102   C.Language = std::move(Language);
  109   C.Contents = std::move(Code);

  152     Entry.Path = Dir;

   42       Inc.Written =
   44       Inc.Resolved = File ? File->tryGetRealPathName() : "";
  123     RealPathNames[Child] = IncludedRealName;
  198     Suggested = HeaderSearchInfo->suggestPathToFileForDiagnostics(
  206     Suggested = llvm::sys::path::convert_to_slash(
  213     Suggested = "<" + Suggested + ">";
  215     Suggested = "\"" + Suggested + "\"";

  240   Result.Name = Unresolved.getAsString();
  298       Result.Name = Split.second;

   26     Message = llvm::toString(std::move(Unhandled));

  844         Event.Payload = llvm::join(Enclosing, "::");
  860           Event.Payload = llvm::join(Enclosing, "::");
  870         Event.Payload = std::move(NSName);
  905       Current = std::move(Event.Payload);
 1086       CurrentNamespace = std::move(Enclosing.back());

  835   FStatus.state = renderTUAction(Action);

  172   U.Scheme = percentDecode(SchemeStr);
  179     U.Authority = percentDecode(Uri.substr(0, Pos));
  182   U.Body = percentDecode(Uri);

  113   URIStorage = Loc.uri.uri();
  252       File.Name = llvm::sys::path::filename(Inc.Resolved);
  272       Macro.Name = M->Name;
  298       Result.back().Name = printName(AST.getASTContext(), *ND);
  608       Req, [&](const Symbol &S) { Hover.Documentation = S.Documentation; });
  619   HI.LocalScope = getLocalScope(D);
  625     HI.Documentation = getDeclComment(Ctx, *ND);
  626     HI.Name = printName(Ctx, *ND);
  706   HI.Definition = printDefinition(D);
  731   HI.Name = Macro.Name;
  749         HI.Definition =
 1002           NewSymbol.containerName = printQualifiedName(*ParentND);
 1007       NewSymbol.USR = USR.str();
 1015     NewMacro.name = M->Name;
 1019       NewMacro.USR = USR.str();
 1061   THI.name = printName(Ctx, ND);
 1092   THI.name = S.Name;

  203   T.Tag = filenameWithoutExtension(Cmd.Filename);

   61   LS.AbsolutePath = StartSourceFile.str();
   62   LS.DependentTU = DependentTU;

   50     DiskShardRoot = CDBDirectory.str();
  111     this->HomeDir = HomeDir.str().str();

   24   FullPathMapping[Path] = CanonicalPath;

  504     Result.Cmd->Directory = Cmd.Directory;

  159   FileURIStorage = toURI(SM, Path, Opts);

   64   Request.Query = Names.second;

  101   this->MacroName = T->text(Inputs.AST.getSourceManager());

   99   Cmd.Filename = testPath("root/A.cc");
  100   Cmd.Directory = testPath("root");
  139   Cmd.Filename = testPath("root/A.cc");
  140   Cmd.Directory = testPath("root");
  152   Cmd.Filename = testPath("root/B.cc");
  196   Cmd.Filename = testPath("root/A.cc");
  197   Cmd.Directory = testPath("root");
  265   Cmd.Filename = testPath("root/A.cc");
  266   Cmd.Directory = testPath("root");
  314   Cmd.Filename = testPath("root/A.cc");
  315   Cmd.Directory = testPath("root");
  388   Cmd.Filename = testPath("root/A.cc");
  389   Cmd.Directory = testPath("root");
  450   Cmd.Directory = testPath("root/build");
  456   Cmd.Directory = testPath("root");
  488   Cmd.Directory = testPath("build");
  544   Cmd.Directory = testPath("build");
  598     Target.lookup(Req, [&](const Symbol &S) { ReadName = S.Name; });

  149       FS.Files[testPath(FileWithContents.first)] = FileWithContents.second;

 1056     P.Text = Label.substr(Range.Begin, Range.End - Range.Begin);

  209   TU.Code = Test.code();
  725   TU.Code = Test.code();
  751   TU.Code = Test.code();

  150   File.Filename = (Basename + ".cpp").str();
  151   File.HeaderFilename = (Basename + ".h").str();
  152   File.HeaderCode = Code;
  329   Test.Code = MainCode.code();
  336   Test2.Code = MainCode.code();
  381   TU.Code = Main.code();

   82     FSProvider.Files[Path] = Contents;
  339     FSProvider.Files[FilePath] = Contents;

   45     Name = FirstLine.rtrim(" {");
  522     TU.Code = Code;

  211   MainFile = testPath("main.h");
  216   MainFile = testPath("sub/main.cpp");
  224   SearchDirArg = (llvm::Twine("-I") + Subdir + "/..").str();
  226   BarHeader = testPath("sub/bar.h");
  255   Inc.Resolved = testPath("sub/bar.h");

  367   Test.Code = Test1Code.code();
  384   Test2.Code = Test2Code.code();

   35     InBuf = std::move(InData);

  294     TU.Code = Test.code();

  106   TU.Code = Test.code();

  171   FS.Files[FooCpp] = SourceAnnotations.code();

  117     File.HeaderCode = HeaderCode;
  118     File.Code = Code;
  251     TestHeaderURI = URI::create(TestHeaderName).toString();
  252     TestFileURI = URI::create(TestFileName).toString();
  517   TestFileName = testPath("test.m");
  535   TestFileName = testPath("test.m");
  658   TestFileName = testPath("foo.cpp");
  663   TestFileName = testPath("foo.h");
  736   TestHeaderURI = URI::create(testPath(TestHeaderName)).toString();
  745   TestHeaderName = testPath("x.h");
  746   TestFileName = testPath("x.cpp");
 1053   TestFileName = testPath("no_ext_main");
 1054   TestFileURI = URI::create(TestFileName).toString();
 1073   TestFileName = testPath("main.cc");
 1074   TestFileURI = URI::create(TestFileName).toString();

  129   Req.Query = Query;

   51     Inputs.Contents = std::move(Contents);

   35     TU.Code = Code;
   41     TU.HeaderCode = HeaderCode;

   73   TU.Code = Input.code();
   96   TU.Code = Input.code();
  121       EditedMainFile = Unwrapped;

  949   Header = "void bar();" + Header;

  467   Request.Query = Name;

  157   TU.Code = SymbolCpp.code();
  158   TU.HeaderCode = SymbolHeader.code();
  205   TU.HeaderCode = SymbolHeader.code();
  466     TU.Code = T.code();
  573   FS.Files[HeaderInPreambleH] = HeaderInPreambleAnnotations.code();
  575   FS.Files[HeaderNotInPreambleH] = HeaderNotInPreambleAnnotations.code();
 1870   FS.Files[FooCpp] = SourceAnnotations.code();
 1877   FS.Files[FooH] = HeaderAnnotations.code();
 1919   FS.Files[FooM] = ObjC.code();
 1940   FS.Files[FooCpp] = FooWithHeader.code();
 1944   FS.Files[FooH] = FooHeader.code();
 2125   TU.Code = Main.code();
 2138   IndexedTU.Code = IndexedMain.code();
 2150   TU.Code = ("\n\n" + Main.code()).str();

  321   ModuleMapDirectory = ModularizeUtilities::getDirectoryFromPath(ModuleMapPath);

  818   CommandLine = sys::path::stem(sys::path::filename(Argv0));

   36   ModuleMapTargetOptions() { Triple = llvm::sys::getDefaultTargetTriple(); }
  460     Tmp = Tmp2.substr(2);
  496   FilePath = getCanonicalPath(FilePath);
  508   FilePath = getCanonicalPath(FilePath);

  160     SafeName = "_" + SafeName;
  179     FilePath = NativePath.substr(NativePrefix.size() + 1);
  181     FilePath = HeaderFilePath;
  201     Stem = ensureNoCollisionWithReservedName(Stem);
  202     Stem = ensureVaidModuleName(Stem);

  861     SourcePath = ModularizeUtilities::getCanonicalPath(SourcePath);

  245     Results[FilePath.str().str()] = Context.getRewrittenText(FileToFileID[FilePath]);

  246   Res = runCheckOnCode<UseCharCheck, IfFalseCheck>(Code);
  256   Res = runCheckOnCode<StartsWithPotaCheck, EndsWithTatoCheck>(Code);
  266   Res = runCheckOnCode<UseCharCheck, IfFalseCheck, StartsWithPotaCheck,
  296   Res = runCheckOnCode<UseCharCheck, IfFalseCheck>(Code);
  298   Res = runCheckOnCode<IfFalseCheck, UseCharCheck>(Code);
  322   Res = runCheckOnCode<IfFalseCheck, StartsWithPotaCheck>(Code);
  324   Res = runCheckOnCode<StartsWithPotaCheck, IfFalseCheck>(Code);
  351   Res = runCheckOnCode<UseCharCheck, IfFalseCheck, StartsWithPotaCheck>(Code);
  353   Res = runCheckOnCode<StartsWithPotaCheck, IfFalseCheck, UseCharCheck>(Code);
  383   Res = runCheckOnCode<IfFalseCheck, StartsWithPotaCheck>(Code);
  402   Res = runCheckOnCode<StartsWithPotaCheck, EndsWithTatoCheck>(Code);

  137   ResourcesPath = driver::Driver::GetResourcesPath(LibClangPath);
  145   ToolchainPath = llvm::sys::path::parent_path(
  166   File = std::string(TempPath.begin(), TempPath.end());

   81     InvocationEmissionPath = Str;

 1106     encoding = Ctx.getObjCEncodingForMethodDecl(OMD);
 1108     encoding = Ctx.getObjCEncodingForPropertyDecl(OPD, nullptr);
 1110     encoding = Ctx.getObjCEncodingForFunctionDecl(FD);

  550   CInvok->getHeaderSearchOpts().ModuleFormat =

  121   ToCode = ToSrcCode;

  100           [&ErrorText](const ImportError &Err) { ErrorText = Err.message(); });

   70   Formatted = formatComment(
   80   Formatted = formatComment(
   90   Formatted = formatComment(
  100   Formatted = formatComment(

   66     VerifyResult = Result.str();

  424         Name = Named->getNameAsString();

   48     compiler.getTargetOpts().Triple = llvm::Triple::normalize(

  267     compiler.getTargetOpts().Triple = llvm::Triple::normalize(

  118     compiler.getTargetOpts().Triple = llvm::Triple::normalize(

   48     TestRootDir = pathBuf.str();
   50     TestWatchedDir = pathBuf.str();

  240   Result = cleanup(Code, Ranges);

  275     Invocation->getFrontendOpts().OutputFile = StringRef(PCHFilename);

   85     S.QName = ND->getQualifiedNameAsString();
   98     S.QName = Name->getName();

  508   String1 = Lexer::Stringify(StringRef(String1));
  510   String3 = Lexer::Stringify(StringRef(String3));
  512   String5 = Lexer::Stringify(StringRef(String5));

   50     ResultCtx.PreferredType = Context.getPreferredType().getAsString();
   51     ResultCtx.PtrDiffType =

  115     VFS[FilePath] = Content;
  277     FileToContent[File] = "void " + Symbol + "() {}";

 1309     Code = Input;

   37     TestDir = Dir.str();
   54       Filename = Path.str();
   66       Filename = Path.str();

   52       MacroHierarchyName = macroName(Root->getName());

   64       NS = Spelling.getValueAsString("Namespace");
  170         AN = Attr->getValueAsString("ParseKind");
  181         AN = NormalizeAttrName(Attr->getName()).str();
  943       QualifiedTypeName = getAttrName().str() + "Attr::" + type;
 2051       SubRuleFunction =
 2261         SuperName = R->getName();
 3743         AttrName = Attr.getValueAsString("ParseKind");
 3748         AttrName = NormalizeAttrName(StringRef(Attr.getName())).str();
 3927         Name = Spelling.nameSpace() + "::";
 3930         Name = Spelling.nameSpace() + " ";

   72     CatName = getCategoryFromDiagGroup(Parents[i], DiagGroupParents);
  792     *I = "|" + *I + "|";
 1088       Sub->Name = Text.substr(0, NameSize).str();

   32     name = getPackageFullName(DI->getDef());

  204       Name = "const " + Name;
  504   void setVarname(const StringRef s) { VarName = s; }
  807           Suffix = (Twine(", ") + IA.ExtraCheckArgs).str();
 1100   FullName = (Twine(BaseName) + Param->acleSuffix()).str();
 1125   ShortName = join(std::begin(NameParts), std::end(NameParts), "_");
 1189     CustomCodeGenArgs["CustomCodeGenType"] =
 1196         CustomCodeGenArgs[Name] = itostr(II->getValue());
 1198         CustomCodeGenArgs[Name] = SI->getValue();
 1314           FunctionName = "__arm_" + FunctionName;

  641     S = "S" + S;
  643     S = "U" + S;
  648     S = "I" + S;
 1420         Cast = "(" + T2.str() + ")";
 1431       Arg = "(" + BaseType.str() + ") {";
 1441       Arg = V.getName();
 1448       Arg = "(" + CastToType.str() + ")" + Arg;
 1451       Arg = "(" + CastToType.str() + ")" + Arg;
 1475     RetExpr = RetVar.getName() + " = ";
 1587     N = SI->getAsUnquotedString();
 1589     N = emitDagArg(DI->getArg(0), "").second;
 1662       N = "reint" + utostr(++I);
 1669     S = "*(" + castToType.str() + " *) &" + Intr.Variables[N].getName() + "";
 1672     S = "(" + castToType.str() + ")(" + R.second + ")";
 1954       VariablePostfix = "_" + utostr(Emitter.getUniqueNumber());
 2267       UpperBound = utostr(Def->getReturnType().getElementSizeInBits() - 1);
 2287       UpperBound = utostr(T.getNumElements() - 1);
 2509         InGuard = (*I)->getGuard();
 2616         InGuard = (*I)->getGuard();

   69     FatBinaryName = ArchiveFilename;
  108     FatBinaryName = Filename;

  218   DebugMapObject &operator=(DebugMapObject &&) = default;

  278       Entry = ResolvedPath.str();

   99     Thin.Arch = getArchName(Thin.Arch);

  290       BI.IDStr = sys::path::stem(BundleID);
  292       BI.IDStr = BundleID;
  446   SDKPath = sys::path::parent_path(SDKPath);

  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="));
  254       thinlto_object_suffix_replace =
  260       cache_dir = opt.substr(strlen("cache-dir="));
  262       cache_policy = opt.substr(strlen("cache-policy="));
  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="));
  874   Conf.DefaultTriple = sys::getDefaultTargetTriple();

  746     e2.Name = e1.name;
  747     e2.SymbolName = e1.symbolName;
  748     e2.ExtName = e1.extName;
  809     config->outputFile = saver.save(m.OutputFile);
  810   config->importName = saver.save(m.ImportName);
  897       s = "_" + s;
 1530   config->mapFile = getMapFile(args);
 1722     config->outputFile =

  321     path = s.str();
  512     path = config->outputFile + ".manifest";

  841   dllName = StringRef(nameStart);
  885     path = replaceThinLTOSuffix(mb.getBufferIdentifier());

   82   c.CPU = getCPUStr();

   86     ret[syms[i]] = std::move(str[i]);

  909   config->rpath = getRpath(args);

   47       f->toStringCache = f->getName();
   49       f->toStringCache = (f->archiveName + "(" + f->getName() + ")").str();
 1362   this->archiveName = archiveName;
 1366     path = replaceThinLTOSuffix(mb.getBufferIdentifier());

  202     this->archiveName = archiveName;
  300     this->archiveName = archiveName;

  312     srcFile = toString(file);
  345     archive = " in archive " + file->archiveName;

   92   c.CPU = getCPUStr();
   97   c.OptPipeline = config->ltoNewPmPasses;
   98   c.AAPipeline = config->ltoAAPipeline;
  101   c.RemarksFilename = config->optRemarksFilename;
  102   c.RemarksPasses = config->optRemarksPasses;
  104   c.RemarksFormat = config->optRemarksFormat;
  106   c.SampleProfile = config->ltoSampleProfile;
  109   c.DwoDir = config->dwoDir;
  111   c.CSIRProfile = config->ltoCSProfileFile;

   91   sec->location = location;

   98     ret[syms[i]] = std::move(str[i]);

  666     msg = "relocation refers to a symbol in a discarded section: " +
  740     newName = name;
  757     newName = (name.substr(0, i) + name.substr(i + 1)).str();
  785     msg = "undefined " + visibility() + "symbol: " + toString(sym);

  851     cmd->memoryRegionName = next();
  855     cmd->lmaRegionName = next();
  922     cmd->commandString =

   74       _archiveMemberPath = (_archivePath + "(" + _path + ")").str();
   81   void setArchivePath(StringRef path) { _archivePath = path; }

  193     LLVM_DEBUG(reason = formatReason("override", lc._override, rc._override));
  203         reason = formatReason("contentPerms", (int)leftPerms, (int)rightPerms));
  212     LLVM_DEBUG(reason =
  229     LLVM_DEBUG(reason = formatReason(".o order", (int)leftFile->ordinal(),
  239     LLVM_DEBUG(reason = formatReason("ordinal", (int)leftRoot->ordinal(),

   92           _refNames[target] = newName;
  122       _refNames[&atom] = newName;
  136         _refNames[prevAtom] = newName2;

   94     this->archiveName = archiveName;
  157     this->archiveName = archiveName;

  117     m_type.m_type_name = name;
  124       m_type.m_type_name = type->GetName().GetStringRef();

  142     m_fixed_expression = std::move(fixed_expression);

  145   void SetProcessPluginName(llvm::StringRef plugin) { m_plugin_name = plugin; }

   49   void SetName(llvm::StringRef name) { m_name = name; }
   51   void SetQueueName(llvm::StringRef queue_name) { m_queue_name = queue_name; }

   41   RegularExpression &operator=(RegularExpression &&rhs) = default;

  128     m_version = std::move(version);
  145     m_cwd = cwd.str();

   29     m_packet = str;

  342     void SetValue(llvm::StringRef S) { m_value = S; }

  397       common_prefix =

  182   m_opaque_ptr->m_output = std::string();

  111     error = llvm::toString(std::move(e));
  121     error = llvm::toString(std::move(e));
  130     error = llvm::toString(std::move(e));

   84       local_data = static_cast<StreamString *>(m_opaque_up.get())->GetString();
  132       local_data = static_cast<StreamString *>(m_opaque_up.get())->GetString();
  153       local_data = static_cast<StreamString *>(m_opaque_up.get())->GetString();

 1808         regexstr = llvm::Regex::escape(name) + ".*";
 1976       regexstr = llvm::Regex::escape(name) + ".*";

  296         m_one_liner = option_arg;

 1542           m_funct_name = option_arg;
 1546           m_class_name = option_arg;
 1550           m_short_help = option_arg;
 1659     m_cmd_name = command[0].ref();

  551                         scope_string = GetScopeString(var_sp).str();
  597                 scope_string = GetScopeString(var_sp).str();
  656               scope_string = GetScopeString(var_sp).str();
  753         m_class_name = std::string(option_arg);
  756         m_module = std::string(option_arg);
  759         m_function = std::string(option_arg);

  110         sub_command = entry.ref();

 1256         stop = option_arg;
 1259         notify = option_arg;
 1262         pass = option_arg;

   70         file_name = option_arg;
   74         symbol_name = option_arg;
  664         file_name = option_arg;
  668         symbol_name = option_arg;

 2854           uuid_str = module_spec.GetUUID().GetAsString();
 3267         m_str = option_arg;
 3278         m_str = option_arg;
 3603         m_str = option_arg;
 3626         m_str = option_arg;
 3631         m_str = option_arg;
 3636         m_str = option_arg;
 4431         m_class_name = option_arg;
 4469         m_function_name = option_arg;
 4475         m_file_name = option_arg;
 4480         m_module_name = option_arg;
 4492         m_thread_name = option_arg;
 4497         m_queue_name = option_arg;

  310         m_class_name = std::string(option_arg);
  320         m_category = std::string(option_arg);
  730         m_category = std::string(option_arg);
 1202     m_format_string = std::string(option_arg);
 1217     m_python_script = option_arg;
 1221     m_python_function = option_arg;
 1228     m_category = std::string(option_arg);
 2413         m_category = std::string(option_arg);
 2718     m_cmd_help_long = stream.GetString();

  652         m_condition = option_arg;

  328         m_one_liner = option_arg;

  811         value = matches[1].str();
  878         key = matches[1].str();
  879         value = matches[2].str();
  919           value = value.substr(1, len - 2);
 1342   m_description = description;

 1893         entry.string = format_str.str();
 1935           entry.string = value.str();
 2146             entry.printf_format = variable_format.str();

   24   m_prefix = FormatAnsiTerminalCodes(prefix);
   25   m_suffix = FormatAnsiTerminalCodes(suffix);

  319   line_buffer = line_buffer.substr(pos + 1);
  469   m_prompt = prompt;
  484   m_continuation_prompt = prompt;
  560           line = lines.CopyList();

   85           shortname = cxx_method.GetContext().str() + "::";

  771               qualified_name = cpp_method.GetBasename().str();
  773               qualified_name = cpp_method.GetScopeQualifiedName();

  862           uuid_str = uuid_ptr->GetAsString();
  942             uuid_str = uuid_ptr->GetAsString();

   29     m_data = std::string();

  411         m_location_str = sstr.GetString();

   63         dest = reg_sstr.GetString();
  117         dest = sstr.GetString();
  194     dest = sstr.GetString();

   86     retval = s.GetString();
  129   dest = stream.GetString();

   49     m_expression_paths[i] = std::string(".") + path;

   57     m_repl_source_path = tmpdir_file_spec.GetPath();
  513   m_repl_source_path = GetSourcePath();

  204     full_prefix_storage = prefix;

  190         m_path = lldb_history_file.str();
  310   m_current_prompt = PromptForIndex(line_index);
  407   m_input_lines[m_current_line_index] =
  590       new_line_fragment = FixIndentation(new_line_fragment, indent_correction);
  705   m_input_lines[m_current_line_index] =
  950       to_add = to_add.substr(request.GetCursorArgumentPrefix().size());
  959       to_add = to_add.substr(request.GetCursorArgumentPrefix().size());
  975     longest_prefix =

  239   raw_path = (parent_path + dir).str();

  136   m_plugin_name = plugin;

  288     host_str = matches[1].str();
  289     port_str = matches[2].str();
  292       host_str = host_str.substr(1, host_str.size() - 2);
  312     port_str = host_and_port;

  226           m_uri = *addr;
  770   m_uri = socket->GetRemoteConnectionURI();

  145     var = std::string(pvar);

 1391     alias_result = result_str.GetString();
 1432   alias_result = result_str.GetString();
 1641         command_string = *hist_str;
 1642         original_command_string = *hist_str;
 1737       remainder = command_string.substr(actual_cmd_name_len);
 3111     command_line = revised_command_line.GetString();

   46   m_cmd_help_short = help;
   47   m_cmd_syntax = syntax;
   76   m_cmd_syntax = syntax_str.GetString();
   83 void CommandObject::SetCommandName(llvm::StringRef name) { m_cmd_name = name; }
   85 void CommandObject::SetHelp(llvm::StringRef str) { m_cmd_help_short = str; }
   87 void CommandObject::SetHelpLong(llvm::StringRef str) { m_cmd_help_long = str; }
   89 void CommandObject::SetSyntax(llvm::StringRef str) { m_cmd_syntax = str; }
  676   help_text = sstr.GetString();
  694   help_text = sstr.GetString();

   98       m_current_format = value_str;

   62     value_str = value.str();

  370           m_mnemonics = mnemonic_strm.GetString();
  387           m_opcode_name = matches[1].str();
  388           m_mnemonics = matches[2].str();

 1351           uuid = ku.second.GetAsString();

  283   entry.path = ReadStringFromMemory(entry.path_addr);

  405       image_infos[i].min_version_os_sdk =

   63   m_dump = clang::QualType(type, 0).getAsString();
   66 ASTDumper::ASTDumper(clang::QualType type) { m_dump = type.getAsString(); }
   69   m_dump = clang::QualType::getFromOpaquePtr(type).getAsString();
   73   m_dump = ClangUtil::GetQualType(compiler_type).getAsString();

  257   search_opts.ModuleCachePath = module_cache.str();
  260   search_opts.ResourceDir = GetClangResourceDir().GetPath();
  361     m_compiler->getTargetOpts().Triple = llvm::sys::getDefaultTargetTriple();
  382   m_compiler->getTargetOpts().CPU = target_arch.GetClangTargetCPU();
  385   abi = GetClangTargetABI(target_arch);
  781         ToInsert = R.Declaration->getNameAsString();
  794           Description = V->getType().getAsString(m_desc_policy);
  796           Description = F->getType().getAsString(m_desc_policy);
  809         ToInsert = R.Macro->getName().str();

  181   m_start_marker = "#line 1 \"" + filename.str() + "\"\n";
  483     text = wrap_stream.GetString();

  396   m_filename = m_clang_state->GetNextExprFileName();
  619           m_fixed_text =

   19     m_path = path.str();
   76     m_resource_inc = resource_dir.str();

  256     description = instance->FormatDescription(report);

  110       className = apiName.substr(2, spacePos - 2);
  111       selector = apiName.substr(spacePos + 1, apiName.length() - spacePos - 2);

  649     summary = summary + " in " + GetSymbolNameFromAddress(process_sp, pc);
  665       summary = "Race on " + object_type + " object";
  680         summary = summary + " at " + global_name;
  682         summary = summary + " at " + Sprintf("0x%llx", addr);
  690         summary = summary + " on file descriptor " + Sprintf("%d", fd);
  736       global_name = GetSymbolNameFromAddress(process_sp, global_addr);
  738         result = Sprintf("'%s' is a global variable (0x%llx)",
  741         result = Sprintf("0x%llx is a global variable", global_addr);
  747         filename = decl.GetFile().GetPath();
  764         result = Sprintf("Location is a %ld-byte %s object at 0x%llx", size,
  767         result =
  775       result = Sprintf("Location is stack of thread %d", tid);
  781       result = Sprintf("Location is TLS of thread %d", tid);
  787       result = Sprintf("Location is file descriptor %d", fd);
  815     stop_reason_description = issue_description + " detected";
  961       result = Sprintf("%s access by thread %d",
  965       result = Sprintf("modifying access by thread %d", thread_id);
  967       result = Sprintf("%s%s of size %d%s by thread %d",
  976     result = Sprintf("Thread %d created", thread_id);
  987       result = Sprintf("Heap block allocated by thread %d", thread_id);
  989       result =
  998     result = Sprintf("Mutex M%d created", mutex_id);
 1004     result = Sprintf("Thread %d", thread_id);

   71     retval.name = ReadQuotedString(type);
  140         element.name = elem_name.GetString();
  204     name = ReadQuotedString(type);

 2861     m_pragmas[kv_pair.first.trim().str()] = kv_pair.second.trim().str();
 2929       m_slang_version = kv_pair.second.str();
 2931       m_bcc_version = kv_pair.second.str();

  173     m_device_id = host;
  284   version_string = llvm::StringRef(version_string).trim().str();
  325   tmpdir = llvm::StringRef(tmpdir).trim().str();

  120     m_device_id = host;
  192       connect_url = url_str.str();

  169           xcode_contents_path = fspec.GetPath();
  199                 xcode_contents_path = default_xcode_sdk.substr(

  754   path = remote_file.GetPath();

  301       m_platform_scheme = scheme;
  302       m_platform_hostname = hostname;
  303       path = pathname;
  533   connect_url =
  775           description = object_sp->GetStringValue();

  298       m_stop_description = GetCrashReasonString(reason, *info);
  368   m_stop_description = ostr.str();

  209       vendor_id = columns[1].str();

  127   info.name = string_or_error->str();

  292   m_description = strm.GetString();

   44     m_continue_packet = payload;

  757       error_str = response.GetStringRef().substr(1);
  778     exe_path = exe_file.GetPath(false);
 1000             m_gdb_server_name = value;
 1158             arch_name = value;
 1185               os_name = value;
 1188             vendor_name = value;
 1956         vendor = value;
 1958         os_type = value;
 2049             os_name = value;
 2052           vendor_name = value;
 2069           elf_abi = value;
 2557       socket_name = socket_name_osp->GetStringValue();
 3750   out = output.str();

  137     socket_name = GetDomainSocketPath("gdbserver").GetPath();
  176       hostname = value;

 2068       thread_name = object->GetStringValue();
 2073       queue_name = object->GetStringValue();
 2099       reason = object->GetStringValue();
 2101       description = object->GetStringValue();
 2112                 expedited_register_map[reg] = object->GetStringValue();
 2255         thread_name = value;
 2276         reason = value;
 2325         description = ostr.GetString();
 2336           expedited_register_map[reg] = std::move(value);
 4360             gdb_type = value.str();
 4362             gdb_group = value.str();
 4976     m_partial_profile_data = input.substr(pos);
 5298           response_str = process->HarmonizeThreadIdsForProfileData(response);

  102         m_dispatch_queue_name =

 2997     dest = str_stream.GetString();

  327           unnamed_type_name =
  990     context_name = ns->getQualifiedNameAsString();
  992     context_name = tag->getQualifiedNameAsString();

  454     name = GetSimpleTypeName(mr.ModifiedType.getSimpleKind());
  456     name = computeTypeName(stream.typeCollection(), mr.ModifiedType);

  599       name = MSVCUndecoratedNameParser::DropScope(pdb_func->getName());

  907           m_public_names[addr] = symbol_up->getRawSymbol().getName();
 1487         type_name = enum_type->getName();
 1490         type_name = typedef_type->getName();
 1492         type_name = class_type->getName();
 1937             func_decorated_name = pdb_public_sym->getName();

  675   m_target_triple = target_triple.str();
 3935       type_name = typedef_decl->getQualifiedNameAsString();
 3937       type_name = qual_type.getAsString(printing_policy);
 4643               name = cxx_method_decl->getDeclName().getAsString();
 4681               name = objc_method_decl->getSelector().getAsString();
 4711                 name = objc_method_decl->getSelector().getAsString();
 6918           child_name = llvm::formatv("[{0}]", idx);

  312     uuid_str = module_uuid.GetAsString("");
  316     uuid_str = uuid_str + ".debug";

  698         remaining_partial_path = partial_path.substr(pos);

  181     new_path = remapped.GetPath();

  147         module_name = module_file_spec.GetPath();
  181       module_name = module_file_spec.GetPath();

  209           m_description = strm.GetString();
  242           m_description = strm.GetString();
  634       m_description = strm.GetString();
  972         m_description = strm.GetString();
 1037       m_description = strm.GetString();

 1776     *warnings = sstr.GetString();

  638     m_suffix = original_args;
  658       m_suffix = arg_string;
  684     m_suffix = original_args;

   85   Val.data = fromHex(Scalar);

   78 void ProcessInfo::SetArg0(llvm::StringRef arg) { m_arg0 = arg; }

  326     file = absolute_path.GetPath();

  142       m_string = llvm::sys::StrError(m_code);
  246   m_string = err_str;
  275     m_string = buf.str();

  214       Macro = GetRecordDummyMacro(
  222       Macro = GetRecordConstructorMacro(Record->getNameAsString(),
  230       Macro = GetRecordMethodMacro(

  271       connection_host = final_host_and_port.substr(0, colon_pos);
  272       connection_port = final_host_and_port.substr(colon_pos + 1);

   67     cwd = Path.str();

   55 m_dwarf_test_exe = GetInputFilePath("test-dwarf.exe");

   76   s_test_executable = GetInputFilePath(module_name);

  170   m_d = std::string(d);

   42   process_info.m_triple = fromHex(elements["triple"]);

   58     FullName = Option->getValueAsString("FullName");
   59     ShortName = Option->getValueAsString("ShortName");
   62       ArgType = A->getValue()->getAsUnquotedString();
   66       Validator = Option->getValueAsString("Validator");
   69       ArgEnum = Option->getValueAsString("ArgEnum");
   75       Description = D->getValue()->getAsUnquotedString();

  293     CacheName = CacheDir + CacheSubdir;

 1051       ArchiveName = Rest;

  285   CurrentExecPrefix =
  310     ActiveIncludeDir = std::string(LLVM_SRC_ROOT) + "/include";
  317       ActiveBinDir = ActiveObjRoot + "/bin";
  318       ActiveLibDir = ActiveObjRoot + "/lib" + LLVM_LIBDIR_SUFFIX;
  319       ActiveCMakeDir = ActiveLibDir + "/cmake/llvm";
  324       ActiveBinDir = ActiveObjRoot + "/" + build_mode + "/bin";
  325       ActiveLibDir =
  328       ActiveCMakeDir =
  334     ActiveIncludeOption =
  338     ActiveIncludeDir = ActivePrefix + "/include";
  341     ActiveBinDir = path.str();
  342     ActiveLibDir = ActivePrefix + "/lib" + LLVM_LIBDIR_SUFFIX;
  343     ActiveCMakeDir = ActiveLibDir + "/cmake/llvm";
  344     ActiveIncludeOption = "-I" + ActiveIncludeDir;
  452         LibFileName = Lib;
  454         LibFileName = (SharedPrefix + Lib + "." + SharedExt).str();
  458       LibFileName = (StaticPrefix + Lib + "." + StaticExt).str();

  407       RemappedFilenames[Filename] =
  415     InvRemappedFilenames[RemappedFilename.getValue()] = RemappedFilename.getKey();
  512     DC.DemangledNames[Function.Name] = Symbols[I++].rtrim();
  874   ViewOpts.CreatedTimeStr = (found != std::string::npos)

   54     Name = Group.getName();

  362     Filename = SF;
  364     Filename = buildLinkToFile(SF, FCS);
  525     Snippets[I] = escape(Snippets[I], getOptions());
  547       Snippets[0] = Highlight(Snippets[0], 1, 1 + Snippets[0].size());
  560       Snippets[I + 1] = Highlight(Snippets[I + 1], CurSeg->Col,
  565     Snippets.back() = Highlight(Snippets.back(), 1, 1 + Snippets.back().size());
  590       Snippets[I + 1] =
  617     Count = tag("pre", formatCount(Line.getExecutionCount()));
  684     SourceLabel = tag("td", tag("pre", "Source"));
  687     SourceLabel =

  130     Result = demangle(OS, Mangled);

  396       FnPrefix = Name;

   87   InstrBenchmark.CpuName = State.getTargetMachine().getTargetCPU();
   88   InstrBenchmark.LLVMTriple =
  123       InstrBenchmark.Error = toString(std::move(E));
  141     InstrBenchmark.Error = toString(std::move(E));

   99     CT.Info = ExecutionClassDescription;
  121     CT.Info = ExecutionClassDescription;
  140       CT.Info = ExecutionClassDescription;

  162   CT.Info = formatv("{0}, repeating an unconstrained assignment", Msg);

  230           CT.Config = formatv("{3}(%{0}, %{1}, {2})", RegInfo.getName(BaseReg),

  216     ArchName = FO->getArchTriple().getArchName();
  318     C.OutputFile = InputArgs.getLastArgValue(LIPO_output);

  317   CurrentActivity = ("loading file '" + Path + "'").str();
  437   OldPrefix = Split.first.str();
  438   NewPrefix = Split.second.str();
  618         OutputName = Filename + ".thinlto.bc";
  620       OutputName = getThinLTOOutputFile(OutputName, OldPrefix, NewPrefix);
  648         OutputName = Filename + ".imports";
  650       OutputName =
  678         OutputName = Filename + ".thinlto.promoted.bc";
  711         OutputName = Filename + ".thinlto.imported.bc";
  744         OutputName = Filename + ".thinlto.internalized.bc";
  769         OutputName = Filename + ".thinlto.imported.bc";
  798         OutputName = std::get<1>(BinName) + ".thinlto.o";
  946     CurrentActivity = "loading file '" + InputFilenames[i] + "'";

  415     FeaturesStr = Features.getString();

 1872                   ArchitectureName = I->getArchFlagName();
 1903                     ArchiveName = A->getFileName();
 1905                       ArchitectureName = I->getArchFlagName();
 1972                   ArchiveName = A->getFileName();
 2006             ArchitectureName = O.getArchFlagName();
 2037               ArchiveName = A->getFileName();
 2039                 ArchitectureName = O.getArchFlagName();

  390       Sym.Name = I->getValue();
  393       Sym.Name = (Config.SymbolsPrefix + Sym.Name).str();
  621         Sec.Name = SR.NewName;
  635         Sec.Name = (Config.AllocSectionsPrefix + Sec.Name).str();
  664             Sec.Name = (prefix + TargetSec->Name).str();
  666             Sec.Name =

  515     Name = ".z" + Sec.Name.substr(1);
  652   Sym.Name = Name.str();
 1512     Sec.Name = unwrapOrError(ElfFile.getSectionName(&Shdr));

  492     Name = SecName.str();
  500     Name = SecName.str();
  548       Name = "." + Name.substr(2);

   33   S.Sectname =
   36   S.Segname =
   38   S.CanonicalName = (Twine(S.Segname) + "," + S.Sectname).str();
  181   SE.Name = StringRef(StrTable.data() + nlist.n_strx).str();

 2403             ArchitectureName = I->getArchFlagName();
 2519       ArchitectureName = I->getArchFlagName();
 7209     FeaturesStr = Features.getString();
 7355         DSYMPath = FullPath.str();

  565     SymbolizerOpts.DefaultArch = DefaultArch;
  616     ErrorMessage = toString(ExpectedLineInfo.takeError());
 1281         SymbolName = demangle(SymbolName);

  552     NameInsert = formatv("[{0}]", SectionName).str();
  929         LineStr = utostr(Line.getStartLine());

  240         H = "0x" + utohexstr(Hash);
  242         H = "0x" + utohexstr(Hash) + ", our hash = 0x" + utohexstr(OurHash);

   35   Result.Name = Name;
   44   Result.Name = Module;
   93         NamedStreams[NSE.second] = NSE.first();

   37   CurMessage = "Error parsing file: expected " + Expected.str() + ", got " +

 1803   SOName = getDynamicString(SONameOffset);
 2761   Str = printEnum(e->e_ident[ELF::EI_CLASS], makeArrayRef(ElfClass));
 2763   Str = printEnum(e->e_ident[ELF::EI_DATA], makeArrayRef(ElfDataEncoding));
 2772   Str = printEnum(e->e_ident[ELF::EI_OSABI], makeArrayRef(ElfOSABI));
 2774   Str = "0x" + to_hexString(e->e_ident[ELF::EI_ABIVERSION]);
 2776   Str = printEnum(e->e_type, makeArrayRef(ElfObjectFileType));
 2778   Str = printEnum(e->e_machine, makeArrayRef(ElfMachineType));
 2780   Str = "0x" + to_hexString(e->e_version);
 2782   Str = "0x" + to_hexString(e->e_entry);
 2784   Str = to_string(e->e_phoff) + " (bytes into file)";
 2786   Str = to_string(e->e_shoff) + " (bytes into file)";
 2790     ElfFlags =
 2795     ElfFlags = printFlags(e->e_flags, makeArrayRef(ElfHeaderRISCVFlags));
 2796   Str = "0x" + to_hexString(e->e_flags);
 2798     Str = Str + ", " + ElfFlags;
 2800   Str = to_string(e->e_ehsize) + " (bytes)";
 2802   Str = to_string(e->e_phentsize) + " (bytes)";
 2806   Str = to_string(e->e_shentsize) + " (bytes)";
 2808   Str = getSectionHeadersNumString(Obj, this->FileName);
 2810   Str = getSectionHeaderTableIndexString(Obj, this->FileName);
 2924     TargetName = unwrapOrError(this->FileName, Obj->getSectionName(Sec));
 2928     TargetName = this->dumper()->getFullSymbolName(
 2953   Fields[4].Str = SymbolName;
 3212     Fields[1].Str = unwrapOrError<StringRef>(
 3214     Fields[2].Str =
 3221     Fields[7].Str = getGNUFlags(Sec.sh_flags);
 3326   Fields[0].Str = to_string(format_decimal(Idx++, 6)) + ":";
 3334     Fields[3].Str = printEnum(SymbolType, makeArrayRef(AMDGPUSymbolTypes));
 3336     Fields[3].Str = printEnum(SymbolType, makeArrayRef(ElfSymbolTypes));
 3338   Fields[4].Str =
 3340   Fields[5].Str =
 3347   Fields[6].Str = getSymbolSectionNdx(Obj, Symbol, FirstSym);
 3349   Fields[7].Str =
 3364   Fields[1].Str = to_string(format_decimal(Bucket, 3)) + ":";
 3374     Fields[4].Str = printEnum(SymbolType, makeArrayRef(AMDGPUSymbolTypes));
 3376     Fields[4].Str = printEnum(SymbolType, makeArrayRef(ElfSymbolTypes));
 3378   Fields[5].Str =
 3380   Fields[6].Str =
 3382   Fields[7].Str = getSymbolSectionNdx(Obj, Symbol, FirstSym);
 3383   Fields[8].Str = this->dumper()->getFullSymbolName(Symbol, StrTable, true);
 3568     Fields[0].Str = getElfPtType(Header->e_machine, Phdr.p_type);
 3574     Fields[6].Str = printPhdrFlags(Phdr.p_flags);
 3645     Name = maybeDemangle(*ErrOrName);
 3822           VersionName = "(" + VersionName + ")";
 4740     FuncName = getSymbolName(FuncSym);
 5318     TargetName = unwrapOrError(this->FileName, Obj->getSectionName(Sec));
 5322     TargetName = this->dumper()->getFullSymbolName(

  203       ModuleName = std::string(pos, end - pos);
  207       ModuleName = std::string(pos, name_length);

  290     Row.Function = FuncIdHelper.SymbolOrNumber(FuncId);
  291     Row.DebugInfo = FuncIdHelper.FileLineAndColumn(FuncId);

  206       G[Record.FuncId].SymbolName = FuncIdHelper.SymbolOrNumber(Record.FuncId);

  109     Ret = (Name + " [" + Twine(++It.first->second) + "]").str();
  111     Ret = Name;
  140       SymbolNames[Index] =
  143       SymbolNames[Index] = Name;

  150   LC.PayloadString = StringRef(Start, Size).str();
  432       Entry.ImportName = std::string(reinterpret_cast<const char *>(CurrPtr));
  450     Child.Name = std::string(reinterpret_cast<const char *>(CurrPtr));

   34         N = N + NS->getName().str() + "::";
   39         N = N + TY->getName().str() + "::";
   53         Name = Name + SP->getName().str();

   41     PassName = "FunctionPass Printer: " + PassToPrintName;
   74     PassName = "CallGraphSCCPass Printer: " + PassToPrintName;
  111     PassName = "ModulePass Printer: " + PassToPrintName;
  143     PassName = "LoopPass Printer: " + PassToPrintName;
  176     PassName = "RegionPass Printer: " + PassToPrintName;
  211     PassName = "BasicBlockPass Printer: " + PassToPrintName;

  638     CPUStr = getCPUStr();
  639     FeaturesStr = getFeaturesStr();

  150       Location = escapeString(FileName + ":" + std::to_string(LineBegin) + "-" +
  155     ErrorMessage = escapeString(ErrorMessage);

 1206   BaseName = getIslCompatibleName("CopyStmt_", "",
 1481     Name = "__" + Iterator->getValue();
 1502       ParameterName = getCallParamName(Call);
 1508         ParameterName = Val->getName();
 1519     ParameterName = getIslCompatibleName("", ParameterName, "");

  136     Location = FileName + ":" + std::to_string(LineBegin) + "-" +

   58       Dumpfile = (Twine(Stem) + Filename + ".ll").str();

  211     ValStr = std::string("_") + std::string(Val->getName());
  213     ValStr = std::to_string(Number);

  651     AName = ASpace.get_tuple_name(isl::dim::set);
  655     BName = BSpace.get_tuple_name(isl::dim::set);
  736       Str = isl::map(BSet.unwrap()).to_str();
  738       Str = isl::set(BSet).to_str();

   35         FileName = Scope->getFilename();

  394       Coverage->BinaryHash = parseScalarString(KVNode.getValue());
  562     LineInfo->FileName = normalizeFilename(LineInfo->FileName);
  579       FrameInfo.FileName = normalizeFilename(FrameInfo.FileName);
  873   Coverage->BinaryHash = toHex(Hasher.final());
 1027       Prefix = utostr(I);
 1036       NewPoint.Id = Prefix + CovPoint.Id;

   59     Filename = std::string(llvm::sys::path::parent_path(ClInputFile)) +

  375   Buffer = std::string("\xa1") + Result;
  387   Buffer = std::string("\xbf") + Result;
  408   Buffer = std::string("\xd9\x01") + Result;
  419   Buffer = std::string("\xd9\xff") + Result;
  440   Buffer = std::string("\xda\x00\x01", 3) + Result;
  451   Buffer = std::string("\xda\xff\xff") + Result;
  472   Buffer = std::string("\xdb\x00\x00\x00\x01", 5) + Result;
  483   Buffer = std::string("\xdb\x00\x01\x00\x00", 5) + Result;
  504   Buffer = std::string("\xc4\x01") + Result;
  515   Buffer = std::string("\xc4\xff") + Result;
  536   Buffer = std::string("\xc5\x00\x01", 3) + Result;
  547   Buffer = std::string("\xc5\xff\xff") + Result;
  568   Buffer = std::string("\xc6\x00\x00\x00\x01", 5) + Result;
  579   Buffer = std::string("\xc6\x00\x01\x00\x00", 5) + Result;
  774   Buffer = std::string("\xd4\x01") + Result;
  786   Buffer = std::string("\xd5\x01") + Result;
  798   Buffer = std::string("\xd6\x01") + Result;
  810   Buffer = std::string("\xd7\x01") + Result;
  822   Buffer = std::string("\xd8\x01") + Result;
  846   Buffer = std::string("\xc7\xff\x01", 3) + Result;
  858   Buffer = std::string("\xc8\x01\x00\x01", 4) + Result;
  870   Buffer = std::string("\xc8\xff\xff\x01") + Result;
  882   Buffer = std::string("\xc9\x00\x01\x00\x00\x01", 6) + Result;

   53     HostTriple = Triple::normalize(HostTriple);

   31     FoundMsg = CME.message();

   29     FoundMsg = IPE.message();

   73     WorkingDirectory = Path.str();

 1112       value.str = scalar.str();

   55   Hash = toHex(Sha1Stream.sha1());
   74   Hash = toHex(Sha1Stream.sha1());

 1375 	return *this = std::move(__str);

  485 	__st = _M_traits.transform_primary(__st.data(),

  871 	    *__result = _GLIBCXX_MOVE(*__first);
  975 	  *++__dest = _GLIBCXX_MOVE(*__first);
 1367 		  *(__p + __n - 1) = _GLIBCXX_MOVE(__t);
 1390 		  *__p = _GLIBCXX_MOVE(__t);
 1830 	  *__last = _GLIBCXX_MOVE(*__next);
 1834       *__last = _GLIBCXX_MOVE(__val);
 1852 	      *__first = _GLIBCXX_MOVE(__val);
 2312 	      *__result = _GLIBCXX_MOVE(*__first2);
 2317 	      *__result = _GLIBCXX_MOVE(*__first1);
 2351 	      *--__result = _GLIBCXX_MOVE(*__last1);
 2361 	      *--__result = _GLIBCXX_MOVE(*__last2);
 2647 	      *__result = _GLIBCXX_MOVE(*__first2);
 2652 	      *__result = _GLIBCXX_MOVE(*__first1);

  324 	      *__result = *__first;
  343 	      *__result = std::move(*__first);
  548 	    *--__result = std::move(*--__last);

  135 	  *(__first + __holeIndex) = _GLIBCXX_MOVE(*(__first + __parent));
  139       *(__first + __holeIndex) = _GLIBCXX_MOVE(__value);
  225 	  *(__first + __holeIndex) = _GLIBCXX_MOVE(*(__first + __secondChild));
  231 	  *(__first + __holeIndex) = _GLIBCXX_MOVE(*(__first
  252       *__result = _GLIBCXX_MOVE(*__first);

  396 	first = std::forward<first_type>(__p.first);
  397 	second = std::forward<second_type>(__p.second);

  201 	      *__seed = _GLIBCXX_MOVE(*__prev);

  386       *__position = std::forward<_Arg>(__arg);

  173 	      __ret = __string_type(this->pbase(), this->pptr());
  175  	      __ret = __string_type(this->pbase(), this->egptr());

  304 	_M_head(*this) = std::forward<_Head>(_M_head(__in));
  322 	  _M_head(*this) = std::forward<_UHead>
  434 	_M_head(*this) = std::forward<_Head>(_M_head(__in));
 1252 	  this->_M_head(*this) = std::forward<_U1>(__in.first);
 1253 	  this->_M_tail(*this)._M_head(*this) = std::forward<_U2>(__in.second);

  916   AsmString =
 1136     Entry->Name = "MCK_" + getEnumNameForToken(Token);
 1137     Entry->ValueName = Token;
 1271     CI->ClassName = "Reg" + utostr(Index);
 1272     CI->Name = "MCK_Reg" + utostr(Index);
 1306       CI->Name = "MCK_" + RC.getName();
 1309       CI->ValueName = CI->ValueName + "," + RC.getName();
 1313       CI->DiagnosticType = SI->getValue();
 1317       CI->DiagnosticString = SI->getValue();
 1338       CI->ClassName = Rec->getName();
 1339       CI->Name = "MCK_" + Rec->getName().str();
 1340       CI->ValueName = Rec->getName();
 1342       CI->ValueName = CI->ValueName + "," + Rec->getName().str();
 1375     CI->ClassName = Rec->getValueAsString("Name");
 1376     CI->Name = "MCK_" + CI->ClassName;
 1377     CI->ValueName = Rec->getName();
 1382       CI->PredicateMethod = SI->getValue();
 1385       CI->PredicateMethod = "is" + CI->ClassName;
 1391       CI->RenderMethod = SI->getValue();
 1394       CI->RenderMethod = "add" + CI->ClassName + "Operands";
 1400       CI->ParserMethod = SI->getValue();
 1405       CI->DiagnosticType = SI->getValue();
 1408       CI->DiagnosticString = SI->getValue();
 1421       CI->DefaultMethod = SI->getValue();
 1424       CI->DefaultMethod = "default" + CI->ClassName + "Operands";
 2092         Class = Op.Class->isRegisterClass() ? "Reg" : Op.Class->ClassName;
 2106         Name = getEnumNameForToken(Name);
 2181         Ty = getEnumNameForToken(Ty);
 2212           Reg = getQualifiedName(OpInfo.Register);
 2213           Name = "reg" + OpInfo.Register->getName().str();
 2216         Name = "CVT_" + Name;

  241       UniqueOperandCommands[i] = "    // " + Instrs + "\n" +
  510       AsmName = Reg.TheDef->getValueAsString("AsmName");
  512         AsmName = Reg.getName();
  531         AsmName = AltNames[Idx];
  836       Cond = std::string("MI->getNumOperands() == ") + utostr(NumMIOps);
  895               Cond = std::string("MRI.getRegClass(") + Target.getName().str() +
  899               Cond = Op + ".getReg() == MI->getOperand(" +
  917             Cond = (Target.getName() + ClassName + "ValidateMCOperand(" + Op +
  930           Cond = Op + ".getImm() == " + itostr(CGA.ResultOperands[i].getImm());
  942           Cond = Op + ".getReg() == " + Target.getName().str() + "::" +
  965             Cond = ("!STI.getFeatureBits()[" + Namespace + "::" + Op.substr(1) +
  969             Cond =

  153           Modifier = std::string(AsmString.begin()+ModifierStart,

  226         extractStr = "op.extractBits(" + itostr(hiBit - loBit) + ", " +
  231         extractStr = "op.extractBitsAsZExtValue(" + itostr(hiBit - loBit) +
  240       maskStr = "UINT64_C(" + utostr(opMask) + ")";

 1318     Result = "    auto *N = cast<" + ClassName.str() + ">(Node);\n";

   23   Features = R->getValueAsString("Features");

   83       PrintMethod = Rec->getValueAsString("PrintMethod");
   84       OperandType = Rec->getValueAsString("OperandType");
   85       OperandNamespace = Rec->getValueAsString("OperandNamespace");
   86       EncoderMethod = Rec->getValueAsString("EncoderMethod");
   88       PrintMethod = Rec->getValueAsString("PrintMethod");
   89       OperandType = Rec->getValueAsString("OperandType");
   90       OperandNamespace = Rec->getValueAsString("OperandNamespace");
   92       EncoderMethod = Rec->getValueAsString("EncoderMethod");
  185     SubOpName = OpName.substr(DotIdx+1);
  190     OpName = OpName.substr(0, DotIdx);
  241     Name = Name.substr(wpos);
  343     DisableEncoding = P.second;
  364   AsmString = R->getValueAsString("AsmString");
  430     DeprecatedReason = R->getValueAsString("ComplexDeprecationPredicate");
  434     DeprecatedReason = Dep->getValue()->getAsString();
  668   AsmString = R->getValueAsString("AsmString");

  101     Name = MapRec->getName();
  107     FilterClass = Filter->getValue()->getAsUnquotedString();

   55   Name = R->getName();
   57     Namespace = R->getValueAsString("Namespace");
 1942       RegUnitSets.back().Name =

  557       Name = Name + "Model";
  980     Name = ItinClassDef->getName();

   61     Name = Def->getName();

  209      Namespace = R->getValueAsString("Namespace");
  529   SelectFunc  = R->getValueAsString("SelectFunc");
  624   EnumName = std::string(DefName.begin()+4, DefName.end());
  627     GCCBuiltinName = R->getValueAsString("GCCBuiltinName");
  629     MSBuiltinName = R->getValueAsString("MSBuiltinName");
  631   TargetPrefix = R->getValueAsString("TargetPrefix");
  632   Name = R->getValueAsString("LLVMName");

  356       Types.back() = TypeOverride;

  104   Target = Targets[0]->getName();

  507         SubRegNo = getQualifiedName(SR->getDef());
  509         SubRegNo = Dst->getChild(1)->getLeafValue()->getAsString();

 1776     Decoder = String->getValue();
 1785     Decoder = "Decode" + Record->getName().str() + "RegisterClass";
 1787     Decoder = "DecodePointerLikeRegClass" +
 1843       TiedNames[InOutOperands[i].second] = InOutOperands[SO.first].second;
 1844       TiedNames[InOutOperands[SO.first].second] = InOutOperands[i].second;
 1940         Decoder = String->getValue();
 1955         Decoder = "Decode" + TypeRecord->getName().str() + "RegisterClass";
 1958         Decoder = "DecodePointerLikeRegClass" +
 1967         Decoder = String->getValue();

  360     Explanation = Separator + "Has a predicate (" + explainPredicates(N) + ")";
 1501     SymbolicName = Name;

  605     CurOp = Source.TheDef->getName().str();

  261         LHSs = StringRef(LHSs).upper();
  262         RHSs = StringRef(RHSs).upper();
  346           Repr = StringRef(Repr).upper();
  545   Index->Name = Name;
  651     Enum->Name = EnumRec->getName();
  652     Enum->PreprocessorGuard = EnumRec->getName();
  668     Table->Name = TableRec->getName();
  669     Table->PreprocessorGuard = TableRec->getName();
  670     Table->CppTypeName = TableRec->getValueAsString("CppTypeName");
  737       Enum->Name = (Twine(Class->getName()) + "Values").str();
  738       Enum->PreprocessorGuard = Class->getName().upper();
  747     Table->Name = (Twine(Class->getName()) + "sList").str();
  748     Table->PreprocessorGuard = Class->getName().upper();
  749     Table->CppTypeName = Class->getName();

   78     Names[SF.second.Index] = SF.second.getEnumName();

   68   Name = Rec->getName();
   97   Name      = Rec->getName();

  187   big_o.benchmark_name = benchmark_name + "_BigO";
  204   rms.benchmark_name = benchmark_name + "_RMS";

  120     rate = StrCat(" ", HumanReadableNumber(result.bytes_per_second), "B/s");
  126     items =

   95   indent = std::string(6, ' ');
  112   indent = std::string(4, ' ');

  154     data.benchmark_name = reports[0].benchmark_name + "_" + Stat.name_;

   57         *mantissa = mantissa_stream.str();
   72           *mantissa = mantissa_stream.str();
   83   *mantissa = mantissa_stream.str();

  200   *arg = ArgT();
  227     Part = "0x" + Part;
  235     Val = Val.substr(Pos + 1);
  405     if (SplitIdx != std::string::npos) value = ln.substr(SplitIdx + 1);
  476     if (SplitIdx != std::string::npos) value = ln.substr(SplitIdx + 1);

 3191         explanations[exam_pos] = s.str();

  561           test_case_name = instantiation_name + "/";

  170     dir = std::string(c_str(), last_sep + 1 - c_str());
  189     file = base_name.string() + "." + extension;
  191     file = base_name.string() + "_" + StreamableToString(number)

  516     positive = std::string(p, dash);   // Everything up to the dash
  517     negative = std::string(dash + 1);  // Everything after the dash
 3833   trace.message = message.GetString();