351 "^(default|thinlto-pre-link|thinlto|lto-pre-link|lto)<(O[0123sz])>$");
355 "print-pipeline-passes",
356 cl::desc(
"Print a '-passes' compatible string describing the pipeline "
357 "(best-effort only)."));
369class TriggerCrashModulePass :
public PassInfoMixin<TriggerCrashModulePass> {
378class TriggerCrashFunctionPass
385 static StringRef name() {
return "TriggerCrashFunctionPass"; }
390class TriggerVerifierErrorPass
398 GlobalValue::LinkageTypes::InternalLinkage,
399 "__bad_alias",
nullptr, &M);
419 static StringRef name() {
return "TriggerVerifierErrorPass"; }
424class RequireAllMachineFunctionPropertiesPass
425 :
public PassInfoMixin<RequireAllMachineFunctionPropertiesPass> {
434 MFProps.
set(MachineFunctionProperties::Property::FailedISel);
435 MFProps.
set(MachineFunctionProperties::Property::FailsVerification);
436 MFProps.
set(MachineFunctionProperties::Property::IsSSA);
437 MFProps.
set(MachineFunctionProperties::Property::Legalized);
438 MFProps.
set(MachineFunctionProperties::Property::NoPHIs);
439 MFProps.
set(MachineFunctionProperties::Property::NoVRegs);
440 MFProps.
set(MachineFunctionProperties::Property::RegBankSelected);
441 MFProps.
set(MachineFunctionProperties::Property::Selected);
442 MFProps.
set(MachineFunctionProperties::Property::TiedOpsRewritten);
443 MFProps.
set(MachineFunctionProperties::Property::TracksDebugUserValues);
444 MFProps.
set(MachineFunctionProperties::Property::TracksLiveness);
447 static StringRef name() {
return "RequireAllMachineFunctionPropertiesPass"; }
453 std::optional<PGOOptions> PGOOpt,
455 : TM(TM), PTO(PTO), PGOOpt(PGOOpt),
PIC(
PIC) {
457 TM->registerPassBuilderCallbacks(*
this);
463#define MODULE_PASS(NAME, CREATE_PASS) \
464 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
465#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
466 PIC->addClassToPassName(CLASS, NAME);
467#define MODULE_ANALYSIS(NAME, CREATE_PASS) \
468 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
469#define FUNCTION_PASS(NAME, CREATE_PASS) \
470 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
471#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
472 PIC->addClassToPassName(CLASS, NAME);
473#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
474 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
475#define LOOPNEST_PASS(NAME, CREATE_PASS) \
476 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
477#define LOOP_PASS(NAME, CREATE_PASS) \
478 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
479#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
480 PIC->addClassToPassName(CLASS, NAME);
481#define LOOP_ANALYSIS(NAME, CREATE_PASS) \
482 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
483#define CGSCC_PASS(NAME, CREATE_PASS) \
484 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
485#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
486 PIC->addClassToPassName(CLASS, NAME);
487#define CGSCC_ANALYSIS(NAME, CREATE_PASS) \
488 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
489#include "PassRegistry.def"
491#define MACHINE_FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
492 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
493#define MACHINE_FUNCTION_PASS(NAME, CREATE_PASS) \
494 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
495#define MACHINE_FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, \
497 PIC->addClassToPassName(CLASS, NAME);
498#include "llvm/Passes/MachinePassRegistry.def"
504#define MODULE_ANALYSIS(NAME, CREATE_PASS) \
505 MAM.registerPass([&] { return CREATE_PASS; });
506#include "PassRegistry.def"
508 for (
auto &
C : ModuleAnalysisRegistrationCallbacks)
513#define CGSCC_ANALYSIS(NAME, CREATE_PASS) \
514 CGAM.registerPass([&] { return CREATE_PASS; });
515#include "PassRegistry.def"
517 for (
auto &
C : CGSCCAnalysisRegistrationCallbacks)
527#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
528 FAM.registerPass([&] { return CREATE_PASS; });
529#include "PassRegistry.def"
531 for (
auto &
C : FunctionAnalysisRegistrationCallbacks)
538#define MACHINE_FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
539 MFAM.registerPass([&] { return CREATE_PASS; });
540#include "llvm/Passes/MachinePassRegistry.def"
542 for (
auto &
C : MachineFunctionAnalysisRegistrationCallbacks)
547#define LOOP_ANALYSIS(NAME, CREATE_PASS) \
548 LAM.registerPass([&] { return CREATE_PASS; });
549#include "PassRegistry.def"
551 for (
auto &
C : LoopAnalysisRegistrationCallbacks)
555static std::optional<std::pair<bool, bool>>
557 std::pair<bool, bool> Params;
558 if (!
Name.consume_front(
"function"))
562 if (!
Name.consume_front(
"<") || !
Name.consume_back(
">"))
564 while (!
Name.empty()) {
565 auto [Front, Back] =
Name.split(
';');
567 if (Front ==
"eager-inv")
569 else if (Front ==
"no-rerun")
570 Params.second =
true;
578 if (!
Name.consume_front(
"devirt<") || !
Name.consume_back(
">"))
581 if (
Name.getAsInteger(0, Count) || Count < 0)
601 while (!Params.
empty()) {
603 std::tie(ParamName, Params) = Params.
split(
';');
605 if (ParamName == OptionName) {
608 return make_error<StringError>(
623 while (!Params.
empty()) {
625 std::tie(ParamName, Params) = Params.
split(
';');
629 return make_error<StringError>(
630 formatv(
"invalid HardwareLoopPass parameter '{0}' ", ParamName).str(),
635 if (ParamName.
consume_front(
"hardware-loop-counter-bitwidth=")) {
638 return make_error<StringError>(
639 formatv(
"invalid HardwareLoopPass parameter '{0}' ", ParamName).str(),
644 if (ParamName ==
"force-hardware-loops") {
646 }
else if (ParamName ==
"force-hardware-loop-phi") {
648 }
else if (ParamName ==
"force-nested-hardware-loop") {
650 }
else if (ParamName ==
"force-hardware-loop-guard") {
653 return make_error<StringError>(
654 formatv(
"invalid HardwarePass parameter '{0}' ", ParamName).str(),
658 return HardwareLoopOpts;
664 while (!Params.
empty()) {
666 std::tie(ParamName, Params) = Params.
split(
';');
667 std::optional<OptimizationLevel> OptLevel =
parseOptLevel(ParamName);
669 if (OptLevel && !OptLevel->isOptimizingForSize()) {
670 UnrollOpts.
setOptLevel(OptLevel->getSpeedupLevel());
676 return make_error<StringError>(
677 formatv(
"invalid LoopUnrollPass parameter '{0}' ", ParamName).str(),
684 if (ParamName ==
"partial") {
686 }
else if (ParamName ==
"peeling") {
688 }
else if (ParamName ==
"profile-peeling") {
690 }
else if (ParamName ==
"runtime") {
692 }
else if (ParamName ==
"upperbound") {
695 return make_error<StringError>(
696 formatv(
"invalid LoopUnrollPass parameter '{0}' ", ParamName).str(),
705 Params,
"vfe-linkage-unit-visibility",
"GlobalDCE");
725 Params,
"skip-non-recursive-function-attrs",
"PostOrderFunctionAttrs");
734 return make_error<StringError>(
735 formatv(
"too many CFGuardPass parameters '{0}' ", Params).str(),
738 if (Param ==
"check")
740 if (Param ==
"dispatch")
743 return make_error<StringError>(
744 formatv(
"invalid CFGuardPass mechanism: '{0}' ", Param).str(),
754 "EntryExitInstrumenter");
763 "LowerMatrixIntrinsics");
768 while (!Params.
empty()) {
770 std::tie(ParamName, Params) = Params.
split(
';');
772 if (ParamName ==
"kernel") {
773 Result.CompileKernel =
true;
775 return make_error<StringError>(
776 formatv(
"invalid AddressSanitizer pass parameter '{0}' ", ParamName)
786 while (!Params.
empty()) {
788 std::tie(ParamName, Params) = Params.
split(
';');
790 if (ParamName ==
"recover") {
792 }
else if (ParamName ==
"kernel") {
793 Result.CompileKernel =
true;
795 return make_error<StringError>(
796 formatv(
"invalid HWAddressSanitizer pass parameter '{0}' ", ParamName)
806 while (!Params.
empty()) {
808 std::tie(ParamName, Params) = Params.
split(
';');
810 if (ParamName ==
"thinlto") {
812 }
else if (ParamName ==
"emit-summary") {
813 Result.EmitLTOSummary =
true;
815 return make_error<StringError>(
816 formatv(
"invalid EmbedBitcode pass parameter '{0}' ", ParamName)
826 while (!Params.
empty()) {
828 std::tie(ParamName, Params) = Params.
split(
';');
830 if (ParamName ==
"recover") {
832 }
else if (ParamName ==
"kernel") {
836 return make_error<StringError>(
837 formatv(
"invalid argument to MemorySanitizer pass track-origins "
842 }
else if (ParamName ==
"eager-checks") {
843 Result.EagerChecks =
true;
845 return make_error<StringError>(
846 formatv(
"invalid MemorySanitizer pass parameter '{0}' ", ParamName)
857 while (!Params.
empty()) {
859 std::tie(ParamName, Params) = Params.
split(
';');
862 if (ParamName ==
"speculate-blocks") {
864 }
else if (ParamName ==
"simplify-cond-branch") {
866 }
else if (ParamName ==
"forward-switch-cond") {
868 }
else if (ParamName ==
"switch-range-to-icmp") {
870 }
else if (ParamName ==
"switch-to-lookup") {
872 }
else if (ParamName ==
"keep-loops") {
874 }
else if (ParamName ==
"hoist-common-insts") {
876 }
else if (ParamName ==
"hoist-loads-stores-with-cond-faulting") {
878 }
else if (ParamName ==
"sink-common-insts") {
880 }
else if (ParamName ==
"speculate-unpredictables") {
883 APInt BonusInstThreshold;
885 return make_error<StringError>(
886 formatv(
"invalid argument to SimplifyCFG pass bonus-threshold "
892 return make_error<StringError>(
893 formatv(
"invalid SimplifyCFG pass parameter '{0}' ", ParamName).str(),
904 Result.setVerifyFixpoint(
true);
905 while (!Params.
empty()) {
907 std::tie(ParamName, Params) = Params.
split(
';');
910 if (ParamName ==
"verify-fixpoint") {
915 return make_error<StringError>(
916 formatv(
"invalid argument to InstCombine pass max-iterations "
922 return make_error<StringError>(
923 formatv(
"invalid InstCombine pass parameter '{0}' ", ParamName).str(),
933 while (!Params.
empty()) {
935 std::tie(ParamName, Params) = Params.
split(
';');
938 if (ParamName ==
"interleave-forced-only") {
940 }
else if (ParamName ==
"vectorize-forced-only") {
943 return make_error<StringError>(
944 formatv(
"invalid LoopVectorize parameter '{0}' ", ParamName).str(),
952 std::pair<bool, bool>
Result = {
false,
true};
953 while (!Params.
empty()) {
955 std::tie(ParamName, Params) = Params.
split(
';');
958 if (ParamName ==
"nontrivial") {
960 }
else if (ParamName ==
"trivial") {
963 return make_error<StringError>(
964 formatv(
"invalid LoopUnswitch pass parameter '{0}' ", ParamName)
974 while (!Params.
empty()) {
976 std::tie(ParamName, Params) = Params.
split(
';');
979 if (ParamName ==
"allowspeculation") {
982 return make_error<StringError>(
983 formatv(
"invalid LICM pass parameter '{0}' ", ParamName).str(),
991 std::pair<bool, bool>
Result = {
true,
false};
992 while (!Params.
empty()) {
994 std::tie(ParamName, Params) = Params.
split(
';');
997 if (ParamName ==
"header-duplication") {
999 }
else if (ParamName ==
"prepare-for-lto") {
1002 return make_error<StringError>(
1003 formatv(
"invalid LoopRotate pass parameter '{0}' ", ParamName).str(),
1012 while (!Params.
empty()) {
1014 std::tie(ParamName, Params) = Params.
split(
';');
1017 if (ParamName ==
"split-footer-bb") {
1020 return make_error<StringError>(
1021 formatv(
"invalid MergedLoadStoreMotion pass parameter '{0}' ",
1032 while (!Params.
empty()) {
1034 std::tie(ParamName, Params) = Params.
split(
';');
1037 if (ParamName ==
"pre") {
1039 }
else if (ParamName ==
"load-pre") {
1041 }
else if (ParamName ==
"split-backedge-load-pre") {
1043 }
else if (ParamName ==
"memdep") {
1046 return make_error<StringError>(
1047 formatv(
"invalid GVN pass parameter '{0}' ", ParamName).str(),
1056 while (!Params.
empty()) {
1058 std::tie(ParamName, Params) = Params.
split(
';');
1061 if (ParamName ==
"func-spec")
1064 return make_error<StringError>(
1065 formatv(
"invalid IPSCCP pass parameter '{0}' ", ParamName).str(),
1073 while (!Params.
empty()) {
1075 std::tie(ParamName, Params) = Params.
split(
';');
1079 return make_error<StringError>(
1080 formatv(
"invalid argument to Scalarizer pass min-bits "
1081 "parameter: '{0}' ",
1091 if (ParamName ==
"load-store")
1093 else if (ParamName ==
"variable-insert-extract")
1096 return make_error<StringError>(
1097 formatv(
"invalid Scalarizer pass parameter '{0}' ", ParamName).str(),
1106 if (Params.
empty() || Params ==
"modify-cfg")
1108 if (Params ==
"preserve-cfg")
1110 return make_error<StringError>(
1111 formatv(
"invalid SROA pass parameter '{0}' (either preserve-cfg or "
1112 "modify-cfg can be specified)",
1119parseStackLifetimeOptions(
StringRef Params) {
1121 while (!Params.
empty()) {
1123 std::tie(ParamName, Params) = Params.
split(
';');
1125 if (ParamName ==
"may") {
1127 }
else if (ParamName ==
"must") {
1130 return make_error<StringError>(
1131 formatv(
"invalid StackLifetime parameter '{0}' ", ParamName).str(),
1140 "DependenceAnalysisPrinter");
1145 "SeparateConstOffsetFromGEP");
1154parseFunctionSimplificationPipelineOptions(
StringRef Params) {
1157 return make_error<StringError>(
1158 formatv(
"invalid function-simplification parameter '{0}' ", Params)
1167 "MemorySSAPrinterPass");
1172 "SpeculativeExecutionPass");
1177 while (!Params.
empty()) {
1179 std::tie(ParamName, Params) = Params.
split(
';');
1184 return make_error<StringError>(
1185 formatv(
"invalid MemProfUse pass parameter '{0}' ", ParamName).str(),
1193parseStructuralHashPrinterPassOptions(
StringRef Params) {
1196 if (Params ==
"detailed")
1198 if (Params ==
"call-target-ignored")
1200 return make_error<StringError>(
1201 formatv(
"invalid structural hash printer parameter '{0}' ", Params).str(),
1207 "WinEHPreparePass");
1212 while (!Params.
empty()) {
1214 std::tie(ParamName, Params) = Params.
split(
';');
1217 if (ParamName ==
"group-by-use")
1219 else if (ParamName ==
"ignore-single-use")
1221 else if (ParamName ==
"merge-const")
1223 else if (ParamName ==
"merge-external")
1227 return make_error<StringError>(
1228 formatv(
"invalid GlobalMergePass parameter '{0}' ", ParamName)
1238 while (!Params.
empty()) {
1240 std::tie(ParamName, Params) = Params.
split(
';');
1245 return make_error<StringError>(
1246 formatv(
"invalid Internalize pass parameter '{0}' ", ParamName).str(),
1257 while (!Params.
empty()) {
1259 std::tie(ParamName, Params) = Params.
split(
';');
1262 std::optional<RegAllocFilterFunc>
Filter =
1265 return make_error<StringError>(
1266 formatv(
"invalid regallocfast register filter '{0}' ", ParamName)
1275 if (ParamName ==
"no-clear-vregs") {
1280 return make_error<StringError>(
1281 formatv(
"invalid regallocfast pass parameter '{0}' ", ParamName).str(),
1288parseBoundsCheckingOptions(
StringRef Params) {
1291 while (!Params.
empty()) {
1293 std::tie(ParamName, Params) = Params.
split(
';');
1294 if (ParamName ==
"trap") {
1296 }
else if (ParamName ==
"rt") {
1298 }
else if (ParamName ==
"rt-abort") {
1300 }
else if (ParamName ==
"min-rt") {
1302 }
else if (ParamName ==
"min-rt-abort") {
1304 }
else if (ParamName ==
"merge") {
1307 return make_error<StringError>(
1308 formatv(
"invalid BoundsChecking pass parameter '{0}' ", ParamName)
1321 return Name.starts_with(
"default") ||
Name.starts_with(
"thinlto") ||
1322 Name.starts_with(
"lto");
1333template <
typename PassManagerT,
typename CallbacksT>
1335 if (!Callbacks.empty()) {
1336 PassManagerT DummyPM;
1337 for (
auto &CB : Callbacks)
1338 if (CB(
Name, DummyPM, {}))
1344template <
typename CallbacksT>
1350 StringRef NameNoBracket =
Name.take_until([](
char C) {
return C ==
'<'; });
1353 if (
Name ==
"module")
1355 if (
Name ==
"cgscc")
1357 if (NameNoBracket ==
"function")
1359 if (
Name ==
"coro-cond")
1362#define MODULE_PASS(NAME, CREATE_PASS) \
1365#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1366 if (PassBuilder::checkParametrizedPassName(Name, NAME)) \
1368#define MODULE_ANALYSIS(NAME, CREATE_PASS) \
1369 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \
1371#include "PassRegistry.def"
1373 return callbacksAcceptPassName<ModulePassManager>(
Name, Callbacks);
1376template <
typename CallbacksT>
1379 StringRef NameNoBracket =
Name.take_until([](
char C) {
return C ==
'<'; });
1380 if (
Name ==
"cgscc")
1382 if (NameNoBracket ==
"function")
1389#define CGSCC_PASS(NAME, CREATE_PASS) \
1392#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1393 if (PassBuilder::checkParametrizedPassName(Name, NAME)) \
1395#define CGSCC_ANALYSIS(NAME, CREATE_PASS) \
1396 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \
1398#include "PassRegistry.def"
1400 return callbacksAcceptPassName<CGSCCPassManager>(
Name, Callbacks);
1403template <
typename CallbacksT>
1406 StringRef NameNoBracket =
Name.take_until([](
char C) {
return C ==
'<'; });
1407 if (NameNoBracket ==
"function")
1409 if (
Name ==
"loop" ||
Name ==
"loop-mssa" ||
Name ==
"machine-function")
1412#define FUNCTION_PASS(NAME, CREATE_PASS) \
1415#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1416 if (PassBuilder::checkParametrizedPassName(Name, NAME)) \
1418#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
1419 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \
1421#include "PassRegistry.def"
1423 return callbacksAcceptPassName<FunctionPassManager>(
Name, Callbacks);
1426template <
typename CallbacksT>
1429 if (
Name ==
"machine-function")
1432#define MACHINE_FUNCTION_PASS(NAME, CREATE_PASS) \
1435#define MACHINE_FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, \
1437 if (PassBuilder::checkParametrizedPassName(Name, NAME)) \
1440#define MACHINE_FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
1441 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \
1444#include "llvm/Passes/MachinePassRegistry.def"
1446 return callbacksAcceptPassName<MachineFunctionPassManager>(
Name, Callbacks);
1449template <
typename CallbacksT>
1451 bool &UseMemorySSA) {
1452 UseMemorySSA =
false;
1455 UseMemorySSA =
true;
1459#define LOOPNEST_PASS(NAME, CREATE_PASS) \
1462#include "PassRegistry.def"
1464 return callbacksAcceptPassName<LoopPassManager>(
Name, Callbacks);
1467template <
typename CallbacksT>
1469 bool &UseMemorySSA) {
1470 UseMemorySSA =
false;
1473 UseMemorySSA =
true;
1477#define LOOP_PASS(NAME, CREATE_PASS) \
1480#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1481 if (PassBuilder::checkParametrizedPassName(Name, NAME)) \
1483#define LOOP_ANALYSIS(NAME, CREATE_PASS) \
1484 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \
1486#include "PassRegistry.def"
1488 return callbacksAcceptPassName<LoopPassManager>(
Name, Callbacks);
1491std::optional<std::vector<PassBuilder::PipelineElement>>
1492PassBuilder::parsePipelineText(
StringRef Text) {
1493 std::vector<PipelineElement> ResultPipeline;
1498 std::vector<PipelineElement> &Pipeline = *PipelineStack.
back();
1499 size_t Pos =
Text.find_first_of(
",()");
1500 Pipeline.push_back({
Text.substr(0, Pos), {}});
1503 if (Pos ==
Text.npos)
1506 char Sep =
Text[Pos];
1514 PipelineStack.
push_back(&Pipeline.back().InnerPipeline);
1518 assert(Sep ==
')' &&
"Bogus separator!");
1523 if (PipelineStack.
size() == 1)
1524 return std::nullopt;
1527 }
while (
Text.consume_front(
")"));
1535 if (!
Text.consume_front(
","))
1536 return std::nullopt;
1539 if (PipelineStack.
size() > 1)
1541 return std::nullopt;
1543 assert(PipelineStack.
back() == &ResultPipeline &&
1544 "Wrong pipeline at the bottom of the stack!");
1545 return {std::move(ResultPipeline)};
1549 const PipelineElement &E) {
1550 auto &
Name = E.Name;
1551 auto &InnerPipeline = E.InnerPipeline;
1554 if (!InnerPipeline.empty()) {
1555 if (
Name ==
"module") {
1557 if (
auto Err = parseModulePassPipeline(NestedMPM, InnerPipeline))
1559 MPM.
addPass(std::move(NestedMPM));
1562 if (
Name ==
"coro-cond") {
1564 if (
auto Err = parseModulePassPipeline(NestedMPM, InnerPipeline))
1569 if (
Name ==
"cgscc") {
1571 if (
auto Err = parseCGSCCPassPipeline(CGPM, InnerPipeline))
1578 return make_error<StringError>(
1579 "cannot have a no-rerun module to function adaptor",
1582 if (
auto Err = parseFunctionPassPipeline(FPM, InnerPipeline))
1589 for (
auto &
C : ModulePipelineParsingCallbacks)
1590 if (
C(
Name, MPM, InnerPipeline))
1594 return make_error<StringError>(
1595 formatv(
"invalid use of '{0}' pass as module pipeline",
Name).str(),
1604 return make_error<StringError>(
1605 formatv(
"unknown default pipeline alias '{0}'",
Name).str(),
1608 assert(Matches.
size() == 3 &&
"Must capture two matched strings!");
1620 if (Matches[1] ==
"default") {
1622 }
else if (Matches[1] ==
"thinlto-pre-link") {
1624 }
else if (Matches[1] ==
"thinlto") {
1626 }
else if (Matches[1] ==
"lto-pre-link") {
1635 assert(Matches[1] ==
"lto" &&
"Not one of the matched options!");
1642#define MODULE_PASS(NAME, CREATE_PASS) \
1643 if (Name == NAME) { \
1644 MPM.addPass(CREATE_PASS); \
1645 return Error::success(); \
1647#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1648 if (checkParametrizedPassName(Name, NAME)) { \
1649 auto Params = parsePassParameters(PARSER, Name, NAME); \
1651 return Params.takeError(); \
1652 MPM.addPass(CREATE_PASS(Params.get())); \
1653 return Error::success(); \
1655#define MODULE_ANALYSIS(NAME, CREATE_PASS) \
1656 if (Name == "require<" NAME ">") { \
1658 RequireAnalysisPass< \
1659 std::remove_reference_t<decltype(CREATE_PASS)>, Module>()); \
1660 return Error::success(); \
1662 if (Name == "invalidate<" NAME ">") { \
1663 MPM.addPass(InvalidateAnalysisPass< \
1664 std::remove_reference_t<decltype(CREATE_PASS)>>()); \
1665 return Error::success(); \
1667#define CGSCC_PASS(NAME, CREATE_PASS) \
1668 if (Name == NAME) { \
1669 MPM.addPass(createModuleToPostOrderCGSCCPassAdaptor(CREATE_PASS)); \
1670 return Error::success(); \
1672#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1673 if (checkParametrizedPassName(Name, NAME)) { \
1674 auto Params = parsePassParameters(PARSER, Name, NAME); \
1676 return Params.takeError(); \
1678 createModuleToPostOrderCGSCCPassAdaptor(CREATE_PASS(Params.get()))); \
1679 return Error::success(); \
1681#define FUNCTION_PASS(NAME, CREATE_PASS) \
1682 if (Name == NAME) { \
1683 MPM.addPass(createModuleToFunctionPassAdaptor(CREATE_PASS)); \
1684 return Error::success(); \
1686#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1687 if (checkParametrizedPassName(Name, NAME)) { \
1688 auto Params = parsePassParameters(PARSER, Name, NAME); \
1690 return Params.takeError(); \
1691 MPM.addPass(createModuleToFunctionPassAdaptor(CREATE_PASS(Params.get()))); \
1692 return Error::success(); \
1694#define LOOPNEST_PASS(NAME, CREATE_PASS) \
1695 if (Name == NAME) { \
1696 MPM.addPass(createModuleToFunctionPassAdaptor( \
1697 createFunctionToLoopPassAdaptor(CREATE_PASS, false, false))); \
1698 return Error::success(); \
1700#define LOOP_PASS(NAME, CREATE_PASS) \
1701 if (Name == NAME) { \
1702 MPM.addPass(createModuleToFunctionPassAdaptor( \
1703 createFunctionToLoopPassAdaptor(CREATE_PASS, false, false))); \
1704 return Error::success(); \
1706#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1707 if (checkParametrizedPassName(Name, NAME)) { \
1708 auto Params = parsePassParameters(PARSER, Name, NAME); \
1710 return Params.takeError(); \
1712 createModuleToFunctionPassAdaptor(createFunctionToLoopPassAdaptor( \
1713 CREATE_PASS(Params.get()), false, false))); \
1714 return Error::success(); \
1716#include "PassRegistry.def"
1718 for (
auto &
C : ModulePipelineParsingCallbacks)
1719 if (
C(
Name, MPM, InnerPipeline))
1721 return make_error<StringError>(
1727 const PipelineElement &E) {
1728 auto &
Name = E.Name;
1729 auto &InnerPipeline = E.InnerPipeline;
1732 if (!InnerPipeline.empty()) {
1733 if (
Name ==
"cgscc") {
1735 if (
auto Err = parseCGSCCPassPipeline(NestedCGPM, InnerPipeline))
1738 CGPM.
addPass(std::move(NestedCGPM));
1743 if (
auto Err = parseFunctionPassPipeline(FPM, InnerPipeline))
1747 std::move(FPM), Params->first, Params->second));
1752 if (
auto Err = parseCGSCCPassPipeline(NestedCGPM, InnerPipeline))
1759 for (
auto &
C : CGSCCPipelineParsingCallbacks)
1760 if (
C(
Name, CGPM, InnerPipeline))
1764 return make_error<StringError>(
1765 formatv(
"invalid use of '{0}' pass as cgscc pipeline",
Name).str(),
1770#define CGSCC_PASS(NAME, CREATE_PASS) \
1771 if (Name == NAME) { \
1772 CGPM.addPass(CREATE_PASS); \
1773 return Error::success(); \
1775#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1776 if (checkParametrizedPassName(Name, NAME)) { \
1777 auto Params = parsePassParameters(PARSER, Name, NAME); \
1779 return Params.takeError(); \
1780 CGPM.addPass(CREATE_PASS(Params.get())); \
1781 return Error::success(); \
1783#define CGSCC_ANALYSIS(NAME, CREATE_PASS) \
1784 if (Name == "require<" NAME ">") { \
1785 CGPM.addPass(RequireAnalysisPass< \
1786 std::remove_reference_t<decltype(CREATE_PASS)>, \
1787 LazyCallGraph::SCC, CGSCCAnalysisManager, LazyCallGraph &, \
1788 CGSCCUpdateResult &>()); \
1789 return Error::success(); \
1791 if (Name == "invalidate<" NAME ">") { \
1792 CGPM.addPass(InvalidateAnalysisPass< \
1793 std::remove_reference_t<decltype(CREATE_PASS)>>()); \
1794 return Error::success(); \
1796#define FUNCTION_PASS(NAME, CREATE_PASS) \
1797 if (Name == NAME) { \
1798 CGPM.addPass(createCGSCCToFunctionPassAdaptor(CREATE_PASS)); \
1799 return Error::success(); \
1801#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1802 if (checkParametrizedPassName(Name, NAME)) { \
1803 auto Params = parsePassParameters(PARSER, Name, NAME); \
1805 return Params.takeError(); \
1806 CGPM.addPass(createCGSCCToFunctionPassAdaptor(CREATE_PASS(Params.get()))); \
1807 return Error::success(); \
1809#define LOOPNEST_PASS(NAME, CREATE_PASS) \
1810 if (Name == NAME) { \
1811 CGPM.addPass(createCGSCCToFunctionPassAdaptor( \
1812 createFunctionToLoopPassAdaptor(CREATE_PASS, false, false))); \
1813 return Error::success(); \
1815#define LOOP_PASS(NAME, CREATE_PASS) \
1816 if (Name == NAME) { \
1817 CGPM.addPass(createCGSCCToFunctionPassAdaptor( \
1818 createFunctionToLoopPassAdaptor(CREATE_PASS, false, false))); \
1819 return Error::success(); \
1821#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1822 if (checkParametrizedPassName(Name, NAME)) { \
1823 auto Params = parsePassParameters(PARSER, Name, NAME); \
1825 return Params.takeError(); \
1827 createCGSCCToFunctionPassAdaptor(createFunctionToLoopPassAdaptor( \
1828 CREATE_PASS(Params.get()), false, false))); \
1829 return Error::success(); \
1831#include "PassRegistry.def"
1833 for (
auto &
C : CGSCCPipelineParsingCallbacks)
1834 if (
C(
Name, CGPM, InnerPipeline))
1836 return make_error<StringError>(
1842 const PipelineElement &E) {
1843 auto &
Name = E.Name;
1844 auto &InnerPipeline = E.InnerPipeline;
1847 if (!InnerPipeline.empty()) {
1848 if (
Name ==
"function") {
1850 if (
auto Err = parseFunctionPassPipeline(NestedFPM, InnerPipeline))
1853 FPM.
addPass(std::move(NestedFPM));
1856 if (
Name ==
"loop" ||
Name ==
"loop-mssa") {
1858 if (
auto Err = parseLoopPassPipeline(LPM, InnerPipeline))
1861 bool UseMemorySSA = (
Name ==
"loop-mssa");
1863 return Pipeline.Name.contains(
"simple-loop-unswitch");
1865 bool UseBPI =
llvm::any_of(InnerPipeline, [](
auto Pipeline) {
1866 return Pipeline.Name ==
"loop-predication";
1872 if (
Name ==
"machine-function") {
1874 if (
auto Err = parseMachinePassPipeline(MFPM, InnerPipeline))
1880 for (
auto &
C : FunctionPipelineParsingCallbacks)
1881 if (
C(
Name, FPM, InnerPipeline))
1885 return make_error<StringError>(
1886 formatv(
"invalid use of '{0}' pass as function pipeline",
Name).str(),
1891#define FUNCTION_PASS(NAME, CREATE_PASS) \
1892 if (Name == NAME) { \
1893 FPM.addPass(CREATE_PASS); \
1894 return Error::success(); \
1896#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1897 if (checkParametrizedPassName(Name, NAME)) { \
1898 auto Params = parsePassParameters(PARSER, Name, NAME); \
1900 return Params.takeError(); \
1901 FPM.addPass(CREATE_PASS(Params.get())); \
1902 return Error::success(); \
1904#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
1905 if (Name == "require<" NAME ">") { \
1907 RequireAnalysisPass< \
1908 std::remove_reference_t<decltype(CREATE_PASS)>, Function>()); \
1909 return Error::success(); \
1911 if (Name == "invalidate<" NAME ">") { \
1912 FPM.addPass(InvalidateAnalysisPass< \
1913 std::remove_reference_t<decltype(CREATE_PASS)>>()); \
1914 return Error::success(); \
1920#define LOOPNEST_PASS(NAME, CREATE_PASS) \
1921 if (Name == NAME) { \
1922 FPM.addPass(createFunctionToLoopPassAdaptor(CREATE_PASS, false, false)); \
1923 return Error::success(); \
1925#define LOOP_PASS(NAME, CREATE_PASS) \
1926 if (Name == NAME) { \
1927 FPM.addPass(createFunctionToLoopPassAdaptor(CREATE_PASS, false, false)); \
1928 return Error::success(); \
1930#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1931 if (checkParametrizedPassName(Name, NAME)) { \
1932 auto Params = parsePassParameters(PARSER, Name, NAME); \
1934 return Params.takeError(); \
1935 FPM.addPass(createFunctionToLoopPassAdaptor(CREATE_PASS(Params.get()), \
1937 return Error::success(); \
1939#include "PassRegistry.def"
1941 for (
auto &
C : FunctionPipelineParsingCallbacks)
1942 if (
C(
Name, FPM, InnerPipeline))
1944 return make_error<StringError>(
1945 formatv(
"unknown function pass '{0}'",
Name).str(),
1950 const PipelineElement &E) {
1952 auto &InnerPipeline = E.InnerPipeline;
1955 if (!InnerPipeline.empty()) {
1956 if (
Name ==
"loop") {
1958 if (
auto Err = parseLoopPassPipeline(NestedLPM, InnerPipeline))
1961 LPM.
addPass(std::move(NestedLPM));
1965 for (
auto &
C : LoopPipelineParsingCallbacks)
1966 if (
C(
Name, LPM, InnerPipeline))
1970 return make_error<StringError>(
1971 formatv(
"invalid use of '{0}' pass as loop pipeline",
Name).str(),
1976#define LOOPNEST_PASS(NAME, CREATE_PASS) \
1977 if (Name == NAME) { \
1978 LPM.addPass(CREATE_PASS); \
1979 return Error::success(); \
1981#define LOOP_PASS(NAME, CREATE_PASS) \
1982 if (Name == NAME) { \
1983 LPM.addPass(CREATE_PASS); \
1984 return Error::success(); \
1986#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1987 if (checkParametrizedPassName(Name, NAME)) { \
1988 auto Params = parsePassParameters(PARSER, Name, NAME); \
1990 return Params.takeError(); \
1991 LPM.addPass(CREATE_PASS(Params.get())); \
1992 return Error::success(); \
1994#define LOOP_ANALYSIS(NAME, CREATE_PASS) \
1995 if (Name == "require<" NAME ">") { \
1996 LPM.addPass(RequireAnalysisPass< \
1997 std::remove_reference_t<decltype(CREATE_PASS)>, Loop, \
1998 LoopAnalysisManager, LoopStandardAnalysisResults &, \
2000 return Error::success(); \
2002 if (Name == "invalidate<" NAME ">") { \
2003 LPM.addPass(InvalidateAnalysisPass< \
2004 std::remove_reference_t<decltype(CREATE_PASS)>>()); \
2005 return Error::success(); \
2007#include "PassRegistry.def"
2009 for (
auto &
C : LoopPipelineParsingCallbacks)
2010 if (
C(
Name, LPM, InnerPipeline))
2012 return make_error<StringError>(
formatv(
"unknown loop pass '{0}'",
Name).str(),
2017 const PipelineElement &E) {
2019 if (!E.InnerPipeline.empty())
2020 return make_error<StringError>(
"invalid pipeline",
2023#define MACHINE_MODULE_PASS(NAME, CREATE_PASS) \
2024 if (Name == NAME) { \
2025 MFPM.addPass(CREATE_PASS); \
2026 return Error::success(); \
2028#define MACHINE_FUNCTION_PASS(NAME, CREATE_PASS) \
2029 if (Name == NAME) { \
2030 MFPM.addPass(CREATE_PASS); \
2031 return Error::success(); \
2033#define MACHINE_FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, \
2035 if (checkParametrizedPassName(Name, NAME)) { \
2036 auto Params = parsePassParameters(PARSER, Name, NAME); \
2038 return Params.takeError(); \
2039 MFPM.addPass(CREATE_PASS(Params.get())); \
2040 return Error::success(); \
2042#define MACHINE_FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
2043 if (Name == "require<" NAME ">") { \
2045 RequireAnalysisPass<std::remove_reference_t<decltype(CREATE_PASS)>, \
2046 MachineFunction>()); \
2047 return Error::success(); \
2049 if (Name == "invalidate<" NAME ">") { \
2050 MFPM.addPass(InvalidateAnalysisPass< \
2051 std::remove_reference_t<decltype(CREATE_PASS)>>()); \
2052 return Error::success(); \
2054#include "llvm/Passes/MachinePassRegistry.def"
2056 for (
auto &
C : MachineFunctionPipelineParsingCallbacks)
2057 if (
C(
Name, MFPM, E.InnerPipeline))
2059 return make_error<StringError>(
2060 formatv(
"unknown machine pass '{0}'",
Name).str(),
2065#define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS) \
2066 if (Name == NAME) { \
2067 AA.registerModuleAnalysis< \
2068 std::remove_reference_t<decltype(CREATE_PASS)>>(); \
2071#define FUNCTION_ALIAS_ANALYSIS(NAME, CREATE_PASS) \
2072 if (Name == NAME) { \
2073 AA.registerFunctionAnalysis< \
2074 std::remove_reference_t<decltype(CREATE_PASS)>>(); \
2077#include "PassRegistry.def"
2079 for (
auto &
C : AAParsingCallbacks)
2085Error PassBuilder::parseMachinePassPipeline(
2087 for (
const auto &Element : Pipeline) {
2088 if (
auto Err = parseMachinePass(MFPM, Element))
2096 for (
const auto &Element : Pipeline) {
2097 if (
auto Err = parseLoopPass(LPM, Element))
2103Error PassBuilder::parseFunctionPassPipeline(
2105 for (
const auto &Element : Pipeline) {
2106 if (
auto Err = parseFunctionPass(FPM, Element))
2114 for (
const auto &Element : Pipeline) {
2115 if (
auto Err = parseCGSCCPass(CGPM, Element))
2147 for (
const auto &Element : Pipeline) {
2148 if (
auto Err = parseModulePass(MPM, Element))
2159 auto Pipeline = parsePipelineText(PipelineText);
2160 if (!Pipeline || Pipeline->empty())
2161 return make_error<StringError>(
2162 formatv(
"invalid pipeline '{0}'", PipelineText).str(),
2172 Pipeline = {{
"cgscc", std::move(*Pipeline)}};
2174 FunctionPipelineParsingCallbacks)) {
2175 Pipeline = {{
"function", std::move(*Pipeline)}};
2178 Pipeline = {{
"function", {{UseMemorySSA ?
"loop-mssa" :
"loop",
2179 std::move(*Pipeline)}}}};
2180 }
else if (
isLoopPassName(FirstName, LoopPipelineParsingCallbacks,
2182 Pipeline = {{
"function", {{UseMemorySSA ?
"loop-mssa" :
"loop",
2183 std::move(*Pipeline)}}}};
2185 FirstName, MachineFunctionPipelineParsingCallbacks)) {
2186 Pipeline = {{
"function", {{
"machine-function", std::move(*Pipeline)}}}};
2188 for (
auto &
C : TopLevelPipelineParsingCallbacks)
2189 if (
C(MPM, *Pipeline))
2193 auto &InnerPipeline = Pipeline->front().InnerPipeline;
2194 return make_error<StringError>(
2195 formatv(
"unknown {0} name '{1}'",
2196 (InnerPipeline.empty() ?
"pass" :
"pipeline"), FirstName)
2202 if (
auto Err = parseModulePassPipeline(MPM, *Pipeline))
2210 auto Pipeline = parsePipelineText(PipelineText);
2211 if (!Pipeline || Pipeline->empty())
2212 return make_error<StringError>(
2213 formatv(
"invalid pipeline '{0}'", PipelineText).str(),
2218 return make_error<StringError>(
2219 formatv(
"unknown cgscc pass '{0}' in pipeline '{1}'", FirstName,
2224 if (
auto Err = parseCGSCCPassPipeline(CGPM, *Pipeline))
2233 auto Pipeline = parsePipelineText(PipelineText);
2234 if (!Pipeline || Pipeline->empty())
2235 return make_error<StringError>(
2236 formatv(
"invalid pipeline '{0}'", PipelineText).str(),
2241 return make_error<StringError>(
2242 formatv(
"unknown function pass '{0}' in pipeline '{1}'", FirstName,
2247 if (
auto Err = parseFunctionPassPipeline(FPM, *Pipeline))
2255 auto Pipeline = parsePipelineText(PipelineText);
2256 if (!Pipeline || Pipeline->empty())
2257 return make_error<StringError>(
2258 formatv(
"invalid pipeline '{0}'", PipelineText).str(),
2261 if (
auto Err = parseLoopPassPipeline(CGPM, *Pipeline))
2269 auto Pipeline = parsePipelineText(PipelineText);
2270 if (!Pipeline || Pipeline->empty())
2271 return make_error<StringError>(
2272 formatv(
"invalid machine pass pipeline '{0}'", PipelineText).str(),
2275 if (
auto Err = parseMachinePassPipeline(MFPM, *Pipeline))
2284 if (PipelineText ==
"default") {
2289 while (!PipelineText.
empty()) {
2291 std::tie(
Name, PipelineText) = PipelineText.
split(
',');
2292 if (!parseAAPassName(AA,
Name))
2293 return make_error<StringError>(
2294 formatv(
"unknown alias analysis name '{0}'",
Name).str(),
2301std::optional<RegAllocFilterFunc>
2303 if (FilterName ==
"all")
2305 for (
auto &
C : RegClassFilterParsingCallbacks)
2306 if (
auto F =
C(FilterName))
2308 return std::nullopt;
2316 OS <<
" " <<
PassName <<
"<" << Params <<
">\n";
2322 OS <<
"Module passes:\n";
2323#define MODULE_PASS(NAME, CREATE_PASS) printPassName(NAME, OS);
2324#include "PassRegistry.def"
2326 OS <<
"Module passes with params:\n";
2327#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2328 printPassName(NAME, PARAMS, OS);
2329#include "PassRegistry.def"
2331 OS <<
"Module analyses:\n";
2332#define MODULE_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
2333#include "PassRegistry.def"
2335 OS <<
"Module alias analyses:\n";
2336#define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
2337#include "PassRegistry.def"
2339 OS <<
"CGSCC passes:\n";
2340#define CGSCC_PASS(NAME, CREATE_PASS) printPassName(NAME, OS);
2341#include "PassRegistry.def"
2343 OS <<
"CGSCC passes with params:\n";
2344#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2345 printPassName(NAME, PARAMS, OS);
2346#include "PassRegistry.def"
2348 OS <<
"CGSCC analyses:\n";
2349#define CGSCC_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
2350#include "PassRegistry.def"
2352 OS <<
"Function passes:\n";
2353#define FUNCTION_PASS(NAME, CREATE_PASS) printPassName(NAME, OS);
2354#include "PassRegistry.def"
2356 OS <<
"Function passes with params:\n";
2357#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2358 printPassName(NAME, PARAMS, OS);
2359#include "PassRegistry.def"
2361 OS <<
"Function analyses:\n";
2362#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
2363#include "PassRegistry.def"
2365 OS <<
"Function alias analyses:\n";
2366#define FUNCTION_ALIAS_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
2367#include "PassRegistry.def"
2369 OS <<
"LoopNest passes:\n";
2370#define LOOPNEST_PASS(NAME, CREATE_PASS) printPassName(NAME, OS);
2371#include "PassRegistry.def"
2373 OS <<
"Loop passes:\n";
2374#define LOOP_PASS(NAME, CREATE_PASS) printPassName(NAME, OS);
2375#include "PassRegistry.def"
2377 OS <<
"Loop passes with params:\n";
2378#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2379 printPassName(NAME, PARAMS, OS);
2380#include "PassRegistry.def"
2382 OS <<
"Loop analyses:\n";
2383#define LOOP_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
2384#include "PassRegistry.def"
2386 OS <<
"Machine module passes (WIP):\n";
2387#define MACHINE_MODULE_PASS(NAME, CREATE_PASS) printPassName(NAME, OS);
2388#include "llvm/Passes/MachinePassRegistry.def"
2390 OS <<
"Machine function passes (WIP):\n";
2391#define MACHINE_FUNCTION_PASS(NAME, CREATE_PASS) printPassName(NAME, OS);
2392#include "llvm/Passes/MachinePassRegistry.def"
2394 OS <<
"Machine function analyses (WIP):\n";
2395#define MACHINE_FUNCTION_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
2396#include "llvm/Passes/MachinePassRegistry.def"
2402 TopLevelPipelineParsingCallbacks.push_back(
C);
unsigned const MachineRegisterInfo * MRI
AggressiveInstCombiner - Combine expression patterns to form expressions with fewer,...
This file implements a simple N^2 alias analysis accuracy evaluator.
Provides passes to inlining "always_inline" functions.
This is the interface for LLVM's primary stateless and local alias analysis.
This file provides the interface for LLVM's Call Graph Profile pass.
This header provides classes for managing passes over SCCs of the call graph.
This file provides interfaces used to build and manipulate a call graph, which is a very useful tool ...
Defines an IR pass for CodeGen Prepare.
This file declares an analysis pass that computes CycleInfo for LLVM IR, specialized from GenericCycl...
This file provides the interface for a simple, fast CSE pass.
This file provides a pass which clones the current module and runs the provided pass pipeline on the ...
Super simple passes to force specific function attrs from the commandline into the IR for debugging p...
Provides passes for computing function attributes based on interprocedural analyses.
This file provides the interface for the GCOV style profiler pass.
This file provides the interface for LLVM's Global Value Numbering pass which eliminates fully redund...
This is the interface for a simple mod/ref and alias analysis over globals.
Defines an IR pass for the creation of hardware loops.
AcceleratorCodeSelection - Identify all functions reachable from a kernel, removing those that are un...
This file defines passes to print out IR in various granularities.
This header defines various interfaces for pass management in LLVM.
Interfaces for passes which infer implicit function attributes from the name and signature of functio...
This file provides the primary interface to the instcombine pass.
Defines passes for running instruction simplification across chunks of IR.
This file provides the interface for LLVM's PGO Instrumentation lowering pass.
This file contains the declaration of the InterleavedAccessPass class, its corresponding pass name is...
See the comments on JumpThreadingPass.
Implements a lazy call graph analysis and related passes for the new pass manager.
This file defines the interface for the loop cache analysis.
This file provides the interface for LLVM's Loop Data Prefetching Pass.
This file implements the Loop Fusion pass.
This header defines the LoopLoadEliminationPass object.
This file defines the interface for the loop nest analysis.
This header provides classes for managing a pipeline of passes over loops in LLVM IR.
This file provides the interface for the pass responsible for removing expensive ubsan checks.
The header file for the LowerConstantIntrinsics pass as used by the new pass manager.
The header file for the LowerExpectIntrinsic pass as used by the new pass manager.
This file exposes an interface to building/using memory SSA to walk memory instructions using a use/d...
This pass performs merges of loads and stores on both sides of a.
This is the interface to build a ModuleSummaryIndex for a module.
Contains a collection of routines for determining if a given instruction is guaranteed to execute if ...
This file provides the interface for LLVM's Global Value Numbering pass.
This file declares a simple ARC-aware AliasAnalysis using special knowledge of Objective C to enhance...
This header enumerates the LLVM-provided high-level optimization levels.
This file provides the interface for IR based instrumentation passes ( (profile-gen,...
CGSCCAnalysisManager CGAM
FunctionAnalysisManager FAM
ModuleAnalysisManager MAM
PassInstrumentationCallbacks PIC
PassBuilder PB(Machine, PassOpts->PTO, std::nullopt, &PIC)
static bool isModulePassName(StringRef Name, CallbacksT &Callbacks)
static bool callbacksAcceptPassName(StringRef Name, CallbacksT &Callbacks)
Tests whether registered callbacks will accept a given pass name.
static std::optional< int > parseDevirtPassName(StringRef Name)
static bool startsWithDefaultPipelineAliasPrefix(StringRef Name)
Tests whether a pass name starts with a valid prefix for a default pipeline alias.
static bool isLoopNestPassName(StringRef Name, CallbacksT &Callbacks, bool &UseMemorySSA)
static bool isMachineFunctionPassName(StringRef Name, CallbacksT &Callbacks)
static std::optional< OptimizationLevel > parseOptLevel(StringRef S)
static bool isLoopPassName(StringRef Name, CallbacksT &Callbacks, bool &UseMemorySSA)
static std::optional< std::pair< bool, bool > > parseFunctionPipelineName(StringRef Name)
static bool isCGSCCPassName(StringRef Name, CallbacksT &Callbacks)
static void printPassName(StringRef PassName, raw_ostream &OS)
static bool isFunctionPassName(StringRef Name, CallbacksT &Callbacks)
static const Regex DefaultAliasRegex("^(default|thinlto-pre-link|thinlto|lto-pre-link|lto)<(O[0123sz])>$")
This file implements the PredicateInfo analysis, which creates an Extended SSA form for operations us...
This pass is required to take advantage of the interprocedural register allocation infrastructure.
This file implements relative lookup table converter that converts lookup tables to relative lookup t...
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file provides the interface for LLVM's Scalar Replacement of Aggregates pass.
This file provides the interface for the pseudo probe implementation for AutoFDO.
This file provides the interface for the sampled PGO loader pass.
This is the interface for a SCEV-based alias analysis.
This pass converts vector operations into scalar operations (or, optionally, operations on smaller ve...
This is the interface for a metadata-based scoped no-alias analysis.
This file contains the declaration of the SelectOptimizePass class, its corresponding pass name is se...
This file provides the interface for the pass responsible for both simplifying and canonicalizing the...
This file implements the StringSwitch template, which mimics a switch() statement whose cases are str...
Target-Independent Code Generator Pass Configuration Options pass.
This is the interface for a metadata-based TBAA.
static const char PassName[]
A manager for alias analyses.
Class for arbitrary precision integers.
uint64_t getZExtValue() const
Get zero extended value.
int64_t getSExtValue() const
Get sign extended value.
A container for analyses that lazily runs them and caches their results.
bool registerPass(PassBuilderT &&PassBuilder)
Register an analysis pass with the manager.
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
LLVM Basic Block Representation.
const Instruction * getTerminator() const LLVM_READONLY
Returns the terminator instruction if the block is well formed or null if the block is not well forme...
Lightweight error class with error context and mandatory checking.
static ErrorSuccess success()
Create a success value.
Tagged union holding either a T or a Error.
static GlobalAlias * create(Type *Ty, unsigned AddressSpace, LinkageTypes Linkage, const Twine &Name, Constant *Aliasee, Module *Parent)
If a parent module is specified, the alias is automatically inserted into the end of the specified mo...
An analysis over an "outer" IR unit that provides access to an analysis manager over an "inner" IR un...
static constexpr LLT scalar(unsigned SizeInBits)
Get a low-level scalar or aggregate "bag of bits".
An RAII based helper class to modify MachineFunctionProperties when running pass.
Properties which a MachineFunction may have at a given point in time.
MachineFunctionProperties & set(Property P)
MachineRegisterInfo & getRegInfo()
getRegInfo - Return information about the registers currently in use.
const MachineFunctionProperties & getProperties() const
Get the function properties.
A Module instance is used to store all the information related to an LLVM module.
static const OptimizationLevel O3
Optimize for fast execution as much as possible.
static const OptimizationLevel Oz
A very specialized mode that will optimize for code size at any and all costs.
static const OptimizationLevel O0
Disable as many optimizations as possible.
static const OptimizationLevel Os
Similar to O2 but tries to optimize for small code size instead of fast execution without triggering ...
static const OptimizationLevel O2
Optimize for fast execution as much as possible without triggering significant incremental compile ti...
static const OptimizationLevel O1
Optimize quickly without destroying debuggability.
This class provides access to building LLVM's passes.
void printPassNames(raw_ostream &OS)
Print pass names.
static bool checkParametrizedPassName(StringRef Name, StringRef PassName)
AAManager buildDefaultAAPipeline()
Build the default AAManager with the default alias analysis pipeline registered.
Error parseAAPipeline(AAManager &AA, StringRef PipelineText)
Parse a textual alias analysis pipeline into the provided AA manager.
ModulePassManager buildThinLTOPreLinkDefaultPipeline(OptimizationLevel Level)
Build a pre-link, ThinLTO-targeting default optimization pipeline to a pass manager.
PassBuilder(TargetMachine *TM=nullptr, PipelineTuningOptions PTO=PipelineTuningOptions(), std::optional< PGOOptions > PGOOpt=std::nullopt, PassInstrumentationCallbacks *PIC=nullptr)
void registerLoopAnalyses(LoopAnalysisManager &LAM)
Registers all available loop analysis passes.
std::optional< RegAllocFilterFunc > parseRegAllocFilter(StringRef RegAllocFilterName)
Parse RegAllocFilterName to get RegAllocFilterFunc.
void crossRegisterProxies(LoopAnalysisManager &LAM, FunctionAnalysisManager &FAM, CGSCCAnalysisManager &CGAM, ModuleAnalysisManager &MAM, MachineFunctionAnalysisManager *MFAM=nullptr)
Cross register the analysis managers through their proxies.
ModulePassManager buildPerModuleDefaultPipeline(OptimizationLevel Level, ThinOrFullLTOPhase Phase=ThinOrFullLTOPhase::None)
Build a per-module default optimization pipeline.
Error parsePassPipeline(ModulePassManager &MPM, StringRef PipelineText)
Parse a textual pass pipeline description into a ModulePassManager.
ModulePassManager buildLTODefaultPipeline(OptimizationLevel Level, ModuleSummaryIndex *ExportSummary)
Build an LTO default optimization pipeline to a pass manager.
ModulePassManager buildThinLTODefaultPipeline(OptimizationLevel Level, const ModuleSummaryIndex *ImportSummary)
Build a ThinLTO default optimization pipeline to a pass manager.
void registerModuleAnalyses(ModuleAnalysisManager &MAM)
Registers all available module analysis passes.
void registerCGSCCAnalyses(CGSCCAnalysisManager &CGAM)
Registers all available CGSCC analysis passes.
static Expected< bool > parseSinglePassOption(StringRef Params, StringRef OptionName, StringRef PassName)
Handle passes only accept one bool-valued parameter.
void registerMachineFunctionAnalyses(MachineFunctionAnalysisManager &MFAM)
Registers all available machine function analysis passes.
void registerParseTopLevelPipelineCallback(const std::function< bool(ModulePassManager &, ArrayRef< PipelineElement >)> &C)
Register a callback for a top-level pipeline entry.
ModulePassManager buildLTOPreLinkDefaultPipeline(OptimizationLevel Level)
Build a pre-link, LTO-targeting default optimization pipeline to a pass manager.
void registerFunctionAnalyses(FunctionAnalysisManager &FAM)
Registers all available function analysis passes.
LLVM_ATTRIBUTE_MINSIZE std::enable_if_t< is_detected< HasRunOnLoopT, PassT >::value > addPass(PassT &&Pass)
LLVM_ATTRIBUTE_MINSIZE std::enable_if_t<!std::is_same_v< PassT, PassManager > > addPass(PassT &&Pass)
Tunable parameters for passes in the default pipelines.
bool SLPVectorization
Tuning option to enable/disable slp loop vectorization, set based on opt level.
bool LoopVectorization
Tuning option to enable/disable loop vectorization, set based on opt level.
static PointerType * getUnqual(Type *ElementType)
This constructs a pointer to an object of the specified type in the default address space (address sp...
A set of analyses that are preserved following a run of a transformation pass.
static PreservedAnalyses none()
Convenience factory function for the empty preserved set.
static PreservedAnalyses all()
Construct a special preserved set that preserves all passes.
bool match(StringRef String, SmallVectorImpl< StringRef > *Matches=nullptr, std::string *Error=nullptr) const
matches - Match the regex against a given String.
void push_back(const T &Elt)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
StringRef - Represent a constant reference to a string, i.e.
std::pair< StringRef, StringRef > split(char Separator) const
Split into two substrings around the first occurrence of a separator character.
bool getAsInteger(unsigned Radix, T &Result) const
Parse the current string as an integer of the specified radix.
std::string str() const
str - Get the contents as an std::string.
constexpr bool empty() const
empty - Check if the string is empty.
char front() const
front - Get the first character in the string.
bool consume_front(StringRef Prefix)
Returns true if this StringRef has the given prefix and removes that prefix.
A switch()-like statement whose cases are string literals.
StringSwitch & Case(StringLiteral S, T Value)
Primary interface to the complete machine description for the target machine.
This function has undefined behavior.
self_iterator getIterator()
This class implements an extremely fast bulk output stream that can only output to a stream.
Interfaces for registering analysis passes, producing common pass manager configurations,...
@ C
The default llvm calling convention, compatible with C.
PointerTypeMap run(const Module &M)
Compute the PointerTypeMap for the module M.
This is an optimization pass for GlobalISel generic memory operations.
ModuleToFunctionPassAdaptor createModuleToFunctionPassAdaptor(FunctionPassT &&Pass, bool EagerlyInvalidate=false)
A function to deduce a function pass type and wrap it in the templated adaptor.
DevirtSCCRepeatedPass createDevirtSCCRepeatedPass(CGSCCPassT &&Pass, int MaxIterations)
A function to deduce a function pass type and wrap it in the templated adaptor.
std::error_code inconvertibleErrorCode()
The value returned by this function can be returned from convertToErrorCode for Error values where no...
OuterAnalysisManagerProxy< ModuleAnalysisManager, MachineFunction > ModuleAnalysisManagerMachineFunctionProxy
Provide the ModuleAnalysisManager to Function proxy.
OuterAnalysisManagerProxy< ModuleAnalysisManager, Function > ModuleAnalysisManagerFunctionProxy
Provide the ModuleAnalysisManager to Function proxy.
InnerAnalysisManagerProxy< MachineFunctionAnalysisManager, Module > MachineFunctionAnalysisManagerModuleProxy
OuterAnalysisManagerProxy< ModuleAnalysisManager, LazyCallGraph::SCC, LazyCallGraph & > ModuleAnalysisManagerCGSCCProxy
A proxy from a ModuleAnalysisManager to an SCC.
bool any_of(R &&range, UnaryPredicate P)
Provide wrappers to std::any_of which take ranges instead of having to pass begin/end explicitly.
ModuleToPostOrderCGSCCPassAdaptor createModuleToPostOrderCGSCCPassAdaptor(CGSCCPassT &&Pass)
A function to deduce a function pass type and wrap it in the templated adaptor.
auto formatv(bool Validate, const char *Fmt, Ts &&...Vals)
CGSCCToFunctionPassAdaptor createCGSCCToFunctionPassAdaptor(FunctionPassT &&Pass, bool EagerlyInvalidate=false, bool NoRerun=false)
A function to deduce a function pass type and wrap it in the templated adaptor.
InnerAnalysisManagerProxy< FunctionAnalysisManager, Module > FunctionAnalysisManagerModuleProxy
Provide the FunctionAnalysisManager to Module proxy.
FunctionToMachineFunctionPassAdaptor createFunctionToMachineFunctionPassAdaptor(MachineFunctionPassT &&Pass)
InnerAnalysisManagerProxy< MachineFunctionAnalysisManager, Function > MachineFunctionAnalysisManagerFunctionProxy
OuterAnalysisManagerProxy< FunctionAnalysisManager, Loop, LoopStandardAnalysisResults & > FunctionAnalysisManagerLoopProxy
A proxy from a FunctionAnalysisManager to a Loop.
cl::opt< bool > PrintPipelinePasses
Common option used by multiple tools to print pipeline passes.
OuterAnalysisManagerProxy< CGSCCAnalysisManager, Function > CGSCCAnalysisManagerFunctionProxy
A proxy from a CGSCCAnalysisManager to a Function.
std::enable_if_t< is_detected< HasRunOnLoopT, LoopPassT >::value, FunctionToLoopPassAdaptor > createFunctionToLoopPassAdaptor(LoopPassT &&Pass, bool UseMemorySSA=false, bool UseBlockFrequencyInfo=false, bool UseBranchProbabilityInfo=false)
A function to deduce a loop pass type and wrap it in the templated adaptor.
@ Detailed
Hash with opcode only.
@ CallTargetIgnored
Hash with opcode and operands.
A special type used by analysis passes to provide an address that identifies that particular analysis...
A set of parameters to control various transforms performed by GVN pass.
HardwareLoopOptions & setForceNested(bool Force)
HardwareLoopOptions & setDecrement(unsigned Count)
HardwareLoopOptions & setForceGuard(bool Force)
HardwareLoopOptions & setForce(bool Force)
HardwareLoopOptions & setCounterBitwidth(unsigned Width)
HardwareLoopOptions & setForcePhi(bool Force)
A set of parameters to control various transforms performed by IPSCCP pass.
A set of parameters used to control various transforms performed by the LoopUnroll pass.
LoopUnrollOptions & setPeeling(bool Peeling)
Enables or disables loop peeling.
LoopUnrollOptions & setOptLevel(int O)
LoopUnrollOptions & setPartial(bool Partial)
Enables or disables partial unrolling.
LoopUnrollOptions & setFullUnrollMaxCount(unsigned O)
LoopUnrollOptions & setUpperBound(bool UpperBound)
Enables or disables the use of trip count upper bound in loop unrolling.
LoopUnrollOptions & setRuntime(bool Runtime)
Enables or disables unrolling of loops with runtime trip count.
LoopUnrollOptions & setProfileBasedPeeling(int O)
LoopVectorizeOptions & setVectorizeOnlyWhenForced(bool Value)
LoopVectorizeOptions & setInterleaveOnlyWhenForced(bool Value)
A CRTP mix-in to automatically provide informational APIs needed for passes.
static StringRef name()
Gets the name of the pass we are mixed into.
This class manages callbacks registration, as well as provides a way for PassInstrumentation to pass ...
void registerClassToPassNameCallback(CallableT C)
RegAllocFilterFunc Filter