328 "^(default|thinlto-pre-link|thinlto|lto-pre-link|lto)<(O[0123sz])>$");
332 "print-pipeline-passes",
333 cl::desc(
"Print a '-passes' compatible string describing the pipeline "
334 "(best-effort only)."));
346class TriggerCrashModulePass :
public PassInfoMixin<TriggerCrashModulePass> {
355class TriggerCrashFunctionPass
362 static StringRef name() {
return "TriggerCrashFunctionPass"; }
367class TriggerVerifierErrorPass
375 GlobalValue::LinkageTypes::InternalLinkage,
376 "__bad_alias",
nullptr, &M);
396 static StringRef name() {
return "TriggerVerifierErrorPass"; }
401class RequireAllMachineFunctionPropertiesPass
402 :
public PassInfoMixin<RequireAllMachineFunctionPropertiesPass> {
411 MFProps.
set(MachineFunctionProperties::Property::FailedISel);
412 MFProps.
set(MachineFunctionProperties::Property::FailsVerification);
413 MFProps.
set(MachineFunctionProperties::Property::IsSSA);
414 MFProps.
set(MachineFunctionProperties::Property::Legalized);
415 MFProps.
set(MachineFunctionProperties::Property::NoPHIs);
416 MFProps.
set(MachineFunctionProperties::Property::NoVRegs);
417 MFProps.
set(MachineFunctionProperties::Property::RegBankSelected);
418 MFProps.
set(MachineFunctionProperties::Property::Selected);
419 MFProps.
set(MachineFunctionProperties::Property::TiedOpsRewritten);
420 MFProps.
set(MachineFunctionProperties::Property::TracksDebugUserValues);
421 MFProps.
set(MachineFunctionProperties::Property::TracksLiveness);
424 static StringRef name() {
return "RequireAllMachineFunctionPropertiesPass"; }
430 std::optional<PGOOptions> PGOOpt,
432 :
TM(
TM), PTO(PTO), PGOOpt(PGOOpt),
PIC(
PIC) {
434 TM->registerPassBuilderCallbacks(*
this);
440#define MODULE_PASS(NAME, CREATE_PASS) \
441 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
442#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
443 PIC->addClassToPassName(CLASS, NAME);
444#define MODULE_ANALYSIS(NAME, CREATE_PASS) \
445 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
446#define FUNCTION_PASS(NAME, CREATE_PASS) \
447 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
448#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
449 PIC->addClassToPassName(CLASS, NAME);
450#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
451 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
452#define LOOPNEST_PASS(NAME, CREATE_PASS) \
453 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
454#define LOOP_PASS(NAME, CREATE_PASS) \
455 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
456#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
457 PIC->addClassToPassName(CLASS, NAME);
458#define LOOP_ANALYSIS(NAME, CREATE_PASS) \
459 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
460#define CGSCC_PASS(NAME, CREATE_PASS) \
461 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
462#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
463 PIC->addClassToPassName(CLASS, NAME);
464#define CGSCC_ANALYSIS(NAME, CREATE_PASS) \
465 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
466#include "PassRegistry.def"
468#define MACHINE_FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
469 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
470#define MACHINE_FUNCTION_PASS(NAME, CREATE_PASS) \
471 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
472#include "llvm/Passes/MachinePassRegistry.def"
478#define MODULE_ANALYSIS(NAME, CREATE_PASS) \
479 MAM.registerPass([&] { return CREATE_PASS; });
480#include "PassRegistry.def"
482 for (
auto &
C : ModuleAnalysisRegistrationCallbacks)
487#define CGSCC_ANALYSIS(NAME, CREATE_PASS) \
488 CGAM.registerPass([&] { return CREATE_PASS; });
489#include "PassRegistry.def"
491 for (
auto &
C : CGSCCAnalysisRegistrationCallbacks)
501#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
502 FAM.registerPass([&] { return CREATE_PASS; });
503#include "PassRegistry.def"
505 for (
auto &
C : FunctionAnalysisRegistrationCallbacks)
512#define MACHINE_FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
513 MFAM.registerPass([&] { return CREATE_PASS; });
514#include "llvm/Passes/MachinePassRegistry.def"
516 for (
auto &
C : MachineFunctionAnalysisRegistrationCallbacks)
521#define LOOP_ANALYSIS(NAME, CREATE_PASS) \
522 LAM.registerPass([&] { return CREATE_PASS; });
523#include "PassRegistry.def"
525 for (
auto &
C : LoopAnalysisRegistrationCallbacks)
529static std::optional<std::pair<bool, bool>>
531 std::pair<bool, bool> Params;
532 if (!
Name.consume_front(
"function"))
536 if (!
Name.consume_front(
"<") || !
Name.consume_back(
">"))
538 while (!
Name.empty()) {
539 auto [Front, Back] =
Name.split(
';');
541 if (Front ==
"eager-inv")
543 else if (Front ==
"no-rerun")
544 Params.second =
true;
552 if (!
Name.consume_front(
"devirt<") || !
Name.consume_back(
">"))
555 if (
Name.getAsInteger(0, Count) || Count < 0)
575 while (!Params.
empty()) {
577 std::tie(ParamName, Params) = Params.
split(
';');
579 if (ParamName == OptionName) {
582 return make_error<StringError>(
597 while (!Params.
empty()) {
599 std::tie(ParamName, Params) = Params.
split(
';');
603 return make_error<StringError>(
604 formatv(
"invalid HardwareLoopPass parameter '{0}' ", ParamName).str(),
609 if (ParamName.
consume_front(
"hardware-loop-counter-bitwidth=")) {
612 return make_error<StringError>(
613 formatv(
"invalid HardwareLoopPass parameter '{0}' ", ParamName).str(),
618 if (ParamName ==
"force-hardware-loops") {
620 }
else if (ParamName ==
"force-hardware-loop-phi") {
622 }
else if (ParamName ==
"force-nested-hardware-loop") {
624 }
else if (ParamName ==
"force-hardware-loop-guard") {
627 return make_error<StringError>(
628 formatv(
"invalid HardwarePass parameter '{0}' ", ParamName).str(),
632 return HardwareLoopOpts;
638 while (!Params.
empty()) {
640 std::tie(ParamName, Params) = Params.
split(
';');
641 std::optional<OptimizationLevel> OptLevel =
parseOptLevel(ParamName);
643 if (OptLevel && !OptLevel->isOptimizingForSize()) {
644 UnrollOpts.
setOptLevel(OptLevel->getSpeedupLevel());
650 return make_error<StringError>(
651 formatv(
"invalid LoopUnrollPass parameter '{0}' ", ParamName).str(),
658 if (ParamName ==
"partial") {
660 }
else if (ParamName ==
"peeling") {
662 }
else if (ParamName ==
"profile-peeling") {
664 }
else if (ParamName ==
"runtime") {
666 }
else if (ParamName ==
"upperbound") {
669 return make_error<StringError>(
670 formatv(
"invalid LoopUnrollPass parameter '{0}' ", ParamName).str(),
679 Params,
"vfe-linkage-unit-visibility",
"GlobalDCE");
699 Params,
"skip-non-recursive-function-attrs",
"PostOrderFunctionAttrs");
708 return make_error<StringError>(
709 formatv(
"too many CFGuardPass parameters '{0}' ", Params).str(),
712 if (Param ==
"check")
714 if (Param ==
"dispatch")
717 return make_error<StringError>(
718 formatv(
"invalid CFGuardPass mechanism: '{0}' ", Param).str(),
728 "EntryExitInstrumenter");
737 "LowerMatrixIntrinsics");
742 while (!Params.
empty()) {
744 std::tie(ParamName, Params) = Params.
split(
';');
746 if (ParamName ==
"kernel") {
747 Result.CompileKernel =
true;
749 return make_error<StringError>(
750 formatv(
"invalid AddressSanitizer pass parameter '{0}' ", ParamName)
760 while (!Params.
empty()) {
762 std::tie(ParamName, Params) = Params.
split(
';');
764 if (ParamName ==
"recover") {
766 }
else if (ParamName ==
"kernel") {
767 Result.CompileKernel =
true;
769 return make_error<StringError>(
770 formatv(
"invalid HWAddressSanitizer pass parameter '{0}' ", ParamName)
780 while (!Params.
empty()) {
782 std::tie(ParamName, Params) = Params.
split(
';');
784 if (ParamName ==
"thinlto") {
786 }
else if (ParamName ==
"emit-summary") {
787 Result.EmitLTOSummary =
true;
789 return make_error<StringError>(
790 formatv(
"invalid EmbedBitcode pass parameter '{0}' ", ParamName)
800 while (!Params.
empty()) {
802 std::tie(ParamName, Params) = Params.
split(
';');
804 if (ParamName ==
"recover") {
806 }
else if (ParamName ==
"kernel") {
810 return make_error<StringError>(
811 formatv(
"invalid argument to MemorySanitizer pass track-origins "
816 }
else if (ParamName ==
"eager-checks") {
817 Result.EagerChecks =
true;
819 return make_error<StringError>(
820 formatv(
"invalid MemorySanitizer pass parameter '{0}' ", ParamName)
831 while (!Params.
empty()) {
833 std::tie(ParamName, Params) = Params.
split(
';');
836 if (ParamName ==
"speculate-blocks") {
838 }
else if (ParamName ==
"simplify-cond-branch") {
840 }
else if (ParamName ==
"forward-switch-cond") {
842 }
else if (ParamName ==
"switch-range-to-icmp") {
844 }
else if (ParamName ==
"switch-to-lookup") {
846 }
else if (ParamName ==
"keep-loops") {
848 }
else if (ParamName ==
"hoist-common-insts") {
850 }
else if (ParamName ==
"sink-common-insts") {
852 }
else if (ParamName ==
"speculate-unpredictables") {
855 APInt BonusInstThreshold;
857 return make_error<StringError>(
858 formatv(
"invalid argument to SimplifyCFG pass bonus-threshold "
864 return make_error<StringError>(
865 formatv(
"invalid SimplifyCFG pass parameter '{0}' ", ParamName).str(),
876 Result.setVerifyFixpoint(
true);
877 while (!Params.
empty()) {
879 std::tie(ParamName, Params) = Params.
split(
';');
882 if (ParamName ==
"use-loop-info") {
884 }
else if (ParamName ==
"verify-fixpoint") {
889 return make_error<StringError>(
890 formatv(
"invalid argument to InstCombine pass max-iterations "
896 return make_error<StringError>(
897 formatv(
"invalid InstCombine pass parameter '{0}' ", ParamName).str(),
907 while (!Params.
empty()) {
909 std::tie(ParamName, Params) = Params.
split(
';');
912 if (ParamName ==
"interleave-forced-only") {
914 }
else if (ParamName ==
"vectorize-forced-only") {
917 return make_error<StringError>(
918 formatv(
"invalid LoopVectorize parameter '{0}' ", ParamName).str(),
926 std::pair<bool, bool>
Result = {
false,
true};
927 while (!Params.
empty()) {
929 std::tie(ParamName, Params) = Params.
split(
';');
932 if (ParamName ==
"nontrivial") {
934 }
else if (ParamName ==
"trivial") {
937 return make_error<StringError>(
938 formatv(
"invalid LoopUnswitch pass parameter '{0}' ", ParamName)
948 while (!Params.
empty()) {
950 std::tie(ParamName, Params) = Params.
split(
';');
953 if (ParamName ==
"allowspeculation") {
956 return make_error<StringError>(
957 formatv(
"invalid LICM pass parameter '{0}' ", ParamName).str(),
965 std::pair<bool, bool>
Result = {
true,
false};
966 while (!Params.
empty()) {
968 std::tie(ParamName, Params) = Params.
split(
';');
971 if (ParamName ==
"header-duplication") {
973 }
else if (ParamName ==
"prepare-for-lto") {
976 return make_error<StringError>(
977 formatv(
"invalid LoopRotate pass parameter '{0}' ", ParamName).str(),
986 while (!Params.
empty()) {
988 std::tie(ParamName, Params) = Params.
split(
';');
991 if (ParamName ==
"split-footer-bb") {
994 return make_error<StringError>(
995 formatv(
"invalid MergedLoadStoreMotion pass parameter '{0}' ",
1006 while (!Params.
empty()) {
1008 std::tie(ParamName, Params) = Params.
split(
';');
1011 if (ParamName ==
"pre") {
1013 }
else if (ParamName ==
"load-pre") {
1015 }
else if (ParamName ==
"split-backedge-load-pre") {
1017 }
else if (ParamName ==
"memdep") {
1020 return make_error<StringError>(
1021 formatv(
"invalid GVN pass parameter '{0}' ", ParamName).str(),
1030 while (!Params.
empty()) {
1032 std::tie(ParamName, Params) = Params.
split(
';');
1035 if (ParamName ==
"func-spec")
1038 return make_error<StringError>(
1039 formatv(
"invalid IPSCCP pass parameter '{0}' ", ParamName).str(),
1046 if (Params.
empty() || Params ==
"modify-cfg")
1048 if (Params ==
"preserve-cfg")
1050 return make_error<StringError>(
1051 formatv(
"invalid SROA pass parameter '{0}' (either preserve-cfg or "
1052 "modify-cfg can be specified)",
1059parseStackLifetimeOptions(
StringRef Params) {
1061 while (!Params.
empty()) {
1063 std::tie(ParamName, Params) = Params.
split(
';');
1065 if (ParamName ==
"may") {
1067 }
else if (ParamName ==
"must") {
1070 return make_error<StringError>(
1071 formatv(
"invalid StackLifetime parameter '{0}' ", ParamName).str(),
1080 "DependenceAnalysisPrinter");
1085 "SeparateConstOffsetFromGEP");
1094parseFunctionSimplificationPipelineOptions(
StringRef Params) {
1097 return make_error<StringError>(
1098 formatv(
"invalid function-simplification parameter '{0}' ", Params)
1107 "MemorySSAPrinterPass");
1112 "SpeculativeExecutionPass");
1117 while (!Params.
empty()) {
1119 std::tie(ParamName, Params) = Params.
split(
';');
1124 return make_error<StringError>(
1125 formatv(
"invalid MemProfUse pass parameter '{0}' ", ParamName).str(),
1134 "StructuralHashPrinterPass");
1139 "WinEHPreparePass");
1144 while (!Params.
empty()) {
1146 std::tie(ParamName, Params) = Params.
split(
';');
1149 if (ParamName ==
"group-by-use")
1151 else if (ParamName ==
"ignore-single-use")
1153 else if (ParamName ==
"merge-const")
1155 else if (ParamName ==
"merge-external")
1159 return make_error<StringError>(
1160 formatv(
"invalid GlobalMergePass parameter '{0}' ", ParamName)
1170 while (!Params.
empty()) {
1172 std::tie(ParamName, Params) = Params.
split(
';');
1177 return make_error<StringError>(
1178 formatv(
"invalid Internalize pass parameter '{0}' ", ParamName).str(),
1189 while (!Params.
empty()) {
1191 std::tie(ParamName, Params) = Params.
split(
';');
1194 std::optional<RegAllocFilterFunc>
Filter =
1197 return make_error<StringError>(
1198 formatv(
"invalid regallocfast register filter '{0}' ", ParamName)
1207 if (ParamName ==
"no-clear-vregs") {
1212 return make_error<StringError>(
1213 formatv(
"invalid regallocfast pass parameter '{0}' ", ParamName).str(),
1229 return Name.starts_with(
"default") ||
Name.starts_with(
"thinlto") ||
1230 Name.starts_with(
"lto");
1241template <
typename PassManagerT,
typename CallbacksT>
1243 if (!Callbacks.empty()) {
1244 PassManagerT DummyPM;
1245 for (
auto &CB : Callbacks)
1246 if (CB(
Name, DummyPM, {}))
1252template <
typename CallbacksT>
1258 StringRef NameNoBracket =
Name.take_until([](
char C) {
return C ==
'<'; });
1261 if (
Name ==
"module")
1263 if (
Name ==
"cgscc")
1265 if (NameNoBracket ==
"function")
1267 if (
Name ==
"coro-cond")
1270#define MODULE_PASS(NAME, CREATE_PASS) \
1273#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1274 if (PassBuilder::checkParametrizedPassName(Name, NAME)) \
1276#define MODULE_ANALYSIS(NAME, CREATE_PASS) \
1277 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \
1279#include "PassRegistry.def"
1281 return callbacksAcceptPassName<ModulePassManager>(
Name, Callbacks);
1284template <
typename CallbacksT>
1287 StringRef NameNoBracket =
Name.take_until([](
char C) {
return C ==
'<'; });
1288 if (
Name ==
"cgscc")
1290 if (NameNoBracket ==
"function")
1297#define CGSCC_PASS(NAME, CREATE_PASS) \
1300#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1301 if (PassBuilder::checkParametrizedPassName(Name, NAME)) \
1303#define CGSCC_ANALYSIS(NAME, CREATE_PASS) \
1304 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \
1306#include "PassRegistry.def"
1308 return callbacksAcceptPassName<CGSCCPassManager>(
Name, Callbacks);
1311template <
typename CallbacksT>
1314 StringRef NameNoBracket =
Name.take_until([](
char C) {
return C ==
'<'; });
1315 if (NameNoBracket ==
"function")
1317 if (
Name ==
"loop" ||
Name ==
"loop-mssa" ||
Name ==
"machine-function")
1320#define FUNCTION_PASS(NAME, CREATE_PASS) \
1323#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1324 if (PassBuilder::checkParametrizedPassName(Name, NAME)) \
1326#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
1327 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \
1329#include "PassRegistry.def"
1331 return callbacksAcceptPassName<FunctionPassManager>(
Name, Callbacks);
1334template <
typename CallbacksT>
1337 if (
Name ==
"machine-function")
1340#define MACHINE_FUNCTION_PASS(NAME, CREATE_PASS) \
1343#define MACHINE_FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, \
1345 if (PassBuilder::checkParametrizedPassName(Name, NAME)) \
1348#define MACHINE_FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
1349 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \
1352#include "llvm/Passes/MachinePassRegistry.def"
1354 return callbacksAcceptPassName<MachineFunctionPassManager>(
Name, Callbacks);
1357template <
typename CallbacksT>
1359 bool &UseMemorySSA) {
1360 UseMemorySSA =
false;
1363 UseMemorySSA =
true;
1367#define LOOPNEST_PASS(NAME, CREATE_PASS) \
1370#include "PassRegistry.def"
1372 return callbacksAcceptPassName<LoopPassManager>(
Name, Callbacks);
1375template <
typename CallbacksT>
1377 bool &UseMemorySSA) {
1378 UseMemorySSA =
false;
1381 UseMemorySSA =
true;
1385#define LOOP_PASS(NAME, CREATE_PASS) \
1388#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1389 if (PassBuilder::checkParametrizedPassName(Name, NAME)) \
1391#define LOOP_ANALYSIS(NAME, CREATE_PASS) \
1392 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \
1394#include "PassRegistry.def"
1396 return callbacksAcceptPassName<LoopPassManager>(
Name, Callbacks);
1399std::optional<std::vector<PassBuilder::PipelineElement>>
1400PassBuilder::parsePipelineText(
StringRef Text) {
1401 std::vector<PipelineElement> ResultPipeline;
1406 std::vector<PipelineElement> &Pipeline = *PipelineStack.
back();
1407 size_t Pos =
Text.find_first_of(
",()");
1408 Pipeline.push_back({
Text.substr(0, Pos), {}});
1411 if (Pos ==
Text.npos)
1414 char Sep =
Text[Pos];
1422 PipelineStack.
push_back(&Pipeline.back().InnerPipeline);
1426 assert(Sep ==
')' &&
"Bogus separator!");
1431 if (PipelineStack.
size() == 1)
1432 return std::nullopt;
1435 }
while (
Text.consume_front(
")"));
1443 if (!
Text.consume_front(
","))
1444 return std::nullopt;
1447 if (PipelineStack.
size() > 1)
1449 return std::nullopt;
1451 assert(PipelineStack.
back() == &ResultPipeline &&
1452 "Wrong pipeline at the bottom of the stack!");
1453 return {std::move(ResultPipeline)};
1457 const PipelineElement &E) {
1458 auto &
Name = E.Name;
1459 auto &InnerPipeline = E.InnerPipeline;
1462 if (!InnerPipeline.empty()) {
1463 if (
Name ==
"module") {
1465 if (
auto Err = parseModulePassPipeline(NestedMPM, InnerPipeline))
1470 if (
Name ==
"coro-cond") {
1472 if (
auto Err = parseModulePassPipeline(NestedMPM, InnerPipeline))
1477 if (
Name ==
"cgscc") {
1479 if (
auto Err = parseCGSCCPassPipeline(CGPM, InnerPipeline))
1486 return make_error<StringError>(
1487 "cannot have a no-rerun module to function adaptor",
1490 if (
auto Err = parseFunctionPassPipeline(FPM, InnerPipeline))
1497 for (
auto &
C : ModulePipelineParsingCallbacks)
1502 return make_error<StringError>(
1503 formatv(
"invalid use of '{0}' pass as module pipeline",
Name).str(),
1512 return make_error<StringError>(
1513 formatv(
"unknown default pipeline alias '{0}'",
Name).str(),
1516 assert(Matches.
size() == 3 &&
"Must capture two matched strings!");
1528 if (Matches[1] ==
"default") {
1530 }
else if (Matches[1] ==
"thinlto-pre-link") {
1532 }
else if (Matches[1] ==
"thinlto") {
1534 }
else if (Matches[1] ==
"lto-pre-link") {
1543 assert(Matches[1] ==
"lto" &&
"Not one of the matched options!");
1550#define MODULE_PASS(NAME, CREATE_PASS) \
1551 if (Name == NAME) { \
1552 MPM.addPass(CREATE_PASS); \
1553 return Error::success(); \
1555#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1556 if (checkParametrizedPassName(Name, NAME)) { \
1557 auto Params = parsePassParameters(PARSER, Name, NAME); \
1559 return Params.takeError(); \
1560 MPM.addPass(CREATE_PASS(Params.get())); \
1561 return Error::success(); \
1563#define MODULE_ANALYSIS(NAME, CREATE_PASS) \
1564 if (Name == "require<" NAME ">") { \
1566 RequireAnalysisPass< \
1567 std::remove_reference_t<decltype(CREATE_PASS)>, Module>()); \
1568 return Error::success(); \
1570 if (Name == "invalidate<" NAME ">") { \
1571 MPM.addPass(InvalidateAnalysisPass< \
1572 std::remove_reference_t<decltype(CREATE_PASS)>>()); \
1573 return Error::success(); \
1575#define CGSCC_PASS(NAME, CREATE_PASS) \
1576 if (Name == NAME) { \
1577 MPM.addPass(createModuleToPostOrderCGSCCPassAdaptor(CREATE_PASS)); \
1578 return Error::success(); \
1580#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1581 if (checkParametrizedPassName(Name, NAME)) { \
1582 auto Params = parsePassParameters(PARSER, Name, NAME); \
1584 return Params.takeError(); \
1586 createModuleToPostOrderCGSCCPassAdaptor(CREATE_PASS(Params.get()))); \
1587 return Error::success(); \
1589#define FUNCTION_PASS(NAME, CREATE_PASS) \
1590 if (Name == NAME) { \
1591 MPM.addPass(createModuleToFunctionPassAdaptor(CREATE_PASS)); \
1592 return Error::success(); \
1594#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1595 if (checkParametrizedPassName(Name, NAME)) { \
1596 auto Params = parsePassParameters(PARSER, Name, NAME); \
1598 return Params.takeError(); \
1599 MPM.addPass(createModuleToFunctionPassAdaptor(CREATE_PASS(Params.get()))); \
1600 return Error::success(); \
1602#define LOOPNEST_PASS(NAME, CREATE_PASS) \
1603 if (Name == NAME) { \
1604 MPM.addPass(createModuleToFunctionPassAdaptor( \
1605 createFunctionToLoopPassAdaptor(CREATE_PASS, false, false))); \
1606 return Error::success(); \
1608#define LOOP_PASS(NAME, CREATE_PASS) \
1609 if (Name == NAME) { \
1610 MPM.addPass(createModuleToFunctionPassAdaptor( \
1611 createFunctionToLoopPassAdaptor(CREATE_PASS, false, false))); \
1612 return Error::success(); \
1614#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1615 if (checkParametrizedPassName(Name, NAME)) { \
1616 auto Params = parsePassParameters(PARSER, Name, NAME); \
1618 return Params.takeError(); \
1620 createModuleToFunctionPassAdaptor(createFunctionToLoopPassAdaptor( \
1621 CREATE_PASS(Params.get()), false, false))); \
1622 return Error::success(); \
1624#include "PassRegistry.def"
1626 for (
auto &
C : ModulePipelineParsingCallbacks)
1629 return make_error<StringError>(
1635 const PipelineElement &E) {
1636 auto &
Name = E.Name;
1637 auto &InnerPipeline = E.InnerPipeline;
1640 if (!InnerPipeline.empty()) {
1641 if (
Name ==
"cgscc") {
1643 if (
auto Err = parseCGSCCPassPipeline(NestedCGPM, InnerPipeline))
1646 CGPM.
addPass(std::move(NestedCGPM));
1651 if (
auto Err = parseFunctionPassPipeline(FPM, InnerPipeline))
1655 std::move(FPM), Params->first, Params->second));
1660 if (
auto Err = parseCGSCCPassPipeline(NestedCGPM, InnerPipeline))
1667 for (
auto &
C : CGSCCPipelineParsingCallbacks)
1668 if (
C(
Name, CGPM, InnerPipeline))
1672 return make_error<StringError>(
1673 formatv(
"invalid use of '{0}' pass as cgscc pipeline",
Name).str(),
1678#define CGSCC_PASS(NAME, CREATE_PASS) \
1679 if (Name == NAME) { \
1680 CGPM.addPass(CREATE_PASS); \
1681 return Error::success(); \
1683#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1684 if (checkParametrizedPassName(Name, NAME)) { \
1685 auto Params = parsePassParameters(PARSER, Name, NAME); \
1687 return Params.takeError(); \
1688 CGPM.addPass(CREATE_PASS(Params.get())); \
1689 return Error::success(); \
1691#define CGSCC_ANALYSIS(NAME, CREATE_PASS) \
1692 if (Name == "require<" NAME ">") { \
1693 CGPM.addPass(RequireAnalysisPass< \
1694 std::remove_reference_t<decltype(CREATE_PASS)>, \
1695 LazyCallGraph::SCC, CGSCCAnalysisManager, LazyCallGraph &, \
1696 CGSCCUpdateResult &>()); \
1697 return Error::success(); \
1699 if (Name == "invalidate<" NAME ">") { \
1700 CGPM.addPass(InvalidateAnalysisPass< \
1701 std::remove_reference_t<decltype(CREATE_PASS)>>()); \
1702 return Error::success(); \
1704#define FUNCTION_PASS(NAME, CREATE_PASS) \
1705 if (Name == NAME) { \
1706 CGPM.addPass(createCGSCCToFunctionPassAdaptor(CREATE_PASS)); \
1707 return Error::success(); \
1709#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1710 if (checkParametrizedPassName(Name, NAME)) { \
1711 auto Params = parsePassParameters(PARSER, Name, NAME); \
1713 return Params.takeError(); \
1714 CGPM.addPass(createCGSCCToFunctionPassAdaptor(CREATE_PASS(Params.get()))); \
1715 return Error::success(); \
1717#define LOOPNEST_PASS(NAME, CREATE_PASS) \
1718 if (Name == NAME) { \
1719 CGPM.addPass(createCGSCCToFunctionPassAdaptor( \
1720 createFunctionToLoopPassAdaptor(CREATE_PASS, false, false))); \
1721 return Error::success(); \
1723#define LOOP_PASS(NAME, CREATE_PASS) \
1724 if (Name == NAME) { \
1725 CGPM.addPass(createCGSCCToFunctionPassAdaptor( \
1726 createFunctionToLoopPassAdaptor(CREATE_PASS, false, false))); \
1727 return Error::success(); \
1729#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1730 if (checkParametrizedPassName(Name, NAME)) { \
1731 auto Params = parsePassParameters(PARSER, Name, NAME); \
1733 return Params.takeError(); \
1735 createCGSCCToFunctionPassAdaptor(createFunctionToLoopPassAdaptor( \
1736 CREATE_PASS(Params.get()), false, false))); \
1737 return Error::success(); \
1739#include "PassRegistry.def"
1741 for (
auto &
C : CGSCCPipelineParsingCallbacks)
1742 if (
C(
Name, CGPM, InnerPipeline))
1744 return make_error<StringError>(
1750 const PipelineElement &E) {
1751 auto &
Name = E.Name;
1752 auto &InnerPipeline = E.InnerPipeline;
1755 if (!InnerPipeline.empty()) {
1756 if (
Name ==
"function") {
1758 if (
auto Err = parseFunctionPassPipeline(NestedFPM, InnerPipeline))
1761 FPM.
addPass(std::move(NestedFPM));
1764 if (
Name ==
"loop" ||
Name ==
"loop-mssa") {
1766 if (
auto Err = parseLoopPassPipeline(LPM, InnerPipeline))
1769 bool UseMemorySSA = (
Name ==
"loop-mssa");
1771 return Pipeline.Name.contains(
"simple-loop-unswitch");
1773 bool UseBPI =
llvm::any_of(InnerPipeline, [](
auto Pipeline) {
1774 return Pipeline.Name ==
"loop-predication";
1780 if (
Name ==
"machine-function") {
1782 if (
auto Err = parseMachinePassPipeline(MFPM, InnerPipeline))
1788 for (
auto &
C : FunctionPipelineParsingCallbacks)
1789 if (
C(
Name, FPM, InnerPipeline))
1793 return make_error<StringError>(
1794 formatv(
"invalid use of '{0}' pass as function pipeline",
Name).str(),
1799#define FUNCTION_PASS(NAME, CREATE_PASS) \
1800 if (Name == NAME) { \
1801 FPM.addPass(CREATE_PASS); \
1802 return Error::success(); \
1804#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1805 if (checkParametrizedPassName(Name, NAME)) { \
1806 auto Params = parsePassParameters(PARSER, Name, NAME); \
1808 return Params.takeError(); \
1809 FPM.addPass(CREATE_PASS(Params.get())); \
1810 return Error::success(); \
1812#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
1813 if (Name == "require<" NAME ">") { \
1815 RequireAnalysisPass< \
1816 std::remove_reference_t<decltype(CREATE_PASS)>, Function>()); \
1817 return Error::success(); \
1819 if (Name == "invalidate<" NAME ">") { \
1820 FPM.addPass(InvalidateAnalysisPass< \
1821 std::remove_reference_t<decltype(CREATE_PASS)>>()); \
1822 return Error::success(); \
1828#define LOOPNEST_PASS(NAME, CREATE_PASS) \
1829 if (Name == NAME) { \
1830 FPM.addPass(createFunctionToLoopPassAdaptor(CREATE_PASS, false, false)); \
1831 return Error::success(); \
1833#define LOOP_PASS(NAME, CREATE_PASS) \
1834 if (Name == NAME) { \
1835 FPM.addPass(createFunctionToLoopPassAdaptor(CREATE_PASS, false, false)); \
1836 return Error::success(); \
1838#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1839 if (checkParametrizedPassName(Name, NAME)) { \
1840 auto Params = parsePassParameters(PARSER, Name, NAME); \
1842 return Params.takeError(); \
1843 FPM.addPass(createFunctionToLoopPassAdaptor(CREATE_PASS(Params.get()), \
1845 return Error::success(); \
1847#include "PassRegistry.def"
1849 for (
auto &
C : FunctionPipelineParsingCallbacks)
1850 if (
C(
Name, FPM, InnerPipeline))
1852 return make_error<StringError>(
1853 formatv(
"unknown function pass '{0}'",
Name).str(),
1858 const PipelineElement &E) {
1860 auto &InnerPipeline = E.InnerPipeline;
1863 if (!InnerPipeline.empty()) {
1864 if (
Name ==
"loop") {
1866 if (
auto Err = parseLoopPassPipeline(NestedLPM, InnerPipeline))
1869 LPM.
addPass(std::move(NestedLPM));
1873 for (
auto &
C : LoopPipelineParsingCallbacks)
1874 if (
C(
Name, LPM, InnerPipeline))
1878 return make_error<StringError>(
1879 formatv(
"invalid use of '{0}' pass as loop pipeline",
Name).str(),
1884#define LOOPNEST_PASS(NAME, CREATE_PASS) \
1885 if (Name == NAME) { \
1886 LPM.addPass(CREATE_PASS); \
1887 return Error::success(); \
1889#define LOOP_PASS(NAME, CREATE_PASS) \
1890 if (Name == NAME) { \
1891 LPM.addPass(CREATE_PASS); \
1892 return Error::success(); \
1894#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1895 if (checkParametrizedPassName(Name, NAME)) { \
1896 auto Params = parsePassParameters(PARSER, Name, NAME); \
1898 return Params.takeError(); \
1899 LPM.addPass(CREATE_PASS(Params.get())); \
1900 return Error::success(); \
1902#define LOOP_ANALYSIS(NAME, CREATE_PASS) \
1903 if (Name == "require<" NAME ">") { \
1904 LPM.addPass(RequireAnalysisPass< \
1905 std::remove_reference_t<decltype(CREATE_PASS)>, Loop, \
1906 LoopAnalysisManager, LoopStandardAnalysisResults &, \
1908 return Error::success(); \
1910 if (Name == "invalidate<" NAME ">") { \
1911 LPM.addPass(InvalidateAnalysisPass< \
1912 std::remove_reference_t<decltype(CREATE_PASS)>>()); \
1913 return Error::success(); \
1915#include "PassRegistry.def"
1917 for (
auto &
C : LoopPipelineParsingCallbacks)
1918 if (
C(
Name, LPM, InnerPipeline))
1920 return make_error<StringError>(
formatv(
"unknown loop pass '{0}'",
Name).str(),
1925 const PipelineElement &E) {
1927 if (!E.InnerPipeline.empty())
1928 return make_error<StringError>(
"invalid pipeline",
1931#define MACHINE_MODULE_PASS(NAME, CREATE_PASS) \
1932 if (Name == NAME) { \
1933 MFPM.addPass(CREATE_PASS); \
1934 return Error::success(); \
1936#define MACHINE_FUNCTION_PASS(NAME, CREATE_PASS) \
1937 if (Name == NAME) { \
1938 MFPM.addPass(CREATE_PASS); \
1939 return Error::success(); \
1941#define MACHINE_FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, \
1943 if (checkParametrizedPassName(Name, NAME)) { \
1944 auto Params = parsePassParameters(PARSER, Name, NAME); \
1946 return Params.takeError(); \
1947 MFPM.addPass(CREATE_PASS(Params.get())); \
1948 return Error::success(); \
1950#define MACHINE_FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
1951 if (Name == "require<" NAME ">") { \
1953 RequireAnalysisPass<std::remove_reference_t<decltype(CREATE_PASS)>, \
1954 MachineFunction>()); \
1955 return Error::success(); \
1957 if (Name == "invalidate<" NAME ">") { \
1958 MFPM.addPass(InvalidateAnalysisPass< \
1959 std::remove_reference_t<decltype(CREATE_PASS)>>()); \
1960 return Error::success(); \
1962#include "llvm/Passes/MachinePassRegistry.def"
1964 for (
auto &
C : MachineFunctionPipelineParsingCallbacks)
1965 if (
C(
Name, MFPM, E.InnerPipeline))
1967 return make_error<StringError>(
1968 formatv(
"unknown machine pass '{0}'",
Name).str(),
1973#define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS) \
1974 if (Name == NAME) { \
1975 AA.registerModuleAnalysis< \
1976 std::remove_reference_t<decltype(CREATE_PASS)>>(); \
1979#define FUNCTION_ALIAS_ANALYSIS(NAME, CREATE_PASS) \
1980 if (Name == NAME) { \
1981 AA.registerFunctionAnalysis< \
1982 std::remove_reference_t<decltype(CREATE_PASS)>>(); \
1985#include "PassRegistry.def"
1987 for (
auto &
C : AAParsingCallbacks)
1993Error PassBuilder::parseMachinePassPipeline(
1995 for (
const auto &Element : Pipeline) {
1996 if (
auto Err = parseMachinePass(MFPM, Element))
2004 for (
const auto &Element : Pipeline) {
2005 if (
auto Err = parseLoopPass(LPM, Element))
2011Error PassBuilder::parseFunctionPassPipeline(
2013 for (
const auto &Element : Pipeline) {
2014 if (
auto Err = parseFunctionPass(FPM, Element))
2022 for (
const auto &Element : Pipeline) {
2023 if (
auto Err = parseCGSCCPass(CGPM, Element))
2055 for (
const auto &Element : Pipeline) {
2056 if (
auto Err = parseModulePass(
MPM, Element))
2067 auto Pipeline = parsePipelineText(PipelineText);
2068 if (!Pipeline || Pipeline->empty())
2069 return make_error<StringError>(
2070 formatv(
"invalid pipeline '{0}'", PipelineText).str(),
2080 Pipeline = {{
"cgscc", std::move(*Pipeline)}};
2082 FunctionPipelineParsingCallbacks)) {
2083 Pipeline = {{
"function", std::move(*Pipeline)}};
2086 Pipeline = {{
"function", {{UseMemorySSA ?
"loop-mssa" :
"loop",
2087 std::move(*Pipeline)}}}};
2088 }
else if (
isLoopPassName(FirstName, LoopPipelineParsingCallbacks,
2090 Pipeline = {{
"function", {{UseMemorySSA ?
"loop-mssa" :
"loop",
2091 std::move(*Pipeline)}}}};
2093 FirstName, MachineFunctionPipelineParsingCallbacks)) {
2094 Pipeline = {{
"function", {{
"machine-function", std::move(*Pipeline)}}}};
2096 for (
auto &
C : TopLevelPipelineParsingCallbacks)
2097 if (
C(
MPM, *Pipeline))
2101 auto &InnerPipeline = Pipeline->front().InnerPipeline;
2102 return make_error<StringError>(
2103 formatv(
"unknown {0} name '{1}'",
2104 (InnerPipeline.empty() ?
"pass" :
"pipeline"), FirstName)
2110 if (
auto Err = parseModulePassPipeline(
MPM, *Pipeline))
2118 auto Pipeline = parsePipelineText(PipelineText);
2119 if (!Pipeline || Pipeline->empty())
2120 return make_error<StringError>(
2121 formatv(
"invalid pipeline '{0}'", PipelineText).str(),
2126 return make_error<StringError>(
2127 formatv(
"unknown cgscc pass '{0}' in pipeline '{1}'", FirstName,
2132 if (
auto Err = parseCGSCCPassPipeline(CGPM, *Pipeline))
2141 auto Pipeline = parsePipelineText(PipelineText);
2142 if (!Pipeline || Pipeline->empty())
2143 return make_error<StringError>(
2144 formatv(
"invalid pipeline '{0}'", PipelineText).str(),
2149 return make_error<StringError>(
2150 formatv(
"unknown function pass '{0}' in pipeline '{1}'", FirstName,
2155 if (
auto Err = parseFunctionPassPipeline(FPM, *Pipeline))
2163 auto Pipeline = parsePipelineText(PipelineText);
2164 if (!Pipeline || Pipeline->empty())
2165 return make_error<StringError>(
2166 formatv(
"invalid pipeline '{0}'", PipelineText).str(),
2169 if (
auto Err = parseLoopPassPipeline(CGPM, *Pipeline))
2177 auto Pipeline = parsePipelineText(PipelineText);
2178 if (!Pipeline || Pipeline->empty())
2179 return make_error<StringError>(
2180 formatv(
"invalid machine pass pipeline '{0}'", PipelineText).str(),
2183 if (
auto Err = parseMachinePassPipeline(MFPM, *Pipeline))
2192 if (PipelineText ==
"default") {
2197 while (!PipelineText.
empty()) {
2199 std::tie(
Name, PipelineText) = PipelineText.
split(
',');
2200 if (!parseAAPassName(AA,
Name))
2201 return make_error<StringError>(
2202 formatv(
"unknown alias analysis name '{0}'",
Name).str(),
2209std::optional<RegAllocFilterFunc>
2211 if (FilterName ==
"all")
2213 for (
auto &
C : RegClassFilterParsingCallbacks)
2214 if (
auto F =
C(FilterName))
2216 return std::nullopt;
2224 OS <<
" " <<
PassName <<
"<" << Params <<
">\n";
2230 OS <<
"Module passes:\n";
2231#define MODULE_PASS(NAME, CREATE_PASS) printPassName(NAME, OS);
2232#include "PassRegistry.def"
2234 OS <<
"Module passes with params:\n";
2235#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2236 printPassName(NAME, PARAMS, OS);
2237#include "PassRegistry.def"
2239 OS <<
"Module analyses:\n";
2240#define MODULE_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
2241#include "PassRegistry.def"
2243 OS <<
"Module alias analyses:\n";
2244#define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
2245#include "PassRegistry.def"
2247 OS <<
"CGSCC passes:\n";
2248#define CGSCC_PASS(NAME, CREATE_PASS) printPassName(NAME, OS);
2249#include "PassRegistry.def"
2251 OS <<
"CGSCC passes with params:\n";
2252#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2253 printPassName(NAME, PARAMS, OS);
2254#include "PassRegistry.def"
2256 OS <<
"CGSCC analyses:\n";
2257#define CGSCC_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
2258#include "PassRegistry.def"
2260 OS <<
"Function passes:\n";
2261#define FUNCTION_PASS(NAME, CREATE_PASS) printPassName(NAME, OS);
2262#include "PassRegistry.def"
2264 OS <<
"Function passes with params:\n";
2265#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2266 printPassName(NAME, PARAMS, OS);
2267#include "PassRegistry.def"
2269 OS <<
"Function analyses:\n";
2270#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
2271#include "PassRegistry.def"
2273 OS <<
"Function alias analyses:\n";
2274#define FUNCTION_ALIAS_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
2275#include "PassRegistry.def"
2277 OS <<
"LoopNest passes:\n";
2278#define LOOPNEST_PASS(NAME, CREATE_PASS) printPassName(NAME, OS);
2279#include "PassRegistry.def"
2281 OS <<
"Loop passes:\n";
2282#define LOOP_PASS(NAME, CREATE_PASS) printPassName(NAME, OS);
2283#include "PassRegistry.def"
2285 OS <<
"Loop passes with params:\n";
2286#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2287 printPassName(NAME, PARAMS, OS);
2288#include "PassRegistry.def"
2290 OS <<
"Loop analyses:\n";
2291#define LOOP_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
2292#include "PassRegistry.def"
2294 OS <<
"Machine module passes (WIP):\n";
2295#define MACHINE_MODULE_PASS(NAME, CREATE_PASS) printPassName(NAME, OS);
2296#include "llvm/Passes/MachinePassRegistry.def"
2298 OS <<
"Machine function passes (WIP):\n";
2299#define MACHINE_FUNCTION_PASS(NAME, CREATE_PASS) printPassName(NAME, OS);
2300#include "llvm/Passes/MachinePassRegistry.def"
2302 OS <<
"Machine function analyses (WIP):\n";
2303#define MACHINE_FUNCTION_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
2304#include "llvm/Passes/MachinePassRegistry.def"
2310 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.
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
const char LLVMTargetMachineRef TM
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 header defines various interfaces for pass management in LLVM.
This file implements the PredicateInfo analysis, which creates an Extended SSA form for operations us...
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, bool LTOPreLink=false)
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.
This class manages callbacks registration, as well as provides a way for PassInstrumentation to pass ...
void registerClassToPassNameCallback(CallableT C)
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...
auto formatv(const char *Fmt, Ts &&...Vals) -> formatv_object< decltype(std::make_tuple(support::detail::build_format_adapter(std::forward< Ts >(Vals))...))>
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.
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.
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.
RegAllocFilterFunc Filter