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)
825parseLowerAllowCheckPassOptions(
StringRef Params) {
827 while (!Params.
empty()) {
829 std::tie(ParamName, Params) = Params.
split(
';');
840 std::tie(IndicesStr, CutoffStr) = ParamName.
split(
"]=");
846 return make_error<StringError>(
847 formatv(
"invalid LowerAllowCheck pass cutoffs parameter '{0}' "
853 if (!IndicesStr.
consume_front(
"cutoffs[") || IndicesStr ==
"")
854 return make_error<StringError>(
855 formatv(
"invalid LowerAllowCheck pass index parameter '{0}' "
857 IndicesStr, CutoffStr)
861 while (IndicesStr !=
"") {
863 std::tie(firstIndexStr, IndicesStr) = IndicesStr.
split(
'|');
867 return make_error<StringError>(
868 formatv(
"invalid LowerAllowCheck pass index parameter '{0}' "
870 firstIndexStr, IndicesStr)
877 if (index >=
Result.cutoffs.size())
878 Result.cutoffs.resize(index + 1, 0);
880 Result.cutoffs[index] = cutoff;
883 return make_error<StringError>(
884 formatv(
"invalid LowerAllowCheck pass parameter '{0}' ", ParamName)
895 while (!Params.
empty()) {
897 std::tie(ParamName, Params) = Params.
split(
';');
899 if (ParamName ==
"recover") {
901 }
else if (ParamName ==
"kernel") {
905 return make_error<StringError>(
906 formatv(
"invalid argument to MemorySanitizer pass track-origins "
911 }
else if (ParamName ==
"eager-checks") {
912 Result.EagerChecks =
true;
914 return make_error<StringError>(
915 formatv(
"invalid MemorySanitizer pass parameter '{0}' ", ParamName)
926 while (!Params.
empty()) {
928 std::tie(ParamName, Params) = Params.
split(
';');
931 if (ParamName ==
"speculate-blocks") {
933 }
else if (ParamName ==
"simplify-cond-branch") {
935 }
else if (ParamName ==
"forward-switch-cond") {
937 }
else if (ParamName ==
"switch-range-to-icmp") {
939 }
else if (ParamName ==
"switch-to-lookup") {
941 }
else if (ParamName ==
"keep-loops") {
943 }
else if (ParamName ==
"hoist-common-insts") {
945 }
else if (ParamName ==
"hoist-loads-stores-with-cond-faulting") {
947 }
else if (ParamName ==
"sink-common-insts") {
949 }
else if (ParamName ==
"speculate-unpredictables") {
952 APInt BonusInstThreshold;
954 return make_error<StringError>(
955 formatv(
"invalid argument to SimplifyCFG pass bonus-threshold "
961 return make_error<StringError>(
962 formatv(
"invalid SimplifyCFG pass parameter '{0}' ", ParamName).str(),
973 Result.setVerifyFixpoint(
true);
974 while (!Params.
empty()) {
976 std::tie(ParamName, Params) = Params.
split(
';');
979 if (ParamName ==
"verify-fixpoint") {
984 return make_error<StringError>(
985 formatv(
"invalid argument to InstCombine pass max-iterations "
991 return make_error<StringError>(
992 formatv(
"invalid InstCombine pass parameter '{0}' ", ParamName).str(),
1002 while (!Params.
empty()) {
1004 std::tie(ParamName, Params) = Params.
split(
';');
1007 if (ParamName ==
"interleave-forced-only") {
1009 }
else if (ParamName ==
"vectorize-forced-only") {
1012 return make_error<StringError>(
1013 formatv(
"invalid LoopVectorize parameter '{0}' ", ParamName).str(),
1021 std::pair<bool, bool>
Result = {
false,
true};
1022 while (!Params.
empty()) {
1024 std::tie(ParamName, Params) = Params.
split(
';');
1027 if (ParamName ==
"nontrivial") {
1029 }
else if (ParamName ==
"trivial") {
1032 return make_error<StringError>(
1033 formatv(
"invalid LoopUnswitch pass parameter '{0}' ", ParamName)
1043 while (!Params.
empty()) {
1045 std::tie(ParamName, Params) = Params.
split(
';');
1048 if (ParamName ==
"allowspeculation") {
1051 return make_error<StringError>(
1052 formatv(
"invalid LICM pass parameter '{0}' ", ParamName).str(),
1060 std::pair<bool, bool>
Result = {
true,
false};
1061 while (!Params.
empty()) {
1063 std::tie(ParamName, Params) = Params.
split(
';');
1066 if (ParamName ==
"header-duplication") {
1068 }
else if (ParamName ==
"prepare-for-lto") {
1071 return make_error<StringError>(
1072 formatv(
"invalid LoopRotate pass parameter '{0}' ", ParamName).str(),
1081 while (!Params.
empty()) {
1083 std::tie(ParamName, Params) = Params.
split(
';');
1086 if (ParamName ==
"split-footer-bb") {
1089 return make_error<StringError>(
1090 formatv(
"invalid MergedLoadStoreMotion pass parameter '{0}' ",
1101 while (!Params.
empty()) {
1103 std::tie(ParamName, Params) = Params.
split(
';');
1106 if (ParamName ==
"pre") {
1108 }
else if (ParamName ==
"load-pre") {
1110 }
else if (ParamName ==
"split-backedge-load-pre") {
1112 }
else if (ParamName ==
"memdep") {
1114 }
else if (ParamName ==
"memoryssa") {
1117 return make_error<StringError>(
1118 formatv(
"invalid GVN pass parameter '{0}' ", ParamName).str(),
1127 while (!Params.
empty()) {
1129 std::tie(ParamName, Params) = Params.
split(
';');
1132 if (ParamName ==
"func-spec")
1135 return make_error<StringError>(
1136 formatv(
"invalid IPSCCP pass parameter '{0}' ", ParamName).str(),
1144 while (!Params.
empty()) {
1146 std::tie(ParamName, Params) = Params.
split(
';');
1150 return make_error<StringError>(
1151 formatv(
"invalid argument to Scalarizer pass min-bits "
1152 "parameter: '{0}' ",
1162 if (ParamName ==
"load-store")
1164 else if (ParamName ==
"variable-insert-extract")
1167 return make_error<StringError>(
1168 formatv(
"invalid Scalarizer pass parameter '{0}' ", ParamName).str(),
1177 if (Params.
empty() || Params ==
"modify-cfg")
1179 if (Params ==
"preserve-cfg")
1181 return make_error<StringError>(
1182 formatv(
"invalid SROA pass parameter '{0}' (either preserve-cfg or "
1183 "modify-cfg can be specified)",
1190parseStackLifetimeOptions(
StringRef Params) {
1192 while (!Params.
empty()) {
1194 std::tie(ParamName, Params) = Params.
split(
';');
1196 if (ParamName ==
"may") {
1198 }
else if (ParamName ==
"must") {
1201 return make_error<StringError>(
1202 formatv(
"invalid StackLifetime parameter '{0}' ", ParamName).str(),
1211 "DependenceAnalysisPrinter");
1216 "SeparateConstOffsetFromGEP");
1225parseFunctionSimplificationPipelineOptions(
StringRef Params) {
1228 return make_error<StringError>(
1229 formatv(
"invalid function-simplification parameter '{0}' ", Params)
1238 "MemorySSAPrinterPass");
1243 "SpeculativeExecutionPass");
1248 while (!Params.
empty()) {
1250 std::tie(ParamName, Params) = Params.
split(
';');
1255 return make_error<StringError>(
1256 formatv(
"invalid MemProfUse pass parameter '{0}' ", ParamName).str(),
1264parseStructuralHashPrinterPassOptions(
StringRef Params) {
1267 if (Params ==
"detailed")
1269 if (Params ==
"call-target-ignored")
1271 return make_error<StringError>(
1272 formatv(
"invalid structural hash printer parameter '{0}' ", Params).str(),
1278 "WinEHPreparePass");
1283 while (!Params.
empty()) {
1285 std::tie(ParamName, Params) = Params.
split(
';');
1288 if (ParamName ==
"group-by-use")
1290 else if (ParamName ==
"ignore-single-use")
1292 else if (ParamName ==
"merge-const")
1294 else if (ParamName ==
"merge-external")
1298 return make_error<StringError>(
1299 formatv(
"invalid GlobalMergePass parameter '{0}' ", ParamName)
1309 while (!Params.
empty()) {
1311 std::tie(ParamName, Params) = Params.
split(
';');
1316 return make_error<StringError>(
1317 formatv(
"invalid Internalize pass parameter '{0}' ", ParamName).str(),
1328 while (!Params.
empty()) {
1330 std::tie(ParamName, Params) = Params.
split(
';');
1333 std::optional<RegAllocFilterFunc>
Filter =
1336 return make_error<StringError>(
1337 formatv(
"invalid regallocfast register filter '{0}' ", ParamName)
1346 if (ParamName ==
"no-clear-vregs") {
1351 return make_error<StringError>(
1352 formatv(
"invalid regallocfast pass parameter '{0}' ", ParamName).str(),
1359parseBoundsCheckingOptions(
StringRef Params) {
1361 while (!Params.
empty()) {
1363 std::tie(ParamName, Params) = Params.
split(
';');
1364 if (ParamName ==
"trap") {
1366 }
else if (ParamName ==
"rt") {
1371 }
else if (ParamName ==
"rt-abort") {
1376 }
else if (ParamName ==
"min-rt") {
1381 }
else if (ParamName ==
"min-rt-abort") {
1386 }
else if (ParamName ==
"merge") {
1391 std::tie(ParamEQ, Val) = ParamName.
split(
'=');
1396 return make_error<StringError>(
1397 formatv(
"invalid BoundsChecking pass parameter '{0}' ", ParamName)
1411 return Name.starts_with(
"default") ||
Name.starts_with(
"thinlto") ||
1412 Name.starts_with(
"lto");
1423template <
typename PassManagerT,
typename CallbacksT>
1425 if (!Callbacks.empty()) {
1426 PassManagerT DummyPM;
1427 for (
auto &CB : Callbacks)
1428 if (CB(
Name, DummyPM, {}))
1434template <
typename CallbacksT>
1440 StringRef NameNoBracket =
Name.take_until([](
char C) {
return C ==
'<'; });
1443 if (
Name ==
"module")
1445 if (
Name ==
"cgscc")
1447 if (NameNoBracket ==
"function")
1449 if (
Name ==
"coro-cond")
1452#define MODULE_PASS(NAME, CREATE_PASS) \
1455#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1456 if (PassBuilder::checkParametrizedPassName(Name, NAME)) \
1458#define MODULE_ANALYSIS(NAME, CREATE_PASS) \
1459 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \
1461#include "PassRegistry.def"
1463 return callbacksAcceptPassName<ModulePassManager>(
Name, Callbacks);
1466template <
typename CallbacksT>
1469 StringRef NameNoBracket =
Name.take_until([](
char C) {
return C ==
'<'; });
1470 if (
Name ==
"cgscc")
1472 if (NameNoBracket ==
"function")
1479#define CGSCC_PASS(NAME, CREATE_PASS) \
1482#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1483 if (PassBuilder::checkParametrizedPassName(Name, NAME)) \
1485#define CGSCC_ANALYSIS(NAME, CREATE_PASS) \
1486 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \
1488#include "PassRegistry.def"
1490 return callbacksAcceptPassName<CGSCCPassManager>(
Name, Callbacks);
1493template <
typename CallbacksT>
1496 StringRef NameNoBracket =
Name.take_until([](
char C) {
return C ==
'<'; });
1497 if (NameNoBracket ==
"function")
1499 if (
Name ==
"loop" ||
Name ==
"loop-mssa" ||
Name ==
"machine-function")
1502#define FUNCTION_PASS(NAME, CREATE_PASS) \
1505#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1506 if (PassBuilder::checkParametrizedPassName(Name, NAME)) \
1508#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
1509 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \
1511#include "PassRegistry.def"
1513 return callbacksAcceptPassName<FunctionPassManager>(
Name, Callbacks);
1516template <
typename CallbacksT>
1519 if (
Name ==
"machine-function")
1522#define MACHINE_FUNCTION_PASS(NAME, CREATE_PASS) \
1525#define MACHINE_FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, \
1527 if (PassBuilder::checkParametrizedPassName(Name, NAME)) \
1530#define MACHINE_FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
1531 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \
1534#include "llvm/Passes/MachinePassRegistry.def"
1536 return callbacksAcceptPassName<MachineFunctionPassManager>(
Name, Callbacks);
1539template <
typename CallbacksT>
1541 bool &UseMemorySSA) {
1542 UseMemorySSA =
false;
1545 UseMemorySSA =
true;
1549#define LOOPNEST_PASS(NAME, CREATE_PASS) \
1552#include "PassRegistry.def"
1554 return callbacksAcceptPassName<LoopPassManager>(
Name, Callbacks);
1557template <
typename CallbacksT>
1559 bool &UseMemorySSA) {
1560 UseMemorySSA =
false;
1563 UseMemorySSA =
true;
1567#define LOOP_PASS(NAME, CREATE_PASS) \
1570#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1571 if (PassBuilder::checkParametrizedPassName(Name, NAME)) \
1573#define LOOP_ANALYSIS(NAME, CREATE_PASS) \
1574 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \
1576#include "PassRegistry.def"
1578 return callbacksAcceptPassName<LoopPassManager>(
Name, Callbacks);
1581std::optional<std::vector<PassBuilder::PipelineElement>>
1582PassBuilder::parsePipelineText(
StringRef Text) {
1583 std::vector<PipelineElement> ResultPipeline;
1588 std::vector<PipelineElement> &Pipeline = *PipelineStack.
back();
1589 size_t Pos =
Text.find_first_of(
",()");
1590 Pipeline.push_back({
Text.substr(0, Pos), {}});
1593 if (Pos ==
Text.npos)
1596 char Sep =
Text[Pos];
1604 PipelineStack.
push_back(&Pipeline.back().InnerPipeline);
1608 assert(Sep ==
')' &&
"Bogus separator!");
1613 if (PipelineStack.
size() == 1)
1614 return std::nullopt;
1617 }
while (
Text.consume_front(
")"));
1625 if (!
Text.consume_front(
","))
1626 return std::nullopt;
1629 if (PipelineStack.
size() > 1)
1631 return std::nullopt;
1633 assert(PipelineStack.
back() == &ResultPipeline &&
1634 "Wrong pipeline at the bottom of the stack!");
1635 return {std::move(ResultPipeline)};
1639 const PipelineElement &E) {
1640 auto &
Name = E.Name;
1641 auto &InnerPipeline = E.InnerPipeline;
1644 if (!InnerPipeline.empty()) {
1645 if (
Name ==
"module") {
1647 if (
auto Err = parseModulePassPipeline(NestedMPM, InnerPipeline))
1649 MPM.
addPass(std::move(NestedMPM));
1652 if (
Name ==
"coro-cond") {
1654 if (
auto Err = parseModulePassPipeline(NestedMPM, InnerPipeline))
1659 if (
Name ==
"cgscc") {
1661 if (
auto Err = parseCGSCCPassPipeline(CGPM, InnerPipeline))
1668 return make_error<StringError>(
1669 "cannot have a no-rerun module to function adaptor",
1672 if (
auto Err = parseFunctionPassPipeline(FPM, InnerPipeline))
1679 for (
auto &
C : ModulePipelineParsingCallbacks)
1680 if (
C(
Name, MPM, InnerPipeline))
1684 return make_error<StringError>(
1685 formatv(
"invalid use of '{0}' pass as module pipeline",
Name).str(),
1694 return make_error<StringError>(
1695 formatv(
"unknown default pipeline alias '{0}'",
Name).str(),
1698 assert(Matches.
size() == 3 &&
"Must capture two matched strings!");
1710 if (Matches[1] ==
"default") {
1712 }
else if (Matches[1] ==
"thinlto-pre-link") {
1714 }
else if (Matches[1] ==
"thinlto") {
1716 }
else if (Matches[1] ==
"lto-pre-link") {
1725 assert(Matches[1] ==
"lto" &&
"Not one of the matched options!");
1732#define MODULE_PASS(NAME, CREATE_PASS) \
1733 if (Name == NAME) { \
1734 MPM.addPass(CREATE_PASS); \
1735 return Error::success(); \
1737#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1738 if (checkParametrizedPassName(Name, NAME)) { \
1739 auto Params = parsePassParameters(PARSER, Name, NAME); \
1741 return Params.takeError(); \
1742 MPM.addPass(CREATE_PASS(Params.get())); \
1743 return Error::success(); \
1745#define MODULE_ANALYSIS(NAME, CREATE_PASS) \
1746 if (Name == "require<" NAME ">") { \
1748 RequireAnalysisPass< \
1749 std::remove_reference_t<decltype(CREATE_PASS)>, Module>()); \
1750 return Error::success(); \
1752 if (Name == "invalidate<" NAME ">") { \
1753 MPM.addPass(InvalidateAnalysisPass< \
1754 std::remove_reference_t<decltype(CREATE_PASS)>>()); \
1755 return Error::success(); \
1757#define CGSCC_PASS(NAME, CREATE_PASS) \
1758 if (Name == NAME) { \
1759 MPM.addPass(createModuleToPostOrderCGSCCPassAdaptor(CREATE_PASS)); \
1760 return Error::success(); \
1762#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1763 if (checkParametrizedPassName(Name, NAME)) { \
1764 auto Params = parsePassParameters(PARSER, Name, NAME); \
1766 return Params.takeError(); \
1768 createModuleToPostOrderCGSCCPassAdaptor(CREATE_PASS(Params.get()))); \
1769 return Error::success(); \
1771#define FUNCTION_PASS(NAME, CREATE_PASS) \
1772 if (Name == NAME) { \
1773 MPM.addPass(createModuleToFunctionPassAdaptor(CREATE_PASS)); \
1774 return Error::success(); \
1776#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1777 if (checkParametrizedPassName(Name, NAME)) { \
1778 auto Params = parsePassParameters(PARSER, Name, NAME); \
1780 return Params.takeError(); \
1781 MPM.addPass(createModuleToFunctionPassAdaptor(CREATE_PASS(Params.get()))); \
1782 return Error::success(); \
1784#define LOOPNEST_PASS(NAME, CREATE_PASS) \
1785 if (Name == NAME) { \
1786 MPM.addPass(createModuleToFunctionPassAdaptor( \
1787 createFunctionToLoopPassAdaptor(CREATE_PASS, false, false))); \
1788 return Error::success(); \
1790#define LOOP_PASS(NAME, CREATE_PASS) \
1791 if (Name == NAME) { \
1792 MPM.addPass(createModuleToFunctionPassAdaptor( \
1793 createFunctionToLoopPassAdaptor(CREATE_PASS, false, false))); \
1794 return Error::success(); \
1796#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1797 if (checkParametrizedPassName(Name, NAME)) { \
1798 auto Params = parsePassParameters(PARSER, Name, NAME); \
1800 return Params.takeError(); \
1802 createModuleToFunctionPassAdaptor(createFunctionToLoopPassAdaptor( \
1803 CREATE_PASS(Params.get()), false, false))); \
1804 return Error::success(); \
1806#include "PassRegistry.def"
1808 for (
auto &
C : ModulePipelineParsingCallbacks)
1809 if (
C(
Name, MPM, InnerPipeline))
1811 return make_error<StringError>(
1817 const PipelineElement &E) {
1818 auto &
Name = E.Name;
1819 auto &InnerPipeline = E.InnerPipeline;
1822 if (!InnerPipeline.empty()) {
1823 if (
Name ==
"cgscc") {
1825 if (
auto Err = parseCGSCCPassPipeline(NestedCGPM, InnerPipeline))
1828 CGPM.
addPass(std::move(NestedCGPM));
1833 if (
auto Err = parseFunctionPassPipeline(FPM, InnerPipeline))
1837 std::move(FPM), Params->first, Params->second));
1842 if (
auto Err = parseCGSCCPassPipeline(NestedCGPM, InnerPipeline))
1849 for (
auto &
C : CGSCCPipelineParsingCallbacks)
1850 if (
C(
Name, CGPM, InnerPipeline))
1854 return make_error<StringError>(
1855 formatv(
"invalid use of '{0}' pass as cgscc pipeline",
Name).str(),
1860#define CGSCC_PASS(NAME, CREATE_PASS) \
1861 if (Name == NAME) { \
1862 CGPM.addPass(CREATE_PASS); \
1863 return Error::success(); \
1865#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1866 if (checkParametrizedPassName(Name, NAME)) { \
1867 auto Params = parsePassParameters(PARSER, Name, NAME); \
1869 return Params.takeError(); \
1870 CGPM.addPass(CREATE_PASS(Params.get())); \
1871 return Error::success(); \
1873#define CGSCC_ANALYSIS(NAME, CREATE_PASS) \
1874 if (Name == "require<" NAME ">") { \
1875 CGPM.addPass(RequireAnalysisPass< \
1876 std::remove_reference_t<decltype(CREATE_PASS)>, \
1877 LazyCallGraph::SCC, CGSCCAnalysisManager, LazyCallGraph &, \
1878 CGSCCUpdateResult &>()); \
1879 return Error::success(); \
1881 if (Name == "invalidate<" NAME ">") { \
1882 CGPM.addPass(InvalidateAnalysisPass< \
1883 std::remove_reference_t<decltype(CREATE_PASS)>>()); \
1884 return Error::success(); \
1886#define FUNCTION_PASS(NAME, CREATE_PASS) \
1887 if (Name == NAME) { \
1888 CGPM.addPass(createCGSCCToFunctionPassAdaptor(CREATE_PASS)); \
1889 return Error::success(); \
1891#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1892 if (checkParametrizedPassName(Name, NAME)) { \
1893 auto Params = parsePassParameters(PARSER, Name, NAME); \
1895 return Params.takeError(); \
1896 CGPM.addPass(createCGSCCToFunctionPassAdaptor(CREATE_PASS(Params.get()))); \
1897 return Error::success(); \
1899#define LOOPNEST_PASS(NAME, CREATE_PASS) \
1900 if (Name == NAME) { \
1901 CGPM.addPass(createCGSCCToFunctionPassAdaptor( \
1902 createFunctionToLoopPassAdaptor(CREATE_PASS, false, false))); \
1903 return Error::success(); \
1905#define LOOP_PASS(NAME, CREATE_PASS) \
1906 if (Name == NAME) { \
1907 CGPM.addPass(createCGSCCToFunctionPassAdaptor( \
1908 createFunctionToLoopPassAdaptor(CREATE_PASS, false, false))); \
1909 return Error::success(); \
1911#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1912 if (checkParametrizedPassName(Name, NAME)) { \
1913 auto Params = parsePassParameters(PARSER, Name, NAME); \
1915 return Params.takeError(); \
1917 createCGSCCToFunctionPassAdaptor(createFunctionToLoopPassAdaptor( \
1918 CREATE_PASS(Params.get()), false, false))); \
1919 return Error::success(); \
1921#include "PassRegistry.def"
1923 for (
auto &
C : CGSCCPipelineParsingCallbacks)
1924 if (
C(
Name, CGPM, InnerPipeline))
1926 return make_error<StringError>(
1932 const PipelineElement &E) {
1933 auto &
Name = E.Name;
1934 auto &InnerPipeline = E.InnerPipeline;
1937 if (!InnerPipeline.empty()) {
1938 if (
Name ==
"function") {
1940 if (
auto Err = parseFunctionPassPipeline(NestedFPM, InnerPipeline))
1943 FPM.
addPass(std::move(NestedFPM));
1946 if (
Name ==
"loop" ||
Name ==
"loop-mssa") {
1948 if (
auto Err = parseLoopPassPipeline(LPM, InnerPipeline))
1951 bool UseMemorySSA = (
Name ==
"loop-mssa");
1953 return Pipeline.Name.contains(
"simple-loop-unswitch");
1955 bool UseBPI =
llvm::any_of(InnerPipeline, [](
auto Pipeline) {
1956 return Pipeline.Name ==
"loop-predication";
1962 if (
Name ==
"machine-function") {
1964 if (
auto Err = parseMachinePassPipeline(MFPM, InnerPipeline))
1970 for (
auto &
C : FunctionPipelineParsingCallbacks)
1971 if (
C(
Name, FPM, InnerPipeline))
1975 return make_error<StringError>(
1976 formatv(
"invalid use of '{0}' pass as function pipeline",
Name).str(),
1981#define FUNCTION_PASS(NAME, CREATE_PASS) \
1982 if (Name == NAME) { \
1983 FPM.addPass(CREATE_PASS); \
1984 return Error::success(); \
1986#define FUNCTION_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 FPM.addPass(CREATE_PASS(Params.get())); \
1992 return Error::success(); \
1994#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
1995 if (Name == "require<" NAME ">") { \
1997 RequireAnalysisPass< \
1998 std::remove_reference_t<decltype(CREATE_PASS)>, Function>()); \
1999 return Error::success(); \
2001 if (Name == "invalidate<" NAME ">") { \
2002 FPM.addPass(InvalidateAnalysisPass< \
2003 std::remove_reference_t<decltype(CREATE_PASS)>>()); \
2004 return Error::success(); \
2010#define LOOPNEST_PASS(NAME, CREATE_PASS) \
2011 if (Name == NAME) { \
2012 FPM.addPass(createFunctionToLoopPassAdaptor(CREATE_PASS, false, false)); \
2013 return Error::success(); \
2015#define LOOP_PASS(NAME, CREATE_PASS) \
2016 if (Name == NAME) { \
2017 FPM.addPass(createFunctionToLoopPassAdaptor(CREATE_PASS, false, false)); \
2018 return Error::success(); \
2020#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2021 if (checkParametrizedPassName(Name, NAME)) { \
2022 auto Params = parsePassParameters(PARSER, Name, NAME); \
2024 return Params.takeError(); \
2025 FPM.addPass(createFunctionToLoopPassAdaptor(CREATE_PASS(Params.get()), \
2027 return Error::success(); \
2029#include "PassRegistry.def"
2031 for (
auto &
C : FunctionPipelineParsingCallbacks)
2032 if (
C(
Name, FPM, InnerPipeline))
2034 return make_error<StringError>(
2035 formatv(
"unknown function pass '{0}'",
Name).str(),
2040 const PipelineElement &E) {
2042 auto &InnerPipeline = E.InnerPipeline;
2045 if (!InnerPipeline.empty()) {
2046 if (
Name ==
"loop") {
2048 if (
auto Err = parseLoopPassPipeline(NestedLPM, InnerPipeline))
2051 LPM.
addPass(std::move(NestedLPM));
2055 for (
auto &
C : LoopPipelineParsingCallbacks)
2056 if (
C(
Name, LPM, InnerPipeline))
2060 return make_error<StringError>(
2061 formatv(
"invalid use of '{0}' pass as loop pipeline",
Name).str(),
2066#define LOOPNEST_PASS(NAME, CREATE_PASS) \
2067 if (Name == NAME) { \
2068 LPM.addPass(CREATE_PASS); \
2069 return Error::success(); \
2071#define LOOP_PASS(NAME, CREATE_PASS) \
2072 if (Name == NAME) { \
2073 LPM.addPass(CREATE_PASS); \
2074 return Error::success(); \
2076#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2077 if (checkParametrizedPassName(Name, NAME)) { \
2078 auto Params = parsePassParameters(PARSER, Name, NAME); \
2080 return Params.takeError(); \
2081 LPM.addPass(CREATE_PASS(Params.get())); \
2082 return Error::success(); \
2084#define LOOP_ANALYSIS(NAME, CREATE_PASS) \
2085 if (Name == "require<" NAME ">") { \
2086 LPM.addPass(RequireAnalysisPass< \
2087 std::remove_reference_t<decltype(CREATE_PASS)>, Loop, \
2088 LoopAnalysisManager, LoopStandardAnalysisResults &, \
2090 return Error::success(); \
2092 if (Name == "invalidate<" NAME ">") { \
2093 LPM.addPass(InvalidateAnalysisPass< \
2094 std::remove_reference_t<decltype(CREATE_PASS)>>()); \
2095 return Error::success(); \
2097#include "PassRegistry.def"
2099 for (
auto &
C : LoopPipelineParsingCallbacks)
2100 if (
C(
Name, LPM, InnerPipeline))
2102 return make_error<StringError>(
formatv(
"unknown loop pass '{0}'",
Name).str(),
2107 const PipelineElement &E) {
2109 if (!E.InnerPipeline.empty())
2110 return make_error<StringError>(
"invalid pipeline",
2113#define MACHINE_MODULE_PASS(NAME, CREATE_PASS) \
2114 if (Name == NAME) { \
2115 MFPM.addPass(CREATE_PASS); \
2116 return Error::success(); \
2118#define MACHINE_FUNCTION_PASS(NAME, CREATE_PASS) \
2119 if (Name == NAME) { \
2120 MFPM.addPass(CREATE_PASS); \
2121 return Error::success(); \
2123#define MACHINE_FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, \
2125 if (checkParametrizedPassName(Name, NAME)) { \
2126 auto Params = parsePassParameters(PARSER, Name, NAME); \
2128 return Params.takeError(); \
2129 MFPM.addPass(CREATE_PASS(Params.get())); \
2130 return Error::success(); \
2132#define MACHINE_FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
2133 if (Name == "require<" NAME ">") { \
2135 RequireAnalysisPass<std::remove_reference_t<decltype(CREATE_PASS)>, \
2136 MachineFunction>()); \
2137 return Error::success(); \
2139 if (Name == "invalidate<" NAME ">") { \
2140 MFPM.addPass(InvalidateAnalysisPass< \
2141 std::remove_reference_t<decltype(CREATE_PASS)>>()); \
2142 return Error::success(); \
2144#include "llvm/Passes/MachinePassRegistry.def"
2146 for (
auto &
C : MachineFunctionPipelineParsingCallbacks)
2147 if (
C(
Name, MFPM, E.InnerPipeline))
2149 return make_error<StringError>(
2150 formatv(
"unknown machine pass '{0}'",
Name).str(),
2155#define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS) \
2156 if (Name == NAME) { \
2157 AA.registerModuleAnalysis< \
2158 std::remove_reference_t<decltype(CREATE_PASS)>>(); \
2161#define FUNCTION_ALIAS_ANALYSIS(NAME, CREATE_PASS) \
2162 if (Name == NAME) { \
2163 AA.registerFunctionAnalysis< \
2164 std::remove_reference_t<decltype(CREATE_PASS)>>(); \
2167#include "PassRegistry.def"
2169 for (
auto &
C : AAParsingCallbacks)
2175Error PassBuilder::parseMachinePassPipeline(
2177 for (
const auto &Element : Pipeline) {
2178 if (
auto Err = parseMachinePass(MFPM, Element))
2186 for (
const auto &Element : Pipeline) {
2187 if (
auto Err = parseLoopPass(LPM, Element))
2193Error PassBuilder::parseFunctionPassPipeline(
2195 for (
const auto &Element : Pipeline) {
2196 if (
auto Err = parseFunctionPass(FPM, Element))
2204 for (
const auto &Element : Pipeline) {
2205 if (
auto Err = parseCGSCCPass(CGPM, Element))
2237 for (
const auto &Element : Pipeline) {
2238 if (
auto Err = parseModulePass(MPM, Element))
2249 auto Pipeline = parsePipelineText(PipelineText);
2250 if (!Pipeline || Pipeline->empty())
2251 return make_error<StringError>(
2252 formatv(
"invalid pipeline '{0}'", PipelineText).str(),
2262 Pipeline = {{
"cgscc", std::move(*Pipeline)}};
2264 FunctionPipelineParsingCallbacks)) {
2265 Pipeline = {{
"function", std::move(*Pipeline)}};
2268 Pipeline = {{
"function", {{UseMemorySSA ?
"loop-mssa" :
"loop",
2269 std::move(*Pipeline)}}}};
2270 }
else if (
isLoopPassName(FirstName, LoopPipelineParsingCallbacks,
2272 Pipeline = {{
"function", {{UseMemorySSA ?
"loop-mssa" :
"loop",
2273 std::move(*Pipeline)}}}};
2275 FirstName, MachineFunctionPipelineParsingCallbacks)) {
2276 Pipeline = {{
"function", {{
"machine-function", std::move(*Pipeline)}}}};
2278 for (
auto &
C : TopLevelPipelineParsingCallbacks)
2279 if (
C(MPM, *Pipeline))
2283 auto &InnerPipeline = Pipeline->front().InnerPipeline;
2284 return make_error<StringError>(
2285 formatv(
"unknown {0} name '{1}'",
2286 (InnerPipeline.empty() ?
"pass" :
"pipeline"), FirstName)
2292 if (
auto Err = parseModulePassPipeline(MPM, *Pipeline))
2300 auto Pipeline = parsePipelineText(PipelineText);
2301 if (!Pipeline || Pipeline->empty())
2302 return make_error<StringError>(
2303 formatv(
"invalid pipeline '{0}'", PipelineText).str(),
2308 return make_error<StringError>(
2309 formatv(
"unknown cgscc pass '{0}' in pipeline '{1}'", FirstName,
2314 if (
auto Err = parseCGSCCPassPipeline(CGPM, *Pipeline))
2323 auto Pipeline = parsePipelineText(PipelineText);
2324 if (!Pipeline || Pipeline->empty())
2325 return make_error<StringError>(
2326 formatv(
"invalid pipeline '{0}'", PipelineText).str(),
2331 return make_error<StringError>(
2332 formatv(
"unknown function pass '{0}' in pipeline '{1}'", FirstName,
2337 if (
auto Err = parseFunctionPassPipeline(FPM, *Pipeline))
2345 auto Pipeline = parsePipelineText(PipelineText);
2346 if (!Pipeline || Pipeline->empty())
2347 return make_error<StringError>(
2348 formatv(
"invalid pipeline '{0}'", PipelineText).str(),
2351 if (
auto Err = parseLoopPassPipeline(CGPM, *Pipeline))
2359 auto Pipeline = parsePipelineText(PipelineText);
2360 if (!Pipeline || Pipeline->empty())
2361 return make_error<StringError>(
2362 formatv(
"invalid machine pass pipeline '{0}'", PipelineText).str(),
2365 if (
auto Err = parseMachinePassPipeline(MFPM, *Pipeline))
2374 if (PipelineText ==
"default") {
2379 while (!PipelineText.
empty()) {
2381 std::tie(
Name, PipelineText) = PipelineText.
split(
',');
2382 if (!parseAAPassName(AA,
Name))
2383 return make_error<StringError>(
2384 formatv(
"unknown alias analysis name '{0}'",
Name).str(),
2391std::optional<RegAllocFilterFunc>
2393 if (FilterName ==
"all")
2395 for (
auto &
C : RegClassFilterParsingCallbacks)
2396 if (
auto F =
C(FilterName))
2398 return std::nullopt;
2406 OS <<
" " <<
PassName <<
"<" << Params <<
">\n";
2412 OS <<
"Module passes:\n";
2413#define MODULE_PASS(NAME, CREATE_PASS) printPassName(NAME, OS);
2414#include "PassRegistry.def"
2416 OS <<
"Module passes with params:\n";
2417#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2418 printPassName(NAME, PARAMS, OS);
2419#include "PassRegistry.def"
2421 OS <<
"Module analyses:\n";
2422#define MODULE_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
2423#include "PassRegistry.def"
2425 OS <<
"Module alias analyses:\n";
2426#define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
2427#include "PassRegistry.def"
2429 OS <<
"CGSCC passes:\n";
2430#define CGSCC_PASS(NAME, CREATE_PASS) printPassName(NAME, OS);
2431#include "PassRegistry.def"
2433 OS <<
"CGSCC passes with params:\n";
2434#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2435 printPassName(NAME, PARAMS, OS);
2436#include "PassRegistry.def"
2438 OS <<
"CGSCC analyses:\n";
2439#define CGSCC_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
2440#include "PassRegistry.def"
2442 OS <<
"Function passes:\n";
2443#define FUNCTION_PASS(NAME, CREATE_PASS) printPassName(NAME, OS);
2444#include "PassRegistry.def"
2446 OS <<
"Function passes with params:\n";
2447#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2448 printPassName(NAME, PARAMS, OS);
2449#include "PassRegistry.def"
2451 OS <<
"Function analyses:\n";
2452#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
2453#include "PassRegistry.def"
2455 OS <<
"Function alias analyses:\n";
2456#define FUNCTION_ALIAS_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
2457#include "PassRegistry.def"
2459 OS <<
"LoopNest passes:\n";
2460#define LOOPNEST_PASS(NAME, CREATE_PASS) printPassName(NAME, OS);
2461#include "PassRegistry.def"
2463 OS <<
"Loop passes:\n";
2464#define LOOP_PASS(NAME, CREATE_PASS) printPassName(NAME, OS);
2465#include "PassRegistry.def"
2467 OS <<
"Loop passes with params:\n";
2468#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2469 printPassName(NAME, PARAMS, OS);
2470#include "PassRegistry.def"
2472 OS <<
"Loop analyses:\n";
2473#define LOOP_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
2474#include "PassRegistry.def"
2476 OS <<
"Machine module passes (WIP):\n";
2477#define MACHINE_MODULE_PASS(NAME, CREATE_PASS) printPassName(NAME, OS);
2478#include "llvm/Passes/MachinePassRegistry.def"
2480 OS <<
"Machine function passes (WIP):\n";
2481#define MACHINE_FUNCTION_PASS(NAME, CREATE_PASS) printPassName(NAME, OS);
2482#include "llvm/Passes/MachinePassRegistry.def"
2484 OS <<
"Machine function analyses (WIP):\n";
2485#define MACHINE_FUNCTION_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
2486#include "llvm/Passes/MachinePassRegistry.def"
2492 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.
bool starts_with(StringRef Prefix) const
Check if this string starts with the given Prefix.
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