267 "^(default|thinlto-pre-link|thinlto|lto-pre-link|lto)<(O[0123sz])>$");
271 "print-pipeline-passes",
272 cl::desc(
"Print a '-passes' compatible string describing the pipeline "
273 "(best-effort only)."));
385bool shouldPopulateClassToPassNames() {
392class TriggerCrashPass :
public PassInfoMixin<TriggerCrashPass> {
404 std::optional<PGOOptions> PGOOpt,
406 :
TM(
TM), PTO(PTO), PGOOpt(PGOOpt),
PIC(
PIC) {
408 TM->registerPassBuilderCallbacks(*
this);
409 if (
PIC && shouldPopulateClassToPassNames()) {
410#define MODULE_PASS(NAME, CREATE_PASS) \
411 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
412#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
413 PIC->addClassToPassName(CLASS, NAME);
414#define MODULE_ANALYSIS(NAME, CREATE_PASS) \
415 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
416#define FUNCTION_PASS(NAME, CREATE_PASS) \
417 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
418#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
419 PIC->addClassToPassName(CLASS, NAME);
420#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
421 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
422#define LOOPNEST_PASS(NAME, CREATE_PASS) \
423 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
424#define LOOP_PASS(NAME, CREATE_PASS) \
425 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
426#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
427 PIC->addClassToPassName(CLASS, NAME);
428#define LOOP_ANALYSIS(NAME, CREATE_PASS) \
429 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
430#define CGSCC_PASS(NAME, CREATE_PASS) \
431 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
432#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
433 PIC->addClassToPassName(CLASS, NAME);
434#define CGSCC_ANALYSIS(NAME, CREATE_PASS) \
435 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
436#include "PassRegistry.def"
441#define MODULE_ANALYSIS(NAME, CREATE_PASS) \
442 MAM.registerPass([&] { return CREATE_PASS; });
443#include "PassRegistry.def"
445 for (
auto &
C : ModuleAnalysisRegistrationCallbacks)
450#define CGSCC_ANALYSIS(NAME, CREATE_PASS) \
451 CGAM.registerPass([&] { return CREATE_PASS; });
452#include "PassRegistry.def"
454 for (
auto &
C : CGSCCAnalysisRegistrationCallbacks)
464#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
465 FAM.registerPass([&] { return CREATE_PASS; });
466#include "PassRegistry.def"
468 for (
auto &
C : FunctionAnalysisRegistrationCallbacks)
473#define LOOP_ANALYSIS(NAME, CREATE_PASS) \
474 LAM.registerPass([&] { return CREATE_PASS; });
475#include "PassRegistry.def"
477 for (
auto &
C : LoopAnalysisRegistrationCallbacks)
482 if (!
Name.consume_front(
"repeat<") || !
Name.consume_back(
">"))
485 if (
Name.getAsInteger(0, Count) || Count <= 0)
490static std::optional<std::pair<bool, bool>>
492 std::pair<bool, bool> Params;
493 if (!
Name.consume_front(
"function"))
497 if (!
Name.consume_front(
"<") || !
Name.consume_back(
">"))
499 while (!
Name.empty()) {
500 auto [Front, Back] =
Name.split(
';');
502 if (Front ==
"eager-inv")
504 else if (Front ==
"no-rerun")
505 Params.second =
true;
513 if (!
Name.consume_front(
"devirt<") || !
Name.consume_back(
">"))
516 if (
Name.getAsInteger(0, Count) || Count < 0)
527 return Name.startswith(
"<") &&
Name.endswith(
">");
547template <
typename ParametersParseCallableT>
548auto parsePassParameters(ParametersParseCallableT &&Parser,
StringRef Name,
550 using ParametersT =
typename decltype(Parser(
StringRef{}))::value_type;
555 "unable to strip pass name from parametrized pass specification");
557 if (!Params.
empty() &&
559 assert(
false &&
"invalid format for parametrized pass name");
563 assert((Result ||
Result.template errorIsA<StringError>()) &&
564 "Pass parameter parser can only return StringErrors.");
572 while (!Params.
empty()) {
574 std::tie(ParamName, Params) = Params.
split(
';');
578 return make_error<StringError>(
579 formatv(
"invalid HardwareLoopPass parameter '{0}' ", ParamName).str(),
584 if (ParamName.
consume_front(
"hardware-loop-counter-bitwidth=")) {
587 return make_error<StringError>(
588 formatv(
"invalid HardwareLoopPass parameter '{0}' ", ParamName).str(),
593 if (ParamName ==
"force-hardware-loops") {
595 }
else if (ParamName ==
"force-hardware-loop-phi") {
597 }
else if (ParamName ==
"force-nested-hardware-loop") {
599 }
else if (ParamName ==
"force-hardware-loop-guard") {
602 return make_error<StringError>(
603 formatv(
"invalid HardwarePass parameter '{0}' ", ParamName).str(),
607 return HardwareLoopOpts;
613 while (!Params.
empty()) {
615 std::tie(ParamName, Params) = Params.
split(
';');
629 return make_error<StringError>(
630 formatv(
"invalid LoopUnrollPass parameter '{0}' ", ParamName).str(),
637 if (ParamName ==
"partial") {
639 }
else if (ParamName ==
"peeling") {
641 }
else if (ParamName ==
"profile-peeling") {
643 }
else if (ParamName ==
"runtime") {
645 }
else if (ParamName ==
"upperbound") {
648 return make_error<StringError>(
649 formatv(
"invalid LoopUnrollPass parameter '{0}' ", ParamName).str(),
659 while (!Params.
empty()) {
661 std::tie(ParamName, Params) = Params.
split(
';');
663 if (ParamName == OptionName) {
666 return make_error<StringError>(
676 return parseSinglePassOption(Params,
"only-mandatory",
"InlinerPass");
680 return parseSinglePassOption(Params,
"reuse-storage",
"CoroSplitPass");
684 return parseSinglePassOption(Params,
"skip-non-recursive",
685 "PostOrderFunctionAttrs");
689 return parseSinglePassOption(Params,
"memssa",
"EarlyCSE");
693 return parseSinglePassOption(Params,
"post-inline",
"EntryExitInstrumenter");
697 return parseSinglePassOption(Params,
"single",
"LoopExtractor");
701 return parseSinglePassOption(Params,
"minimal",
"LowerMatrixIntrinsics");
706 while (!Params.
empty()) {
708 std::tie(ParamName, Params) = Params.
split(
';');
710 if (ParamName ==
"kernel") {
711 Result.CompileKernel =
true;
713 return make_error<StringError>(
714 formatv(
"invalid AddressSanitizer pass parameter '{0}' ", ParamName)
724 while (!Params.
empty()) {
726 std::tie(ParamName, Params) = Params.
split(
';');
728 if (ParamName ==
"recover") {
730 }
else if (ParamName ==
"kernel") {
731 Result.CompileKernel =
true;
733 return make_error<StringError>(
734 formatv(
"invalid HWAddressSanitizer pass parameter '{0}' ", ParamName)
744 while (!Params.
empty()) {
746 std::tie(ParamName, Params) = Params.
split(
';');
748 if (ParamName ==
"recover") {
750 }
else if (ParamName ==
"kernel") {
754 return make_error<StringError>(
755 formatv(
"invalid argument to MemorySanitizer pass track-origins "
760 }
else if (ParamName ==
"eager-checks") {
761 Result.EagerChecks =
true;
763 return make_error<StringError>(
764 formatv(
"invalid MemorySanitizer pass parameter '{0}' ", ParamName)
775 while (!Params.
empty()) {
777 std::tie(ParamName, Params) = Params.
split(
';');
780 if (ParamName ==
"forward-switch-cond") {
782 }
else if (ParamName ==
"switch-range-to-icmp") {
784 }
else if (ParamName ==
"switch-to-lookup") {
786 }
else if (ParamName ==
"keep-loops") {
788 }
else if (ParamName ==
"hoist-common-insts") {
790 }
else if (ParamName ==
"sink-common-insts") {
793 APInt BonusInstThreshold;
795 return make_error<StringError>(
796 formatv(
"invalid argument to SimplifyCFG pass bonus-threshold "
802 return make_error<StringError>(
803 formatv(
"invalid SimplifyCFG pass parameter '{0}' ", ParamName).str(),
812 while (!Params.
empty()) {
814 std::tie(ParamName, Params) = Params.
split(
';');
817 if (ParamName ==
"use-loop-info") {
822 return make_error<StringError>(
823 formatv(
"invalid argument to InstCombine pass max-iterations "
829 return make_error<StringError>(
830 formatv(
"invalid InstCombine pass parameter '{0}' ", ParamName).str(),
840 while (!Params.
empty()) {
842 std::tie(ParamName, Params) = Params.
split(
';');
845 if (ParamName ==
"interleave-forced-only") {
847 }
else if (ParamName ==
"vectorize-forced-only") {
850 return make_error<StringError>(
851 formatv(
"invalid LoopVectorize parameter '{0}' ", ParamName).str(),
859 std::pair<bool, bool>
Result = {
false,
true};
860 while (!Params.
empty()) {
862 std::tie(ParamName, Params) = Params.
split(
';');
865 if (ParamName ==
"nontrivial") {
867 }
else if (ParamName ==
"trivial") {
870 return make_error<StringError>(
871 formatv(
"invalid LoopUnswitch pass parameter '{0}' ", ParamName)
881 while (!Params.
empty()) {
883 std::tie(ParamName, Params) = Params.
split(
';');
886 if (ParamName ==
"allowspeculation") {
889 return make_error<StringError>(
890 formatv(
"invalid LICM pass parameter '{0}' ", ParamName).str(),
899 while (!Params.
empty()) {
901 std::tie(ParamName, Params) = Params.
split(
';');
904 if (ParamName ==
"split-footer-bb") {
907 return make_error<StringError>(
908 formatv(
"invalid MergedLoadStoreMotion pass parameter '{0}' ",
919 while (!Params.
empty()) {
921 std::tie(ParamName, Params) = Params.
split(
';');
924 if (ParamName ==
"pre") {
926 }
else if (ParamName ==
"load-pre") {
928 }
else if (ParamName ==
"split-backedge-load-pre") {
930 }
else if (ParamName ==
"memdep") {
933 return make_error<StringError>(
934 formatv(
"invalid GVN pass parameter '{0}' ", ParamName).str(),
943 while (!Params.
empty()) {
945 std::tie(ParamName, Params) = Params.
split(
';');
948 if (ParamName ==
"func-spec")
951 return make_error<StringError>(
952 formatv(
"invalid IPSCCP pass parameter '{0}' ", ParamName).str(),
959 if (Params.
empty() || Params ==
"modify-cfg")
961 if (Params ==
"preserve-cfg")
963 return make_error<StringError>(
964 formatv(
"invalid SROA pass parameter '{0}' (either preserve-cfg or "
965 "modify-cfg can be specified)",
972parseStackLifetimeOptions(
StringRef Params) {
974 while (!Params.
empty()) {
976 std::tie(ParamName, Params) = Params.
split(
';');
978 if (ParamName ==
"may") {
980 }
else if (ParamName ==
"must") {
983 return make_error<StringError>(
984 formatv(
"invalid StackLifetime parameter '{0}' ", ParamName).str(),
992 return parseSinglePassOption(Params,
"normalized-results",
993 "DependenceAnalysisPrinter");
997 return parseSinglePassOption(Params,
"lower-gep",
998 "SeparateConstOffsetFromGEP");
1006 return Name.startswith(
"default") ||
Name.startswith(
"thinlto") ||
1007 Name.startswith(
"lto");
1018template <
typename PassManagerT,
typename CallbacksT>
1020 if (!Callbacks.empty()) {
1021 PassManagerT DummyPM;
1022 for (
auto &CB : Callbacks)
1023 if (CB(
Name, DummyPM, {}))
1029template <
typename CallbacksT>
1035 StringRef NameNoBracket =
Name.take_until([](
char C) {
return C ==
'<'; });
1038 if (
Name ==
"module")
1040 if (
Name ==
"cgscc")
1042 if (NameNoBracket ==
"function")
1044 if (
Name ==
"coro-cond")
1051#define MODULE_PASS(NAME, CREATE_PASS) \
1054#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1055 if (checkParametrizedPassName(Name, NAME)) \
1057#define MODULE_ANALYSIS(NAME, CREATE_PASS) \
1058 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \
1060#include "PassRegistry.def"
1062 return callbacksAcceptPassName<ModulePassManager>(
Name, Callbacks);
1065template <
typename CallbacksT>
1068 StringRef NameNoBracket =
Name.take_until([](
char C) {
return C ==
'<'; });
1069 if (
Name ==
"cgscc")
1071 if (NameNoBracket ==
"function")
1080#define CGSCC_PASS(NAME, CREATE_PASS) \
1083#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1084 if (checkParametrizedPassName(Name, NAME)) \
1086#define CGSCC_ANALYSIS(NAME, CREATE_PASS) \
1087 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \
1089#include "PassRegistry.def"
1091 return callbacksAcceptPassName<CGSCCPassManager>(
Name, Callbacks);
1094template <
typename CallbacksT>
1097 StringRef NameNoBracket =
Name.take_until([](
char C) {
return C ==
'<'; });
1098 if (NameNoBracket ==
"function")
1100 if (
Name ==
"loop" ||
Name ==
"loop-mssa")
1107#define FUNCTION_PASS(NAME, CREATE_PASS) \
1110#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1111 if (checkParametrizedPassName(Name, NAME)) \
1113#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
1114 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \
1116#include "PassRegistry.def"
1118 return callbacksAcceptPassName<FunctionPassManager>(
Name, Callbacks);
1121template <
typename CallbacksT>
1123 bool &UseMemorySSA) {
1124 UseMemorySSA =
false;
1131 UseMemorySSA =
true;
1135#define LOOPNEST_PASS(NAME, CREATE_PASS) \
1138#include "PassRegistry.def"
1140 return callbacksAcceptPassName<LoopPassManager>(
Name, Callbacks);
1143template <
typename CallbacksT>
1145 bool &UseMemorySSA) {
1146 UseMemorySSA =
false;
1153 UseMemorySSA =
true;
1157#define LOOP_PASS(NAME, CREATE_PASS) \
1160#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1161 if (checkParametrizedPassName(Name, NAME)) \
1163#define LOOP_ANALYSIS(NAME, CREATE_PASS) \
1164 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \
1166#include "PassRegistry.def"
1168 return callbacksAcceptPassName<LoopPassManager>(
Name, Callbacks);
1171std::optional<std::vector<PassBuilder::PipelineElement>>
1173 std::vector<PipelineElement> ResultPipeline;
1178 std::vector<PipelineElement> &Pipeline = *PipelineStack.
back();
1179 size_t Pos =
Text.find_first_of(
",()");
1180 Pipeline.push_back({
Text.substr(0, Pos), {}});
1183 if (Pos ==
Text.npos)
1186 char Sep =
Text[Pos];
1194 PipelineStack.
push_back(&Pipeline.back().InnerPipeline);
1198 assert(Sep ==
')' &&
"Bogus separator!");
1203 if (PipelineStack.
size() == 1)
1204 return std::nullopt;
1207 }
while (
Text.consume_front(
")"));
1215 if (!
Text.consume_front(
","))
1216 return std::nullopt;
1219 if (PipelineStack.
size() > 1)
1221 return std::nullopt;
1223 assert(PipelineStack.
back() == &ResultPipeline &&
1224 "Wrong pipeline at the bottom of the stack!");
1225 return {std::move(ResultPipeline)};
1229 const PipelineElement &
E) {
1230 auto &
Name =
E.Name;
1231 auto &InnerPipeline =
E.InnerPipeline;
1234 if (!InnerPipeline.empty()) {
1235 if (
Name ==
"module") {
1237 if (
auto Err = parseModulePassPipeline(NestedMPM, InnerPipeline))
1242 if (
Name ==
"coro-cond") {
1244 if (
auto Err = parseModulePassPipeline(NestedMPM, InnerPipeline))
1249 if (
Name ==
"cgscc") {
1251 if (
auto Err = parseCGSCCPassPipeline(CGPM, InnerPipeline))
1258 return make_error<StringError>(
1259 "cannot have a no-rerun module to function adaptor",
1262 if (
auto Err = parseFunctionPassPipeline(FPM, InnerPipeline))
1270 if (
auto Err = parseModulePassPipeline(NestedMPM, InnerPipeline))
1276 for (
auto &
C : ModulePipelineParsingCallbacks)
1281 return make_error<StringError>(
1282 formatv(
"invalid use of '{0}' pass as module pipeline",
Name).str(),
1291 return make_error<StringError>(
1292 formatv(
"unknown default pipeline alias '{0}'",
Name).str(),
1295 assert(Matches.
size() == 3 &&
"Must capture two matched strings!");
1313 if (Matches[1] ==
"default") {
1315 }
else if (Matches[1] ==
"thinlto-pre-link") {
1317 }
else if (Matches[1] ==
"thinlto") {
1319 }
else if (Matches[1] ==
"lto-pre-link") {
1322 assert(Matches[1] ==
"lto" &&
"Not one of the matched options!");
1329#define MODULE_PASS(NAME, CREATE_PASS) \
1330 if (Name == NAME) { \
1331 MPM.addPass(CREATE_PASS); \
1332 return Error::success(); \
1334#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1335 if (checkParametrizedPassName(Name, NAME)) { \
1336 auto Params = parsePassParameters(PARSER, Name, NAME); \
1338 return Params.takeError(); \
1339 MPM.addPass(CREATE_PASS(Params.get())); \
1340 return Error::success(); \
1342#define MODULE_ANALYSIS(NAME, CREATE_PASS) \
1343 if (Name == "require<" NAME ">") { \
1345 RequireAnalysisPass< \
1346 std::remove_reference_t<decltype(CREATE_PASS)>, Module>()); \
1347 return Error::success(); \
1349 if (Name == "invalidate<" NAME ">") { \
1350 MPM.addPass(InvalidateAnalysisPass< \
1351 std::remove_reference_t<decltype(CREATE_PASS)>>()); \
1352 return Error::success(); \
1354#define CGSCC_PASS(NAME, CREATE_PASS) \
1355 if (Name == NAME) { \
1356 MPM.addPass(createModuleToPostOrderCGSCCPassAdaptor(CREATE_PASS)); \
1357 return Error::success(); \
1359#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1360 if (checkParametrizedPassName(Name, NAME)) { \
1361 auto Params = parsePassParameters(PARSER, Name, NAME); \
1363 return Params.takeError(); \
1365 createModuleToPostOrderCGSCCPassAdaptor(CREATE_PASS(Params.get()))); \
1366 return Error::success(); \
1368#define FUNCTION_PASS(NAME, CREATE_PASS) \
1369 if (Name == NAME) { \
1370 MPM.addPass(createModuleToFunctionPassAdaptor(CREATE_PASS)); \
1371 return Error::success(); \
1373#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1374 if (checkParametrizedPassName(Name, NAME)) { \
1375 auto Params = parsePassParameters(PARSER, Name, NAME); \
1377 return Params.takeError(); \
1378 MPM.addPass(createModuleToFunctionPassAdaptor(CREATE_PASS(Params.get()))); \
1379 return Error::success(); \
1381#define LOOPNEST_PASS(NAME, CREATE_PASS) \
1382 if (Name == NAME) { \
1383 MPM.addPass(createModuleToFunctionPassAdaptor( \
1384 createFunctionToLoopPassAdaptor(CREATE_PASS, false, false))); \
1385 return Error::success(); \
1387#define LOOP_PASS(NAME, CREATE_PASS) \
1388 if (Name == NAME) { \
1389 MPM.addPass(createModuleToFunctionPassAdaptor( \
1390 createFunctionToLoopPassAdaptor(CREATE_PASS, false, false))); \
1391 return Error::success(); \
1393#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1394 if (checkParametrizedPassName(Name, NAME)) { \
1395 auto Params = parsePassParameters(PARSER, Name, NAME); \
1397 return Params.takeError(); \
1399 createModuleToFunctionPassAdaptor(createFunctionToLoopPassAdaptor( \
1400 CREATE_PASS(Params.get()), false, false))); \
1401 return Error::success(); \
1403#include "PassRegistry.def"
1405 for (
auto &
C : ModulePipelineParsingCallbacks)
1408 return make_error<StringError>(
1414 const PipelineElement &
E) {
1415 auto &
Name =
E.Name;
1416 auto &InnerPipeline =
E.InnerPipeline;
1419 if (!InnerPipeline.empty()) {
1420 if (
Name ==
"cgscc") {
1422 if (
auto Err = parseCGSCCPassPipeline(NestedCGPM, InnerPipeline))
1425 CGPM.
addPass(std::move(NestedCGPM));
1430 if (
auto Err = parseFunctionPassPipeline(FPM, InnerPipeline))
1434 std::move(FPM), Params->first, Params->second));
1439 if (
auto Err = parseCGSCCPassPipeline(NestedCGPM, InnerPipeline))
1446 if (
auto Err = parseCGSCCPassPipeline(NestedCGPM, InnerPipeline))
1453 for (
auto &
C : CGSCCPipelineParsingCallbacks)
1454 if (
C(
Name, CGPM, InnerPipeline))
1458 return make_error<StringError>(
1459 formatv(
"invalid use of '{0}' pass as cgscc pipeline",
Name).str(),
1464#define CGSCC_PASS(NAME, CREATE_PASS) \
1465 if (Name == NAME) { \
1466 CGPM.addPass(CREATE_PASS); \
1467 return Error::success(); \
1469#define CGSCC_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 CGPM.addPass(CREATE_PASS(Params.get())); \
1475 return Error::success(); \
1477#define CGSCC_ANALYSIS(NAME, CREATE_PASS) \
1478 if (Name == "require<" NAME ">") { \
1479 CGPM.addPass(RequireAnalysisPass< \
1480 std::remove_reference_t<decltype(CREATE_PASS)>, \
1481 LazyCallGraph::SCC, CGSCCAnalysisManager, LazyCallGraph &, \
1482 CGSCCUpdateResult &>()); \
1483 return Error::success(); \
1485 if (Name == "invalidate<" NAME ">") { \
1486 CGPM.addPass(InvalidateAnalysisPass< \
1487 std::remove_reference_t<decltype(CREATE_PASS)>>()); \
1488 return Error::success(); \
1490#define FUNCTION_PASS(NAME, CREATE_PASS) \
1491 if (Name == NAME) { \
1492 CGPM.addPass(createCGSCCToFunctionPassAdaptor(CREATE_PASS)); \
1493 return Error::success(); \
1495#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1496 if (checkParametrizedPassName(Name, NAME)) { \
1497 auto Params = parsePassParameters(PARSER, Name, NAME); \
1499 return Params.takeError(); \
1500 CGPM.addPass(createCGSCCToFunctionPassAdaptor(CREATE_PASS(Params.get()))); \
1501 return Error::success(); \
1503#define LOOPNEST_PASS(NAME, CREATE_PASS) \
1504 if (Name == NAME) { \
1505 CGPM.addPass(createCGSCCToFunctionPassAdaptor( \
1506 createFunctionToLoopPassAdaptor(CREATE_PASS, false, false))); \
1507 return Error::success(); \
1509#define LOOP_PASS(NAME, CREATE_PASS) \
1510 if (Name == NAME) { \
1511 CGPM.addPass(createCGSCCToFunctionPassAdaptor( \
1512 createFunctionToLoopPassAdaptor(CREATE_PASS, false, false))); \
1513 return Error::success(); \
1515#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1516 if (checkParametrizedPassName(Name, NAME)) { \
1517 auto Params = parsePassParameters(PARSER, Name, NAME); \
1519 return Params.takeError(); \
1521 createCGSCCToFunctionPassAdaptor(createFunctionToLoopPassAdaptor( \
1522 CREATE_PASS(Params.get()), false, false))); \
1523 return Error::success(); \
1525#include "PassRegistry.def"
1527 for (
auto &
C : CGSCCPipelineParsingCallbacks)
1528 if (
C(
Name, CGPM, InnerPipeline))
1530 return make_error<StringError>(
1536 const PipelineElement &
E) {
1537 auto &
Name =
E.Name;
1538 auto &InnerPipeline =
E.InnerPipeline;
1541 if (!InnerPipeline.empty()) {
1542 if (
Name ==
"function") {
1544 if (
auto Err = parseFunctionPassPipeline(NestedFPM, InnerPipeline))
1547 FPM.
addPass(std::move(NestedFPM));
1550 if (
Name ==
"loop" ||
Name ==
"loop-mssa") {
1552 if (
auto Err = parseLoopPassPipeline(LPM, InnerPipeline))
1555 bool UseMemorySSA = (
Name ==
"loop-mssa");
1557 return Pipeline.Name.contains(
"simple-loop-unswitch");
1559 bool UseBPI =
llvm::any_of(InnerPipeline, [](
auto Pipeline) {
1560 return Pipeline.Name ==
"loop-predication";
1568 if (
auto Err = parseFunctionPassPipeline(NestedFPM, InnerPipeline))
1574 for (
auto &
C : FunctionPipelineParsingCallbacks)
1575 if (
C(
Name, FPM, InnerPipeline))
1579 return make_error<StringError>(
1580 formatv(
"invalid use of '{0}' pass as function pipeline",
Name).str(),
1585#define FUNCTION_PASS(NAME, CREATE_PASS) \
1586 if (Name == NAME) { \
1587 FPM.addPass(CREATE_PASS); \
1588 return Error::success(); \
1590#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1591 if (checkParametrizedPassName(Name, NAME)) { \
1592 auto Params = parsePassParameters(PARSER, Name, NAME); \
1594 return Params.takeError(); \
1595 FPM.addPass(CREATE_PASS(Params.get())); \
1596 return Error::success(); \
1598#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
1599 if (Name == "require<" NAME ">") { \
1601 RequireAnalysisPass< \
1602 std::remove_reference_t<decltype(CREATE_PASS)>, Function>()); \
1603 return Error::success(); \
1605 if (Name == "invalidate<" NAME ">") { \
1606 FPM.addPass(InvalidateAnalysisPass< \
1607 std::remove_reference_t<decltype(CREATE_PASS)>>()); \
1608 return Error::success(); \
1614#define LOOPNEST_PASS(NAME, CREATE_PASS) \
1615 if (Name == NAME) { \
1616 FPM.addPass(createFunctionToLoopPassAdaptor(CREATE_PASS, false, false)); \
1617 return Error::success(); \
1619#define LOOP_PASS(NAME, CREATE_PASS) \
1620 if (Name == NAME) { \
1621 FPM.addPass(createFunctionToLoopPassAdaptor(CREATE_PASS, false, false)); \
1622 return Error::success(); \
1624#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1625 if (checkParametrizedPassName(Name, NAME)) { \
1626 auto Params = parsePassParameters(PARSER, Name, NAME); \
1628 return Params.takeError(); \
1629 FPM.addPass(createFunctionToLoopPassAdaptor(CREATE_PASS(Params.get()), \
1631 return Error::success(); \
1633#include "PassRegistry.def"
1635 for (
auto &
C : FunctionPipelineParsingCallbacks)
1636 if (
C(
Name, FPM, InnerPipeline))
1638 return make_error<StringError>(
1639 formatv(
"unknown function pass '{0}'",
Name).str(),
1644 const PipelineElement &
E) {
1646 auto &InnerPipeline =
E.InnerPipeline;
1649 if (!InnerPipeline.empty()) {
1650 if (
Name ==
"loop") {
1652 if (
auto Err = parseLoopPassPipeline(NestedLPM, InnerPipeline))
1655 LPM.
addPass(std::move(NestedLPM));
1660 if (
auto Err = parseLoopPassPipeline(NestedLPM, InnerPipeline))
1666 for (
auto &
C : LoopPipelineParsingCallbacks)
1667 if (
C(
Name, LPM, InnerPipeline))
1671 return make_error<StringError>(
1672 formatv(
"invalid use of '{0}' pass as loop pipeline",
Name).str(),
1677#define LOOPNEST_PASS(NAME, CREATE_PASS) \
1678 if (Name == NAME) { \
1679 LPM.addPass(CREATE_PASS); \
1680 return Error::success(); \
1682#define LOOP_PASS(NAME, CREATE_PASS) \
1683 if (Name == NAME) { \
1684 LPM.addPass(CREATE_PASS); \
1685 return Error::success(); \
1687#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1688 if (checkParametrizedPassName(Name, NAME)) { \
1689 auto Params = parsePassParameters(PARSER, Name, NAME); \
1691 return Params.takeError(); \
1692 LPM.addPass(CREATE_PASS(Params.get())); \
1693 return Error::success(); \
1695#define LOOP_ANALYSIS(NAME, CREATE_PASS) \
1696 if (Name == "require<" NAME ">") { \
1697 LPM.addPass(RequireAnalysisPass< \
1698 std::remove_reference_t<decltype(CREATE_PASS)>, Loop, \
1699 LoopAnalysisManager, LoopStandardAnalysisResults &, \
1701 return Error::success(); \
1703 if (Name == "invalidate<" NAME ">") { \
1704 LPM.addPass(InvalidateAnalysisPass< \
1705 std::remove_reference_t<decltype(CREATE_PASS)>>()); \
1706 return Error::success(); \
1708#include "PassRegistry.def"
1710 for (
auto &
C : LoopPipelineParsingCallbacks)
1711 if (
C(
Name, LPM, InnerPipeline))
1713 return make_error<StringError>(
formatv(
"unknown loop pass '{0}'",
Name).str(),
1718#define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS) \
1719 if (Name == NAME) { \
1720 AA.registerModuleAnalysis< \
1721 std::remove_reference_t<decltype(CREATE_PASS)>>(); \
1724#define FUNCTION_ALIAS_ANALYSIS(NAME, CREATE_PASS) \
1725 if (Name == NAME) { \
1726 AA.registerFunctionAnalysis< \
1727 std::remove_reference_t<decltype(CREATE_PASS)>>(); \
1730#include "PassRegistry.def"
1732 for (
auto &
C : AAParsingCallbacks)
1740 for (
const auto &Element : Pipeline) {
1741 if (
auto Err = parseLoopPass(LPM, Element))
1747Error PassBuilder::parseFunctionPassPipeline(
1749 for (
const auto &Element : Pipeline) {
1750 if (
auto Err = parseFunctionPass(FPM, Element))
1758 for (
const auto &Element : Pipeline) {
1759 if (
auto Err = parseCGSCCPass(CGPM, Element))
1780 for (
const auto &Element : Pipeline) {
1781 if (
auto Err = parseModulePass(
MPM, Element))
1792 auto Pipeline = parsePipelineText(PipelineText);
1793 if (!Pipeline || Pipeline->empty())
1794 return make_error<StringError>(
1795 formatv(
"invalid pipeline '{0}'", PipelineText).str(),
1805 Pipeline = {{
"cgscc", std::move(*Pipeline)}};
1807 FunctionPipelineParsingCallbacks)) {
1808 Pipeline = {{
"function", std::move(*Pipeline)}};
1811 Pipeline = {{
"function", {{UseMemorySSA ?
"loop-mssa" :
"loop",
1812 std::move(*Pipeline)}}}};
1813 }
else if (
isLoopPassName(FirstName, LoopPipelineParsingCallbacks,
1815 Pipeline = {{
"function", {{UseMemorySSA ?
"loop-mssa" :
"loop",
1816 std::move(*Pipeline)}}}};
1818 for (
auto &
C : TopLevelPipelineParsingCallbacks)
1819 if (
C(
MPM, *Pipeline))
1823 auto &InnerPipeline = Pipeline->front().InnerPipeline;
1824 return make_error<StringError>(
1825 formatv(
"unknown {0} name '{1}'",
1826 (InnerPipeline.empty() ?
"pass" :
"pipeline"), FirstName)
1832 if (
auto Err = parseModulePassPipeline(
MPM, *Pipeline))
1840 auto Pipeline = parsePipelineText(PipelineText);
1841 if (!Pipeline || Pipeline->empty())
1842 return make_error<StringError>(
1843 formatv(
"invalid pipeline '{0}'", PipelineText).str(),
1848 return make_error<StringError>(
1849 formatv(
"unknown cgscc pass '{0}' in pipeline '{1}'", FirstName,
1854 if (
auto Err = parseCGSCCPassPipeline(CGPM, *Pipeline))
1863 auto Pipeline = parsePipelineText(PipelineText);
1864 if (!Pipeline || Pipeline->empty())
1865 return make_error<StringError>(
1866 formatv(
"invalid pipeline '{0}'", PipelineText).str(),
1871 return make_error<StringError>(
1872 formatv(
"unknown function pass '{0}' in pipeline '{1}'", FirstName,
1877 if (
auto Err = parseFunctionPassPipeline(FPM, *Pipeline))
1885 auto Pipeline = parsePipelineText(PipelineText);
1886 if (!Pipeline || Pipeline->empty())
1887 return make_error<StringError>(
1888 formatv(
"invalid pipeline '{0}'", PipelineText).str(),
1891 if (
auto Err = parseLoopPassPipeline(CGPM, *Pipeline))
1900 if (PipelineText ==
"default") {
1905 while (!PipelineText.
empty()) {
1907 std::tie(
Name, PipelineText) = PipelineText.
split(
',');
1908 if (!parseAAPassName(AA,
Name))
1909 return make_error<StringError>(
1910 formatv(
"unknown alias analysis name '{0}'",
Name).str(),
1922 OS <<
" " <<
PassName <<
"<" << Params <<
">\n";
1928 OS <<
"Module passes:\n";
1929#define MODULE_PASS(NAME, CREATE_PASS) printPassName(NAME, OS);
1930#include "PassRegistry.def"
1932 OS <<
"Module passes with params:\n";
1933#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1934 printPassName(NAME, PARAMS, OS);
1935#include "PassRegistry.def"
1937 OS <<
"Module analyses:\n";
1938#define MODULE_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
1939#include "PassRegistry.def"
1941 OS <<
"Module alias analyses:\n";
1942#define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
1943#include "PassRegistry.def"
1945 OS <<
"CGSCC passes:\n";
1946#define CGSCC_PASS(NAME, CREATE_PASS) printPassName(NAME, OS);
1947#include "PassRegistry.def"
1949 OS <<
"CGSCC passes with params:\n";
1950#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1951 printPassName(NAME, PARAMS, OS);
1952#include "PassRegistry.def"
1954 OS <<
"CGSCC analyses:\n";
1955#define CGSCC_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
1956#include "PassRegistry.def"
1958 OS <<
"Function passes:\n";
1959#define FUNCTION_PASS(NAME, CREATE_PASS) printPassName(NAME, OS);
1960#include "PassRegistry.def"
1962 OS <<
"Function passes with params:\n";
1963#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1964 printPassName(NAME, PARAMS, OS);
1965#include "PassRegistry.def"
1967 OS <<
"Function analyses:\n";
1968#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
1969#include "PassRegistry.def"
1971 OS <<
"Function alias analyses:\n";
1972#define FUNCTION_ALIAS_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
1973#include "PassRegistry.def"
1975 OS <<
"LoopNest passes:\n";
1976#define LOOPNEST_PASS(NAME, CREATE_PASS) printPassName(NAME, OS);
1977#include "PassRegistry.def"
1979 OS <<
"Loop passes:\n";
1980#define LOOP_PASS(NAME, CREATE_PASS) printPassName(NAME, OS);
1981#include "PassRegistry.def"
1983 OS <<
"Loop passes with params:\n";
1984#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1985 printPassName(NAME, PARAMS, OS);
1986#include "PassRegistry.def"
1988 OS <<
"Loop analyses:\n";
1989#define LOOP_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
1990#include "PassRegistry.def"
1996 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.
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
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 ...
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.
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.
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.
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 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 bool checkParametrizedPassName(StringRef Name, StringRef PassName)
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 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, in order to expose optimization opportun...
This is the interface for a metadata-based scoped no-alias analysis.
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...
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),...
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.
An analysis over an "outer" IR unit that provides access to an analysis manager over an "inner" IR un...
This class provides an interface for updating the loop pass manager based on mutations to the loop ne...
An SCC of the call graph.
A lazily constructed view of the call graph of a module.
This class represents a loop nest and can be used to query its properties.
Represents a single loop in the control flow graph.
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.
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)
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.
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.
A set of analyses that are preserved following a run of a transformation pass.
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 consume_back(StringRef Suffix)
Returns true if this StringRef has the given suffix and removes that suffix.
bool getAsInteger(unsigned Radix, T &Result) const
Parse the current string as an integer of the specified radix.
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 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, Function > ModuleAnalysisManagerFunctionProxy
Provide the ModuleAnalysisManager to Function proxy.
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.
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 CRTP mix-in that provides informational APIs needed for analysis passes.
A special type used by analysis passes to provide an address that identifies that particular analysis...
Support structure for SCC passes to communicate updates the call graph back to the CGSCC pass manager...
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.
The adaptor from a function pass to a loop pass computes these analyses and makes them available to t...
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.