From 56c13e6fa3ac01a9a03d6d028af8101d853b492d Mon Sep 17 00:00:00 2001 From: Rahul Joshi 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 PassBuilder::parseSinglePassOption(StringRef Params, Result = true; } else { return make_error( - formatv("invalid {1} pass parameter '{0}' ", ParamName, PassName) - .str(), + formatv("invalid {} pass parameter '{}'", PassName, ParamName).str(), inconvertibleErrorCode()); } } @@ -662,7 +661,7 @@ Expected parseHardwareLoopOptions(StringRef Params) { int Count; if (ParamName.getAsInteger(0, Count)) return make_error( - formatv("invalid HardwareLoopPass parameter '{0}' ", ParamName).str(), + formatv("invalid HardwareLoopPass parameter '{}'", ParamName).str(), inconvertibleErrorCode()); HardwareLoopOpts.setDecrement(Count); continue; @@ -671,7 +670,7 @@ Expected parseHardwareLoopOptions(StringRef Params) { int Count; if (ParamName.getAsInteger(0, Count)) return make_error( - formatv("invalid HardwareLoopPass parameter '{0}' ", ParamName).str(), + formatv("invalid HardwareLoopPass parameter '{}'", ParamName).str(), inconvertibleErrorCode()); HardwareLoopOpts.setCounterBitwidth(Count); continue; @@ -686,7 +685,7 @@ Expected parseHardwareLoopOptions(StringRef Params) { HardwareLoopOpts.setForceGuard(true); } else { return make_error( - formatv("invalid HardwarePass parameter '{0}' ", ParamName).str(), + formatv("invalid HardwarePass parameter '{}'", ParamName).str(), inconvertibleErrorCode()); } } @@ -715,7 +714,7 @@ Expected parseLoopUnrollOptions(StringRef Params) { int Count; if (ParamName.getAsInteger(0, Count)) return make_error( - formatv("invalid LoopUnrollPass parameter '{0}' ", ParamName).str(), + formatv("invalid LoopUnrollPass parameter '{}'", ParamName).str(), inconvertibleErrorCode()); UnrollOpts.setFullUnrollMaxCount(Count); continue; @@ -734,7 +733,7 @@ Expected parseLoopUnrollOptions(StringRef Params) { UnrollOpts.setUpperBound(Enable); } else { return make_error( - formatv("invalid LoopUnrollPass parameter '{0}' ", ParamName).str(), + formatv("invalid LoopUnrollPass parameter '{}'", ParamName).str(), inconvertibleErrorCode()); } } @@ -773,7 +772,7 @@ Expected parseCFGuardPassOptions(StringRef Params) { auto [Param, RHS] = Params.split(';'); if (!RHS.empty()) return make_error( - formatv("too many CFGuardPass parameters '{0}' ", Params).str(), + formatv("too many CFGuardPass parameters '{}'", Params).str(), inconvertibleErrorCode()); if (Param == "check") @@ -782,7 +781,7 @@ Expected parseCFGuardPassOptions(StringRef Params) { return CFGuardPass::Mechanism::Dispatch; return make_error( - formatv("invalid CFGuardPass mechanism: '{0}' ", Param).str(), + formatv("invalid CFGuardPass mechanism: '{}'", Param).str(), inconvertibleErrorCode()); } @@ -821,7 +820,7 @@ Expected parseIRNormalizerPassOptions(StringRef Params) { Result.ReorderOperands = Enable; else { return make_error( - formatv("invalid normalize pass parameter '{0}' ", ParamName).str(), + formatv("invalid normalize pass parameter '{}'", ParamName).str(), inconvertibleErrorCode()); } } @@ -841,7 +840,7 @@ Expected parseASanPassOptions(StringRef Params) { Result.UseAfterScope = true; } else { return make_error( - formatv("invalid AddressSanitizer pass parameter '{0}' ", ParamName) + formatv("invalid AddressSanitizer pass parameter '{}'", ParamName) .str(), inconvertibleErrorCode()); } @@ -861,7 +860,7 @@ Expected parseHWASanPassOptions(StringRef Params) { Result.CompileKernel = true; } else { return make_error( - formatv("invalid HWAddressSanitizer pass parameter '{0}' ", ParamName) + formatv("invalid HWAddressSanitizer pass parameter '{}'", ParamName) .str(), inconvertibleErrorCode()); } @@ -881,8 +880,7 @@ Expected parseEmbedBitcodePassOptions(StringRef Params) { Result.EmitLTOSummary = true; } else { return make_error( - 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( - 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( - 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( - 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( - formatv("invalid LowerAllowCheck pass parameter '{0}' ", ParamName) + formatv("invalid LowerAllowCheck pass parameter '{}'", ParamName) .str(), inconvertibleErrorCode()); } @@ -972,7 +968,7 @@ Expected parseMSanPassOptions(StringRef Params) { if (ParamName.getAsInteger(0, Result.TrackOrigins)) return make_error( formatv("invalid argument to MemorySanitizer pass track-origins " - "parameter: '{0}' ", + "parameter: '{}'", ParamName) .str(), inconvertibleErrorCode()); @@ -980,7 +976,7 @@ Expected parseMSanPassOptions(StringRef Params) { Result.EagerChecks = true; } else { return make_error( - formatv("invalid MemorySanitizer pass parameter '{0}' ", ParamName) + formatv("invalid MemorySanitizer pass parameter '{}'", ParamName) .str(), inconvertibleErrorCode()); } @@ -1021,13 +1017,14 @@ Expected parseSimplifyCFGOptions(StringRef Params) { if (ParamName.getAsInteger(0, BonusInstThreshold)) return make_error( formatv("invalid argument to SimplifyCFG pass bonus-threshold " - "parameter: '{0}' ", - ParamName).str(), + "parameter: '{}'", + ParamName) + .str(), inconvertibleErrorCode()); Result.bonusInstThreshold(BonusInstThreshold.getSExtValue()); } else { return make_error( - formatv("invalid SimplifyCFG pass parameter '{0}' ", ParamName).str(), + formatv("invalid SimplifyCFG pass parameter '{}'", ParamName).str(), inconvertibleErrorCode()); } } @@ -1051,13 +1048,14 @@ Expected parseInstCombineOptions(StringRef Params) { if (ParamName.getAsInteger(0, MaxIterations)) return make_error( 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( - formatv("invalid InstCombine pass parameter '{0}' ", ParamName).str(), + formatv("invalid InstCombine pass parameter '{}'", ParamName).str(), inconvertibleErrorCode()); } } @@ -1078,7 +1076,7 @@ Expected parseLoopVectorizeOptions(StringRef Params) { Opts.setVectorizeOnlyWhenForced(Enable); } else { return make_error( - formatv("invalid LoopVectorize parameter '{0}' ", ParamName).str(), + formatv("invalid LoopVectorize parameter '{}'", ParamName).str(), inconvertibleErrorCode()); } } @@ -1098,8 +1096,7 @@ Expected> parseLoopUnswitchOptions(StringRef Params) { Result.second = Enable; } else { return make_error( - formatv("invalid LoopUnswitch pass parameter '{0}' ", ParamName) - .str(), + formatv("invalid LoopUnswitch pass parameter '{}'", ParamName).str(), inconvertibleErrorCode()); } } @@ -1117,7 +1114,7 @@ Expected parseLICMOptions(StringRef Params) { Result.AllowSpeculation = Enable; } else { return make_error( - formatv("invalid LICM pass parameter '{0}' ", ParamName).str(), + formatv("invalid LICM pass parameter '{}'", ParamName).str(), inconvertibleErrorCode()); } } @@ -1137,7 +1134,7 @@ Expected> parseLoopRotateOptions(StringRef Params) { Result.second = Enable; } else { return make_error( - formatv("invalid LoopRotate pass parameter '{0}' ", ParamName).str(), + formatv("invalid LoopRotate pass parameter '{}'", ParamName).str(), inconvertibleErrorCode()); } } @@ -1155,7 +1152,7 @@ Expected parseMergedLoadStoreMotionOptions(StringRef Params) { Result = Enable; } else { return make_error( - formatv("invalid MergedLoadStoreMotion pass parameter '{0}' ", + formatv("invalid MergedLoadStoreMotion pass parameter '{}'", ParamName) .str(), inconvertibleErrorCode()); @@ -1183,7 +1180,7 @@ Expected parseGVNOptions(StringRef Params) { Result.setMemorySSA(Enable); } else { return make_error( - formatv("invalid GVN pass parameter '{0}' ", ParamName).str(), + formatv("invalid GVN pass parameter '{}'", ParamName).str(), inconvertibleErrorCode()); } } @@ -1201,7 +1198,7 @@ Expected parseIPSCCPOptions(StringRef Params) { Result.setFuncSpec(Enable); else return make_error( - formatv("invalid IPSCCP pass parameter '{0}' ", ParamName).str(), + formatv("invalid IPSCCP pass parameter '{}'", ParamName).str(), inconvertibleErrorCode()); } return Result; @@ -1217,7 +1214,7 @@ Expected parseScalarizerOptions(StringRef Params) { if (ParamName.getAsInteger(0, Result.ScalarizeMinBits)) { return make_error( formatv("invalid argument to Scalarizer pass min-bits " - "parameter: '{0}' ", + "parameter: '{}'", ParamName) .str(), inconvertibleErrorCode()); @@ -1233,7 +1230,7 @@ Expected parseScalarizerOptions(StringRef Params) { Result.ScalarizeVariableInsertExtract = Enable; else { return make_error( - formatv("invalid Scalarizer pass parameter '{0}' ", ParamName).str(), + formatv("invalid Scalarizer pass parameter '{}'", ParamName).str(), inconvertibleErrorCode()); } } @@ -1247,7 +1244,7 @@ Expected parseSROAOptions(StringRef Params) { if (Params == "preserve-cfg") return SROAOptions::PreserveCFG; return make_error( - 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( - formatv("invalid StackLifetime parameter '{0}' ", ParamName).str(), + formatv("invalid StackLifetime parameter '{}'", ParamName).str(), inconvertibleErrorCode()); } } @@ -1294,8 +1291,7 @@ parseFunctionSimplificationPipelineOptions(StringRef Params) { std::optional L = parseOptLevel(Params); if (!L || *L == OptimizationLevel::O0) { return make_error( - formatv("invalid function-simplification parameter '{0}' ", Params) - .str(), + formatv("invalid function-simplification parameter '{}'", Params).str(), inconvertibleErrorCode()); }; return *L; @@ -1321,7 +1317,7 @@ Expected parseMemProfUsePassOptions(StringRef Params) { Result = ParamName.str(); } else { return make_error( - 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( - formatv("invalid structural hash printer parameter '{0}' ", Params).str(), + formatv("invalid structural hash printer parameter '{}'", Params).str(), inconvertibleErrorCode()); } @@ -1366,12 +1362,11 @@ Expected parseGlobalMergeOptions(StringRef Params) { else if (ParamName.consume_front("max-offset=")) { if (ParamName.getAsInteger(0, Result.MaxOffset)) return make_error( - formatv("invalid GlobalMergePass parameter '{0}' ", ParamName) - .str(), + formatv("invalid GlobalMergePass parameter '{}'", ParamName).str(), inconvertibleErrorCode()); } else { return make_error( - formatv("invalid global-merge pass parameter '{0}' ", Params).str(), + formatv("invalid global-merge pass parameter '{}'", Params).str(), inconvertibleErrorCode()); } } @@ -1388,7 +1383,7 @@ Expected> parseInternalizeGVs(StringRef Params) { PreservedGVs.push_back(ParamName.str()); } else { return make_error( - 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( - 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( - 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( - 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( - formatv("invalid regallocgreedy register filter '{0}' ", Params).str(), + formatv("invalid regallocgreedy register filter '{}'", Params).str(), inconvertibleErrorCode()); } @@ -1502,7 +1497,7 @@ Expected parseMachineBlockPlacementPassOptions(StringRef Params) { AllowTailMerge = !Params.consume_front("no-"); if (Params != "tail-merge") return make_error( - formatv("invalid MachineBlockPlacementPass parameter '{0}' ", Params) + formatv("invalid MachineBlockPlacementPass parameter '{}'", Params) .str(), inconvertibleErrorCode()); } @@ -1515,8 +1510,7 @@ Expected parseVirtRegRewriterPassOptions(StringRef Params) { ClearVirtRegs = !Params.consume_front("no-"); if (Params != "clear-vregs") return make_error( - 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( - 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 Matches; if (!DefaultAliasRegex.match(Name, &Matches)) return make_error( - 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( - 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( - 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( - formatv("unknown cgscc pass '{0}'", Name).str(), - inconvertibleErrorCode()); + return make_error(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( - 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( - 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( - 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(formatv("unknown loop pass '{0}'", Name).str(), + return make_error(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( - 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( - 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( - 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( - formatv("invalid pipeline '{0}'", PipelineText).str(), + formatv("invalid pipeline '{}'", PipelineText).str(), inconvertibleErrorCode()); StringRef FirstName = Pipeline->front().Name; if (!isCGSCCPassName(FirstName, CGSCCPipelineParsingCallbacks)) return make_error( - 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( - formatv("invalid pipeline '{0}'", PipelineText).str(), + formatv("invalid pipeline '{}'", PipelineText).str(), inconvertibleErrorCode()); StringRef FirstName = Pipeline->front().Name; if (!isFunctionPassName(FirstName, FunctionPipelineParsingCallbacks)) return make_error( - 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( - 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( - 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( - formatv("unknown alias analysis name '{0}'", Name).str(), + formatv("unknown alias analysis name '{}'", Name).str(), inconvertibleErrorCode()); }