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

Derived Classes

  116 class TypeSpec : public std::string {

References

    5   std::string x = "hello";
    7     std::string copy(x);

   60 static cl::opt<std::string>
   63 static cl::opt<std::string>
  121       std::string base = InputFilename;

  117   std::string errStr;

   63 static std::string IdentifierStr; // Filled in if tok_identifier
  103     std::string NumStr;
  159   std::string Name;
  162   VariableExprAST(const std::string &Name) : Name(Name) {}
  165   const std::string &getName() const { return Name; }
  195   std::string Callee;
  199   CallExprAST(const std::string &Callee,
  220   std::string VarName;
  224   ForExprAST(const std::string &VarName, std::unique_ptr<ExprAST> Start,
  235   std::vector<std::pair<std::string, std::unique_ptr<ExprAST>>> VarNames;
  240       std::vector<std::pair<std::string, std::unique_ptr<ExprAST>>> VarNames,
  251   std::string Name;
  252   std::vector<std::string> Args;
  257   PrototypeAST(const std::string &Name, std::vector<std::string> Args,
  257   PrototypeAST(const std::string &Name, std::vector<std::string> Args,
  263   const std::string &getName() const { return Name; }
  354   std::string IdName = IdentifierStr;
  423   std::string IdName = IdentifierStr;
  467   std::vector<std::pair<std::string, std::unique_ptr<ExprAST>>> VarNames;
  474     std::string Name = IdentifierStr;
  605   std::string FnName;
  649   std::vector<std::string> ArgNames;
  703 static std::map<std::string, AllocaInst *> NamedValues;
  704 static std::map<std::string, std::unique_ptr<PrototypeAST>> FunctionProtos;
  712 Function *getFunction(std::string Name) {
  730                                           const std::string &VarName) {
  994     const std::string &VarName = VarNames[i].first;

   63 static std::string IdentifierStr; // Filled in if tok_identifier
  103     std::string NumStr;
  159   std::string Name;
  162   VariableExprAST(const std::string &Name) : Name(Name) {}
  165   const std::string &getName() const { return Name; }
  195   std::string Callee;
  199   CallExprAST(const std::string &Callee,
  220   std::string VarName;
  224   ForExprAST(const std::string &VarName, std::unique_ptr<ExprAST> Start,
  235   std::vector<std::pair<std::string, std::unique_ptr<ExprAST>>> VarNames;
  240       std::vector<std::pair<std::string, std::unique_ptr<ExprAST>>> VarNames,
  251   std::string Name;
  252   std::vector<std::string> Args;
  257   PrototypeAST(const std::string &Name, std::vector<std::string> Args,
  257   PrototypeAST(const std::string &Name, std::vector<std::string> Args,
  263   const std::string &getName() const { return Name; }
  354   std::string IdName = IdentifierStr;
  423   std::string IdName = IdentifierStr;
  467   std::vector<std::pair<std::string, std::unique_ptr<ExprAST>>> VarNames;
  474     std::string Name = IdentifierStr;
  605   std::string FnName;
  649   std::vector<std::string> ArgNames;
  703 static std::map<std::string, AllocaInst *> NamedValues;
  704 static std::map<std::string, std::unique_ptr<PrototypeAST>> FunctionProtos;
  712 Function *getFunction(std::string Name) {
  730                                           const std::string &VarName) {
  994     const std::string &VarName = VarNames[i].first;

  120   JITSymbol findSymbol(const std::string Name) {
  121     std::string MangledName;

   63 static std::string IdentifierStr; // Filled in if tok_identifier
  103     std::string NumStr;
  159   std::string Name;
  162   VariableExprAST(const std::string &Name) : Name(Name) {}
  165   const std::string &getName() const { return Name; }
  195   std::string Callee;
  199   CallExprAST(const std::string &Callee,
  220   std::string VarName;
  224   ForExprAST(const std::string &VarName, std::unique_ptr<ExprAST> Start,
  235   std::vector<std::pair<std::string, std::unique_ptr<ExprAST>>> VarNames;
  240       std::vector<std::pair<std::string, std::unique_ptr<ExprAST>>> VarNames,
  251   std::string Name;
  252   std::vector<std::string> Args;
  257   PrototypeAST(const std::string &Name, std::vector<std::string> Args,
  257   PrototypeAST(const std::string &Name, std::vector<std::string> Args,
  263   const std::string &getName() const { return Name; }
  354   std::string IdName = IdentifierStr;
  423   std::string IdName = IdentifierStr;
  467   std::vector<std::pair<std::string, std::unique_ptr<ExprAST>>> VarNames;
  474     std::string Name = IdentifierStr;
  605   std::string FnName;
  649   std::vector<std::string> ArgNames;
  702 static std::map<std::string, AllocaInst *> NamedValues;
  704 static std::map<std::string, std::unique_ptr<PrototypeAST>> FunctionProtos;
  711 Function *getFunction(std::string Name) {
  729                                           const std::string &VarName) {
  993     const std::string &VarName = VarNames[i].first;

   59   const std::string& getName() const;
   68 irgenAndTakeOwnership(FunctionAST &FnAST, const std::string &Suffix);
  192   JITSymbol findSymbol(const std::string Name) {
  201   std::string mangle(const std::string &Name) {
  201   std::string mangle(const std::string &Name) {
  202     std::string MangledName;

   65 static std::string IdentifierStr; // Filled in if tok_identifier
  105     std::string NumStr;
  159   std::string Name;
  162   VariableExprAST(const std::string &Name) : Name(Name) {}
  165   const std::string &getName() const { return Name; }
  195   std::string Callee;
  199   CallExprAST(const std::string &Callee,
  220   std::string VarName;
  224   ForExprAST(const std::string &VarName, std::unique_ptr<ExprAST> Start,
  235   std::vector<std::pair<std::string, std::unique_ptr<ExprAST>>> VarNames;
  240       std::vector<std::pair<std::string, std::unique_ptr<ExprAST>>> VarNames,
  251   std::string Name;
  252   std::vector<std::string> Args;
  257   PrototypeAST(const std::string &Name, std::vector<std::string> Args,
  257   PrototypeAST(const std::string &Name, std::vector<std::string> Args,
  263   const std::string &getName() const { return Name; }
  339   std::string IdName = IdentifierStr;
  408   std::string IdName = IdentifierStr;
  452   std::vector<std::pair<std::string, std::unique_ptr<ExprAST>>> VarNames;
  459     std::string Name = IdentifierStr;
  590   std::string FnName;
  634   std::vector<std::string> ArgNames;
  687 static std::map<std::string, AllocaInst *> NamedValues;
  689 static std::map<std::string, std::unique_ptr<PrototypeAST>> FunctionProtos;
  697 Function *getFunction(std::string Name) {
  715                                           const std::string &VarName) {
  979     const std::string &VarName = VarNames[i].first;
 1041 const std::string& FunctionAST::getName() const {
 1103 irgenAndTakeOwnership(FunctionAST &FnAST, const std::string &Suffix) {

   61   const std::string& getName() const;
   70 irgenAndTakeOwnership(FunctionAST &FnAST, const std::string &Suffix);
  209   JITSymbol findSymbol(const std::string Name) {
  218   std::string mangle(const std::string &Name) {
  218   std::string mangle(const std::string &Name) {
  219     std::string MangledName;

   41 cl::opt<std::string> HostName("hostname",
   82 static std::string IdentifierStr; // Filled in if tok_identifier
  122     std::string NumStr;
  176   std::string Name;
  179   VariableExprAST(const std::string &Name) : Name(Name) {}
  182   const std::string &getName() const { return Name; }
  212   std::string Callee;
  216   CallExprAST(const std::string &Callee,
  237   std::string VarName;
  241   ForExprAST(const std::string &VarName, std::unique_ptr<ExprAST> Start,
  252   std::vector<std::pair<std::string, std::unique_ptr<ExprAST>>> VarNames;
  257       std::vector<std::pair<std::string, std::unique_ptr<ExprAST>>> VarNames,
  268   std::string Name;
  269   std::vector<std::string> Args;
  274   PrototypeAST(const std::string &Name, std::vector<std::string> Args,
  274   PrototypeAST(const std::string &Name, std::vector<std::string> Args,
  280   const std::string &getName() const { return Name; }
  356   std::string IdName = IdentifierStr;
  425   std::string IdName = IdentifierStr;
  469   std::vector<std::pair<std::string, std::unique_ptr<ExprAST>>> VarNames;
  476     std::string Name = IdentifierStr;
  607   std::string FnName;
  651   std::vector<std::string> ArgNames;
  711 static std::map<std::string, AllocaInst *> NamedValues;
  713 static std::map<std::string, std::unique_ptr<PrototypeAST>> FunctionProtos;
  721 Function *getFunction(std::string Name) {
  739                                           const std::string &VarName) {
 1003     const std::string &VarName = VarNames[i].first;
 1065 const std::string& FunctionAST::getName() const {
 1127 irgenAndTakeOwnership(FunctionAST &FnAST, const std::string &Suffix) {

   29 static std::string IdentifierStr; // Filled in if tok_identifier
   53     std::string NumStr;
  105   std::string Name;
  108   VariableExprAST(const std::string &Name) : Name(Name) {}
  124   std::string Callee;
  128   CallExprAST(const std::string &Callee,
  137   std::string Name;
  138   std::vector<std::string> Args;
  141   PrototypeAST(const std::string &Name, std::vector<std::string> Args)
  141   PrototypeAST(const std::string &Name, std::vector<std::string> Args)
  144   const std::string &getName() const { return Name; }
  222   std::string IdName = IdentifierStr;
  325   std::string FnName = IdentifierStr;
  331   std::vector<std::string> ArgNames;

   41 static std::string IdentifierStr; // Filled in if tok_identifier
   65     std::string NumStr;
  121   std::string Name;
  124   VariableExprAST(const std::string &Name) : Name(Name) {}
  144   std::string Callee;
  148   CallExprAST(const std::string &Callee,
  159   std::string Name;
  160   std::vector<std::string> Args;
  163   PrototypeAST(const std::string &Name, std::vector<std::string> Args)
  163   PrototypeAST(const std::string &Name, std::vector<std::string> Args)
  167   const std::string &getName() const { return Name; }
  248   std::string IdName = IdentifierStr;
  351   std::string FnName = IdentifierStr;
  357   std::vector<std::string> ArgNames;
  405 static std::map<std::string, Value *> NamedValues;

   51 static std::string IdentifierStr; // Filled in if tok_identifier
   75     std::string NumStr;
  131   std::string Name;
  134   VariableExprAST(const std::string &Name) : Name(Name) {}
  154   std::string Callee;
  158   CallExprAST(const std::string &Callee,
  169   std::string Name;
  170   std::vector<std::string> Args;
  173   PrototypeAST(const std::string &Name, std::vector<std::string> Args)
  173   PrototypeAST(const std::string &Name, std::vector<std::string> Args)
  177   const std::string &getName() const { return Name; }
  258   std::string IdName = IdentifierStr;
  361   std::string FnName = IdentifierStr;
  367   std::vector<std::string> ArgNames;
  415 static std::map<std::string, Value *> NamedValues;
  418 static std::map<std::string, std::unique_ptr<PrototypeAST>> FunctionProtos;
  425 Function *getFunction(std::string Name) {

   59 static std::string IdentifierStr; // Filled in if tok_identifier
   93     std::string NumStr;
  149   std::string Name;
  152   VariableExprAST(const std::string &Name) : Name(Name) {}
  172   std::string Callee;
  176   CallExprAST(const std::string &Callee,
  197   std::string VarName;
  201   ForExprAST(const std::string &VarName, std::unique_ptr<ExprAST> Start,
  214   std::string Name;
  215   std::vector<std::string> Args;
  218   PrototypeAST(const std::string &Name, std::vector<std::string> Args)
  218   PrototypeAST(const std::string &Name, std::vector<std::string> Args)
  222   const std::string &getName() const { return Name; }
  303   std::string IdName = IdentifierStr;
  372   std::string IdName = IdentifierStr;
  488   std::string FnName = IdentifierStr;
  494   std::vector<std::string> ArgNames;
  542 static std::map<std::string, Value *> NamedValues;
  545 static std::map<std::string, std::unique_ptr<PrototypeAST>> FunctionProtos;
  552 Function *getFunction(std::string Name) {

   63 static std::string IdentifierStr; // Filled in if tok_identifier
  101     std::string NumStr;
  157   std::string Name;
  160   VariableExprAST(const std::string &Name) : Name(Name) {}
  192   std::string Callee;
  196   CallExprAST(const std::string &Callee,
  217   std::string VarName;
  221   ForExprAST(const std::string &VarName, std::unique_ptr<ExprAST> Start,
  234   std::string Name;
  235   std::vector<std::string> Args;
  240   PrototypeAST(const std::string &Name, std::vector<std::string> Args,
  240   PrototypeAST(const std::string &Name, std::vector<std::string> Args,
  246   const std::string &getName() const { return Name; }
  337   std::string IdName = IdentifierStr;
  406   std::string IdName = IdentifierStr;
  537   std::string FnName;
  581   std::vector<std::string> ArgNames;
  634 static std::map<std::string, Value *> NamedValues;
  637 static std::map<std::string, std::unique_ptr<PrototypeAST>> FunctionProtos;
  644 Function *getFunction(std::string Name) {

   68 static std::string IdentifierStr; // Filled in if tok_identifier
  108     std::string NumStr;
  164   std::string Name;
  167   VariableExprAST(const std::string &Name) : Name(Name) {}
  170   const std::string &getName() const { return Name; }
  200   std::string Callee;
  204   CallExprAST(const std::string &Callee,
  225   std::string VarName;
  229   ForExprAST(const std::string &VarName, std::unique_ptr<ExprAST> Start,
  240   std::vector<std::pair<std::string, std::unique_ptr<ExprAST>>> VarNames;
  245       std::vector<std::pair<std::string, std::unique_ptr<ExprAST>>> VarNames,
  256   std::string Name;
  257   std::vector<std::string> Args;
  262   PrototypeAST(const std::string &Name, std::vector<std::string> Args,
  262   PrototypeAST(const std::string &Name, std::vector<std::string> Args,
  268   const std::string &getName() const { return Name; }
  359   std::string IdName = IdentifierStr;
  428   std::string IdName = IdentifierStr;
  472   std::vector<std::pair<std::string, std::unique_ptr<ExprAST>>> VarNames;
  479     std::string Name = IdentifierStr;
  610   std::string FnName;
  654   std::vector<std::string> ArgNames;
  707 static std::map<std::string, AllocaInst *> NamedValues;
  710 static std::map<std::string, std::unique_ptr<PrototypeAST>> FunctionProtos;
  717 Function *getFunction(std::string Name) {
  735                                           const std::string &VarName) {
  999     const std::string &VarName = VarNames[i].first;

   69 static std::string IdentifierStr; // Filled in if tok_identifier
  109     std::string NumStr;
  165   std::string Name;
  168   VariableExprAST(const std::string &Name) : Name(Name) {}
  171   const std::string &getName() const { return Name; }
  201   std::string Callee;
  205   CallExprAST(const std::string &Callee,
  226   std::string VarName;
  230   ForExprAST(const std::string &VarName, std::unique_ptr<ExprAST> Start,
  241   std::vector<std::pair<std::string, std::unique_ptr<ExprAST>>> VarNames;
  246       std::vector<std::pair<std::string, std::unique_ptr<ExprAST>>> VarNames,
  257   std::string Name;
  258   std::vector<std::string> Args;
  263   PrototypeAST(const std::string &Name, std::vector<std::string> Args,
  263   PrototypeAST(const std::string &Name, std::vector<std::string> Args,
  269   const std::string &getName() const { return Name; }
  360   std::string IdName = IdentifierStr;
  429   std::string IdName = IdentifierStr;
  473   std::vector<std::pair<std::string, std::unique_ptr<ExprAST>>> VarNames;
  480     std::string Name = IdentifierStr;
  611   std::string FnName;
  655   std::vector<std::string> ArgNames;
  708 static std::map<std::string, AllocaInst *> NamedValues;
  709 static std::map<std::string, std::unique_ptr<PrototypeAST>> FunctionProtos;
  716 Function *getFunction(std::string Name) {
  734                                           const std::string &VarName) {
  998     const std::string &VarName = VarNames[i].first;
 1225   std::string Error;

   54 std::string getTokName(int Tok) {
  119 static std::string IdentifierStr; // Filled in if tok_identifier
  161     std::string NumStr;
  229   std::string Name;
  232   VariableExprAST(SourceLocation Loc, const std::string &Name)
  234   const std::string &getName() const { return Name; }
  277   std::string Callee;
  281   CallExprAST(SourceLocation Loc, const std::string &Callee,
  314   std::string VarName;
  318   ForExprAST(const std::string &VarName, std::unique_ptr<ExprAST> Start,
  336   std::vector<std::pair<std::string, std::unique_ptr<ExprAST>>> VarNames;
  341       std::vector<std::pair<std::string, std::unique_ptr<ExprAST>>> VarNames,
  358   std::string Name;
  359   std::vector<std::string> Args;
  365   PrototypeAST(SourceLocation Loc, const std::string &Name,
  366                std::vector<std::string> Args, bool IsOperator = false,
  371   const std::string &getName() const { return Name; }
  467   std::string IdName = IdentifierStr;
  540   std::string IdName = IdentifierStr;
  584   std::vector<std::pair<std::string, std::unique_ptr<ExprAST>>> VarNames;
  591     std::string Name = IdentifierStr;
  723   std::string FnName;
  769   std::vector<std::string> ArgNames;
  860 static std::map<std::string, AllocaInst *> NamedValues;
  862 static std::map<std::string, std::unique_ptr<PrototypeAST>> FunctionProtos;
  869 Function *getFunction(std::string Name) {
  887                                           const std::string &VarName) {
 1163     const std::string &VarName = VarNames[i].first;

   75   JITSymbol findSymbol(const std::string Name) {
   80   std::string mangle(const std::string &Name) {
   80   std::string mangle(const std::string &Name) {
   81     std::string MangledName;
   89   JITSymbol findMangledSymbol(const std::string &Name) {

   43     std::string ErrMsg;

   26 static cl::list<std::string> InputFiles(cl::Positional, cl::OneOrMore,
   29 static cl::list<std::string> InputArgv("args", cl::Positional,

40900 static std::string AArch64MnemonicSpellCheck(StringRef S, const FeatureBitset &FBS, unsigned VariantID) {
40933   std::string Res = ", did you mean: ";

   82 cl::list<std::string> AArch64PreLegalizerCombinerHelperOption(

15588     std::string msg;

 1097     std::string Name;
 1182     std::string Name;
 1274     std::string Name;
 1407     std::string Name;
 1525     std::string Repr;
 1568     std::string Name;
 1638     std::string Name;
 1706     std::string Name;
 1808     std::string Name;
 1893     std::string Name;
 1975     std::string Name;
 2082     std::string Name;
 2188     std::string Name;
 3803     std::string Name;
 4793     std::string Name;
 4938     std::string Name;

80452 static std::string AMDGPUMnemonicSpellCheck(StringRef S, const FeatureBitset &FBS, unsigned VariantID) {
80488   std::string Res = ", did you mean: ";

34499     std::string msg;

  754     std::string AsmSuffix;

 1755     std::string msg;

15300     std::string Info;
16386 static std::string ARMMnemonicSpellCheck(StringRef S, const FeatureBitset &FBS, unsigned VariantID) {
16418   std::string Res = ", did you mean: ";

16192     std::string msg;

  165     std::string Name;
  339     std::string Name;

  758     std::string msg;

  619     std::string msg;

11535     std::string msg;

  711     std::string msg;

 1087     std::string msg;

11725 static std::string MipsMnemonicSpellCheck(StringRef S, const FeatureBitset &FBS, unsigned VariantID) {
11757   std::string Res = ", did you mean: ";

 8859     std::string msg;

 7182     std::string Info;
 7212 static std::string PPCMnemonicSpellCheck(StringRef S, const FeatureBitset &FBS, unsigned VariantID) {
 7244   std::string Res = ", did you mean: ";

 6239     std::string msg;

 1377     std::string msg;

  482     std::string Name;

 1673     std::string msg;

 9248 static std::string SystemZMnemonicSpellCheck(StringRef S, const FeatureBitset &FBS, unsigned VariantID) {
 9280   std::string Res = ", did you mean: ";

 8725     std::string msg;

 2473     std::string msg;

 6203   std::string getValueString(const PrintingPolicy &Policy) const {
 6204     std::string ValueName;
 6222   std::string getDiagnosticName(const PrintingPolicy &Policy) const {
13715       std::vector<std::string> Features;

   86     SmallVector<std::string, 4> tagsStorage;
  144     std::string aliasee= Record.readString();
  224     std::string annotation= Record.readString();
  294     std::string label= Record.readString();
  358     std::string message= Record.readString();
  360     std::string replacement= Record.readString();
  561     std::string name= Record.readString();
  595     std::string name= Record.readString();
  710     std::string message= Record.readString();
  711     std::string replacement= Record.readString();
  730     std::string message= Record.readString();
  759     std::string message= Record.readString();
  799     std::string language= Record.readString();
  800     std::string definedIn= Record.readString();
  933     std::string resolver= Record.readString();
  949     std::string section= Record.readString();
 1321     SmallVector<std::string, 4> sanitizersStorage;
 1485     SmallVector<std::string, 4> implVendorsStorage;
 1731     std::string metadataName= Record.readString();
 1912     std::string name= Record.readString();
 1921     std::string name= Record.readString();
 1930     std::string name= Record.readString();
 1939     std::string name= Record.readString();
 1948     std::string name= Record.readString();
 2125     std::string name= Record.readString();
 2193     SmallVector<std::string, 4> diagnosticIdentifiersStorage;
 2246     std::string model= Record.readString();
 2255     std::string featuresStr= Record.readString();
 2362     std::string message= Record.readString();
 2396     std::string guid= Record.readString();
 2447     std::string message= Record.readString();
 2472     std::string aliasee= Record.readString();
 2481     std::string importModule= Record.readString();
 2490     std::string importName= Record.readString();

79636     std::string& retval
79772     std::string &error_string,
80361 std::string& output)
80389 std::string& output)
80417 std::string& output)
80445 std::string& output)
80473 std::string& output)
80504     std::string python_function_name_string = python_module_name;

 9740 using TupleAutomatonAction = std::tuple<SymKind, SymKind, std::string>;

 1703   std::string toString(unsigned Radix, bool Signed) const;

   87   std::string toString(unsigned Radix) const {

  124 inline std::string utohexstr(uint64_t X, bool LowerCase = false) {
  141 inline std::string toHex(StringRef Input, bool LowerCase = false) {
  146   std::string Output;
  156 inline std::string toHex(ArrayRef<uint8_t> Input, bool LowerCase = false) {
  170 inline std::string fromHex(StringRef Input) {
  174   std::string Output;
  223 inline std::string utostr(uint64_t X, bool isNeg = false) {
  238 inline std::string itostr(int64_t X) {
  298 inline std::string join_impl(IteratorT Begin, IteratorT End,
  300   std::string S;
  313 inline std::string join_impl(IteratorT Begin, IteratorT End,
  315   std::string S;
  332 inline void join_items_impl(std::string &Result, Sep Separator) {}
  335 inline void join_items_impl(std::string &Result, Sep Separator,
  341 inline void join_items_impl(std::string &Result, Sep Separator, const Arg1 &A1,
  370 inline std::string join(IteratorT Begin, IteratorT End, StringRef Separator) {
  378 inline std::string join(Range &&R, StringRef Separator) {
  387 inline std::string join_items(Sep Separator, Args &&... Items) {
  388   std::string Result;

  110     /*implicit*/ StringRef(const std::string &Str)
  238     std::string str() const {
  258     typename std::enable_if<std::is_same<T, std::string>::value,
  266     operator std::string() const {
  578     std::string lower() const;
  582     std::string upper() const;
  908   inline std::string &operator+=(std::string &buffer, StringRef string) {
  908   inline std::string &operator+=(std::string &buffer, StringRef string) {

  232   std::string Data;
  286   static std::string normalize(StringRef Str);
  289   std::string normalize() const { return normalize(Data); }
  365   const std::string &str() const { return Data; }
  367   const std::string &getTriple() const { return Data; }
  840   std::string merge(const Triple &Other) const;

  140       const std::string *stdString;
  281     /*implicit*/ Twine(const std::string &Str) : LHSKind(StdStringKind) {
  432     std::string str() const;

  513   virtual std::string getBlockName(const BlockNode &Node) const;
  514   std::string getLoopName(const LoopData &Loop) const;
  567 template <class BlockT> std::string getBlockName(const BlockT *BB) {
  575 template <> inline std::string getBlockName(const BasicBlock *BB) {
  954   std::string getBlockName(const BlockNode &Node) const override {
 1378   static std::string getGraphName(const BlockFrequencyInfoT *G) {
 1382   std::string getNodeAttributes(NodeRef Node, const BlockFrequencyInfoT *Graph,
 1384     std::string Result;
 1412   std::string getNodeLabel(NodeRef Node, const BlockFrequencyInfoT *Graph,
 1414     std::string Result;
 1443   std::string getEdgeAttributes(NodeRef Node, EdgeIter EI,
 1447     std::string Str;

   58   static std::string getGraphName(const Function *F) {
   62   static std::string getSimpleNodeLabel(const BasicBlock *Node,
   67     std::string Str;
   74   static std::string getCompleteNodeLabel(const BasicBlock *Node,
   77     std::string Str;
   86     std::string OutStr = OS.str();
  119   std::string getNodeLabel(const BasicBlock *Node,
  127   static std::string getEdgeSourceLabel(const BasicBlock *Node,
  140       std::string Str;
  150   std::string getEdgeAttributes(const BasicBlock *Node, succ_const_iterator I,

   41                           const std::string &Banner) const override;

  209   DependenceGraphInfo(const std::string &N, const DependenceInfo &DepInfo)
  227   std::string Name;

   55     std::string GraphName = DOTGraphTraits<GraphT>::getGraphName(Graph);
   56     std::string Title = GraphName + " for '" + F.getName().str() + "' function";
   69   std::string Name;
   97     std::string Filename = Name + "." + F.getName().str() + ".dot";
  103     std::string GraphName = DOTGraphTraits<GraphT>::getGraphName(Graph);
  104     std::string Title = GraphName + " for '" + F.getName().str() + "' function";
  121   std::string Name;
  134     std::string Title = DOTGraphTraits<GraphT>::getGraphName(Graph);
  147   std::string Name;
  160     std::string Filename = Name + ".dot";
  166     std::string Title = DOTGraphTraits<GraphT>::getGraphName(Graph);
  183   std::string Name;

  525     std::string getName() const {
  526       std::string Name;
  662     std::string getName() const {
  663       std::string Name;

 1234 void printLoop(Loop &L, raw_ostream &OS, const std::string &Banner = "");

   35                           const std::string &Banner) const override;

  424   std::string getNameStr() const;

  230 std::string RegionBase<Tr>::getNameStr() const {
  231   std::string exitName;
  232   std::string entryName;

   58                           const std::string &Banner) const override;

   51   llvm::DenseMap<unsigned, std::string> CustomNames;

  181   std::string toString() const;
  359   void writeToBlob(std::string &Blob);

   47   std::vector<std::pair<std::string, std::string>> Languages;
   47   std::vector<std::pair<std::string, std::string>> Languages;
   48   std::vector<std::pair<std::string, std::string>> Tools;
   48   std::vector<std::pair<std::string, std::string>> Tools;
   49   std::vector<std::pair<std::string, std::string>> SDKs;
   49   std::vector<std::pair<std::string, std::string>> SDKs;
   54   std::string Name;
  384 std::string toString(WasmSymbolType type);
  385 std::string relocTypetoString(uint32_t type);

  154   Expected<std::string> getBitcodeTargetTriple(MemoryBufferRef Buffer);
  163   Expected<std::string> getBitcodeProducerString(MemoryBufferRef Buffer);

  104         const std::map<std::string, GVSummaryMapTy> *ModuleToSummariesForIndex);
  151                         const std::map<std::string, GVSummaryMapTy>

   44     std::string Name;
   45     std::vector<std::pair<unsigned, std::string>> RecordNames;

   29 static cl::opt<std::string>
   33 static cl::opt<std::string>
   38 static cl::list<std::string>
  218 static cl::opt<std::string> TrapFuncName(
  319 LLVM_ATTRIBUTE_UNUSED static std::string getCPUStr() {
  329 LLVM_ATTRIBUTE_UNUSED static std::string getFeaturesStr() {
  349 LLVM_ATTRIBUTE_UNUSED static std::vector<std::string> getFeatureList() {

   70   std::string Name;
   86   const std::string &getName() const { return Name; }

   35   std::string Value;
   39   StringValue(std::string Value) : Value(std::move(Value)) {}
   65   FlowStringValue(std::string Value) : StringValue(std::move(Value)) {}

  156   std::string getFullName() const;

   73                           const std::string &Banner) const override;

   80   IndexedMap<std::string, VirtReg2IndexFunctor> VReg2Name;

  529   std::string Name;

   49                                    const std::string &Banner ="");
  327   FunctionPass *createMachineVerifierPass(const std::string& Banner);

  595     virtual std::string getGraphNodeLabel(const SUnit *SU) const = 0;
  598     virtual std::string getDAGName() const = 0;

  339     std::string getGraphNodeLabel(const SUnit *SU) const override;
  342     std::string getDAGName() const override;

  428   void viewGraph(const std::string &Title);
  432   std::map<const SDNode *, std::string> NodeGraphAttrs;
  444   const std::string getGraphAttrs(const SDNode *N) const;
 1752   std::map<std::pair<std::string, unsigned>, SDNode *> TargetExternalSymbols;

 1035   std::string getOperationName(const SelectionDAG *G = nullptr) const;

 3872     std::string ConstraintCode;
 3958   virtual void LowerAsmOperandForConstraint(SDValue Op, std::string &Constraint,

  169   std::string
  300   void printAndVerify(const std::string &Banner);
  303   void addPrintPass(const std::string &Banner);
  307   void addVerifyPass(const std::string &Banner);

  378     std::string getEVTString() const;

   38   virtual std::string getTypeName(TypeIndex TI) = 0;

   18 std::string computeTypeName(TypeCollection &Types, TypeIndex Index);

   35   std::string FileName;
   36   std::string FunctionName;
  112   std::string Name;
  120   std::string FunctionName;
  121   std::string Name;
  122   std::string DeclFile;

  483     std::string Key;         ///< The Key we are searching for.

   90   std::string DWPName;
  110                std::string DWPName = "");
  352          std::string DWPName = "");

  135                        std::string &Result,
  268                             std::string &Result) const {

   30   virtual std::string getName() const = 0;

   27   virtual std::string getProgram() const = 0;

   31   virtual std::string getFileName() const = 0;
   32   virtual std::string getObjectFileName() const = 0;
   33   virtual std::string getVirtualFileName() const = 0;
   38   virtual std::string getCode() const = 0;

  103   virtual std::string getCompilerName() const = 0;
  109   virtual std::string getLibraryName() const = 0;
  116   virtual std::string getName() const = 0;
  122   virtual std::string getObjectFileName() const = 0;
  135   virtual std::string getSourceFileName() const = 0;
  140   virtual std::string getSymbolsFileName() const = 0;
  151   virtual std::string getUndecoratedName() const = 0;
  152   virtual std::string getUndecoratedNameEx(PDB_UndnameFlags Flags) const = 0;
  255   virtual std::string getUnused() const = 0;

   29   virtual std::string getFileName() const = 0;
   31   virtual std::string getChecksum() const = 0;

   20   virtual std::string getName() const = 0;

   67   ArrayRef<std::string> source_files() const {
   91   std::string ModuleName;
   92   std::string ObjFileName;
   93   std::vector<std::string> SourceFiles;

   29   std::string getLibraryName() const override;
   30   std::string getName() const override;

   31   std::string getSymbolsFileName() const override;

   79   std::string getCompilerName() const override;
   84   std::string getLibraryName() const override;
   91   std::string getName() const override;
   97   std::string getObjectFileName() const override;
  110   std::string getSourceFileName() const override;
  114   std::string getSymbolsFileName() const override;
  125   std::string getUndecoratedName() const override;
  126   std::string getUndecoratedNameEx(PDB_UndnameFlags Flags) const override;
  229   std::string getUnused() const override;

   33   std::string getName() const override;

   46   std::string getName() const override;

   31   std::string getName() const override;

   38   std::string getName() const override;

  125   std::string FilePath;

   68     std::string StreamName;
  105   DenseMap<uint32_t, std::string> NamedStreamData;

   59     std::string getFunctionName(uint64_t Address, DINameKind NameKind) const;

   31   std::string getSourceFileName() const;
   32   std::string getSourceFileFullPath() const;

   26   std::string getValue() const;

   37                  const std::string &Name, uint32_t OffsetInParent,
   65   std::string Name;
  115                 const std::string &Name, uint32_t OffsetInParent, uint32_t Size,

   41   void printContext(const std::string &FileName, int64_t Line);

   43     std::string DefaultArch;
   44     std::vector<std::string> DsymHints;
   45     std::string FallbackDebugPath;
   46     std::string DWPName;
   58   Expected<DILineInfo> symbolizeCode(const std::string &ModuleName,
   61   symbolizeInlinedCode(const std::string &ModuleName,
   63   Expected<DIGlobal> symbolizeData(const std::string &ModuleName,
   66   symbolizeFrame(const std::string &ModuleName,
   70   static std::string
   71   DemangleName(const std::string &Name,
   88   getOrCreateModuleInfo(const std::string &ModuleName);
   95   ObjectFile *lookUpDsymFile(const std::string &Path,
   97                              const std::string &ArchName);
   98   ObjectFile *lookUpDebuglinkObject(const std::string &Path,
  100                                     const std::string &ArchName);
  103   Expected<ObjectPair> getOrCreateObjectPair(const std::string &Path,
  104                                             const std::string &ArchName);
  109   Expected<ObjectFile *> getOrCreateObject(const std::string &Path,
  110                                           const std::string &ArchName);
  112   std::map<std::string, std::unique_ptr<SymbolizableModule>> Modules;
  115   std::map<std::pair<std::string, std::string>, ObjectPair>
  115   std::map<std::pair<std::string, std::string>, ObjectPair>
  119   std::map<std::string, OwningBinary<Binary>> BinaryForPath;
  123   std::map<std::pair<std::string, std::string>, std::unique_ptr<ObjectFile>>
  123   std::map<std::pair<std::string, std::string>, std::unique_ptr<ObjectFile>>

   51 std::string demangle(const std::string &MangledName);
   51 std::string demangle(const std::string &MangledName);

  264   std::string toString(OutputFlags Flags = OF_Default) const;

   78   std::map<uint64_t, std::string> GlobalAddressReverseMap;
   85   std::map<uint64_t, std::string> &getGlobalAddressReverseMap() {
   95 using FunctionCreator = std::function<void *(const std::string &)>;
  140       std::unique_ptr<Module> M, std::string *ErrorStr,
  146       std::string *ErrorStr, std::shared_ptr<MCJITMemoryManager> MM,
  151                                         std::string *ErrorStr);
  159   std::string getMangledName(const GlobalValue *GV);
  296   int runFunctionAsMain(Function *Fn, const std::vector<std::string> &argv,
  368   virtual uint64_t getGlobalValueAddress(const std::string &Name) {
  376   virtual uint64_t getFunctionAddress(const std::string &Name) {
  530   std::string *ErrorStr;
  537   std::string MArch;
  538   std::string MCPU;
  539   SmallVector<std::string, 4> MAttrs;
  576   EngineBuilder &setErrorStr(std::string *e) {
  659                               const SmallVectorImpl<std::string>& MAttrs);

   49   const std::string &getErrorMessage() const { return ErrMsg; }
   53   std::string ErrMsg;
  707   LinkGraph(std::string Name, unsigned PointerSize,
  716   const std::string &getName() { return Name; }
  902   std::string Name;

  375   virtual JITSymbol findSymbolInLogicalDylib(const std::string &Name) = 0;
  383   virtual JITSymbol findSymbol(const std::string &Name) = 0;

  228     JITSymbol findSymbol(BaseLayerT &BaseLayer, const std::string &Name,
  351   JITSymbol findSymbolIn(VModuleKey K, const std::string &Name,
  365   Error updatePointer(std::string FuncName, JITTargetAddress FnBodyAddr) {
  372         std::string CalledFnName = mangle(FuncName, SrcM.getDataLayout());
  481           std::string FName = mangle(F->getName(), DL);
  570   static std::string mangle(StringRef Name, const DataLayout &DL) {
  571     std::string MangledName;
  590     std::string CalledFnName = mangle(F.getName(), SrcM.getDataLayout());
  597         std::string FnName = mangle(SubF->getName(), SrcM.getDataLayout());
  634     std::string NewName = SrcM.getName();

  516   const std::string &getName() const { return JITDylibName; }
  708   JITDylib(ExecutionSession &ES, std::string Name);
  752   std::string JITDylibName;
  803   JITDylib &createJITDylib(std::string Name,

  110                        std::vector<std::string> CtorDtorNames, VModuleKey K)
  137   std::vector<std::string> CtorDtorNames;
  143     std::vector<std::string> CtorDtorNames, VModuleKey K)
  211   JITEvaluatedSymbol searchOverrides(const std::string &Name) {
  219   void addOverride(const std::string &Name, JITTargetAddress Addr) {

   58   void setGlobalMapping(const std::string &Name, JITTargetAddress Addr) {
   63   void eraseGlobalMapping(const std::string &Name) {
   76   JITSymbol findSymbol(const std::string &Name, bool ExportedSymbolsOnly) {
   91   JITSymbol findSymbolIn(ModuleHandleT H, const std::string &Name,
  105   std::map<std::string, JITTargetAddress> SymbolTable;

  107   JITSymbol findSymbol(const std::string &Name, bool ExportedSymbolsOnly) {
  119   JITSymbol findSymbolIn(VModuleKey K, const std::string &Name,

   89   JITSymbol findSymbol(const std::string &Name, bool ExportedSymbolsOnly) {
  101   JITSymbol findSymbolIn(VModuleKey K, const std::string &Name,

   71   JITTargetMachineBuilder &setCPU(std::string CPU) {
   96   addFeatures(const std::vector<std::string> &FeatureVec);
  118   std::string CPU;

   66   JITDylib &createJITDylib(std::string Name) {
  130   std::string mangle(StringRef UnmangledName);

   41   JITSymbol findSymbolInLogicalDylib(const std::string &Name) final {
   45   JITSymbol findSymbol(const std::string &Name) final {

  147       std::string MangledName;
  228   JITSymbol findSymbol(const std::string &Name, bool ExportedSymbolsOnly) {
  246   JITSymbol findSymbolIn(VModuleKey K, const std::string &Name,

   35   JITSymbol findSymbol(const std::string &Name) final;
   37   JITSymbol findSymbolInLogicalDylib(const std::string &Name) final;

   80   JITSymbol findSymbol(const std::string &Name, bool ExportedSymbolsOnly) {
   92   JITSymbol findSymbolIn(VModuleKey K, const std::string &Name,

   47   DuplicateDefinition(std::string SymbolName);
   50   const std::string &getSymbolName() const;
   52   std::string SymbolName;
   59   JITSymbolNotFound(std::string SymbolName);
   62   const std::string &getSymbolName() const;
   64   std::string SymbolName;

  179     bool finalizeMemory(std::string *ErrMsg = nullptr) override {
  524                          const std::vector<std::string> &Args) {
  581   const std::string &getTargetTriple() const { return RemoteTargetTriple; }
  687   std::string RemoteTargetTriple;

   35                    std::string ResourceDescription = "")
   52   std::string ResourceDescription;
  203                                                std::vector<std::string> Args)> {
  333             std::tuple<std::string, uint32_t, uint32_t, uint32_t, uint32_t>()> {
  341                              JITTargetAddress(std::string SymbolName)> {

   51       std::function<JITTargetAddress(const std::string &Name)>;
  171                                    std::vector<std::string> Args) {
  327   Expected<JITTargetAddress> handleGetSymbolAddress(const std::string &Name) {
  334   Expected<std::tuple<std::string, uint32_t, uint32_t, uint32_t, uint32_t>>
  336     std::string ProcessTriple = sys::getProcessTriple();

  130     static std::string Name = [] {
  131       std::string Name;
  145     static std::string Name = [] {
  146       std::string Name;
  159     static std::string Name = [] {
  160       std::string Name;
  173     static std::string Name = [] {
  174       std::string Name;
  186     static std::string Name = [] {
  187       std::string Name;
  199     static std::string Name = [] {
  200       std::string Name;
  340   static void registerErrorType(std::string Name, SerializeFtor Serialize,
  345     const std::string *KeyName = nullptr;
  392     std::string Key;
  410     std::string ErrMsg;
  422   static std::map<std::string, WrappedErrorDeserializer> Deserializers;
  437 std::map<std::string,
  445 void registerErrorSerialization(std::string Name, SerializeFtor &&Serialize,
  465         std::string Msg;

  130   CouldNotNegotiate(std::string Signature);
  133   const std::string &getSignature() const { return Signature; }
  135   std::string Signature;
  154     static std::string Name = [] {
  155       std::string Name;
  954       : public Function<OrcRPCNegotiate, FunctionIdT(std::string)> {
 1219   FunctionIdT handleNegotiate(const std::string &Name) {
 1342   std::map<std::string, FunctionIdT> LocalFunctionIds;

  159     getSymbolMaterializer(std::string Name) = 0;
  271     JITSymbol::GetAddressFtor getSymbolMaterializer(std::string Name) override {

  134 class SerializationTraits<ChannelT, std::string, StringRef,
  147 class SerializationTraits<ChannelT, std::string, T,
  154     return SerializationTraits<ChannelT, std::string, StringRef>::serialize(C,
  160 class SerializationTraits<ChannelT, std::string, std::string,
  160 class SerializationTraits<ChannelT, std::string, std::string,
  165   static Error serialize(RawByteChannel &C, const std::string &S) {
  166     return SerializationTraits<ChannelT, std::string, StringRef>::serialize(C,
  171   static Error deserialize(RawByteChannel &C, std::string &S) {

   47     : public rpc::Function<AddObject, Expected<ObjHandleT>(std::string)> {
   59     : public rpc::Function<FindSymbol, Expected<RemoteSymbol>(std::string,
   67                            Expected<RemoteSymbol>(ObjHandleT, std::string,
   82                            Expected<RemoteSymbol>(ObjHandleT, std::string)> {
   89                            Expected<RemoteSymbol>(ObjHandleT, std::string)> {
  371   Expected<RemoteSymbol> lookup(ObjHandleT H, const std::string &Name) {
  380                                               const std::string &Name) {
  448     StringMemoryBuffer(std::string Buffer)
  456     std::string Buffer;
  459   JITSymbol lookup(ObjHandleT Id, const std::string &Name) {
  464   JITSymbol lookupInLogicalDylib(ObjHandleT Id, const std::string &Name) {
  469   Expected<ObjHandleT> addObject(std::string ObjBuffer) {
  499   Expected<RemoteSymbol> findSymbol(const std::string &Name,
  508   Expected<RemoteSymbol> findSymbolIn(ObjHandleT H, const std::string &Name,

   79   static uint64_t getSymbolAddressInProcess(const std::string &Name);
   85   virtual uint64_t getSymbolAddress(const std::string &Name) {
  100   JITSymbol findSymbol(const std::string &Name) override {
  108   virtual uint64_t getSymbolAddressInLogicalDylib(const std::string &Name) {
  123   findSymbolInLogicalDylib(const std::string &Name) override {
  137   virtual void *getPointerToNamedFunction(const std::string &Name,

   46   RuntimeDyldError(std::string ErrMsg) : ErrMsg(std::move(ErrMsg)) {}
   49   const std::string &getErrorMessage() const { return ErrMsg; }
   53   std::string ErrMsg;
  152     virtual bool finalizeMemory(std::string *ErrMsg = nullptr) = 0;

  170   std::pair<uint64_t, std::string> getSectionAddr(StringRef FileName,

  142   bool finalizeMemory(std::string *ErrMsg = nullptr) override;

  174   std::string getAsString(bool InAttrGrp = false) const;
  294   std::string getAsString(bool InAttrGrp = false) const;
  642   std::string getAsString(unsigned Index, bool InAttrGrp = false) const;
  708   std::map<std::string, std::string, std::less<>> TargetDepAttrs;
  708   std::map<std::string, std::string, std::less<>> TargetDepAttrs;
  845   using td_type = std::pair<std::string, std::string>;
  845   using td_type = std::pair<std::string, std::string>;
  846   using td_iterator = std::map<std::string, std::string>::iterator;
  846   using td_iterator = std::map<std::string, std::string>::iterator;
  847   using td_const_iterator = std::map<std::string, std::string>::const_iterator;
  847   using td_const_iterator = std::map<std::string, std::string>::const_iterator;

   41   void UpgradeInlineAsmString(std::string *AsmStr);
   92   std::string UpgradeDataLayoutString(StringRef DL, StringRef Triple);

  157   std::string StringRepresentation;
  240   const std::string &getStringRepresentation() const {

  357   std::string getAbsolutePath() const;
  382   const std::string getLocationStr() const;
  390   std::string getAbsolutePath() const;
  419     std::string Key;
  420     std::string Val;
  471   std::string getMsg() const;

   41   virtual DiagnosticPrinter &operator<<(const std::string &Str) = 0;
   74   DiagnosticPrinter &operator<<(const std::string &Str) override;

  357   const std::string &getGC() const;
  358   void setGC(std::string Str);

  491   static std::string getGlobalIdentifier(StringRef Name,
  497   std::string getGlobalIdentifier() const;

   38                                   const std::string &Banner = "",
   44                                       const std::string &Banner = "");
   49                                           const std::string &Banner = "");
   82   std::string Banner;
   87   PrintModulePass(raw_ostream &OS, const std::string &Banner = "",
  101   std::string Banner;
  105   PrintFunctionPass(raw_ostream &OS, const std::string &Banner = "");

   41   std::string AsmString, Constraints;
   47   InlineAsm(FunctionType *Ty, const std::string &AsmString,
   48             const std::string &Constraints, bool hasSideEffects,
   80   const std::string &getAsmString() const { return AsmString; }
   81   const std::string &getConstraintString() const { return Constraints; }
   96   using ConstraintCodeVector = std::vector<std::string>;

 1059   std::string Tag;
 1063   explicit OperandBundleDefT(std::string Tag, std::vector<InputTy> Inputs)
 1065   explicit OperandBundleDefT(std::string Tag, ArrayRef<InputTy> Inputs)

   56   std::string getName(ID id, ArrayRef<Type*> Tys);

  120   void setGC(const Function &Fn, std::string GCName);
  123   const std::string &getGC(const Function &Fn);

 1329   std::string Name;

  177   std::string GlobalScopeAsm;     ///< Inline Asm at global scope.
  185   std::string ModuleID;           ///< Human readable identifier for the module
  186   std::string SourceFileName;     ///< Original source file name for module,
  188   std::string TargetTriple;       ///< Platform target triple Module compiled on
  211   const std::string &getModuleIdentifier() const { return ModuleID; }
  222   const std::string &getSourceFileName() const { return SourceFileName; }
  232   const std::string &getDataLayoutStr() const {
  241   const std::string &getTargetTriple() const { return TargetTriple; }
  249   const std::string &getModuleInlineAsm() const { return GlobalScopeAsm; }

  834   std::string SingleImplName;
  889     std::multimap<GlobalValue::GUID, std::pair<std::string, TypeIdSummary>>;
  933   std::map<std::string, TypeIdCompatibleVtableInfo> TypeIdCompatibleVtableMap;
  967   std::set<std::string> CfiFunctionDefs;
  968   std::set<std::string> CfiFunctionDecls;
 1133   std::set<std::string> &cfiFunctionDefs() { return CfiFunctionDefs; }
 1134   const std::set<std::string> &cfiFunctionDefs() const { return CfiFunctionDefs; }
 1136   std::set<std::string> &cfiFunctionDecls() { return CfiFunctionDecls; }
 1137   const std::set<std::string> &cfiFunctionDecls() const { return CfiFunctionDecls; }
 1235   static std::string getGlobalNameForLocal(StringRef Name, ModuleHash ModHash) {
 1304   const std::map<std::string, TypeIdCompatibleVtableInfo> &

   85       std::string Key;
  281       std::vector<std::string> CfiFunctionDefs(index.CfiFunctionDefs.begin(),
  284       std::vector<std::string> CfiFunctionDecls(index.CfiFunctionDecls.begin(),
  288       std::vector<std::string> CfiFunctionDefs;
  291       std::vector<std::string> CfiFunctionDecls;

   33   const Optional<std::string> Filename;
   62   std::string Msg;

   38   std::string CPU;
   40   std::vector<std::string> MAttrs;
   64   std::string OptPipeline;
   69   std::string AAPipeline;
   73   std::string OverrideTriple;
   77   std::string DefaultTriple;
   80   std::string CSIRProfile;
   83   std::string SampleProfile;
   86   std::string ProfileRemapping;
   89   std::string DwoDir;
   95   std::string SplitDwarfFile;
  100   std::string SplitDwarfOutput;
  103   std::string RemarksFilename = "";
  106   std::string RemarksPasses = "";
  112   std::string RemarksFormat = "";
  118   std::string StatsFile;
  205   Error addSaveTemps(std::string OutputFileName,

   84 std::string getThinLTOOutputFile(const std::string &Path,
   84 std::string getThinLTOOutputFile(const std::string &Path,
   85                                  const std::string &OldPrefix,
   86                                  const std::string &NewPrefix);
  245 using IndexWriteCallback = std::function<void(const std::string &)>;
  246 ThinBackend createWriteIndexesThinBackend(std::string OldPrefix,
  247                                           std::string NewPrefix,
  316     std::map<std::string, CommonResolution> Commons;
  352     std::string IRName;

  210   void emitError(const std::string &ErrMsg);
  211   void emitWarning(const std::string &ErrMsg);
  226   std::vector<std::string> CodegenOptions;
  227   std::string FeatureStr;
  228   std::string MCpu;
  229   std::string MAttr;
  230   std::string NativeObjectPath;
  234   std::string TripleStr;

   49   std::string LinkerOpts;
   51   std::string DependentLibraries;
   85   static std::string getProducerString(MemoryBuffer *Buffer);
  123   const std::string &getTargetTriple() {
  162                                          const char *path, std::string &out_error);
  210   bool objcClassNameFromExpression(const Constant *c, std::string &name);

   38   std::string MCpu;
   39   std::string MAttr;
   97   std::vector<std::string> &getProducedBinaryFiles() {
  127     std::string Path;                    // Path to the cache, empty to disable.
  133   void setCacheDir(std::string Path) { CacheOptions.Path = std::move(Path); }
  189   void setSaveTempsDir(std::string Path) { SaveTempsDir = std::move(Path); }
  195   void setGeneratedObjectsDirectory(std::string Path) {
  200   void setCpu(std::string Cpu) { TMBuilder.MCpu = std::move(Cpu); }
  203   void setAttr(std::string MAttr) { TMBuilder.MAttr = std::move(MAttr); }
  276       std::map<std::string, GVSummaryMapTy> &ModuleToSummariesForIndex,
  295   std::string writeGeneratedObject(int count, StringRef CacheEntryPath,
  308   std::vector<std::string> ProducedBinaryFiles;
  325   std::string SaveTempsDir;
  328   std::string SavedObjectsDirectoryPath;

   40   llvm::Optional<std::string> readLine() const;
   45   static std::string getDefaultHistoryPath(StringRef ProgName);
   59     std::string Text;
   62     std::vector<std::string> Completions;
   68     Completion(const std::string &TypedText, const std::string &DisplayText)
   68     Completion(const std::string &TypedText, const std::string &DisplayText)
   73     std::string TypedText;
   77     std::string DisplayText;
  105   const std::string &getPrompt() const { return Prompt; }
  106   void setPrompt(const std::string &P) { Prompt = P; }
  112   std::string Prompt;
  113   std::string HistoryPath;
  124     static std::string getCommonPrefix(const std::vector<Completion> &Comps);

  199       std::string buf;

  119   std::vector<std::vector<std::string>> LinkerOptions;
  122   std::vector<std::string> FileNames;
  391   std::vector<std::vector<std::string>> &getLinkerOptions() {
  442   ArrayRef<std::string> getFileNames() { return FileNames; }

  147     std::map<const std::string, const std::string> DebugPrefixMap;
  147     std::map<const std::string, const std::string> DebugPrefixMap;
  150     std::string MainFileName;
  197       std::string SectionName;
  216       std::string SectionName;
  238       std::string SectionName;
  257       std::string SectionName;
  533     void addDebugPrefixMapEntry(const std::string &From, const std::string &To);
  533     void addDebugPrefixMapEntry(const std::string &From, const std::string &To);
  541     const std::string &getMainFileName() const { return MainFileName; }
  572     const SmallVectorImpl<std::string> &getMCDwarfDirs(unsigned CUID = 0) {

   54   std::string Name;
  215   SmallVector<std::string, 3> MCDwarfDirs;
  218   std::string CompilationDir;
  354   const SmallVectorImpl<std::string> &getMCDwarfDirs() const {
  358   SmallVectorImpl<std::string> &getMCDwarfDirs() {

  199                                  std::string &);
  216                          std::string &Info) const;

  206   void writeLinkerOptionsLoadCommand(const std::vector<std::string> &Options);

   57   AsmToken ReturnError(const char *Loc, const std::string &Msg);

   45   std::string Err;
   59   void SetError(SMLoc errLoc, const std::string &err) {
  127   const std::string &getErr() {

  173       void *AsmLoc, std::string &AsmString, unsigned &NumOutputs,
  175       SmallVectorImpl<std::string> &Constraints,
  176       SmallVectorImpl<std::string> &Clobbers, const MCInstrInfo *MII,
  251   virtual bool parseEscapedString(std::string &Data) = 0;

   31   std::string Constraint;

   71   static std::string ParseSectionSpecifier(StringRef Spec,       // In.

  454   virtual void EmitLinkerOptions(ArrayRef<std::string> Kind) {}

   76   std::string CPU; // CPU being targeted.

   22   Optional<std::string> ImportModule;
   23   Optional<std::string> ImportName;

   59   std::string ABIName;
   60   std::string SplitDwarfFile;
   64   std::vector<std::string> IASSearchPaths;

   49 static cl::opt<std::string>

  184   std::vector<std::string> Features;    ///< Subtarget features as a vector
  190   std::string getString() const;
  196   const std::vector<std::string> &getFeatures() const { return Features; }
  217   static std::string StripFlag(StringRef Feature) {
  231   static void Split(std::vector<std::string> &V, StringRef S);

   29   std::string Message;
   32   InstructionError(std::string M, const T &MCI)

  113     Expected<std::string> getFullName() const;

   39 Expected<std::string> computeArchiveRelativePath(StringRef From, StringRef To);

   75   std::string Name;
   79   std::string ExtName;
   83   std::string SymbolName;
   87   std::string AliasTarget;

   29   std::string OutputFile;
   30   std::string ImportName;

   54 std::string getSecIndexForError(const ELFFile<ELFT> *Obj,
  144   std::string getDynamicTagAsString(unsigned Arch, uint64_t Type) const;
  145   std::string getDynamicTagAsString(uint64_t Type) const;

   70   const std::string &getMessage() const { return Msg; }
   73   std::string Msg;

  606   static std::string getBuildPlatform(uint32_t platform) {
  618       std::string ret;
  625   static std::string getBuildTool(uint32_t tools) {
  631       std::string ret;
  638   static std::string getVersionString(uint32_t version) {

   93     std::string getArchFlagName() const {
  106         std::string ArchFlagName(ArchFlag);
  109         std::string ArchFlagName("");

   56   Expected<std::string> getString(size_t Offset) const;

   34   using AsmSymbol = std::pair<std::string, uint32_t>;

   54     std::string getArchFlagName() const {

  157   Error parse(WindowsResource *WR, std::vector<std::string> &Duplicates);
  159               std::vector<std::string> &Duplicates);
  160   void cleanUpManifests(std::vector<std::string> &Duplicates);
  182     const Children<std::string> &getStringChildren() const {
  226     Children<std::string> StringChildren;
  249                     std::vector<std::string> &Duplicates);
  257   std::vector<std::string> InputFilenames;

   64   std::string PayloadString;
   93   std::string Name;
   97   std::string ImportName;

   78   std::string Name;
  164   std::string CSDVersion;
  172                             std::string CSDVersion)

  128   std::string Name;
  129   std::string Version;
  134   std::string Name;

  144   std::string getAsString(const ArgList &Args) const;

  285   std::vector<std::string> getAllArgValues(OptSpecifier Id) const;
  382   mutable std::list<std::string> SynthesizedStrings;

   73   std::string PrefixChars;
  133   std::vector<std::string> suggestValueCompletions(StringRef Option,
  142   std::vector<std::string> findByPrefix(StringRef Cur,
  161   unsigned findNearest(StringRef Option, std::string &NearestString,

  132   std::string getPrefixedName() const {
  133     std::string Ret = getPrefix();

  124                                   const std::string &Banner) const = 0;
  233                           const std::string &Banner) const override;
  290                           const std::string &Banner) const override;
  327                           const std::string &Banner) const override;

   36   PGOOptions(std::string ProfileFile = "", std::string CSProfileGenFile = "",
   36   PGOOptions(std::string ProfileFile = "", std::string CSProfileGenFile = "",
   37              std::string ProfileRemappingFile = "", PGOAction Action = NoAction,
   61   std::string ProfileFile;
   62   std::string CSProfileGenFile;
   63   std::string ProfileRemappingFile;
  635                               std::string ProfileFile,
  636                               std::string ProfileRemappingFile);
  667                          std::string ProfileFile,
  668                          std::string ProfileRemappingFile);

   67   static Expected<PassPlugin> Load(const std::string &Filename);
   87   PassPlugin(const std::string &Filename, const sys::DynamicLibrary &Library)
   90   std::string Filename;

   45   using PrintModuleDesc = std::tuple<const Module *, std::string, StringRef>;

   72   std::string message() const override;
  303   std::string Name;
  310   std::vector<std::string> Filenames;
  481   std::string Filename;
  517   std::vector<std::pair<std::string, uint64_t>> FuncHashMismatches;
  558   ArrayRef<std::pair<std::string, uint64_t>> getHashMismatches() const {

  444   std::string getCoveragePath(StringRef Filename, StringRef MainFilename);
  463   using FileCoverageList = SmallVector<std::pair<std::string, GCOVCoverage>, 4>;

   66 std::string getInstrProfSectionName(InstrProfSectKind IPSK,
  162 std::string getPGOFuncName(const Function &F, bool InLTO = false,
  169 std::string getPGOFuncName(StringRef RawFuncName,
  177 std::string getPGOFuncNameVarName(StringRef FuncName,
  210 Error collectPGOFuncNameStrings(ArrayRef<std::string> NameStrs,
  211                                 bool doCompression, std::string &Result);
  216                                 std::string &Result, bool doCompression = true);
  307   std::string message() const override;
  616   const std::string *BaseFilename;
  617   const std::string *TestFilename;
  633   Error accumulateCounts(const std::string &BaseFilename,
  634                          const std::string &TestFilename, bool IsCS);
  650   const std::string NameFilter;

  106                                        std::string &GUIDBuf) {
  129 static inline std::string getSecName(SecType Type) {
  292 using FunctionSamplesMap = std::map<std::string, FunctionSamples, std::less<>>;
  380     std::string CalleeGUID;

  255   create(const std::string Filename, SampleProfileReader &Reader,
  367     std::string FGUID;
  387   create(const std::string Filename, LLVMContext &C,
  388          const std::string RemapFilename = "");
  394          const std::string RemapFilename = "");
  637   std::vector<std::string> NameTable;
  713   std::vector<std::string> Names;

   97   std::string getArgsAsMsg() const;

   43   std::string ExternalFilePrependPath;

  126   std::string mVecTypeHint = std::string();
  129   std::string mRuntimeHandle = std::string();
  189   std::string mName = std::string();
  191   std::string mTypeName = std::string();
  388   std::string mName = std::string();
  390   std::string mSymbolName = std::string();
  392   std::string mLanguage = std::string();
  424   std::vector<std::string> mPrintf = std::vector<std::string>();
  433 std::error_code fromString(std::string String, Metadata &HSAMetadata);
  436 std::error_code toString(Metadata HSAMetadata, std::string &String);

   42   std::string ErrMsg;

  598 struct OptionValue<std::string> final : OptionValueCopy<std::string> {
  603   OptionValue(const std::string &V) { this->setValue(V); }
  605   OptionValue<std::string> &operator=(const std::string &V) {
  605   OptionValue<std::string> &operator=(const std::string &V) {
 1070 template <> class parser<std::string> : public basic_parser<std::string> {
 1075   bool parse(Option &, StringRef, StringRef Arg, std::string &Value) {

  215 bool convertWideToUTF8(const std::wstring &Source, std::string &Result);
  270 bool convertUTF16ToUTF8String(ArrayRef<char> SrcBytes, std::string &Out);
  279 bool convertUTF16ToUTF8String(ArrayRef<UTF16> Src, std::string &Out);

   44   static std::string getGraphName(const GraphType &) { return ""; }
   50   static std::string getGraphProperties(const GraphType &) {
   70   std::string getNodeLabel(const void *, const GraphType &) {
   78   static std::string getNodeIdentifierLabel(const void *, const GraphType &) {
   83   static std::string getNodeDescription(const void *, const GraphType &) {
   90   static std::string getNodeAttributes(const void *,
   98   static std::string getEdgeAttributes(const void *, EdgeIter,
  106   static std::string getEdgeSourceLabel(const void *, EdgeIter) {
  140   static std::string getEdgeDestLabel(const void *, unsigned) {

   63   void push_back(const std::string &);
  125   unsigned getCounterId(const std::string &Name) const {
  133   std::pair<std::string, std::string> getCounterInfo(unsigned ID) const {
  133   std::pair<std::string, std::string> getCounterInfo(unsigned ID) const {
  138   typedef UniqueVector<std::string> CounterVector;
  161   unsigned addCounter(const std::string &Name, const std::string &Desc) {
  161   unsigned addCounter(const std::string &Name, const std::string &Desc) {
  173     std::string Desc;

   68                                               std::string *errMsg = nullptr);
   78                                               std::string *errMsg = nullptr);
   86                                        std::string *ErrMsg = nullptr) {
  116     static void *SearchForAddressOfSymbol(const std::string &symbolName) {

   27 std::string StrError();
   30 std::string StrError(int errnum);

   56   virtual std::string message() const {
   57     std::string Msg;
  708     std::string Str;
  738     std::string Str;
  769     std::string Str;
  986 inline std::string toString(Error E) {
  987   SmallVector<std::string, 2> Errors;
 1187   const std::string &getMessage() const { return Msg; }
 1190   std::string Msg;
 1199   std::string Buffer;
 1258   std::string FileName;
 1296   ExitOnError(std::string Banner = "", int DefaultErrorExitCode = 1)
 1301   void setBanner(std::string Banner) { this->Banner = std::move(Banner); }
 1334   std::string Banner;

   26                                         const std::string& reason,
   73 LLVM_ATTRIBUTE_NORETURN void report_fatal_error(const std::string &reason,

   27   std::vector<std::string> CheckPrefixes;
   29   std::vector<std::string> ImplicitCheckNot;
   30   std::vector<std::string> GlobalDefines;
   81   std::string getDescription(StringRef Prefix) const;

   26   FileCollector(std::string Root, std::string OverlayRoot);
   26   FileCollector(std::string Root, std::string OverlayRoot);
   62   std::string Root;
   65   std::string OverlayRoot;
   74   StringMap<std::string> SymlinkMap;

   80   std::string FinalPath;

  857   std::string TmpName;
 1204 std::string getMainExecutable(const char *argv0, void *MainExecAddr);
 1217   std::string Path;
 1234   const std::string &path() const { return Path; }

   35                              std::string *Error = nullptr);

  219     format_provider<std::string>::format(V.str(), Stream, Style);

  128   std::string str() const {
  129     std::string Result;
  145   operator std::string() const { return str(); }

   42 std::string EscapeString(const std::string &Label);
   42 std::string EscapeString(const std::string &Label);
   90       std::string label = DTraits.getEdgeSourceLabel(Node, EI);
  114   void writeGraph(const std::string &Title = "") {
  128   void writeHeader(const std::string &Title) {
  129     std::string GraphName = DTraits.getGraphName(G);
  166     std::string NodeAttributes = DTraits.getNodeAttributes(Node, G);
  176       std::string Id = DTraits.getNodeIdentifierLabel(Node, G);
  180       std::string NodeDesc = DTraits.getNodeDescription(Node, G);
  185     std::string edgeSourceLabels;
  201       std::string Id = DTraits.getNodeIdentifierLabel(Node, G);
  205       std::string NodeDesc = DTraits.getNodeDescription(Node, G);
  260   void emitSimpleNode(const void *ID, const std::string &Attr,
  261                    const std::string &Label, unsigned NumEdgeSources = 0,
  262                    const std::vector<std::string> *EdgeSourceLabels = nullptr) {
  285                 const std::string &Attrs) {
  321 std::string createGraphFilename(const Twine &Name, int &FD);
  328 std::string WriteGraph(const GraphType &G, const Twine &Name,
  331                        std::string Filename = "") {
  334   std::string N = Name.str();
  369   std::string Filename = llvm::WriteGraph(G, Name, ShortNames, Title);

   30   std::string getDefaultTargetTriple();
   34   std::string getProcessTriple();

   81 std::string fixUTF8(llvm::StringRef S);
  306   Value(const std::map<std::string, Elt> &C) : Value(json::Object(C)) {}
  308   Value(std::string V) : Type(T_String) {
  313     create<std::string>(std::move(V));
  425       return llvm::StringRef(as<std::string>());
  478                                       std::string, json::Array, json::Object>
  493   ObjectKey(std::string S) : Owned(new std::string(std::move(S))) {
  493   ObjectKey(std::string S) : Owned(new std::string(std::move(S))) {
  514       Owned.reset(new std::string(*C.Owned));
  524   std::string str() const { return Data.str(); }
  529   std::unique_ptr<std::string> Owned;
  561 inline bool fromJSON(const Value &E, std::string &Out) {
  619 bool fromJSON(const Value &E, std::map<std::string, T> &Out) {

   57   Optional<std::pair<std::string, int> > Owner;
   59   std::string ErrorDiagMsg;
   64   static Optional<std::pair<std::string, int> >
   87   std::string getErrorMessage() const;

  226 std::string convert_to_slash(StringRef path, Style style = Style::native);

   23     void operator=(const std::string &Filename);
   25     static std::string& getPlugin(unsigned num);
   30   static cl::opt<PluginLoader, false, cl::parser<std::string> >

   95   static Optional<std::string> GetEnv(StringRef name);
  103   static Optional<std::string> FindInEnvPath(StringRef EnvName,
  105                                              ArrayRef<std::string> IgnoreList);
  107   static Optional<std::string> FindInEnvPath(StringRef EnvName,

   68   ErrorOr<std::string>
  115       std::string *ErrMsg = nullptr, ///< If non-zero, provides a pointer to a
  130                             std::string *ErrMsg = nullptr,
  192       std::string *ErrMsg = nullptr ///< If non-zero, provides a pointer to a

   62     bool isValid(std::string &Error) const;
   81                std::string *Error = nullptr) const;
   93     std::string sub(StringRef Repl, StringRef String,
   94                     std::string *Error = nullptr) const;
  101     static std::string escape(StringRef String);

  426   static std::string toString(uint64_t D, int16_t E, int Width,
  595   std::string toString(unsigned Precision = DefaultPrecision) {

   59 const std::string to_hexString(uint64_t Value, bool UpperCase = true);
   61 template <class T> const std::string to_string(const T &Value) {
   62   std::string number;
  264   void printString(StringRef Label, const std::string &Value) {

   32   bool RemoveFileOnSignal(StringRef Filename, std::string* ErrMsg = nullptr);

   60   std::string BufferName;

   98   std::vector<std::string> IncludeDirectories;
  113   void setIncludeDirs(const std::vector<std::string> &Dirs) {
  168   unsigned AddIncludeFile(const std::string &Filename, SMLoc IncludeLoc,
  169                           std::string &IncludedFile);
  232   std::string Text;
  264   std::string Filename;
  268   std::string Message, LineContents;

   71   create(const std::vector<std::string> &Paths, std::string &Error);
   71   create(const std::vector<std::string> &Paths, std::string &Error);
   75                                                  std::string &Error);
   79   createOrDie(const std::vector<std::string> &Paths);
  105   bool createInternal(const std::vector<std::string> &Paths,
  106                       std::string &Error);
  107   bool createInternal(const MemoryBuffer *MB, std::string &Error);
  119     bool insert(std::string Regexp, unsigned LineNumber, std::string &REError);
  119     bool insert(std::string Regexp, unsigned LineNumber, std::string &REError);
  143              std::string &Error);

   31   StringRef save(const std::string &S) { return save(StringRef(S)); }
   53   StringRef save(const std::string &S) { return save(StringRef(S)); }

   88   std::string File;
   90   std::string Message;

   28   std::string BaseDir;

  652   static const Target *lookupTarget(const std::string &Triple,
  653                                     std::string &Error);
  666   static const Target *lookupTarget(const std::string &ArchName,
  667                                     Triple &TheTriple, std::string &Error);

   43                             llvm::function_ref<std::string()> Detail);
   64   TimeTraceScope(StringRef Name, llvm::function_ref<std::string()> Detail) {

   79   std::string Name;         ///< The name of this time variable.
   80   std::string Description;  ///< Description of this time variable.
  108   const std::string &getName() const { return Name; }
  109   const std::string &getDescription() const { return Description; }
  173     std::string Name;
  174     std::string Description;
  177     PrintRecord(const TimeRecord &Time, const std::string &Name,
  178                 const std::string &Description)
  185   std::string Name;
  186   std::string Description;

   32     std::string Filename;

   42   void insert(std::string Regex);

  141   std::string getAsString() const;

   46   std::string Name;
  109   virtual llvm::ErrorOr<std::string> getName() {
  128   std::string Path;
  133   directory_entry(std::string Path, llvm::sys::fs::file_type Type)
  271   virtual llvm::ErrorOr<std::string> getCurrentWorkingDirectory() const = 0;
  338   llvm::ErrorOr<std::string> getCurrentWorkingDirectory() const override;
  384   llvm::ErrorOr<std::string> getCurrentWorkingDirectory() const override {
  417   std::string WorkingDirectory;
  471   std::string toString() const;
  481   llvm::ErrorOr<std::string> getCurrentWorkingDirectory() const override {
  511   std::string VPath;
  512   std::string RPath;
  580     std::string Name;
  624     std::string ExternalContentsPath;
  658   std::string WorkingDirectory;
  669   std::string ExternalContentsPrefixDir;
  730   llvm::ErrorOr<std::string> getCurrentWorkingDirectory() const override;
  764   std::string OverlayDir;

   79 std::string escape(StringRef Input, bool EscapePrintable = true);
  157   std::string getVerbatimTag() const;

  786   virtual void scalarTag(std::string &) = 0;
  991     std::string Storage;
 1011     std::string Storage;
 1030     std::string ScalarStorage, TagStorage;
 1039     std::string Tag;
 1171   static void output(const std::string &, void *, raw_ostream &);
 1172   static StringRef input(StringRef, void *, std::string &);
 1432   void scalarTag(std::string &) override;
 1494     SmallVector<std::string, 6> ValidKeys;
 1579   void scalarTag(std::string &) override;
 1936   using map_type = std::map<std::string, T>;

  201   raw_ostream &operator<<(const std::string &Str) {
  504   std::string &OS;
  514   explicit raw_string_ostream(std::string &O) : OS(O) {}
  519   std::string& str() {

   78   virtual std::string getAsString() const = 0;
  112   std::string getAsString() const override { return "bit"; }
  132   std::string getAsString() const override;
  152   std::string getAsString() const override { return "code"; }
  170   std::string getAsString() const override { return "int"; }
  188   std::string getAsString() const override;
  210   std::string getAsString() const override;
  230   std::string getAsString() const override;
  271   std::string getAsString() const override;
  362   virtual std::string getAsString() const = 0;
  367   virtual std::string getAsUnquotedString() const { return getAsString(); }
  479   std::string getAsString() const override { return "?"; }
  508   std::string getAsString() const override { return Value ? "1" : "0"; }
  553   std::string getAsString() const override;
  586   std::string getAsString() const override;
  615   std::string getAsString() const override { return "\"" + Value.str() + "\""; }
  617   std::string getAsUnquotedString() const override { return Value; }
  648   std::string getAsString() const override {
  652   std::string getAsUnquotedString() const override { return Value; }
  708   std::string getAsString() const override;
  797   std::string getAsString() const override;
  855   std::string getAsString() const override;
  917   std::string getAsString() const override;
  977   std::string getAsString() const override;
 1031   std::string getAsString() const override;
 1064   std::string getAsString() const override;
 1088   std::string getNameInitAsString() const {
 1101   std::string getAsString() const override { return getName(); }
 1131   std::string getAsString() const override;
 1167   std::string getAsString() const override;
 1200   std::string getAsString() const override;
 1237   std::string getAsString() const override;
 1294   std::string getAsString() const override {
 1369   std::string getAsString() const override;
 1408   std::string getNameInitAsString() const {
 1486   const std::string getNameInitAsString() const {
 1697   using RecordMap = std::map<std::string, std::unique_ptr<Record>, std::less<>>;
 1700   std::map<std::string, Init *, std::less<>> ExtraGlobals;

   32   using StringPair = std::pair<std::string, std::string>;
   32   using StringPair = std::pair<std::string, std::string>;

   26   std::string AggregateString;

   43   virtual std::string getName(unsigned IID, Type **Tys = nullptr,

   85   std::string TargetCPU;
   86   std::string TargetFS;

   80   std::string Code;

   38   ELFSymbol(std::string SymbolName) : Name(SymbolName) {}
   39   std::string Name;
   44   Optional<std::string> Warning;
   56   Optional<std::string> SoName;
   58   std::vector<std::string> NeededLibs;

  148   operator std::string() const;

  121   std::string InstallName;
  275   const std::vector<std::pair<Target, std::string>> &umbrellas() const {
  280   const std::vector<std::pair<Target, std::string>> getParentUmbrellas() const {
  330   const std::vector<std::pair<Target, std::string>> &uuids() const {
  396   std::string Path;
  398   std::string InstallName;
  406   std::vector<std::pair<Target, std::string>> ParentUmbrellas;
  409   std::vector<std::pair<Target, std::string>> UUIDs;

   34   operator std::string() const;

 1463   virtual const std::string getAsStr() const = 0;

   62     std::string getDescription() const {

  204     std::map<std::string, GVSummaryMapTy> &ModuleToSummariesForIndex);
  209     const std::map<std::string, GVSummaryMapTy> &ModuleToSummariesForIndex);

  180   std::string PGOInstrGen;
  182   std::string PGOInstrUse;
  184   std::string PGOSampleUse;

   27   SampleProfileLoaderPass(std::string File = "", std::string RemappingFile = "",
   27   SampleProfileLoaderPass(std::string File = "", std::string RemappingFile = "",
   35   std::string ProfileFileName;
   36   std::string ProfileRemappingFileName;

   49                                   const std::string &ModuleId);
   81   std::string Filter;
   84   std::string Exclude;
  143   std::string InstrProfileOutput;
  157     const std::vector<std::string> &ABIListFiles = std::vector<std::string>(),

   38   PGOInstrumentationGenCreateVar(std::string CSInstrName = "")
   43   std::string CSInstrName;
   60   PGOInstrumentationUse(std::string Filename = "",
   61                         std::string RemappingFilename = "", bool IsCS = false);
   66   std::string ProfileFileName;
   67   std::string ProfileRemappingFileName;

  421   std::string Banner;
  425   PrintLoopPass(raw_ostream &OS, const std::string &Banner = "");

  106     std::string Suffix;
  124                   std::string Suffix = "");
  134                   std::string Suffix = "");

   74   std::string getName(const GlobalValue *SGV, bool DoPromote);

  109 std::string getUniqueModuleId(Module *M);

   50   std::string ProtoName;

   96   bool parse(const std::string &MapFile, RewriteDescriptorList *Descriptors);

   45   std::string Msg;

  210   std::string Data{};
  218   explicit CustomEventRecord(uint64_t S, uint64_t T, uint16_t C, std::string D)
  238   std::string Data{};
  246   explicit CustomEventRecordV5(int32_t S, int32_t D, std::string P)
  266   std::string Data{};
  274   explicit TypedEventRecord(int32_t S, int32_t D, uint16_t E, std::string P)

   61   std::string FunctionName;

   24   std::string Delim;
   27   explicit RecordPrinter(raw_ostream &O, std::string D)

   98   std::string Data;

   36   std::string Function;
   41   std::string Data;

   46     std::string o1, o2;

  101   std::string Messages;

   49 cl::opt<std::string>
   84 cl::opt<std::string> PrintBlockFreqFuncName(
  130   std::string getNodeLabel(const BasicBlock *Node,
  136   std::string getNodeAttributes(const BasicBlock *Node,
  142   std::string getEdgeAttributes(const BasicBlock *Node, EdgeIter EI,

  605 std::string
  610 std::string

   52 cl::opt<std::string> PrintBranchProbFuncName(

   25 static cl::opt<std::string> CFGFuncName(
   30 static cl::opt<std::string> CFGDotFilenamePrefix(
   97   std::string Filename =

  424       std::string Functions;
  620     std::string Banner;
  626     PrintCallGraphPass(const std::string &B, raw_ostream &OS)
  680                                           const std::string &Banner) const {
  684 static std::string getDescription(const CallGraphSCC &SCC) {
  685   std::string Desc = "SCC (";

   27   static std::string getGraphName(CallGraph *Graph) { return "Call graph"; }
   29   std::string getNodeLabel(CallGraphNode *Node, CallGraph *Graph) {

   33   std::string getNodeLabel(DomTreeNode *Node, DomTreeNode *Graph) {
   56   static std::string getGraphName(DominatorTree *DT) {
   60   std::string getNodeLabel(DomTreeNode *Node, DominatorTree *G) {
   72   static std::string getGraphName(PostDominatorTree *DT) {
   76   std::string getNodeLabel(DomTreeNode *Node, PostDominatorTree *G ) {

 1791   std::string Name = "\"" + DOT::EscapeString(N.getFunction().getName()) + "\"";

  135     std::string Messages;

  936 void llvm::printLoop(Loop &L, raw_ostream &OS, const std::string &Banner) {

   37   std::string Banner;
   42   PrintLoopPassWrapper(raw_ostream &OS, const std::string &Banner)
  328                                   const std::string &Banner) const {
  389 static std::string getDescription(const Loop &L) {

   73 cl::opt<std::string> ModuleSummaryDotFile(

  183   std::string Banner;
  188   PrintRegionPass(const std::string &B, raw_ostream &o)
  277                                   const std::string &Banner) const {
  281 static std::string getDescription(const Region &R) {

   43   std::string getNodeLabel(RegionNode *Node, RegionNode *Graph) {
   66   static std::string getGraphName(const RegionInfo *) { return "Region Graph"; }
   68   std::string getNodeLabel(RegionNode *Node, RegionInfo *G) {
   73   std::string getEdgeAttributes(RegionNode *srcNode,
  234   std::string GraphName = DOTGraphTraits<RegionInfo *>::getGraphName(RI);

  114 static void UnEscapeLexed(std::string &Str) {

   38     std::string StrVal;
   59     const std::string &getStrVal() const { return StrVal; }

   56 static std::string getTypeString(Type *T) {
   57   std::string Result;
  358   std::string AsmStr;
  371   std::string Str;
  420     std::string Str;
  456   std::string Name = Lex.getStrVal();
  552   std::string Name;
  592   std::string Name = Lex.getStrVal();
  616   std::string Name = Lex.getStrVal();
  667   std::string Str;
  701   std::string Name = Lex.getStrVal();
  872 bool LLParser::parseIndirectSymbol(const std::string &Name, LocTy NameLoc,
 1026 bool LLParser::ParseGlobal(const std::string &Name, LocTy NameLoc,
 1365                                               const std::string &Name) {
 1401 GlobalValue *LLParser::GetGlobalVal(const std::string &Name, Type *Ty,
 1465 Comdat *LLParser::getComdat(const std::string &Name, LocTy Loc) {
 1493 bool LLParser::ParseStringConstant(std::string &Result) {
 1581   std::string Attr = Lex.getStrVal();
 1583   std::string Val;
 2023   std::string Name = Lex.getStrVal();
 2224     std::string SSN;
 2518     std::string Tag;
 2576     std::string Name;
 2874 Value *LLParser::PerFunctionState::GetVal(const std::string &Name, Type *Ty,
 2946                                              const std::string &NameStr,
 3006 BasicBlock *LLParser::PerFunctionState::GetBB(const std::string &Name,
 3020 BasicBlock *LLParser::PerFunctionState::DefineBB(const std::string &Name,
 4298   std::string S;
 5354   std::string FunctionName;
 5377   std::string Section;
 5378   std::string Partition;
 5380   std::string GC;
 5616   std::string Name;
 5631   std::string NameStr;
 7458   std::string Path;
 7494   std::string Name;
 7554   std::string Name;
 7915     std::string Name, GlobalValue::GUID GUID, GlobalValue::LinkageTypes Linkage,
 7988   std::string Name;
 8060 bool LLParser::ParseFunctionSummary(std::string Name, GlobalValue::GUID GUID,
 8130 bool LLParser::ParseVariableSummary(std::string Name, GlobalValue::GUID GUID,
 8185 bool LLParser::ParseAliasSummary(std::string Name, GlobalValue::GUID GUID,

   63     std::string StrVal, StrVal2;
  125     std::map<std::string, std::pair<GlobalValue*, LocTy> > ForwardRefVals;
  130     std::map<std::string, LocTy> ForwardRefComdats;
  166     std::string SourceFileName;
  204     GlobalValue *GetGlobalVal(const std::string &N, Type *Ty, LocTy Loc,
  210     Comdat *getComdat(const std::string &Name, LocTy Loc);
  252     bool ParseStringConstant(std::string &Result);
  323     bool ParseGlobal(const std::string &Name, LocTy NameLoc, unsigned Linkage,
  328     bool parseIndirectSymbol(const std::string &Name, LocTy NameLoc,
  351     bool ParseFunctionSummary(std::string Name, GlobalValue::GUID, unsigned ID);
  352     bool ParseVariableSummary(std::string Name, GlobalValue::GUID, unsigned ID);
  353     bool ParseAliasSummary(std::string Name, GlobalValue::GUID, unsigned ID);
  385     void AddGlobalValueToIndex(std::string Name, GlobalValue::GUID,
  416       std::map<std::string, std::pair<Value*, LocTy> > ForwardRefVals;
  434       Value *GetVal(const std::string &Name, Type *Ty, LocTy Loc, bool IsCall);
  439       bool SetInstName(int NameID, const std::string &NameStr, LocTy NameLoc,
  445       BasicBlock *GetBB(const std::string &Name, LocTy Loc);
  451       BasicBlock *DefineBB(const std::string &Name, int NameID, LocTy Loc);
  547       std::string Name;
  548       ArgInfo(LocTy L, Type *ty, AttributeSet Attr, const std::string &N)

  179 void Document::writeToBlob(std::string &Blob) {

   36 std::string DocNode::toString() const {
   37   std::string S;
  101   std::string V;
  102   StringRef Err = yaml::ScalarTraits<std::string>::input(S, nullptr, V);
  200       return ScalarTraits<std::string>::mustQuote(ScalarStr);

   11 std::string llvm::wasm::toString(wasm::WasmSymbolType Type) {
   27 std::string llvm::wasm::relocTypetoString(uint32_t Type) {

   44     std::string Message;
   90     std::string Message;

  727   std::string Indent(IndentLevel * 2, ' ');
  938           std::string Str;

  173 static Expected<std::string> readIdentificationBlock(BitstreamCursor &Stream) {
  180   std::string ProducerIdentification;
  223 static Expected<std::string> readIdentificationCode(BitstreamCursor &Stream) {
  290       std::string S;
  294       if (S.find("__DATA,__objc_catlist") != std::string::npos ||
  295           S.find("__OBJC,__category") != std::string::npos)
  339 static Expected<std::string> readModuleTriple(BitstreamCursor &Stream) {
  345   std::string Triple;
  372       std::string S;
  384 static Expected<std::string> readTriple(BitstreamCursor &Stream) {
  445   std::string ProducerIdentification;
  453   std::string FullMsg = Message.str();
  493   std::vector<std::string> SectionTable;
  494   std::vector<std::string> GCTable;
  566   std::vector<std::string> BundleTags;
  800   std::string SourceFileName;
 2732       std::string AsmStr, ConstrStr;
 2757       std::string AsmStr, ConstrStr;
 3063   std::string OldFormatName;
 3118   std::string Section;
 3573       std::string S;
 3580       std::string S;
 3587       std::string S;
 3595       std::string S;
 3602       std::string S;
 3609       std::string S;
 3653     std::string DL = llvm::UpgradeDataLayoutString(
 5373   std::string GlobalId =
 6151       std::set<std::string> &CfiFunctionDefs = TheIndex.cfiFunctionDefs();
 6159       std::set<std::string> &CfiFunctionDecls = TheIndex.cfiFunctionDecls();
 6256   std::string message(int IE) const override {
 6447   std::string ProducerIdentification;
 6451     Expected<std::string> ProducerIdentificationOrErr =
 6669 Expected<std::string> llvm::getBitcodeTargetTriple(MemoryBufferRef Buffer) {
 6685 Expected<std::string> llvm::getBitcodeProducerString(MemoryBufferRef Buffer) {

 1879     std::string String(Record.begin(), Record.end());

   44   std::string Data;

  406   const std::map<std::string, GVSummaryMapTy> *ModuleToSummariesForIndex;
  421                      const std::map<std::string, GVSummaryMapTy>
 1156   const std::string &DL = M.getDataLayoutStr();
 1165   std::map<std::string, unsigned> SectionMap;
 1166   std::map<std::string, unsigned> GCMap;
 2326       const std::string &AsmStr = IA->getAsmString();
 2331       const std::string &ConstraintStr = IA->getConstraintString();
 3606                                      const std::string &Id,
 3625     const std::string &Id, const TypeIdCompatibleVtableInfo &Summary,
 4388     std::string Err;
 4450     const std::map<std::string, GVSummaryMapTy> *ModuleToSummariesForIndex) {
 4503     const std::map<std::string, GVSummaryMapTy> *ModuleToSummariesForIndex) {

  491       std::string Name;
  501         std::string Name;

  805   std::string Str;
 1368   std::string Buf;
 1564     std::string Flags;
 2196       std::string S;
 3132     std::string GroupName;

  221         std::string Val(StrStart, StrEnd);
  271         std::string msg;
  363         std::string Val(StrStart, StrEnd);
  453           std::string msg;
  525   std::vector<std::string> RestrRegs;
  548     std::string Msg = "inline asm clobber list contains reserved registers: ";
  554     std::string Note = "Reserved registers on the clobber list may not be "
  595     std::string msg;

   76   std::vector<std::string> &Comments;
   85                      std::vector<std::string> &Comments, bool GenerateComments)

  118   std::string getTypeName(TypeIndex TI) {
  119     std::string TypeName;
  175   std::string &Filepath = FileToFilepathMap[File];
  209   while ((Cursor = Filepath.find("\\.\\", Cursor)) != std::string::npos)
  215   while ((Cursor = Filepath.find("\\..\\", Cursor)) != std::string::npos) {
  221     if (PrevSlash == std::string::npos)
  232   while ((Cursor = Filepath.find("\\\\", Cursor)) != std::string::npos)
  247       std::string Checksum = fromHex(F->getChecksum()->Value);
  320 static std::string getQualifiedName(ArrayRef<StringRef> QualifiedNameComponents,
  322   std::string FullyQualifiedName;
  332 static std::string getFullyQualifiedName(const DIScope *Scope, StringRef Name) {
  350 static std::string getFullyQualifiedName(const DIScope *Ty) {
  368   std::string ScopeName = getFullyQualifiedName(Scope);
  946   std::string FuncName = GlobalValue::dropLLVMManglingEscape(GV->getName());
  992   std::string FuncName;
 1475   std::string FullyQualifiedName =
 2075   std::string FullName = getFullyQualifiedName(Ty);
 2226   std::string FullName = getFullyQualifiedName(Ty);
 2257   std::string FullName = getFullyQualifiedName(Ty);
 2279   std::string FullName = getFullyQualifiedName(Ty);
 2299   std::string FullName = getFullyQualifiedName(Ty);
 2967     ArrayRef<std::pair<std::string, const DIType *>> UDTs) {

  271   std::vector<std::pair<std::string, const DIType *>> LocalUDTs;
  272   std::vector<std::pair<std::string, const DIType *>> GlobalUDTs;
  274   using FileToFilepathMapTy = std::map<const DIFile *, std::string>;
  314   emitDebugInfoForUDTs(ArrayRef<std::pair<std::string, const DIType *>> UDTs);

  236   const std::string Indent(IndentCount, ' ');
  248   const std::string Indent(IndentCount, ' ');

   51   std::vector<std::string> Comments;
  121   ArrayRef<std::string> getComments(const Entry &E) const {

 1127   std::string FullName = getParentContextString(Context) + Name.str();
 1135   std::string FullName = getParentContextString(Context) + Name.str();
 1148   std::string FullName = getParentContextString(Context) + Ty->getName().str();
 1156   std::string FullName = getParentContextString(Context) + Ty->getName().str();

  799     std::string ProducerWithFlags = Producer.str() + " " + Flags.str();

  347     std::vector<std::string> Comments;

  322   std::string ChecksumString = fromHex(Checksum->Value);
  731 std::string DwarfUnit::getParentContextString(const DIScope *Context) const {
  739   std::string CS;

  103   std::string getParentContextString(const DIScope *Context) const;

   52   const std::string &MId = M.getModuleIdentifier();
   54   std::string SymName;

   37   const std::string FEntryName =

  167     const std::string error = ("unsupported GC: " + Name).str() +

 2354           std::string InstStrStorage;

   43 static const std::string CoveragePrefix = "";

  525       std::string Name = Globals[k]->getName();

   88   std::string EmuTlsVarName = ("__emutls_v." + GV->getName()).str();
  139     std::string EmuTlsTmplName = ("__emutls_t." + GV->getName()).str();

  104   using StringInstrPair = std::pair<std::string, MachineInstr *>;
  108     std::string S;
  115     StringInstrMap.push_back({(i == std::string::npos) ? S : S.substr(i), II});

   78 MIToken &MIToken::setOwnedStringValue(std::string StrVal) {
  117 static std::string unescapeQuotedString(StringRef Value) {
  121   std::string Str;

  167   std::string StringValueStorage;
  176   MIToken &setOwnedStringValue(std::string StrVal);

  448   bool parseCFIEscapeValues(std::string& Values);
  518   bool parseStringConstant(std::string &Result);
 1080 static std::string getRegisterName(const TargetRegisterInfo *TRI,
 2033 bool MIParser::parseCFIEscapeValues(std::string &Values) {
 2134     std::string Values;
 2213   std::string Name = Token.stringValue();
 2798     std::string SSN;
 3037 bool MIParser::parseStringConstant(std::string &Result) {

   86   std::string Name;
  274   std::array<std::string *, 3> Outputs{{&Object.DebugVar.Value,
  505     std::string Str;
  529     std::string Str;

   30   std::string MachineFunctions;
   43     std::string Str;

  336   std::string S;

  264 std::string MachineBasicBlock::getFullName() const {
  265   std::string Name;

   64 extern cl::opt<std::string> ViewBlockFreqFuncName;
   76 extern cl::opt<std::string> PrintBlockFreqFuncName;
  124   std::string getNodeLabel(const MachineBasicBlock *Node,
  146   std::string getNodeAttributes(const MachineBasicBlock *Node,
  152   std::string getEdgeAttributes(const MachineBasicBlock *Node, EdgeIter EI,

  195 extern cl::opt<std::string> ViewBlockFreqFuncName;
  564 static std::string getBlockName(const MachineBasicBlock *BB) {
  565   std::string Result;

  529     static std::string getGraphName(const MachineFunction *F) {
  533     std::string getNodeLabel(const MachineBasicBlock *Node,
  535       std::string OutStr;

   34                                              const std::string &Banner) const {

   31   const std::string Banner;
   34   MachineFunctionPrinterPass(raw_ostream &os, const std::string &banner)
   66                                                       const std::string &Banner){

 1096   std::string FunctionName = ("OUTLINED_FUNCTION_" + Twine(Name)).str();
 1163     std::string Dummy;
 1381     std::string Fname = F.getName();

  103 static cl::opt<std::string> SchedOnlyFunc("misched-only-func", cl::Hidden,
 3684   static std::string getGraphName(const ScheduleDAG *G) {
 3701   static std::string getEdgeAttributes(const SUnit *Node,
 3711   static std::string getNodeLabel(const SUnit *SU, const ScheduleDAG *G) {
 3712     std::string Str;
 3723   static std::string getNodeDescription(const SUnit *SU, const ScheduleDAG *G) {
 3727   static std::string getNodeAttributes(const SUnit *N, const ScheduleDAG *G) {
 3728     std::string Str("shape=Mrecord");

  297     const std::string Banner;
  299     MachineVerifierPass(std::string banner = std::string())
  324 FunctionPass *llvm::createMachineVerifierPass(const std::string &Banner) {

 1833   std::string ScheduleDump;

   60 static cl::opt<std::string>

  819   std::string FullyQualifiedName =
  848         std::string GraphFileName = FullyQualifiedName + "." + RS.str() +

  511       std::string Msg = std::string("Error while trying to spill ") +

  596     std::string Name = std::string(AI->getName()) + ".unsafe";

 1173 std::string ScheduleDAGInstrs::getGraphNodeLabel(const SUnit *SU) const {
 1174   std::string s;
 1187 std::string ScheduleDAGInstrs::getDAGName() const {

   30     static std::string getGraphName(const ScheduleDAG *G) {
   42     static std::string getNodeIdentifierLabel(const SUnit *Node,
   44       std::string R;
   52     static std::string getEdgeAttributes(const SUnit *Node,
   63     std::string getNodeLabel(const SUnit *SU, const ScheduleDAG *Graph);
   64     static std::string getNodeAttributes(const SUnit *N,
   76 std::string DOTGraphTraits<ScheduleDAG*>::getNodeLabel(const SUnit *SU,

   96 static cl::opt<std::string>

 1031 std::string ScheduleDAGSDNodes::getDAGName() const {

  129     std::string getGraphNodeLabel(const SUnit *SU) const override;
  131     std::string getDAGName() const override;

 8656   std::string ErrorStr;

   59 std::string SDNode::getOperationName(const SelectionDAG *G) const {

  138 static cl::opt<std::string>
  780   std::string BlockName;
 1505             std::string InstStrStorage;
 1555           std::string InstStrStorage;
 3642   std::string msg;

   44     static std::string getEdgeDestLabel(const void *Node, unsigned i) {
   49     static std::string getEdgeSourceLabel(const void *Node, EdgeIter I) {
   72     static std::string getGraphName(const SelectionDAG *G) {
   80     static std::string getNodeIdentifierLabel(const SDNode *Node,
   82       std::string R;
   95     static std::string getEdgeAttributes(const void *Node, EdgeIter EI,
  107     static std::string getSimpleNodeLabel(const SDNode *Node,
  109       std::string Result = Node->getOperationName(G);
  116     std::string getNodeLabel(const SDNode *Node, const SelectionDAG *Graph);
  117     static std::string getNodeAttributes(const SDNode *N,
  120       const std::string &Attrs = Graph->getGraphAttrs(N);
  122         if (Attrs.find("shape=") == std::string::npos)
  141 std::string DOTGraphTraits<SelectionDAG*>::getNodeLabel(const SDNode *Node,
  150 void SelectionDAG::viewGraph(const std::string &Title) {
  193 const std::string SelectionDAG::getGraphAttrs(const SDNode *N) const {
  195   std::map<const SDNode *, std::string>::const_iterator I =
  274 std::string ScheduleDAGSDNodes::getGraphNodeLabel(const SUnit *SU) const {
  275   std::string s;

 4037                                                   std::string &Constraint,
 6830   std::string NameString = ("__emutls_v." + GA->getGlobal()->getName()).str();

 1832 static std::string getReciprocalOpName(bool IsSqrt, EVT VT) {
 1833   std::string Name = VT.isVector() ? "vec-" : "";
 1908   std::string VTName = getReciprocalOpName(IsSqrt, VT);
 1909   std::string VTNameNoSize = VTName;
 1963   std::string VTName = getReciprocalOpName(IsSqrt, VT);
 1964   std::string VTNameNoSize = VTName;

  652     std::string SizeSpec = ".rodata.str" + utostr(EntrySize) + ".";
  757   std::string Name;
  889       SmallVector<std::string, 4> StrOptions;
  909   std::string ErrorCode =
  946   std::string ErrorCode =
 1455         std::string Directive(" ");
 1532   std::string Name = IsCtor ? ".ctors" : ".dtors";
 1599 static std::string APIntToHexString(const APInt &AI) {
 1601   std::string HexString = AI.toString(16, /*Signed=*/false);
 1610 static std::string scalarConstantToHexString(const Constant *C) {
 1624     std::string HexString;
 1643     std::string COMDATSymName;

  137 static cl::opt<std::string> PrintMachineInstrs(
  186 static cl::opt<std::string>
  191 static cl::opt<std::string>
  196 static cl::opt<std::string>
  201 static cl::opt<std::string>
  467 std::string
  471   std::string Res;
  472   static cl::opt<std::string> *PassNames[] = {&StartAfterOpt, &StartBeforeOpt,
  532     std::string Banner;
  588 void TargetPassConfig::printAndVerify(const std::string &Banner) {
  593 void TargetPassConfig::addPrintPass(const std::string &Banner) {
  598 void TargetPassConfig::addVerifyPass(const std::string &Banner) {

  114 std::string EVT::getEVTString() const {

   23   std::string message(int Condition) const override {

  129     std::string TypeNameStr = Streamer->getTypeName(TypeInd);

  248 std::string llvm::codeview::computeTypeName(TypeCollection &Types,

  243   std::string FrontendVersion;
  249   std::string BackendVersion;
  268   std::string FrontendVersion;
  275   std::string BackendVersion;

   45 static std::string getFlagNames(CodeViewRecordIO &IO, T Value,
   62   std::string FlagLabel;
   74     std::string LabelWithBraces(" ( ");
   97 static std::string getMemberAttributes(CodeViewRecordIO &IO,
  102   std::string AccessSpecifier =
  104   std::string MemberAttrs(AccessSpecifier);
  106     std::string MethodKind =
  111     std::string MethodOptions = getFlagNames(
  123     std::string Attrs = getMemberAttributes(
  204     std::string RecordKindName =
  244     std::string MemberKindName = getLeafTypeName(Record.Kind);
  270   std::string ModifierNames =
  280   std::string CallingConvName = getEnumName(
  282   std::string FuncOptionNames =
  296   std::string CallingConvName = getEnumName(
  298   std::string FuncOptionNames =
  340     std::string PtrType = getEnumName(IO, unsigned(Record.getPointerKind()),
  344     std::string PtrMode = getEnumName(IO, unsigned(Record.getMode()),
  377     std::string PtrMemberGetRepresentation = getEnumName(
  400   std::string PropertiesNames =
  416   std::string PropertiesNames =
  430   std::string PropertiesNames =
  584   std::string ModeName =
  592   std::string Attrs = getMemberAttributes(
  603   std::string Attrs = getMemberAttributes(
  616   std::string Attrs = getMemberAttributes(
  655   std::string Attrs = getMemberAttributes(
  667   std::string Attrs = getMemberAttributes(

   69                            std::string DWPName)
  948                                                   std::string &FunctionName,
 1119   std::string FunctionName(DILineInfo::BadString);
 1818                      std::string DWPName) {
 1838   std::string TargetLookupError;

  349   std::string Str;

 1045     std::string &Result, sys::path::Style Style) const {

  285   std::string File;
  319   std::string Space = DumpOpts.ShowAddresses ? " " : "";

  726       std::string FullPath;

   23   std::string message(int Condition) const override {

   23   std::string message(int Condition) const override {

   28     std::string Checksum = getChecksum();

   51 std::string NativeCompilandSymbol::getLibraryName() const {
   55 std::string NativeCompilandSymbol::getName() const {

   20 Expected<std::string> readStreamData(BinaryStream &Stream, uint32_t Limit) {
   22   std::string Result;
   48   std::string getFileName() const override {
   54   std::string getObjectFileName() const override {
   60   std::string getVirtualFileName() const override {
   68   std::string getCode() const override {
   73     std::string StreamName = ("/src/files/" + VName).str();

   75 std::string NativeExeSymbol::getSymbolsFileName() const {

  150 std::string NativeRawSymbol::getCompilerName() const {
  175 std::string NativeRawSymbol::getLibraryName() const {
  201 std::string NativeRawSymbol::getName() const {
  225 std::string NativeRawSymbol::getObjectFileName() const {
  275 std::string NativeRawSymbol::getSourceFileName() const {
  290 std::string NativeRawSymbol::getSymbolsFileName() const { return {}; }
  328 std::string NativeRawSymbol::getUndecoratedName() const {
  332 std::string NativeRawSymbol::getUndecoratedNameEx(
  732 std::string NativeRawSymbol::getUnused() const {

   54 std::string NativeSymbolEnumerator::getName() const { return Record.Name; }

  304 std::string NativeTypeEnum::getName() const {

   23 std::string NativeTypeTypedef::getName() const { return Record.Name; }

   73 std::string NativeTypeUDT::getName() const {

   15   std::string message(int Condition) const override {

  170     std::string ThisName = computeTypeName(*Types, TI);

   99 std::string PDBContext::getFunctionName(uint64_t Address,

   28 std::string PDBSymbolCompiland::getSourceFileName() const {
   32 std::string PDBSymbolCompiland::getSourceFileFullPath() const {
   33   std::string SourceFileFullPath;
   42   std::string RecordedResult = RawSymbol->getSourceFileName();
   46       std::string EnvWorkingDir, EnvSrc;
   49         std::string Var = Env->getName();
   65           std::string Path = EnvWorkingDir + "\\" + EnvSrc;
   94       std::string FileName = File->getFileName();

   20 std::string PDBSymbolCompilandEnv::getValue() const {

   36     std::unordered_set<std::string> SeenNames;
   40         std::string Name = Child->getName();
   88   std::string Name = getName();

   48                                const PDBSymbol *Symbol, const std::string &Name,
  105                              const std::string &Name, uint32_t OffsetInParent,

   34 void DIPrinter::printContext(const std::string &FileName, int64_t Line) {
   65     std::string FunctionName = Info.FunctionName;
   73   std::string Filename = Info.FileName;
  112   std::string Name = Global.Name;

  224                                                     std::string &Name,
  264     std::string FunctionName;
  289     std::string FunctionName;

   59                               std::string &Name, uint64_t &Addr,

   79 LLVMSymbolizer::symbolizeCode(const std::string &ModuleName,
   88 LLVMSymbolizer::symbolizeInlinedCode(const std::string &ModuleName,
  118 LLVMSymbolizer::symbolizeData(const std::string &ModuleName,
  144 LLVMSymbolizer::symbolizeFrame(const std::string &ModuleName,
  179 std::string getDarwinDWARFResourceForPath(
  180     const std::string &Path, const std::string &Basename) {
  180     const std::string &Path, const std::string &Basename) {
  198 bool findDebugBinary(const std::string &OrigPath,
  199                      const std::string &DebuglinkName, uint32_t CRCHash,
  200                      const std::string &FallbackDebugPath,
  201                      std::string &Result) {
  243 bool getGNUDebuglinkContents(const ObjectFile *Obj, std::string &DebugName,
  289 ObjectFile *LLVMSymbolizer::lookUpDsymFile(const std::string &ExePath,
  290     const MachOObjectFile *MachExeObj, const std::string &ArchName) {
  293   std::vector<std::string> DsymPaths;
  318 ObjectFile *LLVMSymbolizer::lookUpDebuglinkObject(const std::string &Path,
  320                                                   const std::string &ArchName) {
  321   std::string DebuglinkName;
  323   std::string DebugBinaryPath;
  339 LLVMSymbolizer::getOrCreateObjectPair(const std::string &Path,
  340                                       const std::string &ArchName) {
  368 LLVMSymbolizer::getOrCreateObject(const std::string &Path,
  369                                   const std::string &ArchName) {
  426 LLVMSymbolizer::getOrCreateModuleInfo(const std::string &ModuleName) {
  431   std::string BinaryName = ModuleName;
  432   std::string ArchName = Opts.DefaultArch;
  435   if (ColonPos != std::string::npos) {
  436     std::string ArchStr = ModuleName.substr(ColonPos + 1);
  509 std::string
  510 LLVMSymbolizer::DemangleName(const std::string &Name,
  519     std::string Result = DemangledName;
  533     std::string Result = DemangledName;

   16 static bool isItaniumEncoding(const std::string &MangledName) {
   22 std::string llvm::demangle(const std::string &MangledName) {
   22 std::string llvm::demangle(const std::string &MangledName) {
   33   std::string Ret = Demangled;

  115 std::string Node::toString(OutputFlags Flags) const {

   49     std::unique_ptr<Module> M, std::string *ErrorStr,
   55     std::string *ErrorStr, std::shared_ptr<MCJITMemoryManager> MemMgr,
   60                                                 std::string *ErrorStr) =nullptr;
  191 std::string ExecutionEngine::getMangledName(const GlobalValue *GV) {
  223     std::string &V = EEState.getGlobalAddressReverseMap()[CurVal];
  269     std::string &V = EEState.getGlobalAddressReverseMap()[CurVal];
  315   std::map<uint64_t, std::string>::iterator I =
  335               const std::vector<std::string> &InputArgv);
  339                        const std::vector<std::string> &InputArgv) {
  427                                        const std::vector<std::string> &argv,
  461         std::vector<std::string> EnvVars;
 1192   std::map<std::pair<std::string, Type*>,

  106   std::string Error;
  121   std::string Error;
  137   std::string Error;
  196   std::string Error;
  235   std::vector<std::string> ArgVec(ArgV, ArgV + ArgC);
  336   bool finalizeMemory(std::string *ErrMsg) override;
  376 bool SimpleBindingMemoryManager::finalizeMemory(std::string *ErrMsg) {

   64 static ManagedStatic<std::map<std::string, ExFunc> > FuncNames;
  103   std::string ExtName = "lle_";

   35                                      std::string *ErrStr) {
   38     std::string Msg;

  103                                  std::string *ErrorStr = nullptr);

   35   std::string message(int Condition) const override {

  509     std::string ErrMsg;

  469     std::string ErrMsg;

   42 MCJIT::createJIT(std::unique_ptr<Module> M, std::string *ErrorStr,
  216     std::string Buf;
  280 JITSymbol MCJIT::findExistingSymbol(const std::string &Name) {
  289 Module *MCJIT::findModuleForSymbol(const std::string &Name,
  316 uint64_t MCJIT::getSymbolAddress(const std::string &Name,
  318   std::string MangledName;
  333 JITSymbol MCJIT::findSymbol(const std::string &Name,
  390 uint64_t MCJIT::getGlobalValueAddress(const std::string &Name) {
  398 uint64_t MCJIT::getFunctionAddress(const std::string &Name) {
  670 LinkingSymbolResolver::findSymbol(const std::string &Name) {

   34   JITSymbol findSymbol(const std::string &Name) override;
   37   JITSymbol findSymbolInLogicalDylib(const std::string &Name) override {
  290   uint64_t getGlobalValueAddress(const std::string &Name) override;
  291   uint64_t getFunctionAddress(const std::string &Name) override;
  304   createJIT(std::unique_ptr<Module> M, std::string *ErrorStr,
  313   JITSymbol findSymbol(const std::string &Name, bool CheckFunctionsOnly);
  322   uint64_t getSymbolAddress(const std::string &Name,
  337   JITSymbol findExistingSymbol(const std::string &Name);
  338   Module *findModuleForSymbol(const std::string &Name, bool CheckFunctionsOnly);

   38       std::string AliasName = A.getName();

 1728 JITDylib::JITDylib(ExecutionSession &ES, std::string Name)
 1840 JITDylib &ExecutionSession::createJITDylib(std::string Name,
 2143   std::string MangledName;

  185   std::string ErrMsg;
  211     std::string Tmp((*Name).data() + HasGlobalPrefix,

   91       std::string ErrMsg;

   46   std::string ErrMsg;
   62     const std::vector<std::string> &FeatureVec) {

  143 std::string LLJIT::mangle(StringRef UnmangledName) {
  144   std::string MangledName;

   27 JITSymbol NullLegacyResolver::findSymbol(const std::string &Name) {
   32 NullLegacyResolver::findSymbolInLogicalDylib(const std::string &Name) {

   37   std::string Mangled = J.mangle(SymbolName);

   56   virtual JITSymbol findSymbolIn(orc::VModuleKey K, const std::string &Name,
   65     JITSymbol findSymbolIn(orc::VModuleKey K, const std::string &Name,
   85     JITSymbol findSymbolIn(orc::VModuleKey K, const std::string &Name,
  176     JITSymbol findSymbol(const std::string &Name) {
  251   std::string mangle(StringRef Name) {
  252     std::string MangledName;
  297     std::vector<std::string> CtorNames, DtorNames;
  377   JITSymbol findSymbol(const std::string &Name,
  386   JITSymbol findSymbolIn(orc::VModuleKey K, const std::string &Name,
  392   Expected<JITTargetAddress> findSymbolAddress(const std::string &Name,
  410                                                  const std::string &Name,
  427   const std::string &getErrorMessage() const { return ErrMsg; }
  527   std::string ErrMsg;

   29   std::string message(int condition) const override {
   82 DuplicateDefinition::DuplicateDefinition(std::string SymbolName)
   93 const std::string &DuplicateDefinition::getSymbolName() const {
   97 JITSymbolNotFound::JITSymbolNotFound(std::string SymbolName)
  110 const std::string &JITSymbolNotFound::getSymbolName() const {

  118     bool finalizeMemory(std::string *ErrMsg = nullptr) override {
  219   createOrcMCJITReplacement(std::string *ErrorMsg,
  270     std::vector<std::string> CtorNames, DtorNames;
  274         std::string NewCtorName = ("__ORCstatic_ctor." + Twine(CtorId++)).str();
  281         std::string NewDtorName = ("__ORCstatic_dtor." + Twine(DtorId++)).str();
  345   uint64_t getGlobalValueAddress(const std::string &Name) override {
  349   uint64_t getFunctionAddress(const std::string &Name) override {
  451   std::string mangle(StringRef Name) {
  452     std::string MangledName;
  484   std::map<VModuleKey, std::vector<std::string>> UnexecutedConstructors;
  485   std::map<VModuleKey, std::vector<std::string>> UnexecutedDestructors;

   40 CouldNotNegotiate::CouldNotNegotiate(std::string Signature)

   74     std::string SymName = Symbol.str();
  115     std::string SymName = Symbol.str();

  229 RTDyldMemoryManager::getSymbolAddressInProcess(const std::string &Name) {
  290 void *RTDyldMemoryManager::getPointerToNamedFunction(const std::string &Name,

   46   std::string message(int Condition) const override {
 1214         std::string ErrMsg;

  101     EvalResult(std::string ErrorMsg)
  105     const std::string &getErrorMsg() const { return ErrorMsg; }
  109     std::string ErrorMsg;
  132     std::string ErrorMsg("Encountered unexpected token '");
  258       std::string ErrMsg;
  271       std::string ErrMsg;
  354     std::string ErrorMsg = "";
  391     std::string ErrorMsg = "";
  423       std::string ErrMsg("No known address for symbol '");
  789 std::pair<uint64_t, std::string> RuntimeDyldCheckerImpl::getSectionAddr(
  794     std::string ErrMsg;
  819 std::pair<uint64_t, std::string> RuntimeDyldCheckerImpl::getStubOrGOTAddrFor(
  827     std::string ErrMsg;
  871 std::pair<uint64_t, std::string>

   52   std::pair<uint64_t, std::string> getSectionAddr(StringRef FileName,
   56   std::pair<uint64_t, std::string>

 1141       std::string Buf;
 1162         std::string Buf;

   48   std::string Name;
  319   std::string ErrorStr;

   29     std::string Buf;

   42       std::string ErrMsg;
   54         std::string ErrMsg;

  140 bool SectionMemoryManager::finalizeMemory(std::string *ErrMsg) {

   42                               const SmallVectorImpl<std::string>& MAttrs) {
   68     std::string Error;
   78   std::string FeaturesStr;

   39   std::vector<std::string> Args{ExecName};
   68   for (std::string &S : Args)
   76   std::vector<std::string> Args{ExecName};
  132   for (std::string &S : Args)
  190   std::string Buf;

 2584       M->getModuleIdentifier().find('\n') == std::string::npos)
 2593   const std::string &DL = M->getDataLayoutStr();
 2678   std::vector<std::pair<std::string, ModuleHash>> moduleVec;
 2679   std::string RegularLTOModuleName = "[Regular LTO]";
 2913 static std::string getLinkageName(GlobalValue::LinkageTypes LT) {
 2944 static std::string getLinkageNameWithSpace(GlobalValue::LinkageTypes LT) {
 3410     std::string AttrStr;

  150   std::string Kind;
  151   std::string Val;
  216   std::string getAsString(bool InAttrGrp) const;

  276 std::string Attribute::getAsString(bool InAttrGrp) const {
  397     std::string Result;
  415     std::string Result;
  423     std::string Result;
  450     std::string Result = "allocsize(";
  466     std::string Result;
  469     std::string AttrVal = pImpl->getValueAsString();
  695 std::string AttributeSet::getAsString(bool InAttrGrp) const {
  881 std::string AttributeSetNode::getAsString(bool InAttrGrp) const {
  882   std::string Str;
 1380 std::string AttributeList::getAsString(unsigned Index, bool InAttrGrp) const {

 1634 void llvm::UpgradeInlineAsmString(std::string *AsmStr) {
 1637       AsmStr->find("objc_retainAutoreleaseReturnValue") != std::string::npos &&
 1638       (Pos = AsmStr->find("# marker")) != std::string::npos) {
 3641     std::string Name = CI->getName();
 3716   std::string Name = CI->getName();
 3847           std::string NewValue = ValueComp[0].str() + ";" + ValueComp[1].str();
 4021           std::string NewValue;
 4138 std::string llvm::UpgradeDataLayoutString(StringRef DL, StringRef TT) {
 4139   std::string AddrSpaces = "-p270:32:32-p271:32:32-p272:64:64";
 4154   std::string Res = (Groups[1] + AddrSpaces + Groups[3]).toStringRef(Buf).str();

  197   std::string MsgStorage;
  409     std::string E = "Error printing to file: " + dest.error().message();
  418   std::string buf;
  531   std::string buf;
  842   std::string buf;

   27   void operator=(const std::string &Val) {
   31       std::string RegexError;
   46 static cl::opt<PassRemarksOpt, true, cl::parser<std::string>> PassRemarks(
   55 static cl::opt<PassRemarksOpt, true, cl::parser<std::string>> PassRemarksMissed(
   64 static cl::opt<PassRemarksOpt, true, cl::parser<std::string>>

  132 std::string DiagnosticLocation::getAbsolutePath() const {
  142 std::string DiagnosticInfoWithLocationBase::getAbsolutePath() const {
  154 const std::string DiagnosticInfoWithLocationBase::getLocationStr() const {
  333   std::string Str;
  362 std::string DiagnosticInfoOptimizationBase::getMsg() const {
  363   std::string Str;

   48     const std::string &Str) {

  478 const std::string &Function::getGC() const {
  483 void Function::setGC(std::string Str) {
  588 static std::string getMangledTypeStr(Type* Ty) {
  589   std::string Result;
  647 std::string Intrinsic::getName(ID id, ArrayRef<Type*> Tys) {
  649   std::string Result(IntrinsicNameTable[id]);

  136 std::string GlobalValue::getGlobalIdentifier(StringRef Name,
  146   std::string NewName = Name;
  160 std::string GlobalValue::getGlobalIdentifier() const {

   23 PrintModulePass::PrintModulePass(raw_ostream &OS, const std::string &Banner,
   50 PrintFunctionPass::PrintFunctionPass(raw_ostream &OS, const std::string &Banner)
   72   PrintModulePassWrapper(raw_ostream &OS, const std::string &Banner,
   95   PrintFunctionPassWrapper(raw_ostream &OS, const std::string &Banner)
  114   std::string Banner;
  119   PrintBasicBlockPass(raw_ostream &Out, const std::string &Banner)
  147                                         const std::string &Banner,
  153                                             const std::string &Banner) {
  158                                                 const std::string &Banner) {

   30 InlineAsm::InlineAsm(FunctionType *FTy, const std::string &asmString,
   31                      const std::string &constraints, bool hasSideEffects,

  280 void LLVMContext::setGC(const Function &Fn, std::string GCName) {
  290 const std::string &LLVMContext::getGC(const Function &Fn) {

 1399   DenseMap<const Function*, std::string> GCNames;

   93 static cl::list<std::string>
  133   static std::unordered_set<std::string> PrintFuncNames(PrintFuncsList.begin(),
  238   std::string PassName = P->getPassName().str();
  400                           const std::string &Banner) const override {
  468                           const std::string &Banner) const override {
  556                           const std::string &Banner) const override {

  195     std::string Flag;

  221   std::string getAsString() const;
  223   std::vector<std::string> Attrs;
  224   std::string Comments;
  237   std::string A = Name.str();
  255 std::string Attributes::getAsString() const {
  259   std::string Ret = "[";
  268 static std::string linkageToString(GlobalValue::LinkageTypes LT) {
  297 static std::string fflagsToString(FunctionSummary::FFlags F) {
  307 static std::string getSummaryAttributes(GlobalValueSummary* GVS) {
  316 static std::string getNodeVisualName(GlobalValue::GUID Id) {
  320 static std::string getNodeVisualName(const ValueInfo &VI) {
  324 static std::string getNodeLabel(const ValueInfo &VI, GlobalValueSummary *GVS) {
  328   std::string Attrs = getSummaryAttributes(GVS);
  329   std::string Label =

   50                                     const std::string &Banner) const {
   58 static std::string getDescription(const Module &M) {
  154                                       const std::string &Banner) const {
  162 static std::string getDescription(const Function &F) {
  184                                         const std::string &Banner) const {
  198 static std::string getDescription(const BasicBlock &BB) {

  123   std::string PassDescNumbered =
  175   std::string FullDesc = formatv("{0} #{1}", PassID, Count).str();

   39   std::string RegexError;

  500                         unsigned ArgNo, std::string &Suffix);
 4270   const std::string ExpectedName = Intrinsic::getName(ID, ArgTys);

  126       std::string buf;

   75       std::string EntryPath;
   79                   sys::fs::TempFile TempFile, std::string EntryPath,

 1173 std::string lto::getThinLTOOutputFile(const std::string &Path,
 1173 std::string lto::getThinLTOOutputFile(const std::string &Path,
 1174                                       const std::string &OldPrefix,
 1175                                       const std::string &NewPrefix) {
 1192   std::string OldPrefix, NewPrefix;
 1201       std::string OldPrefix, std::string NewPrefix, bool ShouldEmitImportsFiles,
 1201       std::string OldPrefix, std::string NewPrefix, bool ShouldEmitImportsFiles,
 1215     std::string NewModulePath =
 1221     std::map<std::string, GVSummaryMapTy> ModuleToSummariesForIndex;
 1249     std::string OldPrefix, std::string NewPrefix, bool ShouldEmitImportsFiles,
 1249     std::string OldPrefix, std::string NewPrefix, bool ShouldEmitImportsFiles,
 1382   std::string Filename = RemarksFilename;

   56 Error Config::addSaveTemps(std::string OutputFileName,
   75       std::string PathPrefix;
   85       std::string Path = PathPrefix + PathSuffix + ".bc";
  105     std::string Path = OutputFileName + "index.bc";
  132   for (const std::string &A : Conf.MAttrs)
  227                                  std::string PipelineDesc,
  228                                  std::string AAPipelineDesc,
  407   std::string Msg;

   89 cl::opt<std::string>
   94 cl::opt<std::string>
  100 cl::opt<std::string> RemarksFormat(
  105 cl::opt<std::string> LTOStatsFile(
  234     std::string ErrMsg = "could not open bitcode file for writing: ";
  245     std::string ErrMsg = "could not write bitcode file: ";
  350   std::string ErrMsg;
  638     for (std::string &Arg : CodegenOptions)
  663   std::string MsgStorage;
  710 void LTOCodeGenerator::emitError(const std::string &ErrMsg) {
  717 void LTOCodeGenerator::emitWarning(const std::string &ErrMsg) {

   88   ErrorOr<std::string> TripleOrErr =
   95 std::string LTOModule::getProducerString(MemoryBuffer *Buffer) {
  101   ErrorOr<std::string> ProducerOrErr = expectedToErrorOrAndEmitErrors(
  201   std::string TripleStr = M->getTargetTriple();
  207   std::string errMsg;
  215   std::string FeatureStr = Features.getString();
  217   std::string CPU;
  247 LTOModule::objcClassNameFromExpression(const Constant *c, std::string &name) {
  269   std::string superclassName;
  283   std::string className;
  303   std::string targetclassName;
  322   std::string targetclassName;
  654                                            std::string &outErr) {

   75 extern cl::opt<std::string> RemarksFilename;
   76 extern cl::opt<std::string> RemarksPasses;
   78 extern cl::opt<std::string> RemarksFormat;
   92   std::string SaveTempPath = (TempDir + llvm::Twine(count) + Suffix).str();
  382               std::string ErrorMsgBuffer;
  544   std::string ErrMsg;
  554   std::string FeatureStr = Features.getString();
  715     std::map<std::string, GVSummaryMapTy> &ModuleToSummariesForIndex,
  772   std::map<std::string, GVSummaryMapTy> ModuleToSummariesForIndex;
  858 std::string

   23 std::string LineEditor::getDefaultHistoryPath(StringRef ProgName) {
   35 std::string LineEditor::ListCompleterConcept::getCommonPrefix(
   39   std::string CommonPrefix = Comps[0].TypedText;
   63   std::string CommonPrefix = getCommonPrefix(Comps);
  105   std::string ContinuationOutput;
  136       std::string Prevs(Data->PrevCount, '\02');
  173         for (std::vector<std::string>::iterator I = Action.Completions.begin(),
  256 Optional<std::string> LineEditor::readLine() const {

 1309         std::string str;
 1371 static std::string adjustInlineAsm(const std::string &InlineAsm,
 1371 static std::string adjustInlineAsm(const std::string &InlineAsm,
 1417     std::string SrcModuleInlineAsm = adjustInlineAsm(SrcM->getModuleInlineAsm(),

  742   ArrayRef<std::string> FileNames = Asm.getFileNames();
  743   for (const std::string &Name : FileNames)
  750   for (const std::string &Name : FileNames)
  811   std::string RelaSectionName = hasRelocationAddend() ? ".rela" : ".rel";

  145   void EmitLinkerOptions(ArrayRef<std::string> Options) override;
  503 void MCAsmStreamer::EmitLinkerOptions(ArrayRef<std::string> Options) {
  506   for (ArrayRef<std::string>::iterator it = Options.begin() + 1,

  576 void MCContext::addDebugPrefixMapEntry(const std::string &From,
  577                                        const std::string &To) {
  586         std::string RemappedPath =
  593   std::string CompDir = CompilationDir.str();

   51   std::string Error;

   44   std::string TripleName;
   78   std::string CPU;
   85   LLVMDisasmContext(std::string TripleName, void *DisInfo, int TagType,
  101   const std::string &getTripleName() const { return TripleName; }

 1014   const SmallVectorImpl<std::string> &MCDwarfDirs = context.getMCDwarfDirs();

   22                                     std::string &Info) const {

   89   void EmitLinkerOptions(ArrayRef<std::string> Options) override;
  247 void MCMachOStreamer::EmitLinkerOptions(ArrayRef<std::string> Options) {

   52 AsmToken AsmLexer::ReturnError(const char *Loc, const std::string &Msg) {
  516   std::string SavedErr = getErr();

  242   bool parseMSInlineAsm(void *AsmLoc, std::string &AsmString,
  245                         SmallVectorImpl<std::string> &Constraints,
  246                         SmallVectorImpl<std::string> &Clobbers,
  322   bool enterIncludeFile(const std::string &Filename);
  326   bool processIncbinFile(const std::string &Filename, int64_t Skip = 0,
  650   bool parseEscapedString(std::string &Data) override;
  786 bool AsmParser::enterIncludeFile(const std::string &Filename) {
  787   std::string IncludedFile;
  801 bool AsmParser::processIncbinFile(const std::string &Filename, int64_t Skip,
  803   std::string IncludedFile;
 1389 static std::string altMacroString(StringRef AltMacroStr) {
 1390   std::string Res;
 2214   std::string OpcodeStr = IDVal.lower();
 2364   const std::string &Filename = Parser->CppHashInfo.Filename;
 2904 bool AsmParser::parseEscapedString(std::string &Data) {
 2984     std::string Data;
 3369   std::string Path;
 3380   std::string FilenameData;
 3397   std::string SourceString;
 3600   std::string Filename;
 3601   std::string Checksum;
 3982   std::string Data;
 4289   std::string Values;
 4976   std::string Filename;
 4997   std::string Filename;
 5768     void *AsmLoc, std::string &AsmString, unsigned &NumOutputs,
 5770     SmallVectorImpl<std::string> &Constraints,
 5771     SmallVectorImpl<std::string> &Clobbers, const MCInstrInfo *MII,
 5777   SmallVector<std::string, 4> InputConstraints;
 5778   SmallVector<std::string, 4> OutputConstraints;
 5890   std::string AsmStringIR;

  609   SmallVector<std::string, 4> Args;
  614     std::string Data;
  675   std::string SectionSpec = SectionName;
  692   std::string ErrorStr =

  182 std::string MCSectionMachO::ParseSectionSpecifier(StringRef Spec,        // In.

  787       std::string SectionName =

  184   for (const std::string &Feature : Features.getFeatures()) {
  281   for (std::string F : T.getFeatures()) {

  422   const std::vector<std::string> &Options, bool is64Bit)
  425   for (const std::string &Option : Options)
  431   const std::vector<std::string> &Options)
  441   for (const std::string &Option : Options) {

   33 void SubtargetFeatures::Split(std::vector<std::string> &V, StringRef S) {
   52 std::string SubtargetFeatures::getString() const {

  115   std::string Name;
  373       std::string WeakName = (".weak." + MCSym.getName() + ".default").str();
  837   for (const std::string &Name : Asm.getFileNames()) {

  237       std::string Message =

   48   std::string StringMsg = "truncated or malformed archive (" + Msg.str() + ")";
   64       std::string Msg("remaining size of archive too small for next archive "
   78       std::string Buf;
   83       std::string Msg("terminator characters in archive member \"" + Buf +
  157       std::string Buf;
  195       std::string Buf;
  230     std::string Buf;
  248     std::string Buf;
  268     std::string Buf;
  289     std::string Buf;
  308     std::string Buf;
  379       std::string Buf;
  416 Expected<std::string> Archive::Child::getFullName() const {
  445   Expected<std::string> FullNameOrErr = getFullName();
  448   const std::string &FullName = *FullNameOrErr;
  470     std::string Msg("offset to next archive member past the end of the archive "

  239   std::string Header;
  248   std::string Header;
  457     std::string Header;
  482       std::string StringMsg =
  520 Expected<std::string> computeArchiveRelativePath(StringRef From, StringRef To) {

   67                              ArrayRef<const std::string> Strings) {
  109 static Expected<std::string> replace(StringRef S, StringRef From,
  129 static const std::string NullImportDescriptorSymbolName =
  144   std::string ImportDescriptorSymbolName;
  145   std::string NullThunkSymbolName;
  602     Expected<std::string> Name = E.ExtName.empty()

  207       std::string Name;
  315   Error parseName(std::string *Out, uint64_t *Baseaddr) {

  431 std::string ELFFile<ELFT>::getDynamicTagAsString(unsigned Arch,
  495 std::string ELFFile<ELFT>::getDynamicTagAsString(uint64_t Type) const {

  311   std::string Triple;
  384   std::string Err;

   27   std::string message(int ev) const override;
   35 std::string _object_error_category::message(int EV) const {

   89   std::string COFFLinkerOpts;
  169     std::string Name;
  293       std::string FallbackName;

   26   std::string StringMsg = "truncated or malformed fat file (" + Msg.str() + ")";

   25 Expected<std::string> MinidumpFile::getString(size_t Offset) const {
   49   std::string Result;

   77   std::string Err;

  222    std::string Buf;
  304     std::string Buf;
  316     std::string Buf;

  688     std::vector<std::pair<std::string, std::string>> *ProducerVec = nullptr;
  688     std::vector<std::pair<std::string, std::string>> *ProducerVec = nullptr;
  721   llvm::SmallSet<std::string, 8> FeaturesSeen;

  170 static bool convertUTF16LEToUTF8String(ArrayRef<UTF16> Src, std::string &Out) {
  181 static std::string makeDuplicateResourceError(
  183   std::string Ret;
  190     std::string UTF8;
  199     std::string UTF8;
  216     std::string UTF8;
  228 static std::string makeDuplicateResourceError(
  231   std::string Ret;
  264     std::vector<std::string> &Duplicates) {
  330                                    std::vector<std::string> &Duplicates) {
  368                                    std::vector<std::string> &Duplicates) {
  395                                          std::vector<std::string> &Duplicates) {
  537   std::string NameString;

   82         std::string str = utostr(Index);
  155   std::string StringTable;

  260   std::string H = fromHex(Scalar);

  271     std::string Str;

  301   std::string Data;

  954   std::string UnknownFlagsHolder;

   72   std::string OutString;
  466     std::string OutString;
  560     std::string OutString;
  612     std::string OutString;

   68 std::string Arg::getAsString(const ArgList &Args) const {

   92 std::vector<std::string> ArgList::getAllArgValues(OptSpecifier Id) const {

  208 std::vector<std::string>
  219     std::vector<std::string> Result;
  228 std::vector<std::string>
  230   std::vector<std::string> Ret;
  239       std::string S = std::string(In.Prefixes[I]) + std::string(In.Name) + "\t";
  249 unsigned OptTable::findNearest(StringRef Option, std::string &NearestString,
  286     std::string NormalizedName = Option;
  299       std::string Candidate = (CandidatePrefix + CandidateName).str();
  435 static std::string getOptionHelpName(const OptTable &Opts, OptSpecifier Id) {
  437   std::string Name = O.getPrefixedName();
  482   std::string Name;
  502     const std::string &Option = OptionHelp[i].Name;
  547   std::map<std::string, std::vector<OptionInfo>> GroupedOptionHelp;
  571       const std::string &OptName = getOptionHelpName(*this, Id);

  551                                     std::string ProfileFile,
  552                                     std::string ProfileRemappingFile) {
  620                                          bool IsCS, std::string ProfileFile,
  621                                          std::string ProfileRemappingFile) {

   16 Expected<PassPlugin> PassPlugin::Load(const std::string &Filename) {
   17   std::string Error;

   34 Optional<std::pair<const Module *, std::string>> unwrapModule(Any IR) {
   64     std::string LoopName;
  130     std::string Extra = formatv(" (scc: {0})", C->getName());
  153   std::string Extra;
  208   std::string Extra;

  793 static std::string getCoverageMapErrString(coveragemap_error Err) {
  818   std::string message(int IE) const override {
  825 std::string CoverageMapError::message() const {

  757       std::string ObjArch = ObjForArch.getArchFlagName();

  645 static std::string mangleCoveragePath(StringRef Filename, bool PreservePaths) {
  678 std::string FileInfo::getCoveragePath(StringRef Filename,
  686   std::string CoveragePath;
  728     std::string CoveragePath = getCoveragePath(Filename, MainFilename);
  932     const std::string &Filename = FC.first;

   76 static std::string getInstrProfErrString(instrprof_error Err) {
  128   std::string message(int IE) const override {
  165 std::string getInstrProfSectionName(InstrProfSectKind IPSK,
  168   std::string SectName;
  209 std::string InstrProfError::message() const {
  215 std::string getPGOFuncName(StringRef RawFuncName,
  253 std::string getPGOFuncName(const Function &F, bool InLTO, uint64_t Version) {
  287 std::string getPGOFuncNameVarName(StringRef FuncName,
  289   std::string VarName = getInstrProfNameVarPrefix();
  298   while (found != std::string::npos) {
  342     const std::string &PGOFuncName = getPGOFuncName(F, InLTO);
  351       if (pos != std::string::npos) {
  352         const std::string &OtherFuncName = PGOFuncName.substr(0, pos);
  378 Error collectPGOFuncNameStrings(ArrayRef<std::string> NameStrs,
  379                                 bool doCompression, std::string &Result) {
  383   std::string UncompressedNameStrings =
  427                                 std::string &Result, bool doCompression) {
  428   std::vector<std::string> NameStrs;
 1120     if (Pos != std::string::npos) {
 1167 Error OverlapStats::accumulateCounts(const std::string &BaseFilename,
 1168                                      const std::string &TestFilename,

  100   std::string RemappingPathStr = RemappingPath.str();

   73       std::string &Data = SOStream.str(); // with flush
  384   std::string Data;

   44   std::string message(int IE) const override {
  222   std::string OutputString;

 1266 SampleProfileReader::create(const std::string Filename, LLVMContext &C,
 1267                             const std::string RemapFilename) {
 1285 SampleProfileReaderItaniumRemapper::create(const std::string Filename,
 1334                             const std::string RemapFilename) {
 1353       std::string Msg = "Could not create remapper: " + EC.message();

   98   std::string &UncompressedStrings =
  135   std::string LocalBuf;

  100   std::string Buf;

   21 std::string Remark::getArgsAsMsg() const {
   22   std::string Str;

  113   Optional<std::string> Err;

   27   std::string &Message = *static_cast<std::string *>(Ctx);
   53 static SourceMgr setupSM(std::string &LastErrorMessage) {

   46   std::string Message;
   55   std::string LastErrorMessage;

  209 std::error_code fromString(std::string String, Metadata &HSAMetadata) {
  215 std::error_code toString(Metadata HSAMetadata, std::string &String) {

 2258 std::string APInt::toString(unsigned Radix = 10, bool Signed = true) const {

  365   std::string Description;
  386   std::string Description;

   33   std::string Path;

   61   std::string Format;

   92     std::string Pid =
  101     std::string CoverageFilename = (CoveragePrefix + Pid).str();

  136   std::string ProgramName;
  564                                    std::string &NearestString) {
 1053   std::string UTF8Buf;
 1202   llvm::Optional<std::string> envValue = sys::Process::GetEnv(StringRef(envVar));
 1231     if (llvm::Optional<std::string> EnvValue =
 1366     std::string NearestHandlerString;
 1977                                           const OptionValue<std::string> &D,
 2390     std::string CPU = sys::getHostCPUName();

   86 bool convertUTF16ToUTF8String(ArrayRef<char> SrcBytes, std::string &Out) {
  135 bool convertUTF16ToUTF8String(ArrayRef<UTF16> Src, std::string &Out)
  213 bool convertWideToUTF8(const std::wstring &Source, std::string &Result) {

   45 static ManagedStatic<std::vector<std::string>> CurrentDebugType;
  101   void operator=(const std::string &Val) const {
  116 static cl::opt<DebugOnlyOpt, true, cl::parser<std::string> >

   13 class DebugCounterList : public cl::list<std::string, DebugCounter> {
   15   using Base = cl::list<std::string, DebugCounter>;
   68 void DebugCounter::push_back(const std::string &Val) {

   35   static void *DLOpen(const char *Filename, std::string *Err);
  149                                                    std::string *Err) {
  164                                                    std::string *Err) {

   31 std::string StrError() {
   36 std::string StrError(int errnum) {
   37   std::string str;

   32     std::string message(int condition) const override {
  141   std::string ErrMsg;
  158   std::string Tmp = toString(unwrap(Err));