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

References

   66   ExitOnErr.setBanner(std::string(argv[0]) + ": ");

   44     ExitOnErr.setBanner(std::string(argv[0]) + ": ");

   39   ExitOnErr.setBanner(std::string(argv[0]) + ": ");

   87   ExitOnErr.setBanner(std::string(argv[0]) + ": ");

  154   ExitOnErr.setBanner(std::string(argv[0]) + ": ");

40936     Res += Candidates[i].str() + ", ";
40937   return Res + Candidates[i].str() + "?";

80491     Res += Candidates[i].str() + ", ";
80492   return Res + Candidates[i].str() + "?";

16421     Res += Candidates[i].str() + ", ";
16422   return Res + Candidates[i].str() + "?";

11760     Res += Candidates[i].str() + ", ";
11761   return Res + Candidates[i].str() + "?";

 7247     Res += Candidates[i].str() + ", ";
 7248   return Res + Candidates[i].str() + "?";

 9283     Res += Candidates[i].str() + ", ";
 9284   return Res + Candidates[i].str() + "?";

   59     return "CFG for '" + F->getName().str() + "' function";

   56     std::string Title = GraphName + " for '" + F.getName().str() + "' function";
   97     std::string Filename = Name + "." + F.getName().str() + ".dot";
  104     std::string Title = GraphName + " for '" + F.getName().str() + "' function";

   58     return "[index " + std::to_string(Sec - &TableOrErr->front()) + "]";
  240       Err = createError("SHT_NOTE section " + getSecIndexForError(this, &Shdr) +
  384                        getSecIndexForError(this, Sec) +
  394     return createError("section " + getSecIndexForError(this, Sec) +
  401     return createError("section " + getSecIndexForError(this, Sec) +
  407     return createError("section " + getSecIndexForError(this, Sec) +
  568     return createError("section " + getSecIndexForError(this, Section) +
  574                        getSecIndexForError(this, Section) + " data at 0x" +
  595                               getSecIndexForError(this, Section) +
  607                        getSecIndexForError(this, Section) + " is empty");
  610                        getSecIndexForError(this, Section) +
  697     return createError("a section " + getSecIndexForError(this, Section) +

  644     Version = utostr(major) + "." + utostr(minor);

  615   std::string getAsString() const override { return "\"" + Value.str() + "\""; }
  649     return "[{" + Value.str() + "}]";
 1295     return Rec->getAsString() + "." + FieldName->getValue().str();

  612   return getBlockName(Loop.getHeader()) + (Loop.isIrreducible() ? "**" : "*");

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

  203                      ForwardRefComdats.begin()->first + "'");
  207                  "use of undefined value '@" + ForwardRefVals.begin()->first +
  652     return Error(NameLoc, "redefinition of comdat '$" + Name + "'");
  943         return Error(NameLoc, "redefinition of global '@" + Name + "'");
 1069         return Error(NameLoc, "redefinition of global '@" + Name + "'");
 2862                    "use of undefined value '%" + ForwardRefVals.begin()->first +
 2971                        getTypeString(FI->second.first->getType()) + "'");
 2988                      getTypeString(FI->second.first->getType()) + "'");
 3000                    NameStr + "'");
 3038       P.Error(Loc, "unable to create block named '" + Name + "'");
 3331                    getTypeString(SrcVal->getType()) + "' to '" +
 3332                    getTypeString(DestTy) + "'");
 3375                                getTypeString(Val1->getType()) +
 3376                                "' instead of '" + getTypeString(IndexedType) +
 5187                    getTypeString(Ty) + "'");
 5451                      "function '" + FunctionName + "' with wrong type: "
 5452                      "expected '" + getTypeString(PFT) + "' but was '" +
 5453                      getTypeString(Fn->getType()) + "'");
 5458                    FunctionName + "'");
 5460       return Error(NameLoc, "redefinition of function '@" + FunctionName + "'");
 5517                    ArgList[i].Name + "'");
 5904                    getTypeString(ResType) + "'");
 5915                  getTypeString(ResType) + "'");
 6107                    getTypeString(ExpectedTy) + "'");
 6437                                        getTypeString(ExpectedTy) + "'");
 6556                  getTypeString(Op->getType()) + "' to '" +
 6557                  getTypeString(DestTy) + "'");
 6837                    getTypeString(ExpectedTy) + "'");
 7281                            getTypeString(Val1->getType()) + "' instead of '" +
 7282                            getTypeString(IndexedType) + "'");

  455     FullMsg += " (Producer: '" + ProducerIdentification + "' Reader: 'LLVM " +
  455     FullMsg += " (Producer: '" + ProducerIdentification + "' Reader: 'LLVM " +

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

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

  701                      "alloca instruction named '" + Name.Value +

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

  511       std::string Msg = std::string("Error while trying to spill ") +
  512           TRI->getName(Reg) + " from class " + TRI->getRegClassName(&RC) +
  512           TRI->getName(Reg) + " from class " + TRI->getRegClassName(&RC) +
  512           TRI->getName(Reg) + " from class " + TRI->getRegClassName(&RC) +

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

   69       return "<<Unknown Machine Node #" + utostr(getOpcode()) + ">>";
   75       return "<<Unknown Target Node #" + utostr(getOpcode()) + ">>";
   77     return "<<Unknown Node #" + utostr(getOpcode()) + ">>";

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

  652     std::string SizeSpec = ".rodata.str" + utostr(EntrySize) + ".";

   70     FlagLabel += (Flag.Name.str() + " (0x" + utohexstr(Flag.Value) + ")");
   70     FlagLabel += (Flag.Name.str() + " (0x" + utohexstr(Flag.Value) + ")");
  248             .str() +

   47       "<in memory object compiled from " + M.getModuleIdentifier() + ">");

  295     report_fatal_error("Program used external function '" + Name +

 2947   return getLinkageName(LT) + " ";

 3847           std::string NewValue = ValueComp[0].str() + ";" + ValueComp[1].str();

   33         report_fatal_error("Invalid regular expression '" + Val +

  155       NewName = NewName.insert(0, FileName.str() + ":");

  312   return std::string("inst: ") + std::to_string(FS->instCount()) +
  330       getNodeVisualName(VI) + "|" + linkageToString(GVS->linkage());
  332     Label += std::string(" (") + Attrs + ")";
  377                                  : std::string("M") + std::to_string(ModId) +

   59   return "module (" + M.getName().str() + ")";
  163   return "function (" + F.getName().str() + ")";
  199   return "basic block (" + BB.getName().str() + ") in function (" +
  200          BB.getParent()->getName().str() + ")";

 1569         CheckFailed("Attribute '" + A.getAsString() +
 1575       CheckFailed("Attribute '" + A.getAsString() +
 1716          "Attribute '" + RetAttrs.getAsString() +

 1384     Filename += ".thin." + llvm::utostr(Count) + ".yaml";

   82           PathPrefix += utostr(Task) + ".";
   85       std::string Path = PathPrefix + PathSuffix + ".bc";
  237                          AAPipelineDesc + "': " + toString(std::move(Err)));
  262                        PipelineDesc + "': " + toString(std::move(Err)));
  325       report_fatal_error("Failed to create directory " + Conf.DwoDir + ": " +
  329     sys::path::append(DwoFile, std::to_string(Task) + ".dwo");

  235     ErrMsg += Path.str() + ": " + EC.message();
  246     ErrMsg += Path.str() + ": " + Out.os().error().message();

  664   outErr = std::string(path) +

  905       report_fatal_error("Unexistent dir: '" + SavedObjectsDirectoryPath + "'");

 1393                 SrcM->getModuleIdentifier() + "' is '" +
 1394                 SrcM->getDataLayoutStr() + "' whereas '" +
 1395                 DstM.getModuleIdentifier() + "' is '" +
 1396                 DstM.getDataLayoutStr() + "'\n");
 1408                 SrcM->getModuleIdentifier() + "' is '" +
 1409                 SrcM->getTargetTriple() + "' whereas '" +
 1410                 DstM.getModuleIdentifier() + "' is '" + DstM.getTargetTriple() +
 1410                 DstM.getModuleIdentifier() + "' is '" + DstM.getTargetTriple() +

 4987             "Could not find include file '" + Filename + "'"))
 5030     return Error(IncbinLoc, "Could not find incbin file '" + Filename + "'");

   83       return error(std::string("Expected ") + KindName + ", instead got: ",
   83       return error(std::string("Expected ") + KindName + ", instead got: ",

   48   std::string StringMsg = "truncated or malformed archive (" + Msg.str() + ")";
   83       std::string Msg("terminator characters in archive member \"" + Buf +
  164                             "not all decimal numbers: '" + Buf + "' for "
  202                             "not all decimal numbers: '" + Buf + "' for "
  238                           "all decimal numbers: '" + Buf + "' for archive "
  256                           "are not all decimal numbers: '" + Buf + "' for the "
  276                           "are not all decimal numbers: '" + Buf + "' for the "
  296                           "are not all decimal numbers: '" + Buf + "' for the "
  315                           "are not all decimal numbers: '" + Buf + "' for the "
  385                             "not all decimal numbers: '" + Buf + "' for "

  483           "File " + M.MemberName.str() + " exceeds size limit";

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

  739               Feature.Name + "\"",

  778   ExitOnError Err("Invalid " + std::string(SectionName) + " section!");
  809   ExitOnError Err("Error writing type record to " + std::string(SectionName) +

  200       if (Option == std::string(In.Prefixes[I]) + In.Name)
  239       std::string S = std::string(In.Prefixes[I]) + std::string(In.Name) + "\t";
  242       if (StringRef(S).startswith(Cur) && S.compare(std::string(Cur) + "\t"))

  689         mangleCoveragePath(MainFilename, Options.PreservePaths) + "##";

  962       return Prefix.str() + "-COUNT";
  965     return Prefix.str() + "-NEXT";
  967     return Prefix.str() + "-SAME";
  969     return Prefix.str() + "-NOT";
  971     return Prefix.str() + "-DAG";
  973     return Prefix.str() + "-LABEL";
  975     return Prefix.str() + "-EMPTY";

   36       Error = "error: invalid target '" + ArchName + "'.\n";
   54             + "', see --version and --triple.\n";
   74     Error = "No available targets are compatible with triple \"" + TT + "\"";
   80     Error = std::string("Cannot choose between targets \"") + I->Name +
   80     Error = std::string("Cannot choose between targets \"") + I->Name +
   81             "\" and \"" + J->Name + "\"";
   81             "\" and \"" + J->Name + "\"";

  109     MakeErrMsg(ErrMsg, "Cannot open file '" + File + "' for "
  110               + (FD == 0 ? "input" : "output"));

  584     return std::string(Indent, ' ') + "HardLink to -> " +

   72     return reportError(argv0, "error opening " + DependFilename + ":" +
   73                                   EC.message() + "\n");
   90     return reportError(argv0, "Could not open input file '" + InputFilename +
   91                                   "': " + EC.message() + "\n");
  132     return reportError(argv0, "error opening " + OutputFilename + ":" +
  133                                   EC.message() + "\n");

   95   return "bits<" + utostr(Size) + ">";
  131   return "list<" + Ty->getAsString() + ">";
  807   case CAST: Result = "!cast<" + getType()->getAsString() + ">"; break;
  813   return Result + "(" + LHS->getAsString() + ")";
 1041   return Result + "(" + LHS->getAsString() + ", " + RHS->getAsString() + ")";
 1041   return Result + "(" + LHS->getAsString() + ", " + RHS->getAsString() + ")";
 1257           (UnquotedLHS ? LHS->getAsUnquotedString() : LHS->getAsString()) +
 1258           ", " + MHS->getAsString() + ", " + RHS->getAsString() + ")");
 1258           ", " + MHS->getAsString() + ", " + RHS->getAsString() + ")");
 1513   return TI->getAsString() + "{" + utostr(Bit) + "}";
 1513   return TI->getAsString() + "{" + utostr(Bit) + "}";
 1537   return TI->getAsString() + "[" + utostr(Element) + "]";
 1537   return TI->getAsString() + "[" + utostr(Element) + "]";
 1865     Result += getCond(i)->getAsString() + ": ";

  227         PrintFatalError(Loc, "No def named '" + Name + "': " +

  378     PrintError(getLoc(), "Could not find include file '" + Filename + "'");
  385                "File '" + IncludedFile + "' has already been included.");

  168     return Error(Loc, "Value '" + ValName->getAsUnquotedString() +
  185       return Error(Loc, "Value '" + ValName->getAsUnquotedString() +
  218     return Error(Loc, "Value '" + ValName->getAsUnquotedString() +
  219                           "' of type '" + RV->getType()->getAsString() +
  221                           V->getAsString() + InitType + "'");
  540     std::string Msg("Couldn't find class '" + Lex.getCurStrVal() + "'");
  543                Lex.getCurStrVal() + "'");
  565     TokError("Couldn't find multiclass '" + Lex.getCurStrVal() + "'");
 2167         TokError("Cannot access field '" + Lex.getCurStrVal() + "' of value '" +
 2168                  Result->getAsString() + "'");
 2388     TokError("'" + Str + "' is a reserved variable name");
 2487     Error(ValueLoc, "expected a list, got '" + I->getAsString() + Type + "'");
 2832       return TokError("Class '" + CurRec->getNameInitAsString() +
 2969     return TokError("multiclass '" + Name + "' already defined");

  251     std::string SymName = "__hwasan_check_x" + utostr(Reg - AArch64::X0) + "_" +

 2384       TokError("prefetch operand out of range, [0," + utostr(MaxVal) +
 2901       std::string Str("IC " + std::string(IC->Name) + " requires ");
 2911       std::string Str("DC " + std::string(DC->Name) + " requires ");
 2921       std::string Str("AT " + std::string(AT->Name) + " requires ");
 2931       std::string Str("TLBI " + std::string(TLBI->Name) + " requires ");
 2942           Mnemonic.upper() + std::string(PRCTX->Name) + " requires ");

  155   return "S" + utostr(Op0) + "_" + utostr(Op1) + "_C" + utostr(CRn) + "_C" +
  155   return "S" + utostr(Op0) + "_" + utostr(Op1) + "_C" + utostr(CRn) + "_C" +
  155   return "S" + utostr(Op0) + "_" + utostr(Op1) + "_C" + utostr(CRn) + "_C" +
  156          utostr(CRm) + "_" + utostr(Op2);

  268     DisasmLines.push_back(MF->getName().str() + ":");
  559         Comment += " ; " + HexLines[i] + "\n";

  334       std::string fmtstr = itostr(++UniqID) + ":" + Sizes.str().c_str();
  334       std::string fmtstr = itostr(++UniqID) + ":" + Sizes.str().c_str();

  152                                      to_hexString(FixupOffset) +
  267                                      to_hexString(FixupOffset) +

  464       std::string GSModName = ModifierName.str() + "_" + GENERATE_STUBS;

   45     Diagnostic += " (expected an integer in the range " + std::to_string(Min) +
   46       " to " + std::to_string(Max) + ")";
   64       std::to_string(Max) + ")";

  832   AccessKey = TypeName + ":" + std::to_string(InfoKind) + ":" +
  833               std::to_string(PatchImm) + "$" + AccessKey;

  169           report_fatal_error("line " + std::to_string(DL.getLine()) +

   35   OS.AddComment(std::string(BTFKindStr[Kind]) + "(id = " + std::to_string(Id) +
   35   OS.AddComment(std::string(BTFKindStr[Kind]) + "(id = " + std::to_string(Id) +
  667     FileName = File->getDirectory().str() + "/" + File->getFilename().str();
  821       OS.AddComment("Line " + std::to_string(LineInfo.LineNum) + " Col " +

 1906     Warning(IDLoc, "ssnop is deprecated for " + ISA + " and is equivalent to a "

  288     AsmText += "jal " + Name + "\n";
  290     AsmText += "lui  $$25, %hi(" + Name + ")\n";
  291     AsmText += "addiu  $$25, $$25, %lo(" + Name + ")\n";
  471     AsmText += ".reloc 0, R_MIPS_NONE, " + Name + "\n";
  472     AsmText += "la $$25, " + LocalName + "\n";
  474     AsmText += "la $$25, " + Name + "\n";
  477   AsmText += LocalName + " = " + Name + "\n";

  799   std::string SectionName = std::string(".mdebug.") + getCurrentABIString();

  125       NoMips16Subtarget(TT, CPU, FS.empty() ? "-mips16" : FS.str() + ",-mips16",
  128       Mips16Subtarget(TT, CPU, FS.empty() ? "+mips16" : FS.str() + ",+mips16",

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

  281       return error(std::string("Expected ") + KindName + ", instead got: ",
  281       return error(std::string("Expected ") + KindName + ", instead got: ",

  175           printAnnotation(OS, utostr(Depth) + ": " +
  175           printAnnotation(OS, utostr(Depth) + ": " +
  176                                   (Pair.second ? "up" : "down") + " to label" +
  190     return std::string(AI.isNegative() ? "-" : "") + "nan:0x" +

  895     auto message = std::string("unexpected runtime library name: ") + Name;

 1330               "memory operand is only for determining the size, " + RegName +

  315         std::string(" (from '/machine:") + Arg->getValue() + "' flag)";
  315         std::string(" (from '/machine:") + Arg->getValue() + "' flag)";

 1020          (isValidState() ? std::to_string(getNumReturnValues()) : "?") +
 1021          ")[#UC: " + std::to_string(UnresolvedCalls.size()) + "]";
 2131     return "Live[#BB " + std::to_string(AssumedLiveBlocks.size()) + "/" +
 2132            std::to_string(getAssociatedFunction()->size()) + "][#NRI " +
 2133            std::to_string(NoReturnCalls.size()) + "]";
 2511     return std::string("dereferenceable") +
 2512            (isAssumedNonNull() ? "" : "_or_null") +
 2513            (isAssumedGlobal() ? "_globally" : "") + "<" +
 2514            std::to_string(getKnownDereferenceableBytes()) + "-" +
 2515            std::to_string(getAssumedDereferenceableBytes()) + ">";
 2741     return getAssumedAlign() ? ("align<" + std::to_string(getKnownAlign()) +
 2742                                 "-" + std::to_string(getAssumedAlign()) + ">")

 1218                           "Error loading file '" + SummaryFile + "': ");

  691           setInlineRemark(CS, std::string(IR) + "; " + inlineCostStr(*OIC));
 1080         setInlineRemark(CS, std::string(IR) + "; " + inlineCostStr(*OIC));

 1672     ExitOnError ExitOnErr("-lowertypetests-read-summary: " + ClReadSummary +
 1689     ExitOnError ExitOnErr("-lowertypetests-write-summary: " + ClWriteSummary +

  747     ExitOnError ExitOnErr("-wholeprogramdevirt-read-summary: " + ClReadSummary +
  766         "-wholeprogramdevirt-write-summary: " + ClWriteSummary + ": ");

 2487           kAsanReportErrorTemplate + ExpStr + TypeStr + "_n" + EndingStr,
 2491           ClMemoryAccessCallbackPrefix + ExpStr + TypeStr + "N" + EndingStr,

  636   std::string SearchStr = ".symver " + GVName + ",";
  640                 ".symver " + Prefix + GVName + "," + Prefix);

  441         ClMemoryAccessCallbackPrefix + TypeStr + "N" + EndingStr,
  680           "int3\nnopl " + itostr(0x40 + AccessInfo) + "(%rax)",

  111         std::string singleLine = "MD5 " + stream.str() + " " +

  240     SmallString<32> AtomicLoadName("__tsan_atomic" + BitSizeStr + "_load");
  244     SmallString<32> AtomicStoreName("__tsan_atomic" + BitSizeStr + "_store");
  268       SmallString<32> RMWName("__tsan_atomic" + itostr(BitSize) + NamePart);
  273     SmallString<32> AtomicCASName("__tsan_atomic" + BitSizeStr +

 2119     std::string NewName = std::string(Suffix) + ".split-lp";

  607     std::string NewName = std::string(Suffix) + ".split-lp";

  256     report_fatal_error("unable to read rewrite map '" + MapFile + "': " +
  260     report_fatal_error("unable to parse rewrite map '" + MapFile + "'");

   95   std::string Filename = OutputPrefix + "-" + ID + ".bc";

  225     Message = "Found lli: " + *LLIPath + "\n";
  228     Message = LLIPath.getError().message() + "\n";
  390     Message = std::string("Cannot find '") + Command +
  391               "' in PATH: " + Path.getError().message() + "\n";
  396   Message = "Found command in: " + CmdPath + "\n";
  440       sys::fs::createUniqueFile(Bitcode + "-%%%%%%%" + Suffix, UniqueFile);
  515     Message = LLCPath.getError().message() + "\n";
  524   Message = "Found llc: " + *LLCPath + "\n";
  596     Message = "Found lli: " + *LLIPath + "\n";
  599     Message = LLIPath.getError().message() + "\n";
  770       InputFile + "-%%%%%%%" + LTDL_SHLIB_EXT, UniqueFilename);
  847     Message = "Cannot find `" + CCBinary + "' in PATH: " +
  848               CCPath.getError().message() + "\n";
  856       Message = "Cannot find `" + RemoteClient + "' in PATH: " +
  857                 Path.getError().message() + "\n";
  863   Message = "Found CC: " + *CCPath + "\n";

  337         IgnoredFilesPattern.str() + "$)");

  184     return "'" + getAsString(LO) + "'";

   95         return "argument '" + D->getQualifiedNameAsString() + "'";
  100     return "symbol of type '" + S->getType().getAsString() +
  101            "' conjured at statement '" + printStmt(S->getStmt()) + "'";
  105     return "value derived from (" + Visit(S->getParentSymbol()) +
  114     return "metadata of type '" + S->getType().getAsString() + "' tied to " +
  131     return "(" + Visit(S->getLHS()) + ") " +
  132            std::string(BinaryOperator::getOpcodeStr(S->getOpcode())) +
  133            " (" + Visit(S->getRHS()) + ")";
  156     return "region allocated by '" + printStmt(R->getExpr()) + "'";
  185       return "parameter '" + Name + "'";
  187       return "block variable '" + Name + "'";
  189       return "local variable '" + Name + "'";
  191       return "static local variable '" + Name + "'";
  193       return "global variable '" + Name + "'";
  199     return "instance variable '" + R->getDecl()->getNameAsString() + "' of " +
  204     return "field '" + R->getDecl()->getNameAsString() + "' of " +
  210            printStmt(R->getExpr()) + "'";
  214     return "base object '" + R->getDecl()->getQualifiedNameAsString() +
  223            std::string(OS.str()) + ")";
  231            std::string(OS.str()) + ")";
  239            std::string(OS.str()) + ")";

   90             err += E->getSelector().getAsString() + "' message on "
   99             err += E->getSelector().getAsString() + "' message on "

  493     Pass.TA.insert(tok.getLocation(), std::string("(") + attr.str() + ") ");
  505   Pass.TA.insert(tok.getLocation(), std::string(attr) + ", ");

  295         S = "'" + S + "' (aka '" + akaStr + "')";
  295         S = "'" + S + "' (aka '" + akaStr + "')";
  315   S = "'" + S + "'";

 8214         << (std::string("'") + Info.Ctx.BuiltinInfo.getName(BuiltinOp) + "'");
 8214         << (std::string("'") + Info.Ctx.BuiltinInfo.getName(BuiltinOp) + "'");
 8318         << (std::string("'") + Info.Ctx.BuiltinInfo.getName(BuiltinOp) + "'");
 8318         << (std::string("'") + Info.Ctx.BuiltinInfo.getName(BuiltinOp) + "'");
10699         << (std::string("'") + Info.Ctx.BuiltinInfo.getName(BuiltinOp) + "'");
10699         << (std::string("'") + Info.Ctx.BuiltinInfo.getName(BuiltinOp) + "'");
10760         << (std::string("'") + Info.Ctx.BuiltinInfo.getName(BuiltinOp) + "'");
10760         << (std::string("'") + Info.Ctx.BuiltinInfo.getName(BuiltinOp) + "'");

  558     return std::string("'") + Alias + "' (aka '" + S + "')";
  558     return std::string("'") + Alias + "' (aka '" + S + "')";
  559   return std::string("'") + S + "'";

  526           (Entry.getValue().getTypeAsString() + " " + Entry.getKey()).str();

  485     return II->getName().str() + ":";

  189   Builder.defineMacro("_MIPS_ARCH", "\"" + CPU + "\"");

  909   Builder.defineMacro("__code_model_" + CodeModel + "_");
 1799       std::string Converted = "{" + std::string(Constraint, Len) + "}";

 1514                             CGOpts.ThinLTOIndexFile + "': ");

  165   Name += "e" + llvm::to_string(TypeAtEncoding.size()) + "_" + TypeAtEncoding;

 1404       CGF.Builder.CreateGlobalStringPtr(RType.getAsString() + " {\n");

 1109       Name = getMangledName(&D).str() + ".const";
 1111       Name = ("__const." + FunctionName(DC) + "." + D.getName()).str();

  197     appendStr("_AB" + llvm::to_string(FieldOffset.getQuantity()) + "s" +
  198               llvm::to_string(EltSize.getQuantity()) + "n" +
  249     this->appendStr("_t" + llvm::to_string(this->Start.getQuantity()) + "w" +
  261     this->appendStr("_tv" + llvm::to_string(OffsetInBits) + "w" +
  444         CGM.Error(Loc, "special function " + FuncName +

 3445       std::string OffsetName = "__objc_ivar_offset_value_" + ClassName +"." +
 4083       Interface->getNameAsString() +"." + Ivar->getNameAsString();

 1955                         : "_" + StringClass + "ClassReference";

 1814   return (EarlyClobber ? "&{" : "{") + Register.str() + "}";

 1308             pointeeTy.getUnqualifiedType().getAsString(Policy) + "*";
 1319                 Policy) +

 2402     Opt = "/FAILIFMISMATCH:\"" + Name.str() + "=" + Value.str() + "\"";
 2402     Opt = "/FAILIFMISMATCH:\"" + Name.str() + "=" + Value.str() + "\"";
 2458     Opt = "/FAILIFMISMATCH:\"" + Name.str() + "=" + Value.str() + "\"";
 2458     Opt = "/FAILIFMISMATCH:\"" + Name.str() + "=" + Value.str() + "\"";
 5094     Opt = "/FAILIFMISMATCH:\"" + Name.str() + "=" + Value.str() + "\"";
 5094     Opt = "/FAILIFMISMATCH:\"" + Name.str() + "=" + Value.str() + "\"";
 5761     Opt = "/FAILIFMISMATCH:\"" + Name.str() + "=" + Value.str() + "\"";
 5761     Opt = "/FAILIFMISMATCH:\"" + Name.str() + "=" + Value.str() + "\"";
 7987       std::string AttrVal = llvm::utostr(Min) + "," + llvm::utostr(Max);
 9896   std::string Name = Invoke->getName().str() + "_kernel";
 9954   std::string Name = Invoke->getName().str() + "_kernel";

  334         std::string("inotify_init1() error: ") + strerror(errno),
  347         std::string("inotify_add_watch() error: ") + strerror(errno),
  354         std::string("SemaphorePipe::create() error: ") + strerror(errno),

   96       return std::string("\"") + getFilename() + '"';

  404           << std::string("-mfpu=") + AndroidFPU;

 2573     std::string CLStdStr = std::string("-cl-std=") + A->getValue();
 2772           std::string("-fprebuilt-module-path=") + A->getValue()));
 3041         std::string("-fdiagnostics-hotness-threshold=") + A->getValue();

  109         CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + "."));
  128       CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + "."));
 1393   Flags.push_back(std::string(Enabled ? "+" : "-") + Flag);

   90           D.SysRoot + "/Program Files/NVIDIA GPU Computing Toolkit/CUDA/v" +
  116       Candidates.emplace_back(D.SysRoot + "/usr/local/cuda-" + Ver);
  702       "libomptarget-nvptx-" + GpuArch.str() + ".bc";

  490             std::string("-lto-pass-remarks-hotness-threshold=") + A->getValue();
  499           std::string("-lto-pass-remarks-filter=") + A->getValue();
  507           std::string("-lto-pass-remarks-format=") + A->getValue();
  643     CmdArgs.push_back(Args.MakeArgString(std::string("-F") + A->getValue()));

 1098           {"/../sysroot" + M.osSuffix() + "/usr/include"});
 1263                                                M.includeSuffix() +
 1356                                                M.includeSuffix() +
 1885     std::string PrefixDir = SysRoot.str() + "/usr/gcc";
 1917   Prefixes.push_back(SysRoot.str() + "/usr");
 2366       {CandidateTriple.str() + "/gcc/" + CandidateTriple.str(), "../../..",
 2476       std::string basePath = "/usr/lib/gcc/" + ActiveVersion.first.str() + "/"

   57         C.getArgs().MakeArgString(Base.str() + Postfix + "." + Extension);
   57         C.getArgs().MakeArgString(Base.str() + Postfix + "." + Extension);
   57         C.getArgs().MakeArgString(Base.str() + Postfix + "." + Extension);
   60         C.getDriver().GetTemporaryPath(Base.str() + Postfix, Extension);
  209     BundlerInputArg = BundlerInputArg + "," + II.getFilename();
  332     std::string ISAVerBC = "oclc_isa_version_" + GFXVersion + ".amdgcn.bc";

  284       HTC.getHexagonTargetDir(D.InstalledDir, D.PrefixDirs) + "/";

  120     std::string MT = std::string(IsMipsR6 ? "mipsisa64r6" : "mips64") +
  121                      "-linux-" + (IsMipsN32Abi ? "gnuabin32" : "gnuabi64");
  131     std::string MT = std::string(IsMipsR6 ? "mipsisa64r6el" : "mips64el") +
  132                      "-linux-" + (IsMipsN32Abi ? "gnuabin32" : "gnuabi64");
  353     addPathIfExists(D, LibPath + "/../" + GCCTriple.str() + "/lib/../" +
  394                     SysRoot + "/usr/lib/" + MultiarchTriple + "/" +
  410     addPathIfExists(D, SysRoot + "/" + OSLibDir + "/" + ABIName, Paths);
  411     addPathIfExists(D, SysRoot + "/usr/" + OSLibDir + "/" + ABIName, Paths);
  418                     SysRoot + "/usr/lib/" + GCCInstallation.getTriple().str() +
  435     addPathIfExists(D, LibPath + "/../" + GCCTriple.str() + "/lib" +
  542     return "/lib/ld-musl-" + ArchName + ".so.1";
  646     return "/usr/" + Triple.str() + "/lib/" + Loader;
  647   return "/" + LibDir + "/" + Loader;
  928   if (addLibStdCXXIncludePaths(LibDir.str() + "/../include",
  939       InstallDir.str() + "/include/g++-v" + Version.Text,
  940       InstallDir.str() + "/include/g++-v" + Version.MajorStr + "." +
  940       InstallDir.str() + "/include/g++-v" + Version.MajorStr + "." +
  942       InstallDir.str() + "/include/g++-v" + Version.MajorStr,
  944       LibDir.str() + "/../" + TripleStr.str() + "/include/c++/" + Version.Text,
  944       LibDir.str() + "/../" + TripleStr.str() + "/include/c++/" + Version.Text,
  947       LibDir.str() + "/../include/c++",
  950       LibDir.str() + "/../include/g++",

  173         "-D__MSP430i" + MCU.drop_front(7).upper() + "__"));
  175     CC1Args.push_back(DriverArgs.MakeArgString("-D__" + MCU.upper() + "__"));

  318         Args.MakeArgString(std::string("-out:") + Output.getFilename()));
  384           Args.MakeArgString(std::string("-wholearchive:") +
  441                                          TC.getDriver().Dir + "/../lib"));
  721       Args.MakeArgString(std::string("/Fo") + Output.getFilename());

  396   getFilePaths().push_back(Base + Arch + "/sys-root/mingw/lib");
  534                      Base + Arch + "/sys-root/mingw/include");

   38   getFilePaths().push_back(computeSysRoot() + "/usr/lib" + LibSuffix);
  100       Path = getDriver().getInstalledDir() + Path + "/c++/v1";

  107         Args.MakeArgString(std::string("-i:") + A->getValue(0)));
  111       Args.MakeArgString(std::string("-o:") + Output.getFilename()));
  259       LibDir.str() + "/../" + TripleStr.str() + "/include/c++/" + Version.Text,
  259       LibDir.str() + "/../" + TripleStr.str() + "/include/c++/" + Version.Text,

   31   getFilePaths().push_back(computeSysRoot() + "/lib");
   69   addLibStdCXXIncludePaths(computeSysRoot() + "/include/c++/" + Version.Text,
   82   std::string SysRootDir = LibDir.str() + "/../" + TripleStr.str();

  284   addLibStdCXXIncludePaths(LibDir.str() + "/../include", "/c++/" + Version.Text,

  258                        getDriver().SysRoot + "/include/" + MultiarchTriple +

   50             << (std::string(XRayInstrumentOption) + " on " + Triple.str());
   58             << (std::string(XRayInstrumentOption) + " on " + Triple.str());
   67             << (std::string(XRayInstrumentOption) + " on " + Triple.str());
   71           << (std::string(XRayInstrumentOption) + " on " + Triple.str());

 1878     NewCode += Code.substr(LastPos, Pos - LastPos) + "\n";

 1748             "Invalid interface stub format: " + ArgStr.str() +
 1756             "Invalid interface stub format: " + ArgStr.str() + ".";
 2133       Opts.AddPath(Prefix.str() + A->getValue(), frontend::After, false, true);
 2135       Opts.AddPath(Prefix.str() + A->getValue(), frontend::Angled, false, true);

  457         Entry.DefinitionLocation = std::string(DefLoc.getFilename()) + ":" +
  458                                    std::to_string(DefLoc.getLine()) + ":" +
  464       Entry.PointOfInstantiation = std::string(PoiLoc.getFilename()) + ":" +
  465                                    std::to_string(PoiLoc.getLine()) + ":" +

  578                       + getClangFullRepositoryVersion() + "\"");

 1035     Setr += getIvarAccessString(OID) + " = ";
 2288     TypeAsString += " " + Name + " = ";
 2578   Preamble += utostr(Exp->getString()->getByteLength()) + "};\n";
 4027   ResultStr += "__Block_byref_" + Name +
 4047   S += "static " + RT.getAsString(Context->getPrintingPolicy()) + " __" +
 4048          funcName.str() + "_block_func_" + utostr(i);
 4055     S += "(" + StructRef + " *__cself)";
 4057     S += "(" + StructRef + " *__cself)";
 4092     S += Name + " = __cself->" + (*I)->getNameAsString() + "; // bound by ref\n";
 4113       S += "__cself->" + (*I)->getNameAsString() + "; // bound by copy\n";
 4122                               (*I)->getNameAsString() + "; // bound by copy\n";
 4150       S += ", " + utostr(BLOCK_FIELD_IS_BYREF) + "/*BLOCK_FIELD_IS_BYREF*/);";
 4152       S += ", " + utostr(BLOCK_FIELD_IS_BLOCK) + "/*BLOCK_FIELD_IS_BLOCK*/);";
 4154       S += ", " + utostr(BLOCK_FIELD_IS_OBJECT) + "/*BLOCK_FIELD_IS_OBJECT*/);";
 4167       S += ", " + utostr(BLOCK_FIELD_IS_BYREF) + "/*BLOCK_FIELD_IS_BYREF*/);";
 4169       S += ", " + utostr(BLOCK_FIELD_IS_BLOCK) + "/*BLOCK_FIELD_IS_BLOCK*/);";
 4171       S += ", " + utostr(BLOCK_FIELD_IS_OBJECT) + "/*BLOCK_FIELD_IS_OBJECT*/);";
 4250           Constructor += Name + "((struct __block_impl *)_" + Name + ")";
 4252           Constructor += Name + "(_" + Name + ")";
 4264       Constructor += Name + "(_" + Name + "->__forwarding)";
 4313     S += ", __" + FunName.str() + "_block_copy_" + utostr(i);
 4314     S += ", __" + FunName.str() + "_block_dispose_" + utostr(i);
 4362     std::string ImplTag = "__" + FunName.str() + "_block_impl_" + utostr(i);
 4363     std::string DescTag = "__" + FunName.str() + "_block_desc_" + utostr(i);
 5046   ByrefType += " " + Name + ";\n";
 5096   ByrefType += " " + Name + " = {(void*)";
 5098   ByrefType += "," +  ForwardingCastType + "&" + Name + ", ";
 5098   ByrefType += "," +  ForwardingCastType + "&" + Name + ", ";
 5253   std::string Func = "__" + FuncName + "_block_func_" + BlockNumber;
 5286   std::string DescData = "__" + FuncName + "_block_desc_" + BlockNumber + "_DATA";
 5286   std::string DescData = "__" + FuncName + "_block_desc_" + BlockNumber + "_DATA";
 7412   Result += "{\n\t0, " + utostr(NumMethods) + "\n";

  881     Setr += getIvarAccessString(OID) + " = ";
 2200     TypeAsString += " " + Name + " = ";
 2503   Preamble += utostr(Exp->getString()->getByteLength()) + "};\n";
 3241   ResultStr += "__Block_byref_" + Name +
 3257   std::string S = "static " + RT.getAsString(Context->getPrintingPolicy()) + " __" +
 3258                   funcName.str() + "_" + "block_func_" + utostr(i);
 3258                   funcName.str() + "_" + "block_func_" + utostr(i);
 3265     S += "(" + StructRef + " *__cself)";
 3267     S += "(" + StructRef + " *__cself)";
 3302     S += Name + " = __cself->" + (*I)->getNameAsString() + "; // bound by ref\n";
 3323       S += "__cself->" + (*I)->getNameAsString() + "; // bound by copy\n";
 3332                               (*I)->getNameAsString() + "; // bound by copy\n";
 3360       S += ", " + utostr(BLOCK_FIELD_IS_BYREF) + "/*BLOCK_FIELD_IS_BYREF*/);";
 3362       S += ", " + utostr(BLOCK_FIELD_IS_BLOCK) + "/*BLOCK_FIELD_IS_BLOCK*/);";
 3364       S += ", " + utostr(BLOCK_FIELD_IS_OBJECT) + "/*BLOCK_FIELD_IS_OBJECT*/);";
 3377       S += ", " + utostr(BLOCK_FIELD_IS_BYREF) + "/*BLOCK_FIELD_IS_BYREF*/);";
 3379       S += ", " + utostr(BLOCK_FIELD_IS_BLOCK) + "/*BLOCK_FIELD_IS_BLOCK*/);";
 3381       S += ", " + utostr(BLOCK_FIELD_IS_OBJECT) + "/*BLOCK_FIELD_IS_OBJECT*/);";
 3460           Constructor += Name + "((struct __block_impl *)_" + Name + ")";
 3462           Constructor += Name + "(_" + Name + ")";
 3474       Constructor += Name + "(_" + Name + "->__forwarding)";
 3523     S += ", __" + FunName.str() + "_block_copy_" + utostr(i);
 3524     S += ", __" + FunName.str() + "_block_dispose_" + utostr(i);
 3571     std::string ImplTag = "__" + FunName.str() + "_block_impl_" + utostr(i);
 3572     std::string DescTag = "__" + FunName.str() + "_block_desc_" + utostr(i);
 4203   ByrefType += " " + Name + ";\n";
 4245     ByrefType += " " + Name + " = {(void*)";
 4247     ByrefType += "," +  ForwardingCastType + "&" + Name + ", ";
 4247     ByrefType += "," +  ForwardingCastType + "&" + Name + ", ";
 4279     ByrefType += "," +  ForwardingCastType + "&" + Name + ", ";
 4279     ByrefType += "," +  ForwardingCastType + "&" + Name + ", ";
 4398   std::string Tag = "__" + FuncName + "_block_impl_" + BlockNumber;
 4399   std::string Func = "__" + FuncName + "_block_func_" + BlockNumber;
 4424   std::string DescData = "__" + FuncName + "_block_desc_" + BlockNumber + "_DATA";
 4424   std::string DescData = "__" + FuncName + "_block_desc_" + BlockNumber + "_DATA";
 5111     "{\n\t" + utostr(NumMethods) + "\n";
 5543   Result += "\tvoid *defs[" + utostr(ClsDefCount + CatDefCount)+ "];\n";
 5549   + ", " + utostr(CatDefCount) + "\n";
 5549   + ", " + utostr(CatDefCount) + "\n";
 5585   Result += "\t" + utostr(OBJC_ABI_VERSION) +
 5765   Result += "{\n\t0, " + utostr(NumMethods) + "\n";

 1769                                           "\"" + Filename.str() + "\"");
 1809                          FilenameRange, "<" + TypoCorrectionName.str() + ">")
 1811                          FilenameRange, "\"" + TypoCorrectionName.str() + "\"");

  641             << LHS.Val.toString(10, true) + " to " +
  646             << RHS.Val.toString(10, true) + " to " +

 1392   std::string ArchName = II->getName().lower() + "--";

  533       Message += getSpelling(DependencyTok) + " ";

 1275         std::string SubRuleUnlessName = "unless(" + SubRuleName.str() + ")";

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

 1480           PathDisplayStr += PE.Base->getType().getAsString() + " -> ";

 2765       Result += Type.getAsString(Policy) + ")";
 2804         Result = "(" + Quals + " " + Result + ")";
 2804         Result = "(" + Quals + " " + Result + ")";
 3488         Arg += ParamType.getAsString(Policy) + ")";

 5556         << AL << "'" + std::string(Str) + "'";

10815                                           NameInfo.getName().getAsString() +
10833               UsingLoc, "auto &" + NameInfo.getName().getAsString() + " = ");
10848               "constexpr auto " + NameInfo.getName().getAsString() + " = ");

 5743                                       "static_cast<" + TypeStr + ">(")

 5842     std::string Code = "static_cast<" + ParamType.getAsString() + ">(";

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

 6747                   " " + attr.getAttrName()->getName().str() + " ");

 3927           Error("could not find file '" + Filename +"' referenced by AST file");

  175             Pair.FirstCloneInfo.Variable->getNameAsString() + "' here?",
  181                    Pair.SecondCloneInfo.Variable->getNameAsString() + "' here",

   31               RequestRegion->getDescriptiveName() + ". ";
   53   std::string ErrorText{"Request " + RequestRegion->getDescriptiveName() +
   73   std::string ErrorText{"Request " + RequestRegion->getDescriptiveName() +

  156         "a method on '" + ObjT.getAsString() + "' to get the scalar value";

   64       Name += RD->getNameAsString() + "::";

  628         "\"" + ErrorMsg + "\"");

  157         CE->getBeginLoc(), MD->getParent()->getNameAsString() + "::");

   39                                             std::string(ConfigFile) + "'");

   57         llvm::StringRef(modelPath.str() + "/" + D->getName().str() + ".model");
   57         llvm::StringRef(modelPath.str() + "/" + D->getName().str() + ".model");
   59     fileName = llvm::StringRef(D->getName().str() + ".model");

  426     return getRelativeName(V) + "(" + V->getType().getAsString(TypePP) + ")";
  426     return getRelativeName(V) + "(" + V->getType().getAsString(TypePP) + ")";
  428     Value += getRelativeName(N) + ";";
  430     return Value + T->getUnderlyingType().getAsString(TypePP) + ";";
  434           T->getTypeForDecl()->getCanonicalTypeInternal().getAsString(TypePP) +

  122             Log("[" + std::to_string(Count()) + "/" + TotalNumStr +
  122             Log("[" + std::to_string(Count()) + "/" + TotalNumStr +

   98         "::" + cast<NamespaceDecl>(DeclA)->getQualifiedNameAsString() + "::";

  609         "\n" + Comment.str() + " " OFFLOAD_BUNDLER_MAGIC_STR "__START__ ";
  611         "\n" + Comment.str() + " " OFFLOAD_BUNDLER_MAGIC_STR "__END__ ";
  661                            "'" + FilesType + "': invalid file type specified");

  330         errc::invalid_argument, "'" + Target + "': unsupported target triple"));

  248              : (llvm::join(DeclI, DeclE, "::") + "::" + UnqualifiedDeclName)
  830             NamespaceAlias->getNamespace()->getQualifiedNameAsString() +

  441         HTMLTag::TAG_P, "Defined at line " + std::to_string(L.LineNumber) +
  764   InfoTitle = (getTagType(I.TagType) + " " + I.Name).str();

   24   return "*" + Text.str() + "*";
   28   return "**" + Text.str() + "**";
   50   OS << std::string(Num, '#') + " " + Text << "\n\n";
   54   OS << genItalic("Defined at line " + std::to_string(L.LineNumber) + " of " +
  194   writeHeader(getTagType(I.TagType) + " " + I.Name, 1, OS);
  212       writeLine("Inherits from " + Parents + ", " + VParents, OS);

  222           TypoScopeString = ND->getNameAsString() + "::" + TypoScopeString;
  333                                                     : "\"" + FilePath + "\""),
  408       "#include " + Context.getHeaderInfos().front().Header + "\n";

  365                               : "\"" + HeaderPath + "\""));
  414       errs() << "Couldn't open file: " + FilePath.str() + ": "
  415              << Buffer.getError().message() + "\n";

  380     NewCode += "#ifndef " + GuardName + "\n";
  381     NewCode += "#define " + GuardName + "\n\n";
  423       NewCode += "} // namespace " + *It + "\n";
  434       NewCode += "namespace " + *DeclIt + " {\n";
  448     NewCode += "} // namespace " + NS + "\n";
  451     NewCode += "\n#endif // " + GuardName + "\n";
  488     CCIncludes.push_back("#include \"" + Context->Spec.NewHeader + "\"\n");
  769           "#include \"" + Context->Spec.NewHeader + "\"\n";
  829             ? "#include \"" + Context->Spec.OldHeader + "\"\n"

  120                 DiagnosticsEngine::Note, "\"" + BI->first + "\" binds here",

   35     : NamePrefix(CheckName.str() + "."), CheckOptions(CheckOptions) {}

   50     std::string CheckNameInMessage = " [" + Error.DiagnosticName + "]";

   89       FixItInitList += "(" + ParamName + "), ";

  148         getNameAsString(Parents.front()) + "::");

   68         ReplaceType.getAsString(Result.Context->getPrintingPolicy()) + " ");

   43       std::string(RequirePrefix ? "[A-Z][A-Z0-9]+" : "") + "[A-Z][a-zA-Z0-9]*";
   44   return std::string("::(") + FunctionNameMatcher + ")$";

  121     RightText = "std::move(" + RightText + ")";

  645   std::string Range = ("(" + TypeString + " " + VarName + " : " +
  645   std::string Range = ("(" + TypeString + " " + VarName + " : " +

  183         "<" + GetNewExprName(New, SM, getLangOpts()) + ">");

   68                         : (")" + Delimiter + R"(")")) != StringRef::npos;
   82   return (R"(R")" + Delimiter + "(" + Bytes + ")" + Delimiter + R"(")").str();

  195           ReplacementText = " " + OverrideSpelling + " ";

  106         "using " + MatchedDecl->getNameAsString() + " = " +

  232     PartialReserveStmt = "." + MutableFieldName +

  119     ReplacementText = "(" + ReplacementText + ")";

  119                                       " /*" + NewName.str() + "*/");

  183           : ("namespace '" + NestedNamespaceName.str() + "'");

  179   return ExprText + " " + (Negated ? "!=" : "==") + " " + Constant;
  179   return ExprText + " " + (Negated ? "!=" : "==") + " " + Constant;
  179   return ExprText + " " + (Negated ? "!=" : "==") + " " + Constant;

  159            (EndIfStr != "/* " + HeaderGuard.str() + " */");
  248                  StartLoc, "#ifndef " + CPPVar + "\n#define " + CPPVar + "\n\n")
  248                  StartLoc, "#ifndef " + CPPVar + "\n#define " + CPPVar + "\n\n")
  252                      ? "\n#" + Check->formatEndIf(CPPVar) + "\n"

   70         Parts.first.str() + "/internal/" + Parts.second.str();
   72         Parts.first.str() + "/proto/" + Parts.second.str();

  195         return printQualifiedName(*NS) + "::";

  861             !ParentName ? S.name : (ParentName->str() + "::" + S.name);

 1806               (Opts.ShowOrigins ? "[" + llvm::to_string(Origin) + "]" : "") +

   58     return "` " + std::move(R) + " `";
   63     return "` " + std::move(R) + " `";
   64   return "`" + std::move(R) + "`";
   86   return BlockMarker + Language.str() + "\n" + Input.str() + "\n" + BlockMarker;
   86   return BlockMarker + Language.str() + "\n" + Input.str() + "\n" + BlockMarker;
  182       R += "text[" + C.Contents + "]";
  185       R += "code[" + C.Contents + "]";

  213     Suggested = "<" + Suggested + ">";
  215     Suggested = "\"" + Suggested + "\"";

  114           SrcMgr.getFilename(Inputs.Cursor).str() + " Line " +

  333   return Name + "(" + renderParametersForCall() + ")" +
  333   return Name + "(" + renderParametersForCall() + ")" +
  338   return ReturnType + " " + Name + "(" + renderParametersForDefinition() + ")" +
  338   return ReturnType + " " + Name + "(" + renderParametersForDefinition() + ")" +
  338   return ReturnType + " " + Name + "(" + renderParametersForDefinition() + ")" +
  339          " {\n" + getFuncBody(SM) + "\n}\n";
  347   return toSourceCode(SM, BodyRange).str() +
  352   return printType(TypeInfo, *Context) + (PassByReference ? " &" : " ") + Name;

  179   std::string ExtractedVarDecl = std::string("auto ") + VarName.str() + " = " +
  180                                  ExtractionCode.str() + "; ";

  192   std::string Qualifier = printUsingNamespaceName(Ctx, *TargetDirective) + "::";

  581     std::string Name = std::string("Foo") + std::to_string(I) + ".cpp";

   52            "Diag at " + llvm::to_string(Range) + " = [" + Message + "]") {
   52            "Diag at " + llvm::to_string(Range) + " = [" + Message + "]") {
   52            "Diag at " + llvm::to_string(Range) + " = [" + Message + "]") {
   57            "Fix " + llvm::to_string(Range) + " => " +
   58                ::testing::PrintToString(Replacement) + " = [" + Message + "]") {
   58                ::testing::PrintToString(Replacement) + " = [" + Message + "]") {
   58                ::testing::PrintToString(Replacement) + " = [" + Message + "]") {

  563         AnnotatedCode += "$" + std::to_string(I) + "^";

   66       return ArgName == "<" + SpecializationArgs + ">";

  382       std::string Name = "foo" + std::to_string(I) + ".cpp";

   29   std::string ThunkContents = "#import \"" + FullHeaderName + "\"\n";

 1061           getSourceLocationString(PP, InstanceLoc) + ":\n" +
 1062           getSourceLine(PP, InstanceLoc) + "\n";
 1064           getSourceLocationString(PP, DefinitionLoc) + ":\n" +
 1065           getSourceLine(PP, DefinitionLoc) + "\n";
 1083             getSourceLocationString(PP, DefinitionLoc) + ":\n" +
 1084             getSourceLine(PP, DefinitionLoc) + "\n";
 1109           getSourceLocationString(PP, InstanceLoc) + ":\n" +
 1110           getSourceLine(PP, InstanceLoc) + "\n";

  137                          ClangDocVersion + R"raw(</span>
  260                          ClangDocVersion + R"raw(</span>
  313                          ClangDocVersion + R"raw(</span>
  362                          ClangDocVersion + R"raw(</span>
  447                          ClangDocVersion + R"raw(</span>

  106     std::string Content = "#include\"" + std::string(HeaderName) +
  109                           InternalHeader + "\"";
  113     Content += "\n#include \"" + DirtyHeader + "\"";

  257   std::string ExpectedHeader = "#include \"" + Spec.NewHeader + "\"\n\n";
  496                                         CommonHeader +

   22     return "expected: '" + ExpectedWarning->str() + "', saw: '" +
   23            Errors.back().Message.Message + "'";
   44     return "expected: '" + ExpectedWarning->str() + "', saw: '" +
   45            Errors.back().Message.Message + "'";

   42         Aliaser->getNamespaceName(*Result.Context, *Call, "::foo::bar") + "::");

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

 3608   Decl *FromTU = getTuDecl(std::string(StructA) + "const int A::a;", Lang_CXX,
 3639   Decl *FromTU = getTuDecl(std::string(StructA) + "const int A::a = 1 + 2;",
 4239   Decl *FromTU = getTuDecl(std::string(Code) +
 4914       std::string("void foo() { ") + ErroneousStmt + " }",
 4914       std::string("void foo() { ") + ErroneousStmt + " }",
 4941       void f() { )") + ErroneousStmt + R"( }
 4941       void f() { )") + ErroneousStmt + R"( }
 4976         void f() { )") + ErroneousStmt + R"( } // This member has the error
 4976         void f() { )") + ErroneousStmt + R"( } // This member has the error
 5026             void error() { )") + ErroneousStmt + R"( }
 5026             void error() { )") + ErroneousStmt + R"( }
 5102         void f() { )") + ErroneousStmt + R"( } // This member has the error
 5102         void f() { )") + ErroneousStmt + R"( } // This member has the error
 5149           void f() { )") + ErroneousStmt + R"( }
 5149           void f() { )") + ErroneousStmt + R"( }
 5184           void f() { )") + ErroneousStmt + R"( }
 5184           void f() { )") + ErroneousStmt + R"( }
 5227           )") + ErroneousStmt + R"(
 5227           )") + ErroneousStmt + R"(

  157       std::string(GetParam()) + R"(
  170       std::string(GetParam()) + R"(
  185       std::string(GetParam()) + R"( collapse(1)
  200       std::string(GetParam()) + R"( collapse(2)
  214       std::string(GetParam()) + R"( collapse(2)

  217     S += "void test_fn() { " + Body + " }";

  114   const std::string ModExpr = "x " + GetParam() + " 10";
  115   const auto AST = buildASTFromCode("void f() { int x; " + ModExpr + "; }");
  129   const auto AST = buildASTFromCode("void f() { int x; " + ModExpr + "; }");
  404   auto AST = buildASTFromCode(StdRemoveReference + StdMove +
  410   AST = buildASTFromCode(StdRemoveReference + StdMove +
  415   AST = buildASTFromCode(StdRemoveReference + StdMove +
  421       buildASTFromCode(StdRemoveReference + StdMove +
  427   AST = buildASTFromCode(StdRemoveReference + StdMove +
  433   AST = buildASTFromCode(StdRemoveReference + StdMove +
  440   AST = buildASTFromCode(StdRemoveReference + StdMove +
  447   AST = buildASTFromCode(StdRemoveReference + StdMove +
  453   AST = buildASTFromCode(StdRemoveReference + StdMove +
  459       StdRemoveReference + StdMove +
  467       buildASTFromCode(StdRemoveReference + StdForward +
  474       StdRemoveReference + StdForward +
  715   AST = buildASTFromCode(StdRemoveReference + StdForward +
  772   AST = buildASTFromCode(StdRemoveReference + StdForward +

 9094   EXPECT_EQ(std::string("int i;\n") + Code + "int j;\n",
 9095             format(std::string("int    i;\n") + Code + "int    j;\n",

  390         Case.first + "\"}]";

   49                           Context->getRevision() + ":" + Context->getCorpus() +
   49                           Context->getRevision() + ":" + Context->getCorpus() +
   50                               ":" + Context->getCurrentCompilationUnit() +
  274     std::string File = "f" + std::to_string(i) + ".cc";
  277     FileToContent[File] = "void " + Symbol + "() {}";

  483   WriteFile(HeaderName, std::string(HeaderTop) + HeaderBottom);
  495       std::string(HeaderTop) + "int baz;" + HeaderBottom;
  495       std::string(HeaderTop) + "int baz;" + HeaderBottom;
  513   WriteFile(HeaderName, std::string(HeaderTop) + HeaderBottom);
  530       std::string(HeaderTop) + "int baz;" + HeaderBottom;
  530       std::string(HeaderTop) + "int baz;" + HeaderBottom;

  104               + std::string(type, 0, type.size()-1) + ">(Record.readInt())")
  123     .EndsWith("Decl *", "AddDeclRef(" + std::string(name) + ");\n")
  124     .Case("TypeSourceInfo *", "AddTypeSourceInfo(" + std::string(name) + ");\n")
  125     .Case("Expr *", "AddStmt(" + std::string(name) + ");\n")
  126     .Case("IdentifierInfo *", "AddIdentifierRef(" + std::string(name) + ");\n")
  127     .Case("StringRef", "AddString(" + std::string(name) + ");\n")
  128     .Case("ParamIdx", "push_back(" + std::string(name) + ".serialize());\n")
  129     .Default("push_back(" + std::string(name) + ");\n");
  303                                            std::string(getUpperName()) + "()");
  308         return "!get" + getUpperName().str() + "()";
  310         return "!get" + getUpperName().str() + "Loc()";
  312         return "!get" + getUpperName().str() + "().isValid()";
  601       return "!is" + getLowerName().str() + "Expr || !" + getLowerName().str()
  602              + "Expr";
  644           ArgName(getLowerName().str() + "_"), ArgSizeName(ArgName + "Size"),
  653       std::string IteratorType = getLowerName().str() + "_iterator";
  654       std::string BeginFn = getLowerName().str() + "_begin()";
  655       std::string EndFn = getLowerName().str() + "_end()";
  943       QualifiedTypeName = getAttrName().str() + "Attr::" + type;
 1245           getType(), "SA->get" + std::string(getUpperName()) + "Loc()");
 1618       EnumName += (NormalizeNameForSpellingComparison(Namespace).str() +
 1640     Ret += "    " + EnumName + " = " + llvm::utostr(Idx);
 3004         !Test.empty() ? Test + " ? " + llvm::itostr(Version) + " : 0" : "1";
 3357     return '"' + DiagList[0] + " and " + DiagList[1] + '"';
 3364   return '"' + Diag + ", and " + *(DiagList.end() - 1) + '"';
 3435   std::string FnName = "check" + Attr.getName().str() + "AppertainsTo";
 3630   std::string Name = Attr.getName().str() + "AttrSpellingMap";
 3784               Spelling, "return AttributeCommonInfo::AT_" + AttrName + ";"));

  755       Builder.PrintFatalError("Modifier value '" + std::to_string(Idx) +
  757                               std::to_string(ModifierMappings->size()) +
  792     *I = "|" + *I + "|";
  902                   char('A' + mapIndex(P->Index)) + "`");
 1467       PrintFatalError("Invalid character in diagnostic group '" + I.first +

  226   std::string cName() const override { return cNameBase() + "_t"; }
  257     return "Int" + utostr(Bits) + "Ty";
  284     return Element->cNameBase() + "x" + utostr(Lanes);
  287     return "llvm::VectorType::get(" + Element->llvmName() + ", " +
  288            utostr(Lanes) + ")";
  310     return Element->cNameBase() + "x" + utostr(Registers);
  340            utostr(ModifiedLanes) + ")";
  798         SemaChecks.push_back("SemaBuiltinConstantArg(TheCall, " + Index + ")");
  800         SemaChecks.push_back("SemaBuiltinConstantArgRange(TheCall, " + Index +
  801                              ", 0x" + lo.toString(16, true) + ", 0x" +
  802                              hi.toString(16, true) + ")");

 1400     S += "(" + RetVar.getType().str() + ") ";
 1402   S += "__builtin_neon_" + mangleName(N, LocalCK) + "(";
 1405     S += "&" + RetVar.getName() + ", ";
 1420         Cast = "(" + T2.str() + ")";
 1424         S += Cast + V.getName() + ".val[" + utostr(J) + "], ";
 1424         S += Cast + V.getName() + ".val[" + utostr(J) + "], ";
 1431       Arg = "(" + BaseType.str() + ") {";
 1448       Arg = "(" + CastToType.str() + ")" + Arg;
 1451       Arg = "(" + CastToType.str() + ")" + Arg;
 1475     RetExpr = RetVar.getName() + " = ";
 1503       Lines.push_back(DE.emitDag(DI).second + ";");
 1509     Lines.back().insert(0, RetVar.getName() + " = ");
 1570     return std::make_pair(R1.first, R1.second + " " + Op + " " + R2.second);
 1600   S += Callee.getMangledName(true) + "(";
 1669     S = "*(" + castToType.str() + " *) &" + Intr.Variables[N].getName() + "";
 1669     S = "*(" + castToType.str() + " *) &" + Intr.Variables[N].getName() + "";
 1672     S = "(" + castToType.str() + ")(" + R.second + ")";
 1672     S = "(" + castToType.str() + ")(" + R.second + ")";
 1762   std::string S = "__builtin_shufflevector(" + Arg1.second + ", " + Arg2.second;
 1796   std::string S = "(" + T.str() + ") {";
 1818   std::string S = "(" + T.str() + ") {";
 1839   std::string S = "__builtin_shufflevector(" + A.second + ", " + A.second;
 1865       A.first.str() + " " + Intr.Variables[N].getName() + " = " + A.second;
 1865       A.first.str() + " " + Intr.Variables[N].getName() + " = " + A.second;
 1880   assert_with_loc(Idx != std::string::npos, "name should contain '" + ToReplace + "'!");
 2002   std::string ErrMsg = "looking up intrinsic '" + Name.str() + "(";
 2014     ErrMsg += "  - " + I.getReturnType().str() + " " + I.getMangledName();
 2115     std::string S = "BUILTIN(__builtin_neon_" + Def->getMangledName() + ", \"";

  455         outs(), (std::string(argv[0]) + " [options] <input files>").c_str(),

  565     cf.name += ".llvm." + std::to_string(file->offset) + "." +

  236           "could not open '" + pathStr + "': " + mbOrErr.second.message();
  246         error(msg + "; did you mean '" + nearest + "'");
  275   log("Loaded " + toString(obj) + " for " + symName);
  284           toCOFFString(sym) + ": " + parentName + "(" + childName + "): " +
  330   log("Directives: " + toString(file) + ": " + s);
  577       warn(std::string("found ") + (haveMain ? "main" : "wmain") + " and " +
  577       warn(std::string("found ") + (haveMain ? "main" : "wmain") + " and " +
  577       warn(std::string("found ") + (haveMain ? "main" : "wmain") + " and " +
  578            (haveWinMain ? "WinMain" : "wWinMain") +
  783     fatal("cannot create temporary file for import library " + path + ": " +
  934           fatal(toString(obj) + ": could not decode addrsig section: " + err);
  934           fatal(toString(obj) + ": could not decode addrsig section: " + err);
  936           fatal(toString(obj) + ": invalid symbol index in addrsig section");
 1015                               : toString(resourceObjFiles[1])) +
 1161       error("/linkrepro: failed to open " + *path + ": " +
 1728     error("cannot open output file " + config->outputFile + ": " + e.message());

  327         fatal("failed to open " + path + ": " + ec.message());
  415     fatal("failed to open " + Default.path + ": " + ec.message());
  724       fatal(toString(f) + ": " + toString(std::move(ec)));
  849       warn("ignoring unknown argument '" + arg->getAsString(args) + "'");
  851       warn("ignoring unknown argument '" + arg->getAsString(args) +
  852            "', did you mean '" + nearest + "'");
  911                            (std::string(argv0) + " [options] file...").c_str(),

  192     fatal(toString(this) + " is not a COFF file");
  320     error(toString(this) + ": associative comdat " + name + " (sec " +
  512     log(("conflicting comdat type for " + toString(*leader) + ": " +
  611     fatal(toString(this) + ": " + getName() +
  615     fatal(toString(this) + ": " + getName() +
  646       fatal("unknown comdat type " + std::to_string((int)def->Selection) +

   87     checkError(c.addSaveTemps(std::string(config->outputFile) + ".",

   97     fatal("cannot open " + config->mapFile + ": " + ec.message());

  604         log("ignoring symbol record of kind 0x" + utohexstr(symKind) + " in " +
 1057            utohexstr(uint32_t(ss.kind())) + " in file " + toString(&file));
 1179     warn("Cannot use debug info for '" + toString(file) + "' [LNK4099]\n" +
 1179     warn("Cannot use debug info for '" + toString(file) + "' [LNK4099]\n" +

   42     error(toString(file) + ": machine type " + machineToStr(mt) +
  106     res += source.str() + "\n>>>               ";
  326         warn("<root>: locally defined symbol imported: " + toString(*imp) +
  327              " (defined in " + toString(imp->getFile()) + ") [LNK4217]");
  350           warn(toString(file) +
  351                ": locally defined symbol imported: " + toString(*imp) +
  352                " (defined in " + toString(imp->getFile()) + ") [LNK4217]");
  525     res += source.str() + "\n>>>            ";

  972       fatal(toString(*file->impSym) + " was replaced");
  976         fatal("cannot delay-load " + toString(file) +
  997       fatal(toString(*file->thunkSym) + " was replaced");
 1870       log("  " + sc->file->mb.getBufferIdentifier().str() +

  142     return m.str(1) + "(" + m.str(2) + ")";
  142     return m.str(1) + "(" + m.str(2) + ")";

  556       utohexstr(adrpAddr) + " in unpatched output.");

  284           warn(toString(isec->file) +
  406       utohexstr(isec->getVA(sr.off)) + " in unpatched output.");

  150     error(getErrorLocation(loc) + "unknown relocation (" + Twine(type) +

   99     error(getErrorLocation(loc) + "unknown relocation (" + Twine(type) +

  517     error(getErrorLocation(loc) + "unrecognized relocation " + toString(type));

   70     error(getErrorLocation(loc) + "unrecognized relocation " + toString(type));

  129     error(getErrorLocation(loc) + "unknown relocation (" + Twine(type) +

   87     error(getErrorLocation(loc) + "unrecognized relocation " + toString(type));

  183     error(getErrorLocation(loc) + "unknown relocation (" + Twine(type) +
  462   error(getErrorLocation(loc) + "unsupported relocations combination " +
  520   error(getErrorLocation(loc) +
  522         toString(type) + " relocation");

   75       error(toString(f.file) + ": microMIPS 64-bit is not supported");
   79       error(toString(f.file) + ": ABI '" + getAbiName(abi2) +
   84       error(toString(f.file) + ": -mnan=" + getNanName(nan2) +
   89       error(toString(f.file) + ": -mfp" + getFpName(fp2) +
  109       warn(toString(f.file) +
  113       warn(toString(f.file) +
  287       error("incompatible target ISA:\n>>> " + toString(files[0].file) + ": " +
  288             getFullArchName(ret) + "\n>>> " + toString(f.file) + ": " +
  288             getFullArchName(ret) + "\n>>> " + toString(f.file) + ": " +

  238     error(getErrorLocation(loc) + "unknown relocation (" + Twine(type) +

  355       error(toString(f) + ": ABI version 1 is not supported");
  357       error(toString(f) + ": unrecognized e_flags: " + Twine(flag));
  631     error(getErrorLocation(loc) + "unknown relocation (" + Twine(type) +
  836         error(getErrorLocation(loc) +
  856         error(getErrorLocation(loc) +
 1074     error(getErrorLocation(loc) + "split-stack prologue adjustment overflows");

  119       error(toString(f) +
  123       error(toString(f) +
  434     error(getErrorLocation(loc) +

   72     error(getErrorLocation(loc) + "unknown relocation (" + Twine(type) +

  153     error(getErrorLocation(loc) + "unknown relocation (" + Twine(type) +

  126     error(getErrorLocation(loc) + "unknown relocation (" + Twine(type) +
  206       error(getErrorLocation(loc - 3) + "R_X86_64_GOTPC32_TLSDESC must be used "
  246       error(getErrorLocation(loc - 3) + "R_X86_64_GOTPC32_TLSDESC must be used "
  293     error(getErrorLocation(loc - 3) +
  346   error(getErrorLocation(loc - 3) +

  450     message(getLLDVersion() + " (compatible with GNU linkers)");
  460       tar->append("version.txt", getLLDVersion() + "\n");
 1498           fatal(toString(f) + ": could not decode addrsig section: " + err);
 1498           fatal(toString(f) + ": could not decode addrsig section: " + err);
 1537     error(toString(s->file) +
 1540     error(toString(s->file) +
 1543     error(toString(s->file) + ": partitions cannot be used with "
 1546     error(toString(s->file) + ": partitions cannot be used on this target");
 1681       warn(toString(f) + ": --force-bti: file does not have BTI property");
 1684       error(toString(f) + ": --require-cet: file is not compatible with CET");

  138       error("unknown argument '" + arg->getAsString(args) + "'");
  140       error("unknown argument '" + arg->getAsString(args) +
  141             "', did you mean '" + nearest + "'");

  141     error(toString(file) + " is incompatible with " + config->emulation);
  153   error(toString(file) + " is incompatible with " + toString(existing));
  228   return filename + lineno + " (" + path.str() + lineno + ")";
  228   return filename + lineno + " (" + path.str() + lineno + ")";
  358     fatal(toString(this) + ": invalid sh_info in symbol table");
  401     fatal(toString(this) + ": invalid symbol index");
  450     fatal(toString(this) + ":(" + name + "): SHF_MERGE section size (" +
  458     fatal(toString(this) + ":(" + name +
  494     error(toString(f) +
  530           warn(toString(this) + ": --icf=safe is incompatible with object "
  547         fatal(toString(this) + ": empty SHT_GROUP");
  557         fatal(toString(this) + ": unsupported SHT_GROUP format");
  572           fatal(toString(this) +
  603       fatal(toString(this) + ": invalid sh_link index: " + Twine(sec.sh_link));
  644     error(toString(f) + ": unknown Tag_ABI_VFP_args value: " + Twine(vfpArgs));
  649     error(toString(f) + ": incompatible Tag_ABI_VFP_args");
  717       fatal(toString(obj) + ": .note.gnu.property: section too short");
  721       fatal(toString(obj) + ": .note.gnu.property: section too short");
  737         fatal(toString(obj) + ": .note.gnu.property: section too short");
  768     fatal(toString(this) + ": invalid relocated section index: " + Twine(idx));
  778     fatal(toString(this) + ": unsupported relocation reference");
  818       error(toString(this) +
  866       fatal(toString(this) +
 1000       fatal(toString(this) + ": invalid section index: " + Twine(secIdx));
 1018         fatal(toString(this) + ": invalid symbol name offset");
 1041         fatal(toString(this) + ": common symbol '" + StringRef(name.data) +
 1067     fatal(toString(this) + ": unexpected binding: " + Twine((int)binding));
 1083       CHECK(sym.getMember(), toString(this) +
 1092             toString(this) +
 1208         fatal(toString(this) + ": invalid DT_NEEDED entry");
 1213         fatal(toString(this) + ": invalid DT_SONAME entry");

  212       fatal(toString(this) + ": invalid symbol index");

   43   return (toString(sec->file) + ":(" + sec->name + ")").str();
   69     error(toString(this) + ": section too large");
   78     fatal(toString(this) + ": sh_addralign is not a power of 2");
   87       error(toString(file) + ": contains a compressed section, " +
   87       error(toString(file) + ": contains a compressed section, " +
  133     fatal(toString(&file) + ": section sh_addralign is too large");
  154     fatal(toString(this) +
  218       error(toString(this) + ": corrupted compressed section header");
  224       error(toString(this) + ": corrupted compressed section header");
  243       error(toString(this) + ": corrupted compressed section");
  249       error(toString(this) + ": unsupported compression type");
  261     error(toString(this) + ": corrupted compressed section");
  267     error(toString(this) + ": unsupported compression type");
  305     return info->FileName + ":" + std::to_string(info->Line) + ":(" +
  306            secAndOffset + ")";
  315     return srcFile + ":(function " + toString(*d) + ": " + secAndOffset + ")";
  315     return srcFile + ":(function " + toString(*d) + ": " + secAndOffset + ")";
  318   return (srcFile + ":(" + secAndOffset + ")");
  351         return filename + ":(" + toString(*d) + ")" + archive;
  581          isec->getObjMsg(d->value) + " is ignored");
  598   error("R_RISCV_PCREL_LO12 relocation points to " + isec->getObjMsg(d->value) +
  857       std::string msg = getLocation<ELFT>(offset) +
  858                         ": has non-ABS relocation " + toString(type) +
  859                         " against symbol '" + toString(sym) + "'";
  975           error(getErrorLocation(bufLoc) + "call lacks nop, can't restore toc");
 1084         error(toString(this) + ": " + f->getName() +
 1126       fatal(toString(this) +
 1235       fatal(toString(this) + ": string is not null terminated");
 1285     fatal(toString(this) + ": offset is outside the section");

  123     checkError(c.addSaveTemps(config->outputFile.str() + ".",

  682         error(toString(s) + " is being placed in '" + name + "'");
  684         warn(toString(s) + " is being placed in '" + name + "'");
  773     error("memory region '" + sec->memoryRegionName + "' not declared");
  979           error("memory region '" + sec->lmaRegionName + "' not declared");

  423   error("relocation " + toString(type) + " cannot refer to absolute symbol: " +
  620   warn("can't find matching " + toString(pairTy) + " relocation for " +
  679     msg += "\n>>> section group signature: " + signature.str() +
  785     msg = "undefined " + visibility() + "symbol: " + toString(sym);
 1089           error("unresolvable relocation " + toString(type) +
 1090                 " against symbol '" + toString(*ss) +
 1128         errorOrWarn("symbol '" + toString(sym) +
 1146           "can't create dynamic relocation " + toString(type) + " against " +
 1148                                  : "symbol: " + toString(sym)) +
 1154           "relocation " + toString(type) + " cannot be used against " +
 1155           (sym.getName().empty() ? "local symbol" : "symbol " + toString(sym)) +
 1160   errorOrWarn("symbol '" + toString(sym) + "' has no type" +

   78   std::string s = (getCurrentLocation() + ": " + msg).str();
   80     s += "\n>>> " + getLine().str() + "\n>>> " +
   81          std::string(getColumnNumber(), ' ') + "^";

  923         tok.str() + " " +
 1100       tok.str() + " " +

  119         fatal(toString(d.file) +
  245     error(toString(file) + ": symbol " + s + " has undefined version " +
  572     error("duplicate symbol: " + toString(*sym) + "\n>>> defined in " +
  573           toString(sym->file) + "\n>>> defined in " + toString(newFile));
  590   std::string msg = "duplicate symbol: " + toString(*sym) + "\n>>> defined at ";

  531     error("TLS attribute mismatch: " + toString(*this) + "\n>>> defined in " +
  532           toString(newSym.file) + "\n>>> defined in " + toString(file));

  242       error(toString(sec->file) + ": invalid size of .reginfo section");
  419       fatal(toString(sec) + ": invalid CIE reference");
  518         fatal(toString(fde->sec) + ": PC offset is too large: 0x" +
 2566       error(toString(sec) + ": " + toString(std::move(e)));
 2571       error(toString(sec) + ": " + toString(ranges.takeError()));

  104       return {isec, isec->template getLocation<ELFT>(loc - isecLoc) + ": "};

  201   errorOrWarn(errPlace.loc + "relocation " + lld::toString(type) +
  202               " out of range: " + v.str() + " is not in [" + Twine(min).str() +
  202               " out of range: " + v.str() + " is not in [" + Twine(min).str() +
  203               ", " + Twine(max).str() + "]" + hint);
  229     error(getErrorLocation(loc) + "improper alignment for relocation " +
  230           lld::toString(type) + ": 0x" + llvm::utohexstr(v) +
  230           lld::toString(type) + ": 0x" + llvm::utohexstr(v) +

  826   fatal("relocation " + toString(reloc) + " to " + toString(s) +
  826   fatal("relocation " + toString(reloc) + " to " + toString(s) +
  844   fatal("relocation " + toString(reloc) + " to " + toString(s) +
  844   fatal("relocation " + toString(reloc) + " to " + toString(s) +

  257       error(toString(s->file) + " cannot redefine linker defined symbol '" +
  684         fatal(toString(f) +
 1529             error(toString(isec) + ": sh_link points to discarded section " +
 1594         errorOrWarn("assignment to symbol " + toString(*changedSym) +
 1776             error(toString(f) + ": undefined reference to " + toString(*sym));
 1961           error("cannot place " + toString(isec) + " into " + toString(os->name) +
 1961           error("cannot place " + toString(isec) + " into " + toString(os->name) +
 2333   return "[0x" + utohexstr(addr) + ", 0x" + utohexstr(addr + len - 1) + "]";
 2333   return "[0x" + utohexstr(addr) + ", 0x" + utohexstr(addr + len - 1) + "]";

   86       outs(), (std::string(argv0) + " [options] file...").c_str(), "lld",
  145         error("lld doesn't support linking directly against " + *s +
  150         error("lld doesn't support linking directly against " + *s +
  182     message(getLLDVersion() + " (compatible with GNU linkers)");

  145     fatal(prefix() + ": " + ec.message());
  152     fatal(prefix() + ": " + toString(e.takeError()));

  386                         (std::string(args[0]) + " [options] file...").c_str(),
  463             llvm::utohexstr(ctx.pageSize()) + ")");
  573       warn(ec.message() + ", processing '-dependency_info " +
  573       warn(ec.message() + ", processing '-dependency_info " +
  660       error(ec.message() + ", processing '-exported_symbols_list " +
  660       error(ec.message() + ", processing '-exported_symbols_list " +
  686       error(ec.message() + ", processing '-unexported_symbols_list " +
  686       error(ec.message() + ", processing '-unexported_symbols_list " +
  957             llvm::utohexstr(ctx.pageSize()) + ")");
  971       error(ec.message() + ", processing '-order_file " + orderFile->getValue()
  971       error(ec.message() + ", processing '-order_file " + orderFile->getValue()
  972             + "'");
 1100           error(EI.message() + ", processing '-filelist " + arg->getValue());
 1100           error(EI.message() + ", processing '-filelist " + arg->getValue());

 1423     std::string name = std::string(targetName) + "$shim";
 1468     std::string name = std::string(targetName) + "$shim";

  125       llvm_unreachable((Twine("Atom <" + atomToDebugString(atom) +

  260                                 + "/" + section.sectionName.str();
  478                                   + "/" + section.sectionName.str();

  652                      (std::string(argsArr[0]) + " [options] file...").c_str(),
  671       tar->append("version.txt", getLLDVersion() + "\n");

   36   return (toString(c->file) + ":(" + c->getName() + ")").str();

   57   return (toString(e->file) + ":(" + e->getName() + ")").str();

   81   log("info for: " + toString(this) +
  255     fatal(toString(this) + ": not a wasm file");
  257     fatal(toString(this) + ": not a relocatable wasm file");
  269       fatal(toString(this) + ": invalid table elements");
  545     error(toString(mb.getBufferIdentifier()) + ": machine type must be wasm32");

   50   return (toString(g->file) + ":(" + g->getName() + ")").str();

   64     checkError(c.addSaveTemps(config->outputFile.str() + ".",

   79   log("createHeader: " + toString(*this) + " body=" + Twine(bodySize) +
  177   log("writing " + toString(*this) + " size=" + Twine(getSize()) +
  238   log("writing " + toString(*this) + " size=" + Twine(getSize()) +

   37     log("setOffset: " + toString(*this) + ": " + Twine(newOffset));

   39     error(toString(sym->getFile()) + ": undefined symbol: " + toString(*sym));
   94         error(toString(file) + ": relocation " + relocTypeToString(reloc.Type) +

  131   error("symbol type mismatch: " + toString(*existing) + "\n>>> defined as " +
  132         toString(existing->getWasmType()) + " in " +
  133         toString(existing->getFile()) + "\n>>> defined as " + toString(type) +
  133         toString(existing->getFile()) + "\n>>> defined as " + toString(type) +
  261   error("duplicate symbol: " + toString(*existing) + "\n>>> defined in " +
  262         toString(existing->getFile()) + "\n>>> defined in " +
  409       error("import name mismatch for symbol: " + toString(*existing) +
  419       error("import module mismatch for symbol: " + toString(*existing) +

  338   message(toString(file) + ": reference to " + name);

  434     error("'atomics' feature is disallowed by " + disallowed["atomics"] +

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

 1283         ("    " + m_options.m_python_function + "(valobj,internal_dict)");

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

  304           "jit-object-" + module->getModuleIdentifier() + "-%%%.o";

  279   std::string process_task_dir = procdir + llvm::to_string(pid) + taskdir;

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

  665       summary = "Race on " + object_type + " object";

  203       return llvm::Regex::escape(first_template_parameter.str()) +
  218           llvm::Regex::escape(symbol_name.slice(0, pos2 + 1).str()) +
  225     return first_template_parameter.str() + R"(::operator\(\)\(.*\))";

  107   std::string count_path = "." + std::string(type) + "_count";
  108   std::string tid_path = "." + std::string(type) + "_tid";
  109   std::string trace_path = "." + std::string(type) + "_trace";

 2182       ConstString fake_section_name(std::string(".absolute.") + symbol_name);
 2846   std::string needle = std::string(".rel") + section_name;
 2847   std::string needlea = std::string(".rela") + section_name;

  343   std::string platform_dir = "/Platforms/" + GetPlatformName() + "/DeviceSupport";

 1083     std::string packet = "QEnableCompression:type:" + avail_name + ";";

 1069         std::string(toCString()) + "\n" +
 1069         std::string(toCString()) + "\n" +

 3844         FileSpec(m_objfile_sp->GetFileSpec().GetPath() + ".dwp");

  332       files.push_back(dirname + "/" +
  334       files.push_back(dirname + "/.debug/" +
  340         files.push_back(dirname + file_dir.AsCString() + "/" +
  340         files.push_back(dirname + file_dir.AsCString() + "/" +

   78   return FileSpec(module_file_spec.GetPath() + kSymFileExtension);

  737   std::string usage_str = tool_name.str() + "options";

  152         "LLDB_RECORD_RESULT(" + WrittenExpr.str() + ")";

   83   HandlePacket(server, "P4=" + one_register_hex + ";thread:0047;", "OK");
   90   HandlePacket(server, "G" + all_registers_hex + ";thread:0047;", "OK");

   35     SCOPED_TRACE(match.original.GetPath() + " -> " + match.remapped.GetPath());

   30   sys::path::append(DirStr, std::string("server-") +
   31                                 test_info->test_case_name() + "-" +
   31                                 test_info->test_case_name() + "-" +
   32                                 test_info->name() + ".log");

  127       CompletionArgs.push_back("CommandCompletions::e" + Completion.str() +
  169   OS << "constexpr static OptionDefinition g_" + ID + "_options[] = {\n";

   29   ExitOnErr.setBanner(std::string(argv[0]) + ":");

  363     ExitOnErr.setBanner(std::string(argv[0]) + ": ");
  401     ExitOnError ExitOnErr(std::string(*argv) +

  967     fail("error opening '" + ArchiveName + "': " + EC.message());
  972     failIfError(std::move(Err), "unable to load '" + ArchiveName + "'");
 1100           fail(std::string(expected) + " requires an argument");
 1132           fail(std::string("Invalid format ") + match);

  310     ActiveIncludeDir = std::string(LLVM_SRC_ROOT) + "/include";
  318       ActiveLibDir = ActiveObjRoot + "/lib" + LLVM_LIBDIR_SUFFIX;
  324       ActiveBinDir = ActiveObjRoot + "/" + build_mode + "/bin";
  324       ActiveBinDir = ActiveObjRoot + "/" + build_mode + "/bin";
  326           ActiveObjRoot + "/" + build_mode + "/lib" + LLVM_LIBDIR_SUFFIX;
  326           ActiveObjRoot + "/" + build_mode + "/lib" + LLVM_LIBDIR_SUFFIX;
  326           ActiveObjRoot + "/" + build_mode + "/lib" + LLVM_LIBDIR_SUFFIX;
  329           ActivePrefix + "/lib" + LLVM_LIBDIR_SUFFIX + "/cmake/llvm";
  329           ActivePrefix + "/lib" + LLVM_LIBDIR_SUFFIX + "/cmake/llvm";
  335         ("-I" + ActiveIncludeDir + " " + "-I" + ActiveObjRoot + "/include");
  335         ("-I" + ActiveIncludeDir + " " + "-I" + ActiveObjRoot + "/include");
  335         ("-I" + ActiveIncludeDir + " " + "-I" + ActiveObjRoot + "/include");
  342     ActiveLibDir = ActivePrefix + "/lib" + LLVM_LIBDIR_SUFFIX;

  169     Str += Whence.str() + ": ";
  170   Str += Message.str() + "\n";
  924           warning("Could not read coverage for '" + Function->Name + "'.");

   57     Tag += " class='" + ClassName + "'";
   58   return Tag + ">" + Str + "</" + Name + ">";
   58   return Tag + ">" + Str + "</" + Name + ">";
   64   std::string Name = TargetName.empty() ? "" : ("name='" + TargetName + "' ");
   65   return "<a " + Name + "href='" + Link + "'>" + Str + "</a>";
   65   return "<a " + Name + "href='" + Link + "'>" + Str + "</a>";
   65   return "<a " + Name + "href='" + Link + "'>" + Str + "</a>";
  421                           "here") +
  689                                  a(LinkTarget, "jump to first uncovered line") +

   39                          ? std::string(CoverageFileStem.str()) + ".gcno"
   42                          ? std::string(CoverageFileStem.str()) + ".gcda"

   80       std::string Invocation = std::string(argv[0]) + " " + argv[1];
   80       std::string Invocation = std::string(argv[0]) + " " + argv[1];

   82   reportError(EC.message() + ".\n");

  152   ExitOnErr.setBanner(std::string(argv[0]) + ": error: ");

  419                         Filename.str() + ": ");

  470       std::string("Duplicate DWO ID (") + utohexstr(PrevE.first) + ") in " +
  472                           PrevE.second.DWOName) +

  288   ExitOnError ExitOnErr(std::string(*argv) + ": error reading input: ");

   33     return make_error<StringError>("GOT entry in " + G.getName() + ", \"" +
   47         "GOT entry in " + G.getName() + ", \"" +
   68         "Stubs entry in " + G.getName() + ", \"" +

  570       return make_error<StringError>("\"" + Dylib + "\" is not a regular file",
  679     ExitOnErr(make_error<StringError>("Error accessing target '" + TripleName +
  749           "Some checks in " + CheckFile + " failed", inconvertibleErrorCode()));
  800   ExitOnErr.setBanner(std::string(argv[0]) + ": ");

  350   ExitOnErr.setBanner(std::string(argv[0]) + ": ");

  302     reportError("unknown argument '" + Arg->getAsString(InputArgs) + "'");
  757       reportError("-replace " + S.getArchString() +

  332     ExitOnError ExitOnErr("llvm-lto: error loading file '" + Filename + "': ");
  380     ExitOnError ExitOnErr("llvm-lto: error loading file '" + Filename.str() +
  415     ExitOnError ExitOnErr("llvm-lto: error loading file '" + Filename + "': ");
  424   error(EC, "error opening the file '" + OutputFilename + ".thinlto.bc'");
  479   ExitOnError ExitOnErr("llvm-lto: error loading file '" + ThinLTOIndex +
  486                         Buffer.getBufferIdentifier().str() + "': ");
  573       std::string CurrentActivity = "loading file '" + Filename + "'";
  585     error(EC, "error opening the file '" + OutputFilename + "'");
  623       error(EC, "error opening the file '" + OutputName + "'");
  806       error(EC, "error opening the file '" + OutputName + "'");
  825       std::string CurrentActivity = "loading file '" + Filename + "'";
  852       error(EC, "error opening the file '" + OutputName + "'");
  895       ExitOnError ExitOnErr(std::string(*argv) + ": error loading file '" +
  896                             Filename + "': ");
  946     CurrentActivity = "loading file '" + InputFilenames[i] + "'";
  970       error("error adding file '" + InputFilenames[i] + "'");
 1025         error("error opening the file '" + PartFilename + "': " + EC.message());

 1932                 "file: " + Filename + " does not contain architecture");
 2121         error("Unknown architecture named '" + ArchFlags[i] + "'",

  207   std::string FullMsg = (EC.message() + ": " + Msg).str();

  126   error("cannot write symbol section index table '" + Sec.Name + "' ");
  130   error("cannot write symbol table '" + Sec.Name + "' out to binary");
  134   error("cannot write relocation section '" + Sec.Name + "' out to binary");
  138   error("cannot write '" + Sec.Name + "' out to binary");
  142   error("cannot write '" + Sec.Name + "' out to binary");
  443   error("cannot write compressed section '" + Sec.Name + "' ");
  472   error("cannot write compressed section '" + Sec.Name + "' ");
 1344     error("the content of the section " + GroupSec->Name + " is malformed");

 2308             << "unknown architecture named '" + ArchFlags[i] +
 2452             << "architecture: " + ArchFlags[i] + "\n";

  404   return "<file index: " + std::to_string(Index) + ">";

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

 1154       std::string Invocation(ProgName.str() + " " + argv[1]);
 1154       std::string Invocation(ProgName.str() + " " + argv[1]);

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

  182       fatalError("Error opening output file '" + OutArgsInfo[0] +

 1740   default: return "unknown (" + llvm::utostr(Type) + ")";
 1782       W.printBinaryBlock(Name.str() + " Data", Ref);

 2148   return Twine("<Invalid offset 0x" + utohexstr(Value) + ">").str();
 2736   return "0 (" + to_string(Arr[0].sh_size) + ")";
 2749   return to_string(ElfHeader->e_shstrndx) + " (" + to_string(Arr[0].sh_link) +
 3075   return "0x" + to_hexString(Type) + ": <unknown>";
 3293              to_string(format_hex_no_prefix(SectionIndex, 4)) + "]";
 3297              to_string(format_hex_no_prefix(SectionIndex, 4)) + "]";
 3302              to_string(format_hex_no_prefix(SectionIndex, 4)) + "]";
 3344         " [<other: " + to_string(format_hex(Symbol->st_other, 2)) + ">]";
 3607             unwrapOrError(this->FileName, Obj->getSectionName(&Sec)).str() +
 3686     std::string TypeString = std::string("(") +
 3687                              getTypeString(Obj->getHeader()->e_machine, Tag) +
 3822           VersionName = "(" + VersionName + ")";
 4790                       getSymbolName(*RelocSym) + "'"),
 4795                                 getSymbolName(*RelocSym) +
 5875                       "Unknown (" + to_string(format_hex(Type, 10)) + ")");

  788     Version = utostr(MachOObjectFile::getVersionMinMajor(VMC, false)) + "." +
  798       SDK = utostr(MachOObjectFile::getVersionMinMajor(VMC, true)) + "." +

  236                                             Name + "\"",
  350       report_fatal_error("Dylib not found: '" + Dylib + "'.");
  353       report_fatal_error("Error loading '" + Dylib + "': " + ErrMsg);
  378       ErrorAndExit("unable to read input: '" + EC.message() + "'");
  388       ErrorAndExit("unable to create object file: '" + Buf + "'");
  514         ErrorAndExit("unable to read input: '" + EC.message() + "'");
  523         ErrorAndExit("unable to create object file: '" + Buf + "'");
  546     ErrorAndExit("no definition for '" + EntryPoint + "'");
  558       ErrorAndExit("unable to mark function executable: '" + EC.message() +
  587       ErrorAndExit("unable to read input '" + CheckerFileName + "': " +
  592       ErrorAndExit("some checks in '" + CheckerFileName + "' failed");
  711       report_fatal_error("Invalid dummy symbol specification '" + Mapping +
  719       report_fatal_error("Invalid symbol mapping '" + Mapping + "'.");
  740     ErrorAndExit("Error accessing target '" + TripleName + "': " + ErrorStr);
  905       ErrorAndExit("unable to read input: '" + EC.message() + "'");
  915       ErrorAndExit("unable to create object file: '" + Buf + "'");
  965   ExitOnErr.setBanner(std::string(argv[0]) + ": ");

  408        << (VA.SymbolName.size() > 40 ? VA.SymbolName.substr(0, 40) + "..."

  466                     FuncId.size() > 60 ? FuncId.substr(0, 57) + "..." : FuncId,
  475                   LeafFuncId.size() > 60 ? LeafFuncId.substr(0, 57) + "..."

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

  301   return ("Condition in BB '" + BB->getName()).str() +
  332   return ("Non affine branch in BB '" + BB->getName()).str() +
  333          "' with LHS: " + *LHS + " and RHS: " + *RHS;
  415   return "The array \"" + Name +
  442   return "The array subscript of \"" + Name + "\" is not affine";
  457   return "Non affine loop bound '" + *LoopCount +

  150       Location = escapeString(FileName + ":" + std::to_string(LineBegin) + "-" +
  151                               std::to_string(LineEnd) + "\n");

 2094   std::string Msg = toString(Kind) + Suffix + Set.to_str();

  164     str += " : " + ReductionClause.second.substr(2) + ")";

 1601         "F: " + F->getName().str() + " R: " + S.getRegion().getNameStr() +
 1601         "F: " + F->getName().str() + " R: " + S.getRegion().getNameStr() +

   42               std::to_string(Dst) + "i" + std::to_string(DstBits) + ".p" +
   42               std::to_string(Dst) + "i" + std::to_string(DstBits) + ".p" +
   43               std::to_string(Src) + "i" + std::to_string(SrcBits);

   84   std::string FileName = FunctionName + "___" + S.getNameStr() + ".jscop";
  136     Location = FileName + ":" + std::to_string(LineBegin) + "-" +

  196       emitRemark(SAI->getName() + " read from its original value.",
  204     emitRemark(SAI->getName() + " is a ExitPhi node.",
  225           emitRemark(SAI->getName() + " has read after write to the same "
  241         emitRemark(SAI->getName() + " has a maywrite access.",
  251           emitRemark(SAI->getName() + " has more than 1 write access.",
  271           emitRemark("The expansion of " + SAI->getName() +
  282           emitRemark(SAI->getName() +
  292           emitRemark("The expansion of " + SAI->getName() +
  305     emitRemark(SAI->getName() + " has 0 write access.",
  370       MA->getScopArrayInfo()->getName() + "_" + CurrentStmtName + "_expanded";
  370       MA->getScopArrayInfo()->getName() + "_" + CurrentStmtName + "_expanded";

  335                           (utostr(Loc.Line) + ":" + utostr(Loc.Column)));

   56     ErrHandler("failed to open '" + OutputFilename + "': " + EC.message());

 1585         "  %canonical.iv = phi " + ARBitWidthTypeStr +
 1588         "  %canonical.iv.inc = add " + ARBitWidthTypeStr +
 1855         "  %canonical.iv = phi " + ARBitWidthTypeStr +
 1858         "  %canonical.iv.inc = add " + ARBitWidthTypeStr +

  940   auto M = parseModule(std::string("@test = global ") + GetParam().second);

  237   SCOPED_TRACE("Checking Version " + std::to_string(Version) + ", Format " +
  237   SCOPED_TRACE("Checking Version " + std::to_string(Version) + ", Format " +
  366   SCOPED_TRACE("Checking Version " + std::to_string(Version) + ", Format " +
  366   SCOPED_TRACE("Checking Version " + std::to_string(Version) + ", Format " +
  390   SCOPED_TRACE("Checking Version " + std::to_string(Version) + ", Format " +
  390   SCOPED_TRACE("Checking Version " + std::to_string(Version) + ", Format " +

  864   std::string SelfFileRef = std::string("@") + SelfFilePath.c_str();
  868   std::string NestedFileRef = std::string("@") + NestedFilePath.c_str();
  872   std::string FlagFileRef = std::string("@") + FlagFilePath.c_str();
  941   std::string ResponseFileRef = std::string("@") + ResponseFilePath.c_str();

   41   const std::string TempUniqTestFileModel = FinalTestfilePath.str().str() + "-%%%%%%%%";

  669     std::string arm_2 = "arm" + (std::string)(Arch[i]) + "eb";
  672     std::string thumb_2 = "thumb" + (std::string)(Arch[i]) + "eb";

   49     + InputIRSnippet.str() +

 1121         Res += "_" + utostr((unsigned) *it) + "_";
 1394       CI->RenderMethod = "add" + CI->ClassName + "Operands";
 1424       CI->DefaultMethod = "default" + CI->ClassName + "Operands";
 1944   std::string TargetOperandClass = Target.getName().str() + "Operand";
 2582       Matches.emplace_back(CI.ValueName, "return " + CI.Name + ";");
 2605                          "return " + utostr(Reg.EnumValue) + ";");
 2637                            "return " + utostr(Reg.EnumValue) + ";");
 2771       MatchCode += "if (" + FeatureMask + ")\n";

  139       OpsToPrint.push_back(std::make_pair(FirstInst.CGI->Namespace.str() + "::" +
  144         OpsToPrint.push_back(std::make_pair(AWI.CGI->Namespace.str()+"::" +
  175     std::string Command = "    "+Inst.Operands[0].getCode(PassSubtarget)+"\n";
  225         FirstInst.Operands[Op].getCode(PassSubtarget) + "\n";
  241       UniqueOperandCommands[i] = "    // " + Instrs + "\n" +
  861         std::string Op = "MI->getOperand(" + utostr(MIOpNum) + ")";
  895               Cond = std::string("MRI.getRegClass(") + Target.getName().str() +
  896                      "::" + R->getName().str() + "RegClassID).contains(" + Op +
  896                      "::" + R->getName().str() + "RegClassID).contains(" + Op +
  900                      utostr(IAP.getOpIndex(ROName)) + ").getReg()";
  942           Cond = Op + ".getReg() == " + Target.getName().str() + "::" +

   31       return "O << '" + Str + "';";
   32     return "O << \"" + Str + "\";";

  148       Case += "      // op: " + VarName + "\n";
  150         Case += "      " + EncoderMethodName + "(MI, " + utostr(OpIdx);
  153         Case += "      op = " + EncoderMethodName + "(MI, " + utostr(OpIdx);
  158     Case += "      // op: " + VarName + "\n";
  160       Case += "      getMachineOpValue(MI, MI.getOperand(" + utostr(OpIdx) + ")";
  163       Case += "      op = getMachineOpValue(MI, MI.getOperand(" + utostr(OpIdx) + ")";
  226         extractStr = "op.extractBits(" + itostr(hiBit - loBit) + ", " +
  227                      itostr(loBit) + ")";
  228         Case += "      Value.insertBits(" + extractStr + ", " +
  229                 itostr(loInstBit) + ");\n";
  231         extractStr = "op.extractBitsAsZExtValue(" + itostr(hiBit - loBit) +
  232                      ", " + itostr(loBit) + ")";
  233         Case += "      Value.insertBits(" + extractStr + ", " +
  234                 itostr(loInstBit) + ", " + itostr(hiBit - loBit) + ");\n";
  234                 itostr(loInstBit) + ", " + itostr(hiBit - loBit) + ");\n";
  240       maskStr = "UINT64_C(" + utostr(opMask) + ")";
  244         Case += "      op &= " + maskStr + ";\n";
  246           Case += "      op <<= " + itostr(opShift) + ";\n";
  248           Case += "      op >>= " + itostr(-opShift) + ";\n";
  253           Case += "      Value |= (op & " + maskStr + ") << " +
  254                   itostr(opShift) + ";\n";
  256           Case += "      Value |= (op & " + maskStr + ") >> " +
  257                   itostr(-opShift) + ";\n";
  259           Case += "      Value |= (op & " + maskStr + ");\n";
  276         Case += "      case " + itostr(KV.first) + ": {\n";

 1318     Result = "    auto *N = cast<" + ClassName.str() + ">(Node);\n";
 2393       TP.error("Intrinsic '" + Int->Name + "' expects " + Twine(NumParamVTs) +
 2936           error("Node '" + std::string(Entry.getKey()) +
 3052     PrintFatalError("Error getting SDNode '" + Name + "'!");
 3254       I.error("Input $" + Pat->getName() + " must be an identifier!");
 3279     I.error("All $" + Pat->getName() + " inputs must agree with each other");
 3284     I.error("All $" + Pat->getName() + " inputs must agree with each other");
 3381         I.error("cannot set '" + Dest->getName() + "' multiple times");
 3664       I.error("'" + OpName + "' set but does not appear in operand list!");
 3672       I.error("Operand $" + OpName + " does not exist in operand list!");
 3678       I.error("Operand $" + OpName + " should be a set destination: all "
 3682       I.error("Operand $" + OpName + " class mismatch!");
 3712       I.error("Operand $" + OpName +
 3721         I.error("Operand $" + OpName + "'s register class disagrees"
 3745     I.error("Input operand $" + InstInputs.begin()->first +
 3850       PatternTop->error("repetition of value: $" + P->getName() +

 1077         ? std::string("MF->getSubtarget().checkFeatures(\"" + Features + "\")")

  247         Rec->getLoc(), "Operand '" + Name + "' of '" + Rec->getName() +
  258       Rec->getLoc(), "Unrecognized constraint '" + CStr +
  274       Rec->getLoc(), "Illegal format for tied-to constraint: '" + CStr + "'");
  290       Rec->getLoc(), "Input operands '" + LHSOpName + "' and '" + RHSOpName +
  290       Rec->getLoc(), "Input operands '" + LHSOpName + "' and '" + RHSOpName +
  294       Rec->getLoc(), "Output operands '" + LHSOpName + "' and '" + RHSOpName +
  294       Rec->getLoc(), "Output operands '" + LHSOpName + "' and '" + RHSOpName +
  741             Result->getArgName(AliasOpNo)->getAsUnquotedString() + "." +

  248                         RowField->getAsString() + " found in \"" +

  282       PrintFatalError(TheDef->getLoc(), "SubRegIndex " + Idx->getName() +
  665                             Name + "'.");
 2275                                           SubIdx.getName() + "_in_" +

  352               "Opcode " + Opcode->getName().str() +
  810                       "defined for processor " + ProcModel.ModelName +
 1477                         PM.ModelName +
 1965         PrintError(Inst->TheDef->getLoc(), "'" + ProcModel.ModelName +

  622                     "Intrinsic '" + DefName + "' does not start with 'int_'!");
  644       PrintFatalError(DefLoc, "Intrinsic '" + DefName +
  654       PrintFatalError(DefLoc, "Intrinsic '" + DefName +
  656                                   TargetPrefix + ".'!");
  704       PrintFatalError(DefLoc, "Intrinsic '" + DefName +
  740       PrintFatalError(DefLoc, "Intrinsic '" + DefName +

  125                        CGP.getTargetInfo().getName().str() + " target", OS);

  380     AddMatcher(new RecordMatcher("'" + N->getOperator()->getName().str() +
  444     AddMatcher(new RecordMatcher("'" + N->getOperator()->getName().str() +
  710       std::string Value = getQualifiedName(Def) + "RegClassID";
  959   AddMatcher(new EmitNodeMatcher(II.Namespace.str()+"::"+II.TheDef->getName().str(),

  283   CustomDfaEmitter Emitter(Actions, std::string(Name) + "Action");

  107   emitSourceFileHeader(" * " + Target.getName().str() + " Disassembler", OS);

  655                         "name:" + Memo.Name + "  predicate: " + PredicateCheck);
  657       OS << "  if (" + PredicateCheck + ") {\n";
  883                        Target.getName().str() + " target", OS);

 1785     Decoder = "Decode" + Record->getName().str() + "RegisterClass";
 1955         Decoder = "Decode" + TypeRecord->getName().str() + "RegisterClass";

  182     PrintNote("Pattern was `" + Matchers->getArg(I)->getAsString() + "'");

   88   return "GIPFP_" + Predicate.getImmTypeIdentifier().str() + "_" +
   94   return "GIM_Check" + Predicate.getImmTypeIdentifier().str() + "ImmPredicate";
  360     Explanation = Separator + "Has a predicate (" + explainPredicates(N) + ")";
 1321           << MatchTable::NamedValue(RC.getQualifiedName() + "RegClassID")
 1518     return "State.MIs[" + llvm::to_string(InsnVarID) + "]->getOperand(" +
 1519            llvm::to_string(OpIdx) + ")";
 2246           << MatchTable::Comment("MIs[" + llvm::to_string(NewInsnVarID) + "]")
 3499       return failedImport(toString(std::move(Error)) +
 3656                         explainPredicates(Src) + ")");
 3824     return failedImport(toString(std::move(Error)) + " for Src operand (" +
 3825                         to_string(*SrcChild) + ")");
 3950       return failedImport("SDNodeXForm " + Child->getName() +
 4341     return failedImport("Expected " + llvm::to_string(DstINumUses) +
 4343                         llvm::to_string(ExpectedDstINumUses) +
 4344                         " explicit ones and " + llvm::to_string(NumDefaultOps) +
 4545                         toString(std::move(Err)) + ")");
 4548                         toString(std::move(Err)) + ")");
 4620                         to_string(Src->getExtTypes().size()) + " def(s) vs " +
 4621                         to_string(DstI.Operands.NumDefs) + " def(s))");

  143         Res += getQualifiedName(OpR) + "RegClassID, ";
  145         Res += utostr(OpR->getValueAsInt("RegClassKind")) + ", ";
  183         Res += "((" + utostr(Constraint.getTiedOperand()) +
  241     OperandMap[OpList].push_back(Namespace.str() + "::" +

  139          ("Register" + Reg->getName().str() + " not defined!!\n").c_str());
  205                           "Error in Dag '" + Dag->getAsString() +
  219                         "Error in Dag '" + Dag->getAsString() + "'. Operand '" +
  232             ("Error in Dag '" + Dag->getAsString() + "' Found immediate: '" +
  233              II->getAsString() +
  501                       Rec->getName().str() + "'");
  609         CaseStream.indent(6) << "break;\n    } // case " + PrevOp + "\n";
  610       CaseStream.indent(4) << "case " + Namespace + "::" + CurOp + ": {\n";
  610       CaseStream.indent(4) << "case " + Namespace + "::" + CurOp + ": {\n";
  628         CondStream.indent(6) << ("!STI.getFeatureBits()[" + Namespace +
  630                                         .str() +
  634             << ("STI.getFeatureBits()[" + Namespace + "::" + Op + "]").str() +
  634             << ("STI.getFeatureBits()[" + Namespace + "::" + Op + "]").str() +
  645               << std::to_string(OpNo) + ").getReg() ==  MI.getOperand("
  658             << "(MI.getOperand(" + std::to_string(OpNo) + ").isImm()) &&\n" +
  658             << "(MI.getOperand(" + std::to_string(OpNo) + ").isImm()) &&\n" +
  659                    "      (MI.getOperand(" + std::to_string(OpNo) +
  661                    std::to_string(SourceOperandMap[OpNo].Data.Imm) + ") &&\n";
  665         CondStream.indent(6) << "(MI.getOperand(" + std::to_string(OpNo) +
  666                                     ").getReg() == " + Namespace +
  667                                     "::" + Reg->getName().str() + ") &&\n";
  672     CodeStream.indent(6) << "// " + Dest.AsmString + "\n";
  673     CodeStream.indent(6) << "OutInst.setOpcode(" + Namespace +
  674                                 "::" + Dest.TheDef->getName().str() + ");\n";
  677       CodeStream.indent(6) << "// Operand: " + DestOperand.Name + "\n";
  690                 << "(MRI.getRegClass(" + Namespace +
  691                        "::" + DestOperand.Rec->getName().str() +
  692                        "RegClassID).contains(" + "MI.getOperand(" +
  693                        std::to_string(OpIdx) + ").getReg())) &&\n";
  696                                       std::to_string(OpIdx) + "));\n";
  701           CondStream.indent(6) << Namespace + "ValidateMCOperand(" +
  702                                       "MI.getOperand(" + std::to_string(OpIdx) +
  703                                       "), STI, " + std::to_string(Entry) +
  706                                       std::to_string(OpIdx) + "));\n";
  714             << Namespace + "ValidateMCOperand(" + "MCOperand::createImm(" +
  715                    std::to_string(DestOperandMap[OpNo].Data.Imm) + "), STI, " +
  716                    std::to_string(Entry) + ") &&\n";
  719                    std::to_string(DestOperandMap[OpNo].Data.Imm) + "));\n";
  725                                     Namespace + "::" + Reg->getName().str() +
  725                                     Namespace + "::" + Reg->getName().str() +
  736   Func.indent(4) << "} // case " + CurOp + "\n";

  190                                TmpKind + " " + RC->getName() + " subclass",

 1080        << RC.getQualifiedName() + "RegClassID" << ", "
 1381            << "MCRegisterClasses[" << RC.getQualifiedName() + "RegClassID];\n"
 1448   std::string ClassName = Target.getName().str() + "GenRegisterInfo";

  309     ItinString += "  { " + itostr(Cycles) + ", ";
  419   std::string StageTable = "\nextern const llvm::InstrStage " + Target +
  424   std::string OperandCycleTable = "extern const unsigned " + Target +
  429   std::string BypassTable = "extern const unsigned " + Target +
  510           BypassTable += ItinBypassString + ", // " + OperandIdxComment + "\n";
  849                     "defined for processor " + ProcModel.ModelName +
  901                     "defined for processor " + ProcModel.ModelName +

   45     return "Feature_" + TheDef->getName().str() + "Bit";

  181   return ParseInt32(std::string("The value of flag --") + flag, value_str,
  193   return ParseDouble(std::string("The value of flag --") + flag, value_str,

 1264         string("ON_CALL(") + obj + ", " + call + ") invoked");
 1264         string("ON_CALL(") + obj + ", " + call + ") invoked");
 1264         string("ON_CALL(") + obj + ", " + call + ") invoked");
 1264         string("ON_CALL(") + obj + ", " + call + ") invoked");
 1272     const string source_text(string("EXPECT_CALL(") + obj + ", " + call + ")");
 1272     const string source_text(string("EXPECT_CALL(") + obj + ", " + call + ")");
 1272     const string source_text(string("EXPECT_CALL(") + obj + ", " + call + ")");
 1272     const string source_text(string("EXPECT_CALL(") + obj + ", " + call + ")");

  133   return negation ? "not (" + result + ")" : result;

   65   const std::string flag_str = std::string("--gmock_") + flag;

  159     *os << ("<" + pretty_str + ">");

  640         (std::string(prefix) + (prefix[0] == '\0' ? "" : "/") + case_name + "/"
  640         (std::string(prefix) + (prefix[0] == '\0' ? "" : "/") + case_name + "/"
  640         (std::string(prefix) + (prefix[0] == '\0' ? "" : "/") + case_name + "/"

  385   ~DeathTestImpl() { GTEST_DEATH_TEST_CHECK_(read_fd_ == -1); }
  840   GTEST_DEATH_TEST_CHECK_(pipe(pipe_fd) != -1);
  854   GTEST_DEATH_TEST_CHECK_(child_pid != -1);
  971     DeathTestAbort(std::string("chdir(\"") + original_dir + "\") failed: " +
  971     DeathTestAbort(std::string("chdir(\"") + original_dir + "\") failed: " +
  982   DeathTestAbort(std::string("execve(") + args->argv[0] + ", ...) in " +
  982   DeathTestAbort(std::string("execve(") + args->argv[0] + ", ...) in " +
  982   DeathTestAbort(std::string("execve(") + args->argv[0] + ", ...) in " +
  983                  original_dir + " failed: " +
 1077     GTEST_DEATH_TEST_CHECK_(stack != MAP_FAILED);
 1089     GTEST_DEATH_TEST_CHECK_(stack_size > kMaxStackAlignment &&
 1094     GTEST_DEATH_TEST_CHECK_(munmap(stack, stack_size) != -1);
 1110   GTEST_DEATH_TEST_CHECK_(child_pid != -1);
 1131   GTEST_DEATH_TEST_CHECK_(pipe(pipe_fd) != -1);
 1134   GTEST_DEATH_TEST_CHECK_(fcntl(pipe_fd[1], F_SETFD, 0) != -1);
 1137       std::string("--") + GTEST_FLAG_PREFIX_ + kFilterFlag + "="
 1137       std::string("--") + GTEST_FLAG_PREFIX_ + kFilterFlag + "="
 1137       std::string("--") + GTEST_FLAG_PREFIX_ + kFilterFlag + "="
 1138       + info->test_case_name() + "." + info->name();
 1138       + info->test_case_name() + "." + info->name();
 1138       + info->test_case_name() + "." + info->name();
 1140       std::string("--") + GTEST_FLAG_PREFIX_ + kInternalRunDeathTestFlag + "="
 1140       std::string("--") + GTEST_FLAG_PREFIX_ + kInternalRunDeathTestFlag + "="
 1140       std::string("--") + GTEST_FLAG_PREFIX_ + kInternalRunDeathTestFlag + "="
 1141       + file_ + "|" + StreamableToString(line_) + "|"
 1141       + file_ + "|" + StreamableToString(line_) + "|"
 1141       + file_ + "|" + StreamableToString(line_) + "|"
 1142       + StreamableToString(death_test_index) + "|"
 1184           + ") somehow exceeded expected maximum ("
 1185           + StreamableToString(flag->index()) + ")");
 1216         + "\" encountered");

  125   const std::string dot_extension = std::string(".") + extension;
  189     file = base_name.string() + "." + extension;
  192         + "." + extension;
  192         + "." + extension;

 1129            FormatBool(unit_test.Passed()) + "&elapsed_time=" +
 1130            StreamableToString(unit_test.elapsed_time()) + "ms");
 1134     SendLn(std::string("event=TestCaseStart&name=") + test_case.name());
 1139            + "&elapsed_time=" + StreamableToString(test_case.elapsed_time())
 1140            + "ms");
 1144     SendLn(std::string("event=TestStart&name=") + test_info.name());
 1149            FormatBool((test_info.result())->Passed()) +
 1151            StreamableToString((test_info.result())->elapsed_time()) + "ms");
 1158     SendLn("event=TestPartResult&file=" + UrlEncode(file_name) +
 1159            "&line=" + StreamableToString(test_part_result.line_number()) +

  889   return file_name + ":" + StreamableToString(line) + ":";
 1252       return std::string("xml:") + value;

  504   const std::string& full_name = test_case_name + "." + test_name.c_str();
 1761     return "(Invalid Unicode 0x" + String::FormatHexInt(code_point) + ")";
 2812   return internal::StreamableToString(count) + " " +
 2812   return internal::StreamableToString(count) + " " +
 3579   return StreamableToString(time_struct.tm_year + 1900) + "-" +
 3580       String::FormatIntWidth2(time_struct.tm_mon + 1) + "-" +
 3581       String::FormatIntWidth2(time_struct.tm_mday) + "T" +
 3582       String::FormatIntWidth2(time_struct.tm_hour) + ":" +
 3583       String::FormatIntWidth2(time_struct.tm_min) + ":" +
 3658       const string summary = location + "\n" + part.summary();
 3662       const string detail = location + "\n" + part.message();
 5022   const std::string flag_str = std::string("--") + GTEST_FLAG_PREFIX_ + flag;
 5022   const std::string flag_str = std::string("--") + GTEST_FLAG_PREFIX_ + flag;