303 "^(default|thinlto-pre-link|thinlto|lto-pre-link|lto)<(O[0123sz])>$");
307 "print-pipeline-passes",
308 cl::desc(
"Print a '-passes' compatible string describing the pipeline "
309 "(best-effort only)."));
325bool shouldPopulateClassToPassNames() {
333class TriggerCrashPass :
public PassInfoMixin<TriggerCrashPass> {
344class TriggerVerifierErrorPass
352 GlobalValue::LinkageTypes::InternalLinkage,
353 "__bad_alias",
nullptr, &M);
365 static StringRef name() {
return "TriggerVerifierErrorPass"; }
371 std::optional<PGOOptions> PGOOpt,
373 :
TM(
TM), PTO(PTO), PGOOpt(PGOOpt),
PIC(
PIC) {
374 bool ShouldPopulateClassToPassNames =
PIC && shouldPopulateClassToPassNames();
376 TM->registerPassBuilderCallbacks(*
this, ShouldPopulateClassToPassNames);
377 if (ShouldPopulateClassToPassNames) {
378#define MODULE_PASS(NAME, CREATE_PASS) \
379 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
380#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
381 PIC->addClassToPassName(CLASS, NAME);
382#define MODULE_ANALYSIS(NAME, CREATE_PASS) \
383 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
384#define FUNCTION_PASS(NAME, CREATE_PASS) \
385 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
386#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
387 PIC->addClassToPassName(CLASS, NAME);
388#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
389 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
390#define LOOPNEST_PASS(NAME, CREATE_PASS) \
391 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
392#define LOOP_PASS(NAME, CREATE_PASS) \
393 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
394#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
395 PIC->addClassToPassName(CLASS, NAME);
396#define LOOP_ANALYSIS(NAME, CREATE_PASS) \
397 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
398#define CGSCC_PASS(NAME, CREATE_PASS) \
399 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
400#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
401 PIC->addClassToPassName(CLASS, NAME);
402#define CGSCC_ANALYSIS(NAME, CREATE_PASS) \
403 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
404#include "PassRegistry.def"
406#define MACHINE_FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
407 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
408#define MACHINE_FUNCTION_PASS(NAME, CREATE_PASS) \
409 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
410#include "llvm/Passes/MachinePassRegistry.def"
415#define MODULE_ANALYSIS(NAME, CREATE_PASS) \
416 MAM.registerPass([&] { return CREATE_PASS; });
417#include "PassRegistry.def"
419 for (
auto &
C : ModuleAnalysisRegistrationCallbacks)
424#define CGSCC_ANALYSIS(NAME, CREATE_PASS) \
425 CGAM.registerPass([&] { return CREATE_PASS; });
426#include "PassRegistry.def"
428 for (
auto &
C : CGSCCAnalysisRegistrationCallbacks)
438#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
439 FAM.registerPass([&] { return CREATE_PASS; });
440#include "PassRegistry.def"
442 for (
auto &
C : FunctionAnalysisRegistrationCallbacks)
449#define MACHINE_FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
450 MFAM.registerPass([&] { return CREATE_PASS; });
451#include "llvm/Passes/MachinePassRegistry.def"
453 for (
auto &
C : MachineFunctionAnalysisRegistrationCallbacks)
458#define LOOP_ANALYSIS(NAME, CREATE_PASS) \
459 LAM.registerPass([&] { return CREATE_PASS; });
460#include "PassRegistry.def"
462 for (
auto &
C : LoopAnalysisRegistrationCallbacks)
467 if (!
Name.consume_front(
"repeat<") || !
Name.consume_back(
">"))
470 if (
Name.getAsInteger(0, Count) || Count <= 0)
475static std::optional<std::pair<bool, bool>>
477 std::pair<bool, bool> Params;
478 if (!
Name.consume_front(
"function"))
482 if (!
Name.consume_front(
"<") || !
Name.consume_back(
">"))
484 while (!
Name.empty()) {
485 auto [Front, Back] =
Name.split(
';');
487 if (Front ==
"eager-inv")
489 else if (Front ==
"no-rerun")
490 Params.second =
true;
498 if (!
Name.consume_front(
"devirt<") || !
Name.consume_back(
">"))
501 if (
Name.getAsInteger(0, Count) || Count < 0)
521 while (!Params.
empty()) {
523 std::tie(ParamName, Params) = Params.
split(
';');
525 if (ParamName == OptionName) {
528 return make_error<StringError>(
543 while (!Params.
empty()) {
545 std::tie(ParamName, Params) = Params.
split(
';');
549 return make_error<StringError>(
550 formatv(
"invalid HardwareLoopPass parameter '{0}' ", ParamName).str(),
555 if (ParamName.
consume_front(
"hardware-loop-counter-bitwidth=")) {
558 return make_error<StringError>(
559 formatv(
"invalid HardwareLoopPass parameter '{0}' ", ParamName).str(),
564 if (ParamName ==
"force-hardware-loops") {
566 }
else if (ParamName ==
"force-hardware-loop-phi") {
568 }
else if (ParamName ==
"force-nested-hardware-loop") {
570 }
else if (ParamName ==
"force-hardware-loop-guard") {
573 return make_error<StringError>(
574 formatv(
"invalid HardwarePass parameter '{0}' ", ParamName).str(),
578 return HardwareLoopOpts;
584 while (!Params.
empty()) {
586 std::tie(ParamName, Params) = Params.
split(
';');
587 std::optional<OptimizationLevel> OptLevel =
parseOptLevel(ParamName);
589 if (OptLevel && !OptLevel->isOptimizingForSize()) {
590 UnrollOpts.
setOptLevel(OptLevel->getSpeedupLevel());
596 return make_error<StringError>(
597 formatv(
"invalid LoopUnrollPass parameter '{0}' ", ParamName).str(),
604 if (ParamName ==
"partial") {
606 }
else if (ParamName ==
"peeling") {
608 }
else if (ParamName ==
"profile-peeling") {
610 }
else if (ParamName ==
"runtime") {
612 }
else if (ParamName ==
"upperbound") {
615 return make_error<StringError>(
616 formatv(
"invalid LoopUnrollPass parameter '{0}' ", ParamName).str(),
625 Params,
"vfe-linkage-unit-visibility",
"GlobalDCE");
645 Params,
"skip-non-recursive-function-attrs",
"PostOrderFunctionAttrs");
654 return make_error<StringError>(
655 formatv(
"too many CFGuardPass parameters '{0}' ", Params).str(),
658 if (Param ==
"check")
660 if (Param ==
"dispatch")
663 return make_error<StringError>(
664 formatv(
"invalid CFGuardPass mechanism: '{0}' ", Param).str(),
674 "EntryExitInstrumenter");
683 "LowerMatrixIntrinsics");
688 while (!Params.
empty()) {
690 std::tie(ParamName, Params) = Params.
split(
';');
692 if (ParamName ==
"kernel") {
693 Result.CompileKernel =
true;
695 return make_error<StringError>(
696 formatv(
"invalid AddressSanitizer pass parameter '{0}' ", ParamName)
706 while (!Params.
empty()) {
708 std::tie(ParamName, Params) = Params.
split(
';');
710 if (ParamName ==
"recover") {
712 }
else if (ParamName ==
"kernel") {
713 Result.CompileKernel =
true;
715 return make_error<StringError>(
716 formatv(
"invalid HWAddressSanitizer pass parameter '{0}' ", ParamName)
726 while (!Params.
empty()) {
728 std::tie(ParamName, Params) = Params.
split(
';');
730 if (ParamName ==
"thinlto") {
732 }
else if (ParamName ==
"emit-summary") {
733 Result.EmitLTOSummary =
true;
735 return make_error<StringError>(
736 formatv(
"invalid EmbedBitcode pass parameter '{0}' ", ParamName)
746 while (!Params.
empty()) {
748 std::tie(ParamName, Params) = Params.
split(
';');
750 if (ParamName ==
"recover") {
752 }
else if (ParamName ==
"kernel") {
756 return make_error<StringError>(
757 formatv(
"invalid argument to MemorySanitizer pass track-origins "
762 }
else if (ParamName ==
"eager-checks") {
763 Result.EagerChecks =
true;
765 return make_error<StringError>(
766 formatv(
"invalid MemorySanitizer pass parameter '{0}' ", ParamName)
777 while (!Params.
empty()) {
779 std::tie(ParamName, Params) = Params.
split(
';');
782 if (ParamName ==
"speculate-blocks") {
784 }
else if (ParamName ==
"simplify-cond-branch") {
786 }
else if (ParamName ==
"forward-switch-cond") {
788 }
else if (ParamName ==
"switch-range-to-icmp") {
790 }
else if (ParamName ==
"switch-to-lookup") {
792 }
else if (ParamName ==
"keep-loops") {
794 }
else if (ParamName ==
"hoist-common-insts") {
796 }
else if (ParamName ==
"sink-common-insts") {
799 APInt BonusInstThreshold;
801 return make_error<StringError>(
802 formatv(
"invalid argument to SimplifyCFG pass bonus-threshold "
808 return make_error<StringError>(
809 formatv(
"invalid SimplifyCFG pass parameter '{0}' ", ParamName).str(),
820 Result.setVerifyFixpoint(
true);
821 while (!Params.
empty()) {
823 std::tie(ParamName, Params) = Params.
split(
';');
826 if (ParamName ==
"use-loop-info") {
828 }
else if (ParamName ==
"verify-fixpoint") {
833 return make_error<StringError>(
834 formatv(
"invalid argument to InstCombine pass max-iterations "
840 return make_error<StringError>(
841 formatv(
"invalid InstCombine pass parameter '{0}' ", ParamName).str(),
851 while (!Params.
empty()) {
853 std::tie(ParamName, Params) = Params.
split(
';');
856 if (ParamName ==
"interleave-forced-only") {
858 }
else if (ParamName ==
"vectorize-forced-only") {
861 return make_error<StringError>(
862 formatv(
"invalid LoopVectorize parameter '{0}' ", ParamName).str(),
870 std::pair<bool, bool>
Result = {
false,
true};
871 while (!Params.
empty()) {
873 std::tie(ParamName, Params) = Params.
split(
';');
876 if (ParamName ==
"nontrivial") {
878 }
else if (ParamName ==
"trivial") {
881 return make_error<StringError>(
882 formatv(
"invalid LoopUnswitch pass parameter '{0}' ", ParamName)
892 while (!Params.
empty()) {
894 std::tie(ParamName, Params) = Params.
split(
';');
897 if (ParamName ==
"allowspeculation") {
900 return make_error<StringError>(
901 formatv(
"invalid LICM pass parameter '{0}' ", ParamName).str(),
909 std::pair<bool, bool>
Result = {
true,
false};
910 while (!Params.
empty()) {
912 std::tie(ParamName, Params) = Params.
split(
';');
915 if (ParamName ==
"header-duplication") {
917 }
else if (ParamName ==
"prepare-for-lto") {
920 return make_error<StringError>(
921 formatv(
"invalid LoopRotate pass parameter '{0}' ", ParamName).str(),
930 while (!Params.
empty()) {
932 std::tie(ParamName, Params) = Params.
split(
';');
935 if (ParamName ==
"split-footer-bb") {
938 return make_error<StringError>(
939 formatv(
"invalid MergedLoadStoreMotion pass parameter '{0}' ",
950 while (!Params.
empty()) {
952 std::tie(ParamName, Params) = Params.
split(
';');
955 if (ParamName ==
"pre") {
957 }
else if (ParamName ==
"load-pre") {
959 }
else if (ParamName ==
"split-backedge-load-pre") {
961 }
else if (ParamName ==
"memdep") {
964 return make_error<StringError>(
965 formatv(
"invalid GVN pass parameter '{0}' ", ParamName).str(),
974 while (!Params.
empty()) {
976 std::tie(ParamName, Params) = Params.
split(
';');
979 if (ParamName ==
"func-spec")
982 return make_error<StringError>(
983 formatv(
"invalid IPSCCP pass parameter '{0}' ", ParamName).str(),
990 if (Params.
empty() || Params ==
"modify-cfg")
992 if (Params ==
"preserve-cfg")
994 return make_error<StringError>(
995 formatv(
"invalid SROA pass parameter '{0}' (either preserve-cfg or "
996 "modify-cfg can be specified)",
1003parseStackLifetimeOptions(
StringRef Params) {
1005 while (!Params.
empty()) {
1007 std::tie(ParamName, Params) = Params.
split(
';');
1009 if (ParamName ==
"may") {
1011 }
else if (ParamName ==
"must") {
1014 return make_error<StringError>(
1015 formatv(
"invalid StackLifetime parameter '{0}' ", ParamName).str(),
1024 "DependenceAnalysisPrinter");
1029 "SeparateConstOffsetFromGEP");
1033parseFunctionSimplificationPipelineOptions(
StringRef Params) {
1036 return make_error<StringError>(
1037 formatv(
"invalid function-simplification parameter '{0}' ", Params)
1046 "MemorySSAPrinterPass");
1051 "SpeculativeExecutionPass");
1056 while (!Params.
empty()) {
1058 std::tie(ParamName, Params) = Params.
split(
';');
1063 return make_error<StringError>(
1064 formatv(
"invalid MemProfUse pass parameter '{0}' ", ParamName).str(),
1073 "StructuralHashPrinterPass");
1078 "WinEHPreparePass");
1083 while (!Params.
empty()) {
1085 std::tie(ParamName, Params) = Params.
split(
';');
1088 if (ParamName ==
"group-by-use")
1090 else if (ParamName ==
"ignore-single-use")
1092 else if (ParamName ==
"merge-const")
1094 else if (ParamName ==
"merge-external")
1098 return make_error<StringError>(
1099 formatv(
"invalid GlobalMergePass parameter '{0}' ", ParamName)
1112 return Name.starts_with(
"default") ||
Name.starts_with(
"thinlto") ||
1113 Name.starts_with(
"lto");
1124template <
typename PassManagerT,
typename CallbacksT>
1126 if (!Callbacks.empty()) {
1127 PassManagerT DummyPM;
1128 for (
auto &CB : Callbacks)
1129 if (CB(
Name, DummyPM, {}))
1135template <
typename CallbacksT>
1141 StringRef NameNoBracket =
Name.take_until([](
char C) {
return C ==
'<'; });
1144 if (
Name ==
"module")
1146 if (
Name ==
"cgscc")
1148 if (NameNoBracket ==
"function")
1150 if (
Name ==
"coro-cond")
1157#define MODULE_PASS(NAME, CREATE_PASS) \
1160#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1161 if (PassBuilder::checkParametrizedPassName(Name, NAME)) \
1163#define MODULE_ANALYSIS(NAME, CREATE_PASS) \
1164 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \
1166#include "PassRegistry.def"
1168 return callbacksAcceptPassName<ModulePassManager>(
Name, Callbacks);
1171template <
typename CallbacksT>
1174 StringRef NameNoBracket =
Name.take_until([](
char C) {
return C ==
'<'; });
1175 if (
Name ==
"cgscc")
1177 if (NameNoBracket ==
"function")
1186#define CGSCC_PASS(NAME, CREATE_PASS) \
1189#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1190 if (PassBuilder::checkParametrizedPassName(Name, NAME)) \
1192#define CGSCC_ANALYSIS(NAME, CREATE_PASS) \
1193 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \
1195#include "PassRegistry.def"
1197 return callbacksAcceptPassName<CGSCCPassManager>(
Name, Callbacks);
1200template <
typename CallbacksT>
1203 StringRef NameNoBracket =
Name.take_until([](
char C) {
return C ==
'<'; });
1204 if (NameNoBracket ==
"function")
1206 if (
Name ==
"loop" ||
Name ==
"loop-mssa")
1213#define FUNCTION_PASS(NAME, CREATE_PASS) \
1216#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1217 if (PassBuilder::checkParametrizedPassName(Name, NAME)) \
1219#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
1220 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \
1222#include "PassRegistry.def"
1224 return callbacksAcceptPassName<FunctionPassManager>(
Name, Callbacks);
1227template <
typename CallbacksT>
1230 if (
Name ==
"machine-function")
1237#define MACHINE_FUNCTION_PASS(NAME, CREATE_PASS) \
1240#define MACHINE_FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
1241 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \
1244#include "llvm/Passes/MachinePassRegistry.def"
1246 return callbacksAcceptPassName<MachineFunctionPassManager>(
Name, Callbacks);
1249template <
typename CallbacksT>
1251 bool &UseMemorySSA) {
1252 UseMemorySSA =
false;
1259 UseMemorySSA =
true;
1263#define LOOPNEST_PASS(NAME, CREATE_PASS) \
1266#include "PassRegistry.def"
1268 return callbacksAcceptPassName<LoopPassManager>(
Name, Callbacks);
1271template <
typename CallbacksT>
1273 bool &UseMemorySSA) {
1274 UseMemorySSA =
false;
1281 UseMemorySSA =
true;
1285#define LOOP_PASS(NAME, CREATE_PASS) \
1288#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1289 if (PassBuilder::checkParametrizedPassName(Name, NAME)) \
1291#define LOOP_ANALYSIS(NAME, CREATE_PASS) \
1292 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \
1294#include "PassRegistry.def"
1296 return callbacksAcceptPassName<LoopPassManager>(
Name, Callbacks);
1299std::optional<std::vector<PassBuilder::PipelineElement>>
1300PassBuilder::parsePipelineText(
StringRef Text) {
1301 std::vector<PipelineElement> ResultPipeline;
1306 std::vector<PipelineElement> &Pipeline = *PipelineStack.
back();
1307 size_t Pos =
Text.find_first_of(
",()");
1308 Pipeline.push_back({
Text.substr(0, Pos), {}});
1311 if (Pos ==
Text.npos)
1314 char Sep =
Text[Pos];
1322 PipelineStack.
push_back(&Pipeline.back().InnerPipeline);
1326 assert(Sep ==
')' &&
"Bogus separator!");
1331 if (PipelineStack.
size() == 1)
1332 return std::nullopt;
1335 }
while (
Text.consume_front(
")"));
1343 if (!
Text.consume_front(
","))
1344 return std::nullopt;
1347 if (PipelineStack.
size() > 1)
1349 return std::nullopt;
1351 assert(PipelineStack.
back() == &ResultPipeline &&
1352 "Wrong pipeline at the bottom of the stack!");
1353 return {std::move(ResultPipeline)};
1357 const PipelineElement &E) {
1358 auto &
Name = E.Name;
1359 auto &InnerPipeline = E.InnerPipeline;
1362 if (!InnerPipeline.empty()) {
1363 if (
Name ==
"module") {
1365 if (
auto Err = parseModulePassPipeline(NestedMPM, InnerPipeline))
1370 if (
Name ==
"coro-cond") {
1372 if (
auto Err = parseModulePassPipeline(NestedMPM, InnerPipeline))
1377 if (
Name ==
"cgscc") {
1379 if (
auto Err = parseCGSCCPassPipeline(CGPM, InnerPipeline))
1384 if (
Name ==
"machine-function") {
1386 if (
auto Err = parseMachinePassPipeline(MFPM, InnerPipeline))
1393 return make_error<StringError>(
1394 "cannot have a no-rerun module to function adaptor",
1397 if (
auto Err = parseFunctionPassPipeline(FPM, InnerPipeline))
1405 if (
auto Err = parseModulePassPipeline(NestedMPM, InnerPipeline))
1411 for (
auto &
C : ModulePipelineParsingCallbacks)
1416 return make_error<StringError>(
1417 formatv(
"invalid use of '{0}' pass as module pipeline",
Name).str(),
1426 return make_error<StringError>(
1427 formatv(
"unknown default pipeline alias '{0}'",
Name).str(),
1430 assert(Matches.
size() == 3 &&
"Must capture two matched strings!");
1442 if (Matches[1] ==
"default") {
1444 }
else if (Matches[1] ==
"thinlto-pre-link") {
1446 }
else if (Matches[1] ==
"thinlto") {
1448 }
else if (Matches[1] ==
"lto-pre-link") {
1457 assert(Matches[1] ==
"lto" &&
"Not one of the matched options!");
1464#define MODULE_PASS(NAME, CREATE_PASS) \
1465 if (Name == NAME) { \
1466 MPM.addPass(CREATE_PASS); \
1467 return Error::success(); \
1469#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1470 if (checkParametrizedPassName(Name, NAME)) { \
1471 auto Params = parsePassParameters(PARSER, Name, NAME); \
1473 return Params.takeError(); \
1474 MPM.addPass(CREATE_PASS(Params.get())); \
1475 return Error::success(); \
1477#define MODULE_ANALYSIS(NAME, CREATE_PASS) \
1478 if (Name == "require<" NAME ">") { \
1480 RequireAnalysisPass< \
1481 std::remove_reference_t<decltype(CREATE_PASS)>, Module>()); \
1482 return Error::success(); \
1484 if (Name == "invalidate<" NAME ">") { \
1485 MPM.addPass(InvalidateAnalysisPass< \
1486 std::remove_reference_t<decltype(CREATE_PASS)>>()); \
1487 return Error::success(); \
1489#define CGSCC_PASS(NAME, CREATE_PASS) \
1490 if (Name == NAME) { \
1491 MPM.addPass(createModuleToPostOrderCGSCCPassAdaptor(CREATE_PASS)); \
1492 return Error::success(); \
1494#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1495 if (checkParametrizedPassName(Name, NAME)) { \
1496 auto Params = parsePassParameters(PARSER, Name, NAME); \
1498 return Params.takeError(); \
1500 createModuleToPostOrderCGSCCPassAdaptor(CREATE_PASS(Params.get()))); \
1501 return Error::success(); \
1503#define FUNCTION_PASS(NAME, CREATE_PASS) \
1504 if (Name == NAME) { \
1505 MPM.addPass(createModuleToFunctionPassAdaptor(CREATE_PASS)); \
1506 return Error::success(); \
1508#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1509 if (checkParametrizedPassName(Name, NAME)) { \
1510 auto Params = parsePassParameters(PARSER, Name, NAME); \
1512 return Params.takeError(); \
1513 MPM.addPass(createModuleToFunctionPassAdaptor(CREATE_PASS(Params.get()))); \
1514 return Error::success(); \
1516#define LOOPNEST_PASS(NAME, CREATE_PASS) \
1517 if (Name == NAME) { \
1518 MPM.addPass(createModuleToFunctionPassAdaptor( \
1519 createFunctionToLoopPassAdaptor(CREATE_PASS, false, false))); \
1520 return Error::success(); \
1522#define LOOP_PASS(NAME, CREATE_PASS) \
1523 if (Name == NAME) { \
1524 MPM.addPass(createModuleToFunctionPassAdaptor( \
1525 createFunctionToLoopPassAdaptor(CREATE_PASS, false, false))); \
1526 return Error::success(); \
1528#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1529 if (checkParametrizedPassName(Name, NAME)) { \
1530 auto Params = parsePassParameters(PARSER, Name, NAME); \
1532 return Params.takeError(); \
1534 createModuleToFunctionPassAdaptor(createFunctionToLoopPassAdaptor( \
1535 CREATE_PASS(Params.get()), false, false))); \
1536 return Error::success(); \
1538#include "PassRegistry.def"
1540 for (
auto &
C : ModulePipelineParsingCallbacks)
1543 return make_error<StringError>(
1549 const PipelineElement &E) {
1550 auto &
Name = E.Name;
1551 auto &InnerPipeline = E.InnerPipeline;
1554 if (!InnerPipeline.empty()) {
1555 if (
Name ==
"cgscc") {
1557 if (
auto Err = parseCGSCCPassPipeline(NestedCGPM, InnerPipeline))
1560 CGPM.
addPass(std::move(NestedCGPM));
1565 if (
auto Err = parseFunctionPassPipeline(FPM, InnerPipeline))
1569 std::move(FPM), Params->first, Params->second));
1574 if (
auto Err = parseCGSCCPassPipeline(NestedCGPM, InnerPipeline))
1581 if (
auto Err = parseCGSCCPassPipeline(NestedCGPM, InnerPipeline))
1588 for (
auto &
C : CGSCCPipelineParsingCallbacks)
1589 if (
C(
Name, CGPM, InnerPipeline))
1593 return make_error<StringError>(
1594 formatv(
"invalid use of '{0}' pass as cgscc pipeline",
Name).str(),
1599#define CGSCC_PASS(NAME, CREATE_PASS) \
1600 if (Name == NAME) { \
1601 CGPM.addPass(CREATE_PASS); \
1602 return Error::success(); \
1604#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1605 if (checkParametrizedPassName(Name, NAME)) { \
1606 auto Params = parsePassParameters(PARSER, Name, NAME); \
1608 return Params.takeError(); \
1609 CGPM.addPass(CREATE_PASS(Params.get())); \
1610 return Error::success(); \
1612#define CGSCC_ANALYSIS(NAME, CREATE_PASS) \
1613 if (Name == "require<" NAME ">") { \
1614 CGPM.addPass(RequireAnalysisPass< \
1615 std::remove_reference_t<decltype(CREATE_PASS)>, \
1616 LazyCallGraph::SCC, CGSCCAnalysisManager, LazyCallGraph &, \
1617 CGSCCUpdateResult &>()); \
1618 return Error::success(); \
1620 if (Name == "invalidate<" NAME ">") { \
1621 CGPM.addPass(InvalidateAnalysisPass< \
1622 std::remove_reference_t<decltype(CREATE_PASS)>>()); \
1623 return Error::success(); \
1625#define FUNCTION_PASS(NAME, CREATE_PASS) \
1626 if (Name == NAME) { \
1627 CGPM.addPass(createCGSCCToFunctionPassAdaptor(CREATE_PASS)); \
1628 return Error::success(); \
1630#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1631 if (checkParametrizedPassName(Name, NAME)) { \
1632 auto Params = parsePassParameters(PARSER, Name, NAME); \
1634 return Params.takeError(); \
1635 CGPM.addPass(createCGSCCToFunctionPassAdaptor(CREATE_PASS(Params.get()))); \
1636 return Error::success(); \
1638#define LOOPNEST_PASS(NAME, CREATE_PASS) \
1639 if (Name == NAME) { \
1640 CGPM.addPass(createCGSCCToFunctionPassAdaptor( \
1641 createFunctionToLoopPassAdaptor(CREATE_PASS, false, false))); \
1642 return Error::success(); \
1644#define LOOP_PASS(NAME, CREATE_PASS) \
1645 if (Name == NAME) { \
1646 CGPM.addPass(createCGSCCToFunctionPassAdaptor( \
1647 createFunctionToLoopPassAdaptor(CREATE_PASS, false, false))); \
1648 return Error::success(); \
1650#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1651 if (checkParametrizedPassName(Name, NAME)) { \
1652 auto Params = parsePassParameters(PARSER, Name, NAME); \
1654 return Params.takeError(); \
1656 createCGSCCToFunctionPassAdaptor(createFunctionToLoopPassAdaptor( \
1657 CREATE_PASS(Params.get()), false, false))); \
1658 return Error::success(); \
1660#include "PassRegistry.def"
1662 for (
auto &
C : CGSCCPipelineParsingCallbacks)
1663 if (
C(
Name, CGPM, InnerPipeline))
1665 return make_error<StringError>(
1671 const PipelineElement &E) {
1672 auto &
Name = E.Name;
1673 auto &InnerPipeline = E.InnerPipeline;
1676 if (!InnerPipeline.empty()) {
1677 if (
Name ==
"function") {
1679 if (
auto Err = parseFunctionPassPipeline(NestedFPM, InnerPipeline))
1682 FPM.
addPass(std::move(NestedFPM));
1685 if (
Name ==
"loop" ||
Name ==
"loop-mssa") {
1687 if (
auto Err = parseLoopPassPipeline(LPM, InnerPipeline))
1690 bool UseMemorySSA = (
Name ==
"loop-mssa");
1692 return Pipeline.Name.contains(
"simple-loop-unswitch");
1694 bool UseBPI =
llvm::any_of(InnerPipeline, [](
auto Pipeline) {
1695 return Pipeline.Name ==
"loop-predication";
1703 if (
auto Err = parseFunctionPassPipeline(NestedFPM, InnerPipeline))
1709 for (
auto &
C : FunctionPipelineParsingCallbacks)
1710 if (
C(
Name, FPM, InnerPipeline))
1714 return make_error<StringError>(
1715 formatv(
"invalid use of '{0}' pass as function pipeline",
Name).str(),
1720#define FUNCTION_PASS(NAME, CREATE_PASS) \
1721 if (Name == NAME) { \
1722 FPM.addPass(CREATE_PASS); \
1723 return Error::success(); \
1725#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1726 if (checkParametrizedPassName(Name, NAME)) { \
1727 auto Params = parsePassParameters(PARSER, Name, NAME); \
1729 return Params.takeError(); \
1730 FPM.addPass(CREATE_PASS(Params.get())); \
1731 return Error::success(); \
1733#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
1734 if (Name == "require<" NAME ">") { \
1736 RequireAnalysisPass< \
1737 std::remove_reference_t<decltype(CREATE_PASS)>, Function>()); \
1738 return Error::success(); \
1740 if (Name == "invalidate<" NAME ">") { \
1741 FPM.addPass(InvalidateAnalysisPass< \
1742 std::remove_reference_t<decltype(CREATE_PASS)>>()); \
1743 return Error::success(); \
1749#define LOOPNEST_PASS(NAME, CREATE_PASS) \
1750 if (Name == NAME) { \
1751 FPM.addPass(createFunctionToLoopPassAdaptor(CREATE_PASS, false, false)); \
1752 return Error::success(); \
1754#define LOOP_PASS(NAME, CREATE_PASS) \
1755 if (Name == NAME) { \
1756 FPM.addPass(createFunctionToLoopPassAdaptor(CREATE_PASS, false, false)); \
1757 return Error::success(); \
1759#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1760 if (checkParametrizedPassName(Name, NAME)) { \
1761 auto Params = parsePassParameters(PARSER, Name, NAME); \
1763 return Params.takeError(); \
1764 FPM.addPass(createFunctionToLoopPassAdaptor(CREATE_PASS(Params.get()), \
1766 return Error::success(); \
1768#include "PassRegistry.def"
1770 for (
auto &
C : FunctionPipelineParsingCallbacks)
1771 if (
C(
Name, FPM, InnerPipeline))
1773 return make_error<StringError>(
1774 formatv(
"unknown function pass '{0}'",
Name).str(),
1779 const PipelineElement &E) {
1781 auto &InnerPipeline = E.InnerPipeline;
1784 if (!InnerPipeline.empty()) {
1785 if (
Name ==
"loop") {
1787 if (
auto Err = parseLoopPassPipeline(NestedLPM, InnerPipeline))
1790 LPM.
addPass(std::move(NestedLPM));
1795 if (
auto Err = parseLoopPassPipeline(NestedLPM, InnerPipeline))
1801 for (
auto &
C : LoopPipelineParsingCallbacks)
1802 if (
C(
Name, LPM, InnerPipeline))
1806 return make_error<StringError>(
1807 formatv(
"invalid use of '{0}' pass as loop pipeline",
Name).str(),
1812#define LOOPNEST_PASS(NAME, CREATE_PASS) \
1813 if (Name == NAME) { \
1814 LPM.addPass(CREATE_PASS); \
1815 return Error::success(); \
1817#define LOOP_PASS(NAME, CREATE_PASS) \
1818 if (Name == NAME) { \
1819 LPM.addPass(CREATE_PASS); \
1820 return Error::success(); \
1822#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1823 if (checkParametrizedPassName(Name, NAME)) { \
1824 auto Params = parsePassParameters(PARSER, Name, NAME); \
1826 return Params.takeError(); \
1827 LPM.addPass(CREATE_PASS(Params.get())); \
1828 return Error::success(); \
1830#define LOOP_ANALYSIS(NAME, CREATE_PASS) \
1831 if (Name == "require<" NAME ">") { \
1832 LPM.addPass(RequireAnalysisPass< \
1833 std::remove_reference_t<decltype(CREATE_PASS)>, Loop, \
1834 LoopAnalysisManager, LoopStandardAnalysisResults &, \
1836 return Error::success(); \
1838 if (Name == "invalidate<" NAME ">") { \
1839 LPM.addPass(InvalidateAnalysisPass< \
1840 std::remove_reference_t<decltype(CREATE_PASS)>>()); \
1841 return Error::success(); \
1843#include "PassRegistry.def"
1845 for (
auto &
C : LoopPipelineParsingCallbacks)
1846 if (
C(
Name, LPM, InnerPipeline))
1848 return make_error<StringError>(
formatv(
"unknown loop pass '{0}'",
Name).str(),
1853 const PipelineElement &E) {
1855 if (!E.InnerPipeline.empty())
1856 return make_error<StringError>(
"invalid pipeline",
1859#define MACHINE_MODULE_PASS(NAME, CREATE_PASS) \
1860 if (Name == NAME) { \
1861 MFPM.addPass(CREATE_PASS); \
1862 return Error::success(); \
1864#define MACHINE_FUNCTION_PASS(NAME, CREATE_PASS) \
1865 if (Name == NAME) { \
1866 MFPM.addPass(CREATE_PASS); \
1867 return Error::success(); \
1869#include "llvm/Passes/MachinePassRegistry.def"
1871 for (
auto &
C : MachineFunctionPipelineParsingCallbacks)
1872 if (
C(
Name, MFPM, E.InnerPipeline))
1874 return make_error<StringError>(
1875 formatv(
"unknown machine pass '{0}'",
Name).str(),
1880#define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS) \
1881 if (Name == NAME) { \
1882 AA.registerModuleAnalysis< \
1883 std::remove_reference_t<decltype(CREATE_PASS)>>(); \
1886#define FUNCTION_ALIAS_ANALYSIS(NAME, CREATE_PASS) \
1887 if (Name == NAME) { \
1888 AA.registerFunctionAnalysis< \
1889 std::remove_reference_t<decltype(CREATE_PASS)>>(); \
1892#include "PassRegistry.def"
1894 for (
auto &
C : AAParsingCallbacks)
1900Error PassBuilder::parseMachinePassPipeline(
1902 for (
const auto &Element : Pipeline) {
1903 if (
auto Err = parseMachinePass(MFPM, Element))
1911 for (
const auto &Element : Pipeline) {
1912 if (
auto Err = parseLoopPass(LPM, Element))
1918Error PassBuilder::parseFunctionPassPipeline(
1920 for (
const auto &Element : Pipeline) {
1921 if (
auto Err = parseFunctionPass(FPM, Element))
1929 for (
const auto &Element : Pipeline) {
1930 if (
auto Err = parseCGSCCPass(CGPM, Element))
1960 for (
const auto &Element : Pipeline) {
1961 if (
auto Err = parseModulePass(
MPM, Element))
1972 auto Pipeline = parsePipelineText(PipelineText);
1973 if (!Pipeline || Pipeline->empty())
1974 return make_error<StringError>(
1975 formatv(
"invalid pipeline '{0}'", PipelineText).str(),
1985 Pipeline = {{
"cgscc", std::move(*Pipeline)}};
1987 FunctionPipelineParsingCallbacks)) {
1988 Pipeline = {{
"function", std::move(*Pipeline)}};
1991 Pipeline = {{
"function", {{UseMemorySSA ?
"loop-mssa" :
"loop",
1992 std::move(*Pipeline)}}}};
1993 }
else if (
isLoopPassName(FirstName, LoopPipelineParsingCallbacks,
1995 Pipeline = {{
"function", {{UseMemorySSA ?
"loop-mssa" :
"loop",
1996 std::move(*Pipeline)}}}};
1998 FirstName, MachineFunctionPipelineParsingCallbacks)) {
1999 Pipeline = {{
"machine-function", std::move(*Pipeline)}};
2001 for (
auto &
C : TopLevelPipelineParsingCallbacks)
2002 if (
C(
MPM, *Pipeline))
2006 auto &InnerPipeline = Pipeline->front().InnerPipeline;
2007 return make_error<StringError>(
2008 formatv(
"unknown {0} name '{1}'",
2009 (InnerPipeline.empty() ?
"pass" :
"pipeline"), FirstName)
2015 if (
auto Err = parseModulePassPipeline(
MPM, *Pipeline))
2023 auto Pipeline = parsePipelineText(PipelineText);
2024 if (!Pipeline || Pipeline->empty())
2025 return make_error<StringError>(
2026 formatv(
"invalid pipeline '{0}'", PipelineText).str(),
2031 return make_error<StringError>(
2032 formatv(
"unknown cgscc pass '{0}' in pipeline '{1}'", FirstName,
2037 if (
auto Err = parseCGSCCPassPipeline(CGPM, *Pipeline))
2046 auto Pipeline = parsePipelineText(PipelineText);
2047 if (!Pipeline || Pipeline->empty())
2048 return make_error<StringError>(
2049 formatv(
"invalid pipeline '{0}'", PipelineText).str(),
2054 return make_error<StringError>(
2055 formatv(
"unknown function pass '{0}' in pipeline '{1}'", FirstName,
2060 if (
auto Err = parseFunctionPassPipeline(FPM, *Pipeline))
2068 auto Pipeline = parsePipelineText(PipelineText);
2069 if (!Pipeline || Pipeline->empty())
2070 return make_error<StringError>(
2071 formatv(
"invalid pipeline '{0}'", PipelineText).str(),
2074 if (
auto Err = parseLoopPassPipeline(CGPM, *Pipeline))
2082 auto Pipeline = parsePipelineText(PipelineText);
2083 if (!Pipeline || Pipeline->empty())
2084 return make_error<StringError>(
2085 formatv(
"invalid machine pass pipeline '{0}'", PipelineText).str(),
2088 if (
auto Err = parseMachinePassPipeline(MFPM, *Pipeline))
2097 if (PipelineText ==
"default") {
2102 while (!PipelineText.
empty()) {
2104 std::tie(
Name, PipelineText) = PipelineText.
split(
',');
2105 if (!parseAAPassName(AA,
Name))
2106 return make_error<StringError>(
2107 formatv(
"unknown alias analysis name '{0}'",
Name).str(),
2119 OS <<
" " <<
PassName <<
"<" << Params <<
">\n";
2125 OS <<
"Module passes:\n";
2126#define MODULE_PASS(NAME, CREATE_PASS) printPassName(NAME, OS);
2127#include "PassRegistry.def"
2129 OS <<
"Module passes with params:\n";
2130#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2131 printPassName(NAME, PARAMS, OS);
2132#include "PassRegistry.def"
2134 OS <<
"Module analyses:\n";
2135#define MODULE_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
2136#include "PassRegistry.def"
2138 OS <<
"Module alias analyses:\n";
2139#define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
2140#include "PassRegistry.def"
2142 OS <<
"CGSCC passes:\n";
2143#define CGSCC_PASS(NAME, CREATE_PASS) printPassName(NAME, OS);
2144#include "PassRegistry.def"
2146 OS <<
"CGSCC passes with params:\n";
2147#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2148 printPassName(NAME, PARAMS, OS);
2149#include "PassRegistry.def"
2151 OS <<
"CGSCC analyses:\n";
2152#define CGSCC_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
2153#include "PassRegistry.def"
2155 OS <<
"Function passes:\n";
2156#define FUNCTION_PASS(NAME, CREATE_PASS) printPassName(NAME, OS);
2157#include "PassRegistry.def"
2159 OS <<
"Function passes with params:\n";
2160#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2161 printPassName(NAME, PARAMS, OS);
2162#include "PassRegistry.def"
2164 OS <<
"Function analyses:\n";
2165#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
2166#include "PassRegistry.def"
2168 OS <<
"Function alias analyses:\n";
2169#define FUNCTION_ALIAS_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
2170#include "PassRegistry.def"
2172 OS <<
"LoopNest passes:\n";
2173#define LOOPNEST_PASS(NAME, CREATE_PASS) printPassName(NAME, OS);
2174#include "PassRegistry.def"
2176 OS <<
"Loop passes:\n";
2177#define LOOP_PASS(NAME, CREATE_PASS) printPassName(NAME, OS);
2178#include "PassRegistry.def"
2180 OS <<
"Loop passes with params:\n";
2181#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2182 printPassName(NAME, PARAMS, OS);
2183#include "PassRegistry.def"
2185 OS <<
"Loop analyses:\n";
2186#define LOOP_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
2187#include "PassRegistry.def"
2189 OS <<
"Machine module passes (WIP):\n";
2190#define MACHINE_MODULE_PASS(NAME, CREATE_PASS) printPassName(NAME, OS);
2191#include "llvm/Passes/MachinePassRegistry.def"
2193 OS <<
"Machine function passes (WIP):\n";
2194#define MACHINE_FUNCTION_PASS(NAME, CREATE_PASS) printPassName(NAME, OS);
2195#include "llvm/Passes/MachinePassRegistry.def"
2197 OS <<
"Machine function analyses (WIP):\n";
2198#define MACHINE_FUNCTION_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
2199#include "llvm/Passes/MachinePassRegistry.def"
2205 TopLevelPipelineParsingCallbacks.push_back(
C);
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.
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
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 std::optional< int > parseRepeatPassName(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...
This file provides the interface for the pass responsible for removing expensive ubsan checks.
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...
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.
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.
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 an 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 ...
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< PassT, PassManager >::value > 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.
static bool hasLimitedCodeGenPipeline()
Returns true if one of the -start-after, -start-before, -stop-after or -stop-before options is set.
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.
auto formatv(const char *Fmt, Ts &&... Vals) -> formatv_object< decltype(std::make_tuple(detail::build_format_adapter(std::forward< Ts >(Vals))...))>
std::vector< std::string > printAfterPasses()
ModuleToFunctionPassAdaptor createModuleToFunctionPassAdaptor(FunctionPassT &&Pass, bool EagerlyInvalidate=false)
A function to deduce a function pass type and wrap it in the templated adaptor.
RepeatedPass< PassT > createRepeatedPass(int Count, PassT &&P)
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.
std::vector< std::string > printBeforePasses()
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.
ModuleToMachineFunctionPassAdaptor createModuleToMachineFunctionPassAdaptor(MachineFunctionPassT &&Pass)
cl::opt< bool > PrintPipelinePasses("print-pipeline-passes", cl::desc("Print a '-passes' compatible string describing the pipeline " "(best-effort only)."))
OuterAnalysisManagerProxy< FunctionAnalysisManager, Loop, LoopStandardAnalysisResults & > FunctionAnalysisManagerLoopProxy
A proxy from a FunctionAnalysisManager to a Loop.
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.
bool isFilterPassesEmpty()
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.