[llvm] [NFC][LLVM] Use formatv automatic index assignment in PassBuilder (PR #141286)
Rahul Joshi via llvm-commits
llvm-commits at lists.llvm.org
Fri May 23 12:38:21 PDT 2025
https://github.com/jurahul updated https://github.com/llvm/llvm-project/pull/141286
>From 56c13e6fa3ac01a9a03d6d028af8101d853b492d Mon Sep 17 00:00:00 2001
From: Rahul Joshi <rjoshi at nvidia.com>
Date: Fri, 23 May 2025 12:35:56 -0700
Subject: [PATCH] [NFC][LLVM] Use formatv automatic index assignment in
PassBuilder
---
llvm/lib/Passes/PassBuilder.cpp | 149 +++++++++++++++-----------------
1 file changed, 71 insertions(+), 78 deletions(-)
diff --git a/llvm/lib/Passes/PassBuilder.cpp b/llvm/lib/Passes/PassBuilder.cpp
index 49b49e288baa7..697e25846981e 100644
--- a/llvm/lib/Passes/PassBuilder.cpp
+++ b/llvm/lib/Passes/PassBuilder.cpp
@@ -641,8 +641,7 @@ Expected<bool> PassBuilder::parseSinglePassOption(StringRef Params,
Result = true;
} else {
return make_error<StringError>(
- formatv("invalid {1} pass parameter '{0}' ", ParamName, PassName)
- .str(),
+ formatv("invalid {} pass parameter '{}'", PassName, ParamName).str(),
inconvertibleErrorCode());
}
}
@@ -662,7 +661,7 @@ Expected<HardwareLoopOptions> parseHardwareLoopOptions(StringRef Params) {
int Count;
if (ParamName.getAsInteger(0, Count))
return make_error<StringError>(
- formatv("invalid HardwareLoopPass parameter '{0}' ", ParamName).str(),
+ formatv("invalid HardwareLoopPass parameter '{}'", ParamName).str(),
inconvertibleErrorCode());
HardwareLoopOpts.setDecrement(Count);
continue;
@@ -671,7 +670,7 @@ Expected<HardwareLoopOptions> parseHardwareLoopOptions(StringRef Params) {
int Count;
if (ParamName.getAsInteger(0, Count))
return make_error<StringError>(
- formatv("invalid HardwareLoopPass parameter '{0}' ", ParamName).str(),
+ formatv("invalid HardwareLoopPass parameter '{}'", ParamName).str(),
inconvertibleErrorCode());
HardwareLoopOpts.setCounterBitwidth(Count);
continue;
@@ -686,7 +685,7 @@ Expected<HardwareLoopOptions> parseHardwareLoopOptions(StringRef Params) {
HardwareLoopOpts.setForceGuard(true);
} else {
return make_error<StringError>(
- formatv("invalid HardwarePass parameter '{0}' ", ParamName).str(),
+ formatv("invalid HardwarePass parameter '{}'", ParamName).str(),
inconvertibleErrorCode());
}
}
@@ -715,7 +714,7 @@ Expected<LoopUnrollOptions> parseLoopUnrollOptions(StringRef Params) {
int Count;
if (ParamName.getAsInteger(0, Count))
return make_error<StringError>(
- formatv("invalid LoopUnrollPass parameter '{0}' ", ParamName).str(),
+ formatv("invalid LoopUnrollPass parameter '{}'", ParamName).str(),
inconvertibleErrorCode());
UnrollOpts.setFullUnrollMaxCount(Count);
continue;
@@ -734,7 +733,7 @@ Expected<LoopUnrollOptions> parseLoopUnrollOptions(StringRef Params) {
UnrollOpts.setUpperBound(Enable);
} else {
return make_error<StringError>(
- formatv("invalid LoopUnrollPass parameter '{0}' ", ParamName).str(),
+ formatv("invalid LoopUnrollPass parameter '{}'", ParamName).str(),
inconvertibleErrorCode());
}
}
@@ -773,7 +772,7 @@ Expected<CFGuardPass::Mechanism> parseCFGuardPassOptions(StringRef Params) {
auto [Param, RHS] = Params.split(';');
if (!RHS.empty())
return make_error<StringError>(
- formatv("too many CFGuardPass parameters '{0}' ", Params).str(),
+ formatv("too many CFGuardPass parameters '{}'", Params).str(),
inconvertibleErrorCode());
if (Param == "check")
@@ -782,7 +781,7 @@ Expected<CFGuardPass::Mechanism> parseCFGuardPassOptions(StringRef Params) {
return CFGuardPass::Mechanism::Dispatch;
return make_error<StringError>(
- formatv("invalid CFGuardPass mechanism: '{0}' ", Param).str(),
+ formatv("invalid CFGuardPass mechanism: '{}'", Param).str(),
inconvertibleErrorCode());
}
@@ -821,7 +820,7 @@ Expected<IRNormalizerOptions> parseIRNormalizerPassOptions(StringRef Params) {
Result.ReorderOperands = Enable;
else {
return make_error<StringError>(
- formatv("invalid normalize pass parameter '{0}' ", ParamName).str(),
+ formatv("invalid normalize pass parameter '{}'", ParamName).str(),
inconvertibleErrorCode());
}
}
@@ -841,7 +840,7 @@ Expected<AddressSanitizerOptions> parseASanPassOptions(StringRef Params) {
Result.UseAfterScope = true;
} else {
return make_error<StringError>(
- formatv("invalid AddressSanitizer pass parameter '{0}' ", ParamName)
+ formatv("invalid AddressSanitizer pass parameter '{}'", ParamName)
.str(),
inconvertibleErrorCode());
}
@@ -861,7 +860,7 @@ Expected<HWAddressSanitizerOptions> parseHWASanPassOptions(StringRef Params) {
Result.CompileKernel = true;
} else {
return make_error<StringError>(
- formatv("invalid HWAddressSanitizer pass parameter '{0}' ", ParamName)
+ formatv("invalid HWAddressSanitizer pass parameter '{}'", ParamName)
.str(),
inconvertibleErrorCode());
}
@@ -881,8 +880,7 @@ Expected<EmbedBitcodeOptions> parseEmbedBitcodePassOptions(StringRef Params) {
Result.EmitLTOSummary = true;
} else {
return make_error<StringError>(
- formatv("invalid EmbedBitcode pass parameter '{0}' ", ParamName)
- .str(),
+ formatv("invalid EmbedBitcode pass parameter '{}'", ParamName).str(),
inconvertibleErrorCode());
}
}
@@ -912,16 +910,14 @@ parseLowerAllowCheckPassOptions(StringRef Params) {
int cutoff;
if (CutoffStr.getAsInteger(0, cutoff))
return make_error<StringError>(
- formatv("invalid LowerAllowCheck pass cutoffs parameter '{0}' "
- "({1})",
+ formatv("invalid LowerAllowCheck pass cutoffs parameter '{}' ({})",
CutoffStr, Params)
.str(),
inconvertibleErrorCode());
if (!IndicesStr.consume_front("cutoffs[") || IndicesStr == "")
return make_error<StringError>(
- formatv("invalid LowerAllowCheck pass index parameter '{0}' "
- "({1})",
+ formatv("invalid LowerAllowCheck pass index parameter '{}' ({})",
IndicesStr, CutoffStr)
.str(),
inconvertibleErrorCode());
@@ -933,9 +929,9 @@ parseLowerAllowCheckPassOptions(StringRef Params) {
unsigned int index;
if (firstIndexStr.getAsInteger(0, index))
return make_error<StringError>(
- formatv("invalid LowerAllowCheck pass index parameter '{0}' "
- "({1}) {2}",
- firstIndexStr, IndicesStr)
+ formatv(
+ "invalid LowerAllowCheck pass index parameter '{}' ({}) {}",
+ firstIndexStr, IndicesStr)
.str(),
inconvertibleErrorCode());
@@ -949,7 +945,7 @@ parseLowerAllowCheckPassOptions(StringRef Params) {
}
} else {
return make_error<StringError>(
- formatv("invalid LowerAllowCheck pass parameter '{0}' ", ParamName)
+ formatv("invalid LowerAllowCheck pass parameter '{}'", ParamName)
.str(),
inconvertibleErrorCode());
}
@@ -972,7 +968,7 @@ Expected<MemorySanitizerOptions> parseMSanPassOptions(StringRef Params) {
if (ParamName.getAsInteger(0, Result.TrackOrigins))
return make_error<StringError>(
formatv("invalid argument to MemorySanitizer pass track-origins "
- "parameter: '{0}' ",
+ "parameter: '{}'",
ParamName)
.str(),
inconvertibleErrorCode());
@@ -980,7 +976,7 @@ Expected<MemorySanitizerOptions> parseMSanPassOptions(StringRef Params) {
Result.EagerChecks = true;
} else {
return make_error<StringError>(
- formatv("invalid MemorySanitizer pass parameter '{0}' ", ParamName)
+ formatv("invalid MemorySanitizer pass parameter '{}'", ParamName)
.str(),
inconvertibleErrorCode());
}
@@ -1021,13 +1017,14 @@ Expected<SimplifyCFGOptions> parseSimplifyCFGOptions(StringRef Params) {
if (ParamName.getAsInteger(0, BonusInstThreshold))
return make_error<StringError>(
formatv("invalid argument to SimplifyCFG pass bonus-threshold "
- "parameter: '{0}' ",
- ParamName).str(),
+ "parameter: '{}'",
+ ParamName)
+ .str(),
inconvertibleErrorCode());
Result.bonusInstThreshold(BonusInstThreshold.getSExtValue());
} else {
return make_error<StringError>(
- formatv("invalid SimplifyCFG pass parameter '{0}' ", ParamName).str(),
+ formatv("invalid SimplifyCFG pass parameter '{}'", ParamName).str(),
inconvertibleErrorCode());
}
}
@@ -1051,13 +1048,14 @@ Expected<InstCombineOptions> parseInstCombineOptions(StringRef Params) {
if (ParamName.getAsInteger(0, MaxIterations))
return make_error<StringError>(
formatv("invalid argument to InstCombine pass max-iterations "
- "parameter: '{0}' ",
- ParamName).str(),
+ "parameter: '{}'",
+ ParamName)
+ .str(),
inconvertibleErrorCode());
Result.setMaxIterations((unsigned)MaxIterations.getZExtValue());
} else {
return make_error<StringError>(
- formatv("invalid InstCombine pass parameter '{0}' ", ParamName).str(),
+ formatv("invalid InstCombine pass parameter '{}'", ParamName).str(),
inconvertibleErrorCode());
}
}
@@ -1078,7 +1076,7 @@ Expected<LoopVectorizeOptions> parseLoopVectorizeOptions(StringRef Params) {
Opts.setVectorizeOnlyWhenForced(Enable);
} else {
return make_error<StringError>(
- formatv("invalid LoopVectorize parameter '{0}' ", ParamName).str(),
+ formatv("invalid LoopVectorize parameter '{}'", ParamName).str(),
inconvertibleErrorCode());
}
}
@@ -1098,8 +1096,7 @@ Expected<std::pair<bool, bool>> parseLoopUnswitchOptions(StringRef Params) {
Result.second = Enable;
} else {
return make_error<StringError>(
- formatv("invalid LoopUnswitch pass parameter '{0}' ", ParamName)
- .str(),
+ formatv("invalid LoopUnswitch pass parameter '{}'", ParamName).str(),
inconvertibleErrorCode());
}
}
@@ -1117,7 +1114,7 @@ Expected<LICMOptions> parseLICMOptions(StringRef Params) {
Result.AllowSpeculation = Enable;
} else {
return make_error<StringError>(
- formatv("invalid LICM pass parameter '{0}' ", ParamName).str(),
+ formatv("invalid LICM pass parameter '{}'", ParamName).str(),
inconvertibleErrorCode());
}
}
@@ -1137,7 +1134,7 @@ Expected<std::pair<bool, bool>> parseLoopRotateOptions(StringRef Params) {
Result.second = Enable;
} else {
return make_error<StringError>(
- formatv("invalid LoopRotate pass parameter '{0}' ", ParamName).str(),
+ formatv("invalid LoopRotate pass parameter '{}'", ParamName).str(),
inconvertibleErrorCode());
}
}
@@ -1155,7 +1152,7 @@ Expected<bool> parseMergedLoadStoreMotionOptions(StringRef Params) {
Result = Enable;
} else {
return make_error<StringError>(
- formatv("invalid MergedLoadStoreMotion pass parameter '{0}' ",
+ formatv("invalid MergedLoadStoreMotion pass parameter '{}'",
ParamName)
.str(),
inconvertibleErrorCode());
@@ -1183,7 +1180,7 @@ Expected<GVNOptions> parseGVNOptions(StringRef Params) {
Result.setMemorySSA(Enable);
} else {
return make_error<StringError>(
- formatv("invalid GVN pass parameter '{0}' ", ParamName).str(),
+ formatv("invalid GVN pass parameter '{}'", ParamName).str(),
inconvertibleErrorCode());
}
}
@@ -1201,7 +1198,7 @@ Expected<IPSCCPOptions> parseIPSCCPOptions(StringRef Params) {
Result.setFuncSpec(Enable);
else
return make_error<StringError>(
- formatv("invalid IPSCCP pass parameter '{0}' ", ParamName).str(),
+ formatv("invalid IPSCCP pass parameter '{}'", ParamName).str(),
inconvertibleErrorCode());
}
return Result;
@@ -1217,7 +1214,7 @@ Expected<ScalarizerPassOptions> parseScalarizerOptions(StringRef Params) {
if (ParamName.getAsInteger(0, Result.ScalarizeMinBits)) {
return make_error<StringError>(
formatv("invalid argument to Scalarizer pass min-bits "
- "parameter: '{0}' ",
+ "parameter: '{}'",
ParamName)
.str(),
inconvertibleErrorCode());
@@ -1233,7 +1230,7 @@ Expected<ScalarizerPassOptions> parseScalarizerOptions(StringRef Params) {
Result.ScalarizeVariableInsertExtract = Enable;
else {
return make_error<StringError>(
- formatv("invalid Scalarizer pass parameter '{0}' ", ParamName).str(),
+ formatv("invalid Scalarizer pass parameter '{}'", ParamName).str(),
inconvertibleErrorCode());
}
}
@@ -1247,7 +1244,7 @@ Expected<SROAOptions> parseSROAOptions(StringRef Params) {
if (Params == "preserve-cfg")
return SROAOptions::PreserveCFG;
return make_error<StringError>(
- formatv("invalid SROA pass parameter '{0}' (either preserve-cfg or "
+ formatv("invalid SROA pass parameter '{}' (either preserve-cfg or "
"modify-cfg can be specified)",
Params)
.str(),
@@ -1267,7 +1264,7 @@ parseStackLifetimeOptions(StringRef Params) {
Result = StackLifetime::LivenessType::Must;
} else {
return make_error<StringError>(
- formatv("invalid StackLifetime parameter '{0}' ", ParamName).str(),
+ formatv("invalid StackLifetime parameter '{}'", ParamName).str(),
inconvertibleErrorCode());
}
}
@@ -1294,8 +1291,7 @@ parseFunctionSimplificationPipelineOptions(StringRef Params) {
std::optional<OptimizationLevel> L = parseOptLevel(Params);
if (!L || *L == OptimizationLevel::O0) {
return make_error<StringError>(
- formatv("invalid function-simplification parameter '{0}' ", Params)
- .str(),
+ formatv("invalid function-simplification parameter '{}'", Params).str(),
inconvertibleErrorCode());
};
return *L;
@@ -1321,7 +1317,7 @@ Expected<std::string> parseMemProfUsePassOptions(StringRef Params) {
Result = ParamName.str();
} else {
return make_error<StringError>(
- formatv("invalid MemProfUse pass parameter '{0}' ", ParamName).str(),
+ formatv("invalid MemProfUse pass parameter '{}'", ParamName).str(),
inconvertibleErrorCode());
}
}
@@ -1337,7 +1333,7 @@ parseStructuralHashPrinterPassOptions(StringRef Params) {
if (Params == "call-target-ignored")
return StructuralHashOptions::CallTargetIgnored;
return make_error<StringError>(
- formatv("invalid structural hash printer parameter '{0}' ", Params).str(),
+ formatv("invalid structural hash printer parameter '{}'", Params).str(),
inconvertibleErrorCode());
}
@@ -1366,12 +1362,11 @@ Expected<GlobalMergeOptions> parseGlobalMergeOptions(StringRef Params) {
else if (ParamName.consume_front("max-offset=")) {
if (ParamName.getAsInteger(0, Result.MaxOffset))
return make_error<StringError>(
- formatv("invalid GlobalMergePass parameter '{0}' ", ParamName)
- .str(),
+ formatv("invalid GlobalMergePass parameter '{}'", ParamName).str(),
inconvertibleErrorCode());
} else {
return make_error<StringError>(
- formatv("invalid global-merge pass parameter '{0}' ", Params).str(),
+ formatv("invalid global-merge pass parameter '{}'", Params).str(),
inconvertibleErrorCode());
}
}
@@ -1388,7 +1383,7 @@ Expected<SmallVector<std::string, 0>> parseInternalizeGVs(StringRef Params) {
PreservedGVs.push_back(ParamName.str());
} else {
return make_error<StringError>(
- formatv("invalid Internalize pass parameter '{0}' ", ParamName).str(),
+ formatv("invalid Internalize pass parameter '{}'", ParamName).str(),
inconvertibleErrorCode());
}
}
@@ -1408,7 +1403,7 @@ parseRegAllocFastPassOptions(PassBuilder &PB, StringRef Params) {
PB.parseRegAllocFilter(ParamName);
if (!Filter) {
return make_error<StringError>(
- formatv("invalid regallocfast register filter '{0}' ", ParamName)
+ formatv("invalid regallocfast register filter '{}'", ParamName)
.str(),
inconvertibleErrorCode());
}
@@ -1423,7 +1418,7 @@ parseRegAllocFastPassOptions(PassBuilder &PB, StringRef Params) {
}
return make_error<StringError>(
- formatv("invalid regallocfast pass parameter '{0}' ", ParamName).str(),
+ formatv("invalid regallocfast pass parameter '{}'", ParamName).str(),
inconvertibleErrorCode());
}
return Opts;
@@ -1468,7 +1463,7 @@ parseBoundsCheckingOptions(StringRef Params) {
Options.GuardKind = Id;
} else {
return make_error<StringError>(
- formatv("invalid BoundsChecking pass parameter '{0}' ", ParamName)
+ formatv("invalid BoundsChecking pass parameter '{}'", ParamName)
.str(),
inconvertibleErrorCode());
}
@@ -1487,7 +1482,7 @@ parseRegAllocGreedyFilterFunc(PassBuilder &PB, StringRef Params) {
return RAGreedyPass::Options{*Filter, Params};
return make_error<StringError>(
- formatv("invalid regallocgreedy register filter '{0}' ", Params).str(),
+ formatv("invalid regallocgreedy register filter '{}'", Params).str(),
inconvertibleErrorCode());
}
@@ -1502,7 +1497,7 @@ Expected<bool> parseMachineBlockPlacementPassOptions(StringRef Params) {
AllowTailMerge = !Params.consume_front("no-");
if (Params != "tail-merge")
return make_error<StringError>(
- formatv("invalid MachineBlockPlacementPass parameter '{0}' ", Params)
+ formatv("invalid MachineBlockPlacementPass parameter '{}'", Params)
.str(),
inconvertibleErrorCode());
}
@@ -1515,8 +1510,7 @@ Expected<bool> parseVirtRegRewriterPassOptions(StringRef Params) {
ClearVirtRegs = !Params.consume_front("no-");
if (Params != "clear-vregs")
return make_error<StringError>(
- formatv("invalid VirtRegRewriter pass parameter '{0}' ", Params)
- .str(),
+ formatv("invalid VirtRegRewriter pass parameter '{}'", Params).str(),
inconvertibleErrorCode());
}
return ClearVirtRegs;
@@ -1801,7 +1795,7 @@ Error PassBuilder::parseModulePass(ModulePassManager &MPM,
// Normal passes can't have pipelines.
return make_error<StringError>(
- formatv("invalid use of '{0}' pass as module pipeline", Name).str(),
+ formatv("invalid use of '{}' pass as module pipeline", Name).str(),
inconvertibleErrorCode());
;
}
@@ -1811,7 +1805,7 @@ Error PassBuilder::parseModulePass(ModulePassManager &MPM,
SmallVector<StringRef, 3> Matches;
if (!DefaultAliasRegex.match(Name, &Matches))
return make_error<StringError>(
- formatv("unknown default pipeline alias '{0}'", Name).str(),
+ formatv("unknown default pipeline alias '{}'", Name).str(),
inconvertibleErrorCode());
assert(Matches.size() == 3 && "Must capture two matched strings!");
@@ -1928,7 +1922,7 @@ Error PassBuilder::parseModulePass(ModulePassManager &MPM,
if (C(Name, MPM, InnerPipeline))
return Error::success();
return make_error<StringError>(
- formatv("unknown module pass '{0}'", Name).str(),
+ formatv("unknown module pass '{}'", Name).str(),
inconvertibleErrorCode());
}
@@ -1971,7 +1965,7 @@ Error PassBuilder::parseCGSCCPass(CGSCCPassManager &CGPM,
// Normal passes can't have pipelines.
return make_error<StringError>(
- formatv("invalid use of '{0}' pass as cgscc pipeline", Name).str(),
+ formatv("invalid use of '{}' pass as cgscc pipeline", Name).str(),
inconvertibleErrorCode());
}
@@ -2042,9 +2036,8 @@ Error PassBuilder::parseCGSCCPass(CGSCCPassManager &CGPM,
for (auto &C : CGSCCPipelineParsingCallbacks)
if (C(Name, CGPM, InnerPipeline))
return Error::success();
- return make_error<StringError>(
- formatv("unknown cgscc pass '{0}'", Name).str(),
- inconvertibleErrorCode());
+ return make_error<StringError>(formatv("unknown cgscc pass '{}'", Name).str(),
+ inconvertibleErrorCode());
}
Error PassBuilder::parseFunctionPass(FunctionPassManager &FPM,
@@ -2092,7 +2085,7 @@ Error PassBuilder::parseFunctionPass(FunctionPassManager &FPM,
// Normal passes can't have pipelines.
return make_error<StringError>(
- formatv("invalid use of '{0}' pass as function pipeline", Name).str(),
+ formatv("invalid use of '{}' pass as function pipeline", Name).str(),
inconvertibleErrorCode());
}
@@ -2151,7 +2144,7 @@ Error PassBuilder::parseFunctionPass(FunctionPassManager &FPM,
if (C(Name, FPM, InnerPipeline))
return Error::success();
return make_error<StringError>(
- formatv("unknown function pass '{0}'", Name).str(),
+ formatv("unknown function pass '{}'", Name).str(),
inconvertibleErrorCode());
}
@@ -2177,7 +2170,7 @@ Error PassBuilder::parseLoopPass(LoopPassManager &LPM,
// Normal passes can't have pipelines.
return make_error<StringError>(
- formatv("invalid use of '{0}' pass as loop pipeline", Name).str(),
+ formatv("invalid use of '{}' pass as loop pipeline", Name).str(),
inconvertibleErrorCode());
}
@@ -2218,7 +2211,7 @@ Error PassBuilder::parseLoopPass(LoopPassManager &LPM,
for (auto &C : LoopPipelineParsingCallbacks)
if (C(Name, LPM, InnerPipeline))
return Error::success();
- return make_error<StringError>(formatv("unknown loop pass '{0}'", Name).str(),
+ return make_error<StringError>(formatv("unknown loop pass '{}'", Name).str(),
inconvertibleErrorCode());
}
@@ -2266,7 +2259,7 @@ Error PassBuilder::parseMachinePass(MachineFunctionPassManager &MFPM,
if (C(Name, MFPM, E.InnerPipeline))
return Error::success();
return make_error<StringError>(
- formatv("unknown machine pass '{0}'", Name).str(),
+ formatv("unknown machine pass '{}'", Name).str(),
inconvertibleErrorCode());
}
@@ -2368,7 +2361,7 @@ Error PassBuilder::parsePassPipeline(ModulePassManager &MPM,
auto Pipeline = parsePipelineText(PipelineText);
if (!Pipeline || Pipeline->empty())
return make_error<StringError>(
- formatv("invalid pipeline '{0}'", PipelineText).str(),
+ formatv("invalid pipeline '{}'", PipelineText).str(),
inconvertibleErrorCode());
// If the first name isn't at the module layer, wrap the pipeline up
@@ -2401,7 +2394,7 @@ Error PassBuilder::parsePassPipeline(ModulePassManager &MPM,
// Unknown pass or pipeline name!
auto &InnerPipeline = Pipeline->front().InnerPipeline;
return make_error<StringError>(
- formatv("unknown {0} name '{1}'",
+ formatv("unknown {} name '{}'",
(InnerPipeline.empty() ? "pass" : "pipeline"), FirstName)
.str(),
inconvertibleErrorCode());
@@ -2419,13 +2412,13 @@ Error PassBuilder::parsePassPipeline(CGSCCPassManager &CGPM,
auto Pipeline = parsePipelineText(PipelineText);
if (!Pipeline || Pipeline->empty())
return make_error<StringError>(
- formatv("invalid pipeline '{0}'", PipelineText).str(),
+ formatv("invalid pipeline '{}'", PipelineText).str(),
inconvertibleErrorCode());
StringRef FirstName = Pipeline->front().Name;
if (!isCGSCCPassName(FirstName, CGSCCPipelineParsingCallbacks))
return make_error<StringError>(
- formatv("unknown cgscc pass '{0}' in pipeline '{1}'", FirstName,
+ formatv("unknown cgscc pass '{}' in pipeline '{}'", FirstName,
PipelineText)
.str(),
inconvertibleErrorCode());
@@ -2442,13 +2435,13 @@ Error PassBuilder::parsePassPipeline(FunctionPassManager &FPM,
auto Pipeline = parsePipelineText(PipelineText);
if (!Pipeline || Pipeline->empty())
return make_error<StringError>(
- formatv("invalid pipeline '{0}'", PipelineText).str(),
+ formatv("invalid pipeline '{}'", PipelineText).str(),
inconvertibleErrorCode());
StringRef FirstName = Pipeline->front().Name;
if (!isFunctionPassName(FirstName, FunctionPipelineParsingCallbacks))
return make_error<StringError>(
- formatv("unknown function pass '{0}' in pipeline '{1}'", FirstName,
+ formatv("unknown function pass '{}' in pipeline '{}'", FirstName,
PipelineText)
.str(),
inconvertibleErrorCode());
@@ -2464,7 +2457,7 @@ Error PassBuilder::parsePassPipeline(LoopPassManager &CGPM,
auto Pipeline = parsePipelineText(PipelineText);
if (!Pipeline || Pipeline->empty())
return make_error<StringError>(
- formatv("invalid pipeline '{0}'", PipelineText).str(),
+ formatv("invalid pipeline '{}'", PipelineText).str(),
inconvertibleErrorCode());
if (auto Err = parseLoopPassPipeline(CGPM, *Pipeline))
@@ -2478,7 +2471,7 @@ Error PassBuilder::parsePassPipeline(MachineFunctionPassManager &MFPM,
auto Pipeline = parsePipelineText(PipelineText);
if (!Pipeline || Pipeline->empty())
return make_error<StringError>(
- formatv("invalid machine pass pipeline '{0}'", PipelineText).str(),
+ formatv("invalid machine pass pipeline '{}'", PipelineText).str(),
inconvertibleErrorCode());
if (auto Err = parseMachinePassPipeline(MFPM, *Pipeline))
@@ -2500,7 +2493,7 @@ Error PassBuilder::parseAAPipeline(AAManager &AA, StringRef PipelineText) {
std::tie(Name, PipelineText) = PipelineText.split(',');
if (!parseAAPassName(AA, Name))
return make_error<StringError>(
- formatv("unknown alias analysis name '{0}'", Name).str(),
+ formatv("unknown alias analysis name '{}'", Name).str(),
inconvertibleErrorCode());
}
More information about the llvm-commits
mailing list