LLVM: lib/Passes/PassBuilder.cpp Source File (original) (raw)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
346#include
347
348using namespace llvm;
349
351 "^(default|thinlto-pre-link|thinlto|lto-pre-link|lto)<(O[0123sz])>$");
352
353namespace llvm {
355 "print-pipeline-passes",
356 cl::desc("Print a '-passes' compatible string describing the pipeline "
357 "(best-effort only)."));
358}
359
364
365namespace {
366
367
368
369class TriggerCrashModulePass : public PassInfoMixin {
370public:
372 abort();
374 }
375 static StringRef name() { return "TriggerCrashModulePass"; }
376};
377
378class TriggerCrashFunctionPass
379 : public PassInfoMixin {
380public:
382 abort();
384 }
385 static StringRef name() { return "TriggerCrashFunctionPass"; }
386};
387
388
389
390class TriggerVerifierErrorPass
391 : public PassInfoMixin {
392public:
394
395
398 GlobalValue::LinkageTypes::InternalLinkage,
399 "__bad_alias", nullptr, &M);
401 }
402
404
405
409 }
410
412
415 MF.getProperties().set(MachineFunctionProperties::Property::NoVRegs);
417 }
418
419 static StringRef name() { return "TriggerVerifierErrorPass"; }
420};
421
422
423
424class RequireAllMachineFunctionPropertiesPass
425 : public PassInfoMixin {
426public:
430 }
431
434 MFProps.set(MachineFunctionProperties::Property::FailedISel);
435 MFProps.set(MachineFunctionProperties::Property::FailsVerification);
436 MFProps.set(MachineFunctionProperties::Property::IsSSA);
437 MFProps.set(MachineFunctionProperties::Property::Legalized);
438 MFProps.set(MachineFunctionProperties::Property::NoPHIs);
439 MFProps.set(MachineFunctionProperties::Property::NoVRegs);
440 MFProps.set(MachineFunctionProperties::Property::RegBankSelected);
441 MFProps.set(MachineFunctionProperties::Property::Selected);
442 MFProps.set(MachineFunctionProperties::Property::TiedOpsRewritten);
443 MFProps.set(MachineFunctionProperties::Property::TracksDebugUserValues);
444 MFProps.set(MachineFunctionProperties::Property::TracksLiveness);
445 return MFProps;
446 }
447 static StringRef name() { return "RequireAllMachineFunctionPropertiesPass"; }
448};
449
450}
451
453 std::optional PGOOpt,
455 : TM(TM), PTO(PTO), PGOOpt(PGOOpt), PIC(PIC) {
456 if (TM)
457 TM->registerPassBuilderCallbacks(*this);
458 if (PIC) {
460
461
462 (void)this;
463#define MODULE_PASS(NAME, CREATE_PASS) \
464 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
465#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
466 PIC->addClassToPassName(CLASS, NAME);
467#define MODULE_ANALYSIS(NAME, CREATE_PASS) \
468 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
469#define FUNCTION_PASS(NAME, CREATE_PASS) \
470 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
471#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
472 PIC->addClassToPassName(CLASS, NAME);
473#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
474 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
475#define LOOPNEST_PASS(NAME, CREATE_PASS) \
476 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
477#define LOOP_PASS(NAME, CREATE_PASS) \
478 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
479#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
480 PIC->addClassToPassName(CLASS, NAME);
481#define LOOP_ANALYSIS(NAME, CREATE_PASS) \
482 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
483#define CGSCC_PASS(NAME, CREATE_PASS) \
484 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
485#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
486 PIC->addClassToPassName(CLASS, NAME);
487#define CGSCC_ANALYSIS(NAME, CREATE_PASS) \
488 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
489#include "PassRegistry.def"
490
491#define MACHINE_FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
492 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
493#define MACHINE_FUNCTION_PASS(NAME, CREATE_PASS) \
494 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
495#define MACHINE_FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, \
496 PARAMS) \
497 PIC->addClassToPassName(CLASS, NAME);
498#include "llvm/Passes/MachinePassRegistry.def"
499 });
500 }
501}
502
504#define MODULE_ANALYSIS(NAME, CREATE_PASS) \
505 MAM.registerPass([&] { return CREATE_PASS; });
506#include "PassRegistry.def"
507
508 for (auto &C : ModuleAnalysisRegistrationCallbacks)
510}
511
513#define CGSCC_ANALYSIS(NAME, CREATE_PASS) \
514 CGAM.registerPass([&] { return CREATE_PASS; });
515#include "PassRegistry.def"
516
517 for (auto &C : CGSCCAnalysisRegistrationCallbacks)
519}
520
522
523
524
526
527#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
528 FAM.registerPass([&] { return CREATE_PASS; });
529#include "PassRegistry.def"
530
531 for (auto &C : FunctionAnalysisRegistrationCallbacks)
533}
534
537
538#define MACHINE_FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
539 MFAM.registerPass([&] { return CREATE_PASS; });
540#include "llvm/Passes/MachinePassRegistry.def"
541
542 for (auto &C : MachineFunctionAnalysisRegistrationCallbacks)
543 C(MFAM);
544}
545
547#define LOOP_ANALYSIS(NAME, CREATE_PASS) \
548 LAM.registerPass([&] { return CREATE_PASS; });
549#include "PassRegistry.def"
550
551 for (auto &C : LoopAnalysisRegistrationCallbacks)
553}
554
555static std::optional<std::pair<bool, bool>>
557 std::pair<bool, bool> Params;
558 if (.consume_front("function"))
559 return std::nullopt;
560 if (Name.empty())
561 return Params;
562 if (.consume_front("<") ||
.consume_back(">"))
563 return std::nullopt;
564 while (.empty()) {
565 auto [Front, Back] = Name.split(';');
567 if (Front == "eager-inv")
568 Params.first = true;
569 else if (Front == "no-rerun")
570 Params.second = true;
571 else
572 return std::nullopt;
573 }
574 return Params;
575}
576
578 if (.consume_front("devirt<") ||
.consume_back(">"))
579 return std::nullopt;
580 int Count;
581 if (Name.getAsInteger(0, Count) || Count < 0)
582 return std::nullopt;
583 return Count;
584}
585
595}
596
600 bool Result = false;
601 while (!Params.empty()) {
603 std::tie(ParamName, Params) = Params.split(';');
604
605 if (ParamName == OptionName) {
606 Result = true;
607 } else {
608 return make_error(
609 formatv("invalid {1} pass parameter '{0}' ", ParamName, PassName)
610 .str(),
612 }
613 }
614 return Result;
615}
616
617namespace {
618
619
622
623 while (!Params.empty()) {
625 std::tie(ParamName, Params) = Params.split(';');
626 if (ParamName.consume_front("hardware-loop-decrement=")) {
627 int Count;
629 return make_error(
630 formatv("invalid HardwareLoopPass parameter '{0}' ", ParamName).str(),
633 continue;
634 }
635 if (ParamName.consume_front("hardware-loop-counter-bitwidth=")) {
636 int Count;
638 return make_error(
639 formatv("invalid HardwareLoopPass parameter '{0}' ", ParamName).str(),
642 continue;
643 }
644 if (ParamName == "force-hardware-loops") {
645 HardwareLoopOpts.setForce(true);
646 } else if (ParamName == "force-hardware-loop-phi") {
648 } else if (ParamName == "force-nested-hardware-loop") {
650 } else if (ParamName == "force-hardware-loop-guard") {
652 } else {
653 return make_error(
654 formatv("invalid HardwarePass parameter '{0}' ", ParamName).str(),
656 }
657 }
658 return HardwareLoopOpts;
659}
660
661
664 while (!Params.empty()) {
666 std::tie(ParamName, Params) = Params.split(';');
667 std::optional OptLevel = parseOptLevel(ParamName);
668
669 if (OptLevel && !OptLevel->isOptimizingForSize()) {
670 UnrollOpts.setOptLevel(OptLevel->getSpeedupLevel());
671 continue;
672 }
673 if (ParamName.consume_front("full-unroll-max=")) {
674 int Count;
676 return make_error(
677 formatv("invalid LoopUnrollPass parameter '{0}' ", ParamName).str(),
680 continue;
681 }
682
684 if (ParamName == "partial") {
686 } else if (ParamName == "peeling") {
688 } else if (ParamName == "profile-peeling") {
690 } else if (ParamName == "runtime") {
692 } else if (ParamName == "upperbound") {
694 } else {
695 return make_error(
696 formatv("invalid LoopUnrollPass parameter '{0}' ", ParamName).str(),
698 }
699 }
700 return UnrollOpts;
701}
702
705 Params, "vfe-linkage-unit-visibility", "GlobalDCE");
706}
707
710 "CGProfile");
711}
712
715 "InlinerPass");
716}
717
720 "CoroSplitPass");
721}
722
725 Params, "skip-non-recursive-function-attrs", "PostOrderFunctionAttrs");
726}
727
729 if (Params.empty())
731
733 if (.empty())
734 return make_error(
735 formatv("too many CFGuardPass parameters '{0}' ", Params).str(),
737
738 if (Param == "check")
740 if (Param == "dispatch")
742
743 return make_error(
744 formatv("invalid CFGuardPass mechanism: '{0}' ", Param).str(),
746}
747
750}
751
754 "EntryExitInstrumenter");
755}
756
759}
760
763 "LowerMatrixIntrinsics");
764}
765
768 while (!Params.empty()) {
770 std::tie(ParamName, Params) = Params.split(';');
771
772 if (ParamName == "kernel") {
773 Result.CompileKernel = true;
774 } else {
775 return make_error(
776 formatv("invalid AddressSanitizer pass parameter '{0}' ", ParamName)
777 .str(),
779 }
780 }
782}
783
786 while (!Params.empty()) {
788 std::tie(ParamName, Params) = Params.split(';');
789
790 if (ParamName == "recover") {
791 Result.Recover = true;
792 } else if (ParamName == "kernel") {
793 Result.CompileKernel = true;
794 } else {
795 return make_error(
796 formatv("invalid HWAddressSanitizer pass parameter '{0}' ", ParamName)
797 .str(),
799 }
800 }
802}
803
806 while (!Params.empty()) {
808 std::tie(ParamName, Params) = Params.split(';');
809
810 if (ParamName == "thinlto") {
811 Result.IsThinLTO = true;
812 } else if (ParamName == "emit-summary") {
813 Result.EmitLTOSummary = true;
814 } else {
815 return make_error(
816 formatv("invalid EmbedBitcode pass parameter '{0}' ", ParamName)
817 .str(),
819 }
820 }
822}
823
826 while (!Params.empty()) {
828 std::tie(ParamName, Params) = Params.split(';');
829
830 if (ParamName == "recover") {
831 Result.Recover = true;
832 } else if (ParamName == "kernel") {
833 Result.Kernel = true;
834 } else if (ParamName.consume_front("track-origins=")) {
836 return make_error(
837 formatv("invalid argument to MemorySanitizer pass track-origins "
838 "parameter: '{0}' ",
839 ParamName)
840 .str(),
842 } else if (ParamName == "eager-checks") {
843 Result.EagerChecks = true;
844 } else {
845 return make_error(
846 formatv("invalid MemorySanitizer pass parameter '{0}' ", ParamName)
847 .str(),
849 }
850 }
852}
853
854
857 while (!Params.empty()) {
859 std::tie(ParamName, Params) = Params.split(';');
860
862 if (ParamName == "speculate-blocks") {
864 } else if (ParamName == "simplify-cond-branch") {
866 } else if (ParamName == "forward-switch-cond") {
868 } else if (ParamName == "switch-range-to-icmp") {
870 } else if (ParamName == "switch-to-lookup") {
872 } else if (ParamName == "keep-loops") {
874 } else if (ParamName == "hoist-common-insts") {
876 } else if (ParamName == "hoist-loads-stores-with-cond-faulting") {
877 Result.hoistLoadsStoresWithCondFaulting(Enable);
878 } else if (ParamName == "sink-common-insts") {
880 } else if (ParamName == "speculate-unpredictables") {
883 APInt BonusInstThreshold;
884 if (ParamName.getAsInteger(0, BonusInstThreshold))
885 return make_error(
886 formatv("invalid argument to SimplifyCFG pass bonus-threshold "
887 "parameter: '{0}' ",
888 ParamName).str(),
891 } else {
892 return make_error(
893 formatv("invalid SimplifyCFG pass parameter '{0}' ", ParamName).str(),
895 }
896 }
898}
899
902
903
904 Result.setVerifyFixpoint(true);
905 while (!Params.empty()) {
907 std::tie(ParamName, Params) = Params.split(';');
908
910 if (ParamName == "verify-fixpoint") {
913 APInt MaxIterations;
914 if (ParamName.getAsInteger(0, MaxIterations))
915 return make_error(
916 formatv("invalid argument to InstCombine pass max-iterations "
917 "parameter: '{0}' ",
918 ParamName).str(),
921 } else {
922 return make_error(
923 formatv("invalid InstCombine pass parameter '{0}' ", ParamName).str(),
925 }
926 }
928}
929
930
933 while (!Params.empty()) {
935 std::tie(ParamName, Params) = Params.split(';');
936
938 if (ParamName == "interleave-forced-only") {
940 } else if (ParamName == "vectorize-forced-only") {
942 } else {
943 return make_error(
944 formatv("invalid LoopVectorize parameter '{0}' ", ParamName).str(),
946 }
947 }
948 return Opts;
949}
950
952 std::pair<bool, bool> Result = {false, true};
953 while (!Params.empty()) {
955 std::tie(ParamName, Params) = Params.split(';');
956
958 if (ParamName == "nontrivial") {
960 } else if (ParamName == "trivial") {
962 } else {
963 return make_error(
964 formatv("invalid LoopUnswitch pass parameter '{0}' ", ParamName)
965 .str(),
967 }
968 }
970}
971
974 while (!Params.empty()) {
976 std::tie(ParamName, Params) = Params.split(';');
977
979 if (ParamName == "allowspeculation") {
981 } else {
982 return make_error(
983 formatv("invalid LICM pass parameter '{0}' ", ParamName).str(),
985 }
986 }
988}
989
991 std::pair<bool, bool> Result = {true, false};
992 while (!Params.empty()) {
994 std::tie(ParamName, Params) = Params.split(';');
995
997 if (ParamName == "header-duplication") {
999 } else if (ParamName == "prepare-for-lto") {
1001 } else {
1002 return make_error(
1003 formatv("invalid LoopRotate pass parameter '{0}' ", ParamName).str(),
1005 }
1006 }
1008}
1009
1011 bool Result = false;
1012 while (!Params.empty()) {
1014 std::tie(ParamName, Params) = Params.split(';');
1015
1017 if (ParamName == "split-footer-bb") {
1019 } else {
1020 return make_error(
1021 formatv("invalid MergedLoadStoreMotion pass parameter '{0}' ",
1022 ParamName)
1023 .str(),
1025 }
1026 }
1028}
1029
1032 while (!Params.empty()) {
1034 std::tie(ParamName, Params) = Params.split(';');
1035
1037 if (ParamName == "pre") {
1039 } else if (ParamName == "load-pre") {
1041 } else if (ParamName == "split-backedge-load-pre") {
1043 } else if (ParamName == "memdep") {
1045 } else if (ParamName == "memoryssa") {
1047 } else {
1048 return make_error(
1049 formatv("invalid GVN pass parameter '{0}' ", ParamName).str(),
1051 }
1052 }
1054}
1055
1058 while (!Params.empty()) {
1060 std::tie(ParamName, Params) = Params.split(';');
1061
1063 if (ParamName == "func-spec")
1065 else
1066 return make_error(
1067 formatv("invalid IPSCCP pass parameter '{0}' ", ParamName).str(),
1069 }
1071}
1072
1075 while (!Params.empty()) {
1077 std::tie(ParamName, Params) = Params.split(';');
1078
1081 return make_error(
1082 formatv("invalid argument to Scalarizer pass min-bits "
1083 "parameter: '{0}' ",
1084 ParamName)
1085 .str(),
1087 }
1088
1089 continue;
1090 }
1091
1093 if (ParamName == "load-store")
1095 else if (ParamName == "variable-insert-extract")
1096 Result.ScalarizeVariableInsertExtract = Enable;
1097 else {
1098 return make_error(
1099 formatv("invalid Scalarizer pass parameter '{0}' ", ParamName).str(),
1101 }
1102 }
1103
1105}
1106
1108 if (Params.empty() || Params == "modify-cfg")
1110 if (Params == "preserve-cfg")
1112 return make_error(
1113 formatv("invalid SROA pass parameter '{0}' (either preserve-cfg or "
1114 "modify-cfg can be specified)",
1115 Params)
1116 .str(),
1118}
1119
1121parseStackLifetimeOptions(StringRef Params) {
1123 while (!Params.empty()) {
1125 std::tie(ParamName, Params) = Params.split(';');
1126
1127 if (ParamName == "may") {
1129 } else if (ParamName == "must") {
1131 } else {
1132 return make_error(
1133 formatv("invalid StackLifetime parameter '{0}' ", ParamName).str(),
1135 }
1136 }
1138}
1139
1142 "DependenceAnalysisPrinter");
1143}
1144
1147 "SeparateConstOffsetFromGEP");
1148}
1149
1152 "StructurizeCFG");
1153}
1154
1156parseFunctionSimplificationPipelineOptions(StringRef Params) {
1157 std::optional L = parseOptLevel(Params);
1159 return make_error(
1160 formatv("invalid function-simplification parameter '{0}' ", Params)
1161 .str(),
1163 };
1164 return *L;
1165}
1166
1169 "MemorySSAPrinterPass");
1170}
1171
1174 "SpeculativeExecutionPass");
1175}
1176
1179 while (!Params.empty()) {
1181 std::tie(ParamName, Params) = Params.split(';');
1182
1183 if (ParamName.consume_front("profile-filename=")) {
1185 } else {
1186 return make_error(
1187 formatv("invalid MemProfUse pass parameter '{0}' ", ParamName).str(),
1189 }
1190 }
1192}
1193
1195parseStructuralHashPrinterPassOptions(StringRef Params) {
1196 if (Params.empty())
1198 if (Params == "detailed")
1200 if (Params == "call-target-ignored")
1202 return make_error(
1203 formatv("invalid structural hash printer parameter '{0}' ", Params).str(),
1205}
1206
1209 "WinEHPreparePass");
1210}
1211
1214 while (!Params.empty()) {
1216 std::tie(ParamName, Params) = Params.split(';');
1217
1219 if (ParamName == "group-by-use")
1221 else if (ParamName == "ignore-single-use")
1223 else if (ParamName == "merge-const")
1225 else if (ParamName == "merge-external")
1227 else if (ParamName.consume_front("max-offset=")) {
1229 return make_error(
1230 formatv("invalid GlobalMergePass parameter '{0}' ", ParamName)
1231 .str(),
1233 }
1234 }
1236}
1237
1240 while (!Params.empty()) {
1242 std::tie(ParamName, Params) = Params.split(';');
1243
1246 } else {
1247 return make_error(
1248 formatv("invalid Internalize pass parameter '{0}' ", ParamName).str(),
1250 }
1251 }
1252
1254}
1255
1259 while (!Params.empty()) {
1261 std::tie(ParamName, Params) = Params.split(';');
1262
1264 std::optional Filter =
1267 return make_error(
1268 formatv("invalid regallocfast register filter '{0}' ", ParamName)
1269 .str(),
1271 }
1274 continue;
1275 }
1276
1277 if (ParamName == "no-clear-vregs") {
1279 continue;
1280 }
1281
1282 return make_error(
1283 formatv("invalid regallocfast pass parameter '{0}' ", ParamName).str(),
1285 }
1286 return Opts;
1287}
1288
1290parseBoundsCheckingOptions(StringRef Params) {
1292 while (!Params.empty()) {
1294 std::tie(ParamName, Params) = Params.split(';');
1295 if (ParamName == "trap") {
1296 Options.Rt = std::nullopt;
1297 } else if (ParamName == "rt") {
1299 false,
1300 true,
1301 };
1302 } else if (ParamName == "rt-abort") {
1304 false,
1305 false,
1306 };
1307 } else if (ParamName == "min-rt") {
1309 true,
1310 true,
1311 };
1312 } else if (ParamName == "min-rt-abort") {
1314 true,
1315 false,
1316 };
1317 } else if (ParamName == "merge") {
1319 } else {
1322 std::tie(ParamEQ, Val) = ParamName.split('=');
1323 int8_t Id;
1324 if (ParamEQ == "guard" && !Val.getAsInteger(0, Id)) {
1326 } else {
1327 return make_error(
1328 formatv("invalid BoundsChecking pass parameter '{0}' ", ParamName)
1329 .str(),
1331 }
1332 }
1333 }
1335}
1336
1337}
1338
1339
1340
1342 return Name.starts_with("default") || Name.starts_with("thinlto") ||
1343 Name.starts_with("lto");
1344}
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354template <typename PassManagerT, typename CallbacksT>
1356 if (!Callbacks.empty()) {
1357 PassManagerT DummyPM;
1358 for (auto &CB : Callbacks)
1359 if (CB(Name, DummyPM, {}))
1360 return true;
1361 }
1362 return false;
1363}
1364
1365template
1367
1370
1371 StringRef NameNoBracket = Name.take_until([](char C) { return C == '<'; });
1372
1373
1374 if (Name == "module")
1375 return true;
1376 if (Name == "cgscc")
1377 return true;
1378 if (NameNoBracket == "function")
1379 return true;
1380 if (Name == "coro-cond")
1381 return true;
1382
1383#define MODULE_PASS(NAME, CREATE_PASS) \
1384 if (Name == NAME) \
1385 return true;
1386#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1387 if (PassBuilder::checkParametrizedPassName(Name, NAME)) \
1388 return true;
1389#define MODULE_ANALYSIS(NAME, CREATE_PASS) \
1390 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \
1391 return true;
1392#include "PassRegistry.def"
1393
1394 return callbacksAcceptPassName(Name, Callbacks);
1395}
1396
1397template
1399
1400 StringRef NameNoBracket = Name.take_until([](char C) { return C == '<'; });
1401 if (Name == "cgscc")
1402 return true;
1403 if (NameNoBracket == "function")
1404 return true;
1405
1406
1408 return true;
1409
1410#define CGSCC_PASS(NAME, CREATE_PASS) \
1411 if (Name == NAME) \
1412 return true;
1413#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1414 if (PassBuilder::checkParametrizedPassName(Name, NAME)) \
1415 return true;
1416#define CGSCC_ANALYSIS(NAME, CREATE_PASS) \
1417 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \
1418 return true;
1419#include "PassRegistry.def"
1420
1421 return callbacksAcceptPassName(Name, Callbacks);
1422}
1423
1424template
1426
1427 StringRef NameNoBracket = Name.take_until([](char C) { return C == '<'; });
1428 if (NameNoBracket == "function")
1429 return true;
1430 if (Name == "loop" || Name == "loop-mssa" || Name == "machine-function")
1431 return true;
1432
1433#define FUNCTION_PASS(NAME, CREATE_PASS) \
1434 if (Name == NAME) \
1435 return true;
1436#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1437 if (PassBuilder::checkParametrizedPassName(Name, NAME)) \
1438 return true;
1439#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
1440 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \
1441 return true;
1442#include "PassRegistry.def"
1443
1444 return callbacksAcceptPassName(Name, Callbacks);
1445}
1446
1447template
1449
1450 if (Name == "machine-function")
1451 return true;
1452
1453#define MACHINE_FUNCTION_PASS(NAME, CREATE_PASS) \
1454 if (Name == NAME) \
1455 return true;
1456#define MACHINE_FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, \
1457 PARAMS) \
1458 if (PassBuilder::checkParametrizedPassName(Name, NAME)) \
1459 return true;
1460
1461#define MACHINE_FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
1462 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \
1463 return true;
1464
1465#include "llvm/Passes/MachinePassRegistry.def"
1466
1467 return callbacksAcceptPassName(Name, Callbacks);
1468}
1469
1470template
1472 bool &UseMemorySSA) {
1473 UseMemorySSA = false;
1474
1476 UseMemorySSA = true;
1477 return true;
1478 }
1479
1480#define LOOPNEST_PASS(NAME, CREATE_PASS) \
1481 if (Name == NAME) \
1482 return true;
1483#include "PassRegistry.def"
1484
1485 return callbacksAcceptPassName(Name, Callbacks);
1486}
1487
1488template
1490 bool &UseMemorySSA) {
1491 UseMemorySSA = false;
1492
1494 UseMemorySSA = true;
1495 return true;
1496 }
1497
1498#define LOOP_PASS(NAME, CREATE_PASS) \
1499 if (Name == NAME) \
1500 return true;
1501#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1502 if (PassBuilder::checkParametrizedPassName(Name, NAME)) \
1503 return true;
1504#define LOOP_ANALYSIS(NAME, CREATE_PASS) \
1505 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \
1506 return true;
1507#include "PassRegistry.def"
1508
1509 return callbacksAcceptPassName(Name, Callbacks);
1510}
1511
1512std::optional<std::vectorPassBuilder::PipelineElement>
1513PassBuilder::parsePipelineText(StringRef Text) {
1514 std::vector ResultPipeline;
1515
1517 &ResultPipeline};
1518 for (;;) {
1519 std::vector &Pipeline = *PipelineStack.back();
1520 size_t Pos = Text.find_first_of(",()");
1521 Pipeline.push_back({Text.substr(0, Pos), {}});
1522
1523
1524 if (Pos == Text.npos)
1525 break;
1526
1527 char Sep = Text[Pos];
1528 Text = Text.substr(Pos + 1);
1529 if (Sep == ',')
1530
1531 continue;
1532
1533 if (Sep == '(') {
1534
1535 PipelineStack.push_back(&Pipeline.back().InnerPipeline);
1536 continue;
1537 }
1538
1539 assert(Sep == ')' && "Bogus separator!");
1540
1541
1542 do {
1543
1544 if (PipelineStack.size() == 1)
1545 return std::nullopt;
1546
1548 } while (Text.consume_front(")"));
1549
1550
1551 if (Text.empty())
1552 break;
1553
1554
1555
1556 if (.consume_front(","))
1557 return std::nullopt;
1558 }
1559
1560 if (PipelineStack.size() > 1)
1561
1562 return std::nullopt;
1563
1564 assert(PipelineStack.back() == &ResultPipeline &&
1565 "Wrong pipeline at the bottom of the stack!");
1566 return {std::move(ResultPipeline)};
1567}
1568
1570 const PipelineElement &E) {
1571 auto &Name = E.Name;
1572 auto &InnerPipeline = E.InnerPipeline;
1573
1574
1575 if (!InnerPipeline.empty()) {
1576 if (Name == "module") {
1578 if (auto Err = parseModulePassPipeline(NestedMPM, InnerPipeline))
1579 return Err;
1580 MPM.addPass(std::move(NestedMPM));
1582 }
1583 if (Name == "coro-cond") {
1585 if (auto Err = parseModulePassPipeline(NestedMPM, InnerPipeline))
1586 return Err;
1589 }
1590 if (Name == "cgscc") {
1592 if (auto Err = parseCGSCCPassPipeline(CGPM, InnerPipeline))
1593 return Err;
1596 }
1598 if (Params->second)
1599 return make_error(
1600 "cannot have a no-rerun module to function adaptor",
1603 if (auto Err = parseFunctionPassPipeline(FPM, InnerPipeline))
1604 return Err;
1608 }
1609
1610 for (auto &C : ModulePipelineParsingCallbacks)
1611 if (C(Name, MPM, InnerPipeline))
1613
1614
1615 return make_error(
1616 formatv("invalid use of '{0}' pass as module pipeline", Name).str(),
1618 ;
1619 }
1620
1621
1625 return make_error(
1626 formatv("unknown default pipeline alias '{0}'", Name).str(),
1628
1629 assert(Matches.size() == 3 && "Must capture two matched strings!");
1630
1632
1633
1634
1635
1640
1641 if (Matches[1] == "default") {
1643 } else if (Matches[1] == "thinlto-pre-link") {
1645 } else if (Matches[1] == "thinlto") {
1647 } else if (Matches[1] == "lto-pre-link") {
1649
1650
1651
1653 else
1655 } else {
1656 assert(Matches[1] == "lto" && "Not one of the matched options!");
1658 }
1660 }
1661
1662
1663#define MODULE_PASS(NAME, CREATE_PASS) \
1664 if (Name == NAME) { \
1665 MPM.addPass(CREATE_PASS); \
1666 return Error::success(); \
1667 }
1668#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1669 if (checkParametrizedPassName(Name, NAME)) { \
1670 auto Params = parsePassParameters(PARSER, Name, NAME); \
1671 if (!Params) \
1672 return Params.takeError(); \
1673 MPM.addPass(CREATE_PASS(Params.get())); \
1674 return Error::success(); \
1675 }
1676#define MODULE_ANALYSIS(NAME, CREATE_PASS) \
1677 if (Name == "require<" NAME ">") { \
1678 MPM.addPass( \
1679 RequireAnalysisPass< \
1680 std::remove_reference_t<decltype(CREATE_PASS)>, Module>()); \
1681 return Error::success(); \
1682 } \
1683 if (Name == "invalidate<" NAME ">") { \
1684 MPM.addPass(InvalidateAnalysisPass< \
1685 std::remove_reference_t<decltype(CREATE_PASS)>>()); \
1686 return Error::success(); \
1687 }
1688#define CGSCC_PASS(NAME, CREATE_PASS) \
1689 if (Name == NAME) { \
1690 MPM.addPass(createModuleToPostOrderCGSCCPassAdaptor(CREATE_PASS)); \
1691 return Error::success(); \
1692 }
1693#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1694 if (checkParametrizedPassName(Name, NAME)) { \
1695 auto Params = parsePassParameters(PARSER, Name, NAME); \
1696 if (!Params) \
1697 return Params.takeError(); \
1698 MPM.addPass( \
1699 createModuleToPostOrderCGSCCPassAdaptor(CREATE_PASS(Params.get()))); \
1700 return Error::success(); \
1701 }
1702#define FUNCTION_PASS(NAME, CREATE_PASS) \
1703 if (Name == NAME) { \
1704 MPM.addPass(createModuleToFunctionPassAdaptor(CREATE_PASS)); \
1705 return Error::success(); \
1706 }
1707#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1708 if (checkParametrizedPassName(Name, NAME)) { \
1709 auto Params = parsePassParameters(PARSER, Name, NAME); \
1710 if (!Params) \
1711 return Params.takeError(); \
1712 MPM.addPass(createModuleToFunctionPassAdaptor(CREATE_PASS(Params.get()))); \
1713 return Error::success(); \
1714 }
1715#define LOOPNEST_PASS(NAME, CREATE_PASS) \
1716 if (Name == NAME) { \
1717 MPM.addPass(createModuleToFunctionPassAdaptor( \
1718 createFunctionToLoopPassAdaptor(CREATE_PASS, false, false))); \
1719 return Error::success(); \
1720 }
1721#define LOOP_PASS(NAME, CREATE_PASS) \
1722 if (Name == NAME) { \
1723 MPM.addPass(createModuleToFunctionPassAdaptor( \
1724 createFunctionToLoopPassAdaptor(CREATE_PASS, false, false))); \
1725 return Error::success(); \
1726 }
1727#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1728 if (checkParametrizedPassName(Name, NAME)) { \
1729 auto Params = parsePassParameters(PARSER, Name, NAME); \
1730 if (!Params) \
1731 return Params.takeError(); \
1732 MPM.addPass( \
1733 createModuleToFunctionPassAdaptor(createFunctionToLoopPassAdaptor( \
1734 CREATE_PASS(Params.get()), false, false))); \
1735 return Error::success(); \
1736 }
1737#include "PassRegistry.def"
1738
1739 for (auto &C : ModulePipelineParsingCallbacks)
1740 if (C(Name, MPM, InnerPipeline))
1742 return make_error(
1743 formatv("unknown module pass '{0}'", Name).str(),
1745}
1746
1748 const PipelineElement &E) {
1749 auto &Name = E.Name;
1750 auto &InnerPipeline = E.InnerPipeline;
1751
1752
1753 if (!InnerPipeline.empty()) {
1754 if (Name == "cgscc") {
1756 if (auto Err = parseCGSCCPassPipeline(NestedCGPM, InnerPipeline))
1757 return Err;
1758
1759 CGPM.addPass(std::move(NestedCGPM));
1761 }
1764 if (auto Err = parseFunctionPassPipeline(FPM, InnerPipeline))
1765 return Err;
1766
1768 std::move(FPM), Params->first, Params->second));
1770 }
1773 if (auto Err = parseCGSCCPassPipeline(NestedCGPM, InnerPipeline))
1774 return Err;
1778 }
1779
1780 for (auto &C : CGSCCPipelineParsingCallbacks)
1781 if (C(Name, CGPM, InnerPipeline))
1783
1784
1785 return make_error(
1786 formatv("invalid use of '{0}' pass as cgscc pipeline", Name).str(),
1788 }
1789
1790
1791#define CGSCC_PASS(NAME, CREATE_PASS) \
1792 if (Name == NAME) { \
1793 CGPM.addPass(CREATE_PASS); \
1794 return Error::success(); \
1795 }
1796#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1797 if (checkParametrizedPassName(Name, NAME)) { \
1798 auto Params = parsePassParameters(PARSER, Name, NAME); \
1799 if (!Params) \
1800 return Params.takeError(); \
1801 CGPM.addPass(CREATE_PASS(Params.get())); \
1802 return Error::success(); \
1803 }
1804#define CGSCC_ANALYSIS(NAME, CREATE_PASS) \
1805 if (Name == "require<" NAME ">") { \
1806 CGPM.addPass(RequireAnalysisPass< \
1807 std::remove_reference_t<decltype(CREATE_PASS)>, \
1808 LazyCallGraph::SCC, CGSCCAnalysisManager, LazyCallGraph &, \
1809 CGSCCUpdateResult &>()); \
1810 return Error::success(); \
1811 } \
1812 if (Name == "invalidate<" NAME ">") { \
1813 CGPM.addPass(InvalidateAnalysisPass< \
1814 std::remove_reference_t<decltype(CREATE_PASS)>>()); \
1815 return Error::success(); \
1816 }
1817#define FUNCTION_PASS(NAME, CREATE_PASS) \
1818 if (Name == NAME) { \
1819 CGPM.addPass(createCGSCCToFunctionPassAdaptor(CREATE_PASS)); \
1820 return Error::success(); \
1821 }
1822#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1823 if (checkParametrizedPassName(Name, NAME)) { \
1824 auto Params = parsePassParameters(PARSER, Name, NAME); \
1825 if (!Params) \
1826 return Params.takeError(); \
1827 CGPM.addPass(createCGSCCToFunctionPassAdaptor(CREATE_PASS(Params.get()))); \
1828 return Error::success(); \
1829 }
1830#define LOOPNEST_PASS(NAME, CREATE_PASS) \
1831 if (Name == NAME) { \
1832 CGPM.addPass(createCGSCCToFunctionPassAdaptor( \
1833 createFunctionToLoopPassAdaptor(CREATE_PASS, false, false))); \
1834 return Error::success(); \
1835 }
1836#define LOOP_PASS(NAME, CREATE_PASS) \
1837 if (Name == NAME) { \
1838 CGPM.addPass(createCGSCCToFunctionPassAdaptor( \
1839 createFunctionToLoopPassAdaptor(CREATE_PASS, false, false))); \
1840 return Error::success(); \
1841 }
1842#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1843 if (checkParametrizedPassName(Name, NAME)) { \
1844 auto Params = parsePassParameters(PARSER, Name, NAME); \
1845 if (!Params) \
1846 return Params.takeError(); \
1847 CGPM.addPass( \
1848 createCGSCCToFunctionPassAdaptor(createFunctionToLoopPassAdaptor( \
1849 CREATE_PASS(Params.get()), false, false))); \
1850 return Error::success(); \
1851 }
1852#include "PassRegistry.def"
1853
1854 for (auto &C : CGSCCPipelineParsingCallbacks)
1855 if (C(Name, CGPM, InnerPipeline))
1857 return make_error(
1858 formatv("unknown cgscc pass '{0}'", Name).str(),
1860}
1861
1863 const PipelineElement &E) {
1864 auto &Name = E.Name;
1865 auto &InnerPipeline = E.InnerPipeline;
1866
1867
1868 if (!InnerPipeline.empty()) {
1869 if (Name == "function") {
1871 if (auto Err = parseFunctionPassPipeline(NestedFPM, InnerPipeline))
1872 return Err;
1873
1874 FPM.addPass(std::move(NestedFPM));
1876 }
1877 if (Name == "loop" || Name == "loop-mssa") {
1879 if (auto Err = parseLoopPassPipeline(LPM, InnerPipeline))
1880 return Err;
1881
1882 bool UseMemorySSA = (Name == "loop-mssa");
1884 return Pipeline.Name.contains("simple-loop-unswitch");
1885 });
1886 bool UseBPI = llvm::any_of(InnerPipeline, [](auto Pipeline) {
1887 return Pipeline.Name == "loop-predication";
1888 });
1892 }
1893 if (Name == "machine-function") {
1895 if (auto Err = parseMachinePassPipeline(MFPM, InnerPipeline))
1896 return Err;
1899 }
1900
1901 for (auto &C : FunctionPipelineParsingCallbacks)
1902 if (C(Name, FPM, InnerPipeline))
1904
1905
1906 return make_error(
1907 formatv("invalid use of '{0}' pass as function pipeline", Name).str(),
1909 }
1910
1911
1912#define FUNCTION_PASS(NAME, CREATE_PASS) \
1913 if (Name == NAME) { \
1914 FPM.addPass(CREATE_PASS); \
1915 return Error::success(); \
1916 }
1917#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1918 if (checkParametrizedPassName(Name, NAME)) { \
1919 auto Params = parsePassParameters(PARSER, Name, NAME); \
1920 if (!Params) \
1921 return Params.takeError(); \
1922 FPM.addPass(CREATE_PASS(Params.get())); \
1923 return Error::success(); \
1924 }
1925#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
1926 if (Name == "require<" NAME ">") { \
1927 FPM.addPass( \
1928 RequireAnalysisPass< \
1929 std::remove_reference_t<decltype(CREATE_PASS)>, Function>()); \
1930 return Error::success(); \
1931 } \
1932 if (Name == "invalidate<" NAME ">") { \
1933 FPM.addPass(InvalidateAnalysisPass< \
1934 std::remove_reference_t<decltype(CREATE_PASS)>>()); \
1935 return Error::success(); \
1936 }
1937
1938
1939
1940
1941#define LOOPNEST_PASS(NAME, CREATE_PASS) \
1942 if (Name == NAME) { \
1943 FPM.addPass(createFunctionToLoopPassAdaptor(CREATE_PASS, false, false)); \
1944 return Error::success(); \
1945 }
1946#define LOOP_PASS(NAME, CREATE_PASS) \
1947 if (Name == NAME) { \
1948 FPM.addPass(createFunctionToLoopPassAdaptor(CREATE_PASS, false, false)); \
1949 return Error::success(); \
1950 }
1951#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1952 if (checkParametrizedPassName(Name, NAME)) { \
1953 auto Params = parsePassParameters(PARSER, Name, NAME); \
1954 if (!Params) \
1955 return Params.takeError(); \
1956 FPM.addPass(createFunctionToLoopPassAdaptor(CREATE_PASS(Params.get()), \
1957 false, false)); \
1958 return Error::success(); \
1959 }
1960#include "PassRegistry.def"
1961
1962 for (auto &C : FunctionPipelineParsingCallbacks)
1963 if (C(Name, FPM, InnerPipeline))
1965 return make_error(
1966 formatv("unknown function pass '{0}'", Name).str(),
1968}
1969
1971 const PipelineElement &E) {
1973 auto &InnerPipeline = E.InnerPipeline;
1974
1975
1976 if (!InnerPipeline.empty()) {
1977 if (Name == "loop") {
1979 if (auto Err = parseLoopPassPipeline(NestedLPM, InnerPipeline))
1980 return Err;
1981
1982 LPM.addPass(std::move(NestedLPM));
1984 }
1985
1986 for (auto &C : LoopPipelineParsingCallbacks)
1987 if (C(Name, LPM, InnerPipeline))
1989
1990
1991 return make_error(
1992 formatv("invalid use of '{0}' pass as loop pipeline", Name).str(),
1994 }
1995
1996
1997#define LOOPNEST_PASS(NAME, CREATE_PASS) \
1998 if (Name == NAME) { \
1999 LPM.addPass(CREATE_PASS); \
2000 return Error::success(); \
2001 }
2002#define LOOP_PASS(NAME, CREATE_PASS) \
2003 if (Name == NAME) { \
2004 LPM.addPass(CREATE_PASS); \
2005 return Error::success(); \
2006 }
2007#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2008 if (checkParametrizedPassName(Name, NAME)) { \
2009 auto Params = parsePassParameters(PARSER, Name, NAME); \
2010 if (!Params) \
2011 return Params.takeError(); \
2012 LPM.addPass(CREATE_PASS(Params.get())); \
2013 return Error::success(); \
2014 }
2015#define LOOP_ANALYSIS(NAME, CREATE_PASS) \
2016 if (Name == "require<" NAME ">") { \
2017 LPM.addPass(RequireAnalysisPass< \
2018 std::remove_reference_t<decltype(CREATE_PASS)>, Loop, \
2019 LoopAnalysisManager, LoopStandardAnalysisResults &, \
2020 LPMUpdater &>()); \
2021 return Error::success(); \
2022 } \
2023 if (Name == "invalidate<" NAME ">") { \
2024 LPM.addPass(InvalidateAnalysisPass< \
2025 std::remove_reference_t<decltype(CREATE_PASS)>>()); \
2026 return Error::success(); \
2027 }
2028#include "PassRegistry.def"
2029
2030 for (auto &C : LoopPipelineParsingCallbacks)
2031 if (C(Name, LPM, InnerPipeline))
2033 return make_error(formatv("unknown loop pass '{0}'", Name).str(),
2035}
2036
2038 const PipelineElement &E) {
2040 if (!E.InnerPipeline.empty())
2041 return make_error("invalid pipeline",
2043
2044#define MACHINE_MODULE_PASS(NAME, CREATE_PASS) \
2045 if (Name == NAME) { \
2046 MFPM.addPass(CREATE_PASS); \
2047 return Error::success(); \
2048 }
2049#define MACHINE_FUNCTION_PASS(NAME, CREATE_PASS) \
2050 if (Name == NAME) { \
2051 MFPM.addPass(CREATE_PASS); \
2052 return Error::success(); \
2053 }
2054#define MACHINE_FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, \
2055 PARAMS) \
2056 if (checkParametrizedPassName(Name, NAME)) { \
2057 auto Params = parsePassParameters(PARSER, Name, NAME); \
2058 if (!Params) \
2059 return Params.takeError(); \
2060 MFPM.addPass(CREATE_PASS(Params.get())); \
2061 return Error::success(); \
2062 }
2063#define MACHINE_FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
2064 if (Name == "require<" NAME ">") { \
2065 MFPM.addPass( \
2066 RequireAnalysisPass<std::remove_reference_t<decltype(CREATE_PASS)>, \
2067 MachineFunction>()); \
2068 return Error::success(); \
2069 } \
2070 if (Name == "invalidate<" NAME ">") { \
2071 MFPM.addPass(InvalidateAnalysisPass< \
2072 std::remove_reference_t<decltype(CREATE_PASS)>>()); \
2073 return Error::success(); \
2074 }
2075#include "llvm/Passes/MachinePassRegistry.def"
2076
2077 for (auto &C : MachineFunctionPipelineParsingCallbacks)
2078 if (C(Name, MFPM, E.InnerPipeline))
2080 return make_error(
2081 formatv("unknown machine pass '{0}'", Name).str(),
2083}
2084
2086#define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS) \
2087 if (Name == NAME) { \
2088 AA.registerModuleAnalysis< \
2089 std::remove_reference_t<decltype(CREATE_PASS)>>(); \
2090 return true; \
2091 }
2092#define FUNCTION_ALIAS_ANALYSIS(NAME, CREATE_PASS) \
2093 if (Name == NAME) { \
2094 AA.registerFunctionAnalysis< \
2095 std::remove_reference_t<decltype(CREATE_PASS)>>(); \
2096 return true; \
2097 }
2098#include "PassRegistry.def"
2099
2100 for (auto &C : AAParsingCallbacks)
2102 return true;
2103 return false;
2104}
2105
2106Error PassBuilder::parseMachinePassPipeline(
2108 for (const auto &Element : Pipeline) {
2109 if (auto Err = parseMachinePass(MFPM, Element))
2110 return Err;
2111 }
2113}
2114
2117 for (const auto &Element : Pipeline) {
2118 if (auto Err = parseLoopPass(LPM, Element))
2119 return Err;
2120 }
2122}
2123
2124Error PassBuilder::parseFunctionPassPipeline(
2126 for (const auto &Element : Pipeline) {
2127 if (auto Err = parseFunctionPass(FPM, Element))
2128 return Err;
2129 }
2131}
2132
2135 for (const auto &Element : Pipeline) {
2136 if (auto Err = parseCGSCCPass(CGPM, Element))
2137 return Err;
2138 }
2140}
2141
2154 if (MFAM) {
2163 }
2164}
2165
2168 for (const auto &Element : Pipeline) {
2169 if (auto Err = parseModulePass(MPM, Element))
2170 return Err;
2171 }
2173}
2174
2175
2176
2177
2180 auto Pipeline = parsePipelineText(PipelineText);
2181 if (!Pipeline || Pipeline->empty())
2182 return make_error(
2183 formatv("invalid pipeline '{0}'", PipelineText).str(),
2185
2186
2187
2189
2190 if ((FirstName, ModulePipelineParsingCallbacks)) {
2191 bool UseMemorySSA;
2192 if (isCGSCCPassName(FirstName, CGSCCPipelineParsingCallbacks)) {
2193 Pipeline = {{"cgscc", std::move(*Pipeline)}};
2195 FunctionPipelineParsingCallbacks)) {
2196 Pipeline = {{"function", std::move(*Pipeline)}};
2197 } else if (isLoopNestPassName(FirstName, LoopPipelineParsingCallbacks,
2198 UseMemorySSA)) {
2199 Pipeline = {{"function", {{UseMemorySSA ? "loop-mssa" : "loop",
2200 std::move(*Pipeline)}}}};
2201 } else if (isLoopPassName(FirstName, LoopPipelineParsingCallbacks,
2202 UseMemorySSA)) {
2203 Pipeline = {{"function", {{UseMemorySSA ? "loop-mssa" : "loop",
2204 std::move(*Pipeline)}}}};
2206 FirstName, MachineFunctionPipelineParsingCallbacks)) {
2207 Pipeline = {{"function", {{"machine-function", std::move(*Pipeline)}}}};
2208 } else {
2209 for (auto &C : TopLevelPipelineParsingCallbacks)
2210 if (C(MPM, *Pipeline))
2212
2213
2214 auto &InnerPipeline = Pipeline->front().InnerPipeline;
2215 return make_error(
2216 formatv("unknown {0} name '{1}'",
2217 (InnerPipeline.empty() ? "pass" : "pipeline"), FirstName)
2218 .str(),
2220 }
2221 }
2222
2223 if (auto Err = parseModulePassPipeline(MPM, *Pipeline))
2224 return Err;
2226}
2227
2228
2231 auto Pipeline = parsePipelineText(PipelineText);
2232 if (!Pipeline || Pipeline->empty())
2233 return make_error(
2234 formatv("invalid pipeline '{0}'", PipelineText).str(),
2236
2238 if ((FirstName, CGSCCPipelineParsingCallbacks))
2239 return make_error(
2240 formatv("unknown cgscc pass '{0}' in pipeline '{1}'", FirstName,
2241 PipelineText)
2242 .str(),
2244
2245 if (auto Err = parseCGSCCPassPipeline(CGPM, *Pipeline))
2246 return Err;
2248}
2249
2250
2251
2254 auto Pipeline = parsePipelineText(PipelineText);
2255 if (!Pipeline || Pipeline->empty())
2256 return make_error(
2257 formatv("invalid pipeline '{0}'", PipelineText).str(),
2259
2261 if ((FirstName, FunctionPipelineParsingCallbacks))
2262 return make_error(
2263 formatv("unknown function pass '{0}' in pipeline '{1}'", FirstName,
2264 PipelineText)
2265 .str(),
2267
2268 if (auto Err = parseFunctionPassPipeline(FPM, *Pipeline))
2269 return Err;
2271}
2272
2273
2276 auto Pipeline = parsePipelineText(PipelineText);
2277 if (!Pipeline || Pipeline->empty())
2278 return make_error(
2279 formatv("invalid pipeline '{0}'", PipelineText).str(),
2281
2282 if (auto Err = parseLoopPassPipeline(CGPM, *Pipeline))
2283 return Err;
2284
2286}
2287
2290 auto Pipeline = parsePipelineText(PipelineText);
2291 if (!Pipeline || Pipeline->empty())
2292 return make_error(
2293 formatv("invalid machine pass pipeline '{0}'", PipelineText).str(),
2295
2296 if (auto Err = parseMachinePassPipeline(MFPM, *Pipeline))
2297 return Err;
2298
2300}
2301
2303
2304
2305 if (PipelineText == "default") {
2308 }
2309
2310 while (!PipelineText.empty()) {
2312 std::tie(Name, PipelineText) = PipelineText.split(',');
2313 if (!parseAAPassName(AA, Name))
2314 return make_error(
2315 formatv("unknown alias analysis name '{0}'", Name).str(),
2317 }
2318
2320}
2321
2322std::optional
2324 if (FilterName == "all")
2325 return nullptr;
2326 for (auto &C : RegClassFilterParsingCallbacks)
2327 if (auto F = C(FilterName))
2328 return F;
2329 return std::nullopt;
2330}
2331
2334}
2337 OS << " " << PassName << "<" << Params << ">\n";
2338}
2339
2341
2342
2343 OS << "Module passes:\n";
2344#define MODULE_PASS(NAME, CREATE_PASS) printPassName(NAME, OS);
2345#include "PassRegistry.def"
2346
2347 OS << "Module passes with params:\n";
2348#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2349 printPassName(NAME, PARAMS, OS);
2350#include "PassRegistry.def"
2351
2352 OS << "Module analyses:\n";
2353#define MODULE_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
2354#include "PassRegistry.def"
2355
2356 OS << "Module alias analyses:\n";
2357#define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
2358#include "PassRegistry.def"
2359
2360 OS << "CGSCC passes:\n";
2361#define CGSCC_PASS(NAME, CREATE_PASS) printPassName(NAME, OS);
2362#include "PassRegistry.def"
2363
2364 OS << "CGSCC passes with params:\n";
2365#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2366 printPassName(NAME, PARAMS, OS);
2367#include "PassRegistry.def"
2368
2369 OS << "CGSCC analyses:\n";
2370#define CGSCC_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
2371#include "PassRegistry.def"
2372
2373 OS << "Function passes:\n";
2374#define FUNCTION_PASS(NAME, CREATE_PASS) printPassName(NAME, OS);
2375#include "PassRegistry.def"
2376
2377 OS << "Function passes with params:\n";
2378#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2379 printPassName(NAME, PARAMS, OS);
2380#include "PassRegistry.def"
2381
2382 OS << "Function analyses:\n";
2383#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
2384#include "PassRegistry.def"
2385
2386 OS << "Function alias analyses:\n";
2387#define FUNCTION_ALIAS_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
2388#include "PassRegistry.def"
2389
2390 OS << "LoopNest passes:\n";
2391#define LOOPNEST_PASS(NAME, CREATE_PASS) printPassName(NAME, OS);
2392#include "PassRegistry.def"
2393
2394 OS << "Loop passes:\n";
2395#define LOOP_PASS(NAME, CREATE_PASS) printPassName(NAME, OS);
2396#include "PassRegistry.def"
2397
2398 OS << "Loop passes with params:\n";
2399#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2400 printPassName(NAME, PARAMS, OS);
2401#include "PassRegistry.def"
2402
2403 OS << "Loop analyses:\n";
2404#define LOOP_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
2405#include "PassRegistry.def"
2406
2407 OS << "Machine module passes (WIP):\n";
2408#define MACHINE_MODULE_PASS(NAME, CREATE_PASS) printPassName(NAME, OS);
2409#include "llvm/Passes/MachinePassRegistry.def"
2410
2411 OS << "Machine function passes (WIP):\n";
2412#define MACHINE_FUNCTION_PASS(NAME, CREATE_PASS) printPassName(NAME, OS);
2413#include "llvm/Passes/MachinePassRegistry.def"
2414
2415 OS << "Machine function analyses (WIP):\n";
2416#define MACHINE_FUNCTION_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
2417#include "llvm/Passes/MachinePassRegistry.def"
2418}
2419
2422 &C) {
2423 TopLevelPipelineParsingCallbacks.push_back(C);
2424}
unsigned const MachineRegisterInfo * MRI
AggressiveInstCombiner - Combine expression patterns to form expressions with fewer,...
This file implements a simple N^2 alias analysis accuracy evaluator.
Provides passes to inlining "always_inline" functions.
This is the interface for LLVM's primary stateless and local alias analysis.
This file provides the interface for LLVM's Call Graph Profile pass.
This header provides classes for managing passes over SCCs of the call graph.
This file provides interfaces used to build and manipulate a call graph, which is a very useful tool ...
Defines an IR pass for CodeGen Prepare.
This file declares an analysis pass that computes CycleInfo for LLVM IR, specialized from GenericCycl...
This file provides the interface for a simple, fast CSE pass.
This file provides a pass which clones the current module and runs the provided pass pipeline on the ...
Super simple passes to force specific function attrs from the commandline into the IR for debugging p...
Provides passes for computing function attributes based on interprocedural analyses.
This file provides the interface for the GCOV style profiler pass.
This file provides the interface for LLVM's Global Value Numbering pass which eliminates fully redund...
This is the interface for a simple mod/ref and alias analysis over globals.
Defines an IR pass for the creation of hardware loops.
AcceleratorCodeSelection - Identify all functions reachable from a kernel, removing those that are un...
This file defines passes to print out IR in various granularities.
This header defines various interfaces for pass management in LLVM.
Interfaces for passes which infer implicit function attributes from the name and signature of functio...
This file provides the primary interface to the instcombine pass.
Defines passes for running instruction simplification across chunks of IR.
This file provides the interface for LLVM's PGO Instrumentation lowering pass.
This file contains the declaration of the InterleavedAccessPass class, its corresponding pass name is...
See the comments on JumpThreadingPass.
Implements a lazy call graph analysis and related passes for the new pass manager.
This file defines the interface for the loop cache analysis.
This file provides the interface for LLVM's Loop Data Prefetching Pass.
This file implements the Loop Fusion pass.
This header defines the LoopLoadEliminationPass object.
This file defines the interface for the loop nest analysis.
This header provides classes for managing a pipeline of passes over loops in LLVM IR.
This file provides the interface for the pass responsible for removing expensive ubsan checks.
The header file for the LowerConstantIntrinsics pass as used by the new pass manager.
The header file for the LowerExpectIntrinsic pass as used by the new pass manager.
This file exposes an interface to building/using memory SSA to walk memory instructions using a use/d...
This pass performs merges of loads and stores on both sides of a.
This is the interface to build a ModuleSummaryIndex for a module.
Contains a collection of routines for determining if a given instruction is guaranteed to execute if ...
This file provides the interface for LLVM's Global Value Numbering pass.
This file declares a simple ARC-aware AliasAnalysis using special knowledge of Objective C to enhance...
This header enumerates the LLVM-provided high-level optimization levels.
This file provides the interface for IR based instrumentation passes ( (profile-gen,...
CGSCCAnalysisManager CGAM
FunctionAnalysisManager FAM
ModuleAnalysisManager MAM
PassInstrumentationCallbacks PIC
PassBuilder PB(Machine, PassOpts->PTO, std::nullopt, &PIC)
static bool isModulePassName(StringRef Name, CallbacksT &Callbacks)
static bool callbacksAcceptPassName(StringRef Name, CallbacksT &Callbacks)
Tests whether registered callbacks will accept a given pass name.
static std::optional< int > parseDevirtPassName(StringRef Name)
static bool startsWithDefaultPipelineAliasPrefix(StringRef Name)
Tests whether a pass name starts with a valid prefix for a default pipeline alias.
static bool isLoopNestPassName(StringRef Name, CallbacksT &Callbacks, bool &UseMemorySSA)
static bool isMachineFunctionPassName(StringRef Name, CallbacksT &Callbacks)
static std::optional< OptimizationLevel > parseOptLevel(StringRef S)
static bool isLoopPassName(StringRef Name, CallbacksT &Callbacks, bool &UseMemorySSA)
static std::optional< std::pair< bool, bool > > parseFunctionPipelineName(StringRef Name)
static bool isCGSCCPassName(StringRef Name, CallbacksT &Callbacks)
static void printPassName(StringRef PassName, raw_ostream &OS)
static bool isFunctionPassName(StringRef Name, CallbacksT &Callbacks)
static const Regex DefaultAliasRegex("^(default|thinlto-pre-link|thinlto|lto-pre-link|lto)<(O[0123sz])>$")
This file implements the PredicateInfo analysis, which creates an Extended SSA form for operations us...
This pass is required to take advantage of the interprocedural register allocation infrastructure.
This file implements relative lookup table converter that converts lookup tables to relative lookup t...
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file provides the interface for LLVM's Scalar Replacement of Aggregates pass.
This file provides the interface for the pseudo probe implementation for AutoFDO.
This file provides the interface for the sampled PGO loader pass.
This is the interface for a SCEV-based alias analysis.
This pass converts vector operations into scalar operations (or, optionally, operations on smaller ve...
This is the interface for a metadata-based scoped no-alias analysis.
This file contains the declaration of the SelectOptimizePass class, its corresponding pass name is se...
This file provides the interface for the pass responsible for both simplifying and canonicalizing the...
This file implements the StringSwitch template, which mimics a switch() statement whose cases are str...
Target-Independent Code Generator Pass Configuration Options pass.
This pass exposes codegen information to IR-level passes.
This is the interface for a metadata-based TBAA.
LLVM IR instance of the generic uniformity analysis.
static const char PassName[]
A manager for alias analyses.
Class for arbitrary precision integers.
uint64_t getZExtValue() const
Get zero extended value.
int64_t getSExtValue() const
Get sign extended value.
A container for analyses that lazily runs them and caches their results.
bool registerPass(PassBuilderT &&PassBuilder)
Register an analysis pass with the manager.
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
LLVM Basic Block Representation.
const Instruction * getTerminator() const LLVM_READONLY
Returns the terminator instruction if the block is well formed or null if the block is not well forme...
Lightweight error class with error context and mandatory checking.
static ErrorSuccess success()
Create a success value.
Tagged union holding either a T or a Error.
static GlobalAlias * create(Type *Ty, unsigned AddressSpace, LinkageTypes Linkage, const Twine &Name, Constant *Aliasee, Module *Parent)
If a parent module is specified, the alias is automatically inserted into the end of the specified mo...
An analysis over an "outer" IR unit that provides access to an analysis manager over an "inner" IR un...
static constexpr LLT scalar(unsigned SizeInBits)
Get a low-level scalar or aggregate "bag of bits".
An RAII based helper class to modify MachineFunctionProperties when running pass.
Properties which a MachineFunction may have at a given point in time.
MachineFunctionProperties & set(Property P)
MachineRegisterInfo & getRegInfo()
getRegInfo - Return information about the registers currently in use.
const MachineFunctionProperties & getProperties() const
Get the function properties.
A Module instance is used to store all the information related to an LLVM module.
static const OptimizationLevel O3
Optimize for fast execution as much as possible.
static const OptimizationLevel Oz
A very specialized mode that will optimize for code size at any and all costs.
static const OptimizationLevel O0
Disable as many optimizations as possible.
static const OptimizationLevel Os
Similar to O2 but tries to optimize for small code size instead of fast execution without triggering ...
static const OptimizationLevel O2
Optimize for fast execution as much as possible without triggering significant incremental compile ti...
static const OptimizationLevel O1
Optimize quickly without destroying debuggability.
This class provides access to building LLVM's passes.
void printPassNames(raw_ostream &OS)
Print pass names.
static bool checkParametrizedPassName(StringRef Name, StringRef PassName)
AAManager buildDefaultAAPipeline()
Build the default AAManager with the default alias analysis pipeline registered.
Error parseAAPipeline(AAManager &AA, StringRef PipelineText)
Parse a textual alias analysis pipeline into the provided AA manager.
ModulePassManager buildThinLTOPreLinkDefaultPipeline(OptimizationLevel Level)
Build a pre-link, ThinLTO-targeting default optimization pipeline to a pass manager.
PassBuilder(TargetMachine *TM=nullptr, PipelineTuningOptions PTO=PipelineTuningOptions(), std::optional< PGOOptions > PGOOpt=std::nullopt, PassInstrumentationCallbacks *PIC=nullptr)
void registerLoopAnalyses(LoopAnalysisManager &LAM)
Registers all available loop analysis passes.
std::optional< RegAllocFilterFunc > parseRegAllocFilter(StringRef RegAllocFilterName)
Parse RegAllocFilterName to get RegAllocFilterFunc.
void crossRegisterProxies(LoopAnalysisManager &LAM, FunctionAnalysisManager &FAM, CGSCCAnalysisManager &CGAM, ModuleAnalysisManager &MAM, MachineFunctionAnalysisManager *MFAM=nullptr)
Cross register the analysis managers through their proxies.
ModulePassManager buildPerModuleDefaultPipeline(OptimizationLevel Level, ThinOrFullLTOPhase Phase=ThinOrFullLTOPhase::None)
Build a per-module default optimization pipeline.
Error parsePassPipeline(ModulePassManager &MPM, StringRef PipelineText)
Parse a textual pass pipeline description into a ModulePassManager.
ModulePassManager buildLTODefaultPipeline(OptimizationLevel Level, ModuleSummaryIndex *ExportSummary)
Build an LTO default optimization pipeline to a pass manager.
ModulePassManager buildThinLTODefaultPipeline(OptimizationLevel Level, const ModuleSummaryIndex *ImportSummary)
Build a ThinLTO default optimization pipeline to a pass manager.
void registerModuleAnalyses(ModuleAnalysisManager &MAM)
Registers all available module analysis passes.
void registerCGSCCAnalyses(CGSCCAnalysisManager &CGAM)
Registers all available CGSCC analysis passes.
static Expected< bool > parseSinglePassOption(StringRef Params, StringRef OptionName, StringRef PassName)
Handle passes only accept one bool-valued parameter.
void registerMachineFunctionAnalyses(MachineFunctionAnalysisManager &MFAM)
Registers all available machine function analysis passes.
void registerParseTopLevelPipelineCallback(const std::function< bool(ModulePassManager &, ArrayRef< PipelineElement >)> &C)
Register a callback for a top-level pipeline entry.
ModulePassManager buildLTOPreLinkDefaultPipeline(OptimizationLevel Level)
Build a pre-link, LTO-targeting default optimization pipeline to a pass manager.
void registerFunctionAnalyses(FunctionAnalysisManager &FAM)
Registers all available function analysis passes.
LLVM_ATTRIBUTE_MINSIZE std::enable_if_t< is_detected< HasRunOnLoopT, PassT >::value > addPass(PassT &&Pass)
LLVM_ATTRIBUTE_MINSIZE std::enable_if_t<!std::is_same_v< PassT, PassManager > > addPass(PassT &&Pass)
Tunable parameters for passes in the default pipelines.
bool SLPVectorization
Tuning option to enable/disable slp loop vectorization, set based on opt level.
bool LoopVectorization
Tuning option to enable/disable loop vectorization, set based on opt level.
static PointerType * getUnqual(Type *ElementType)
This constructs a pointer to an object of the specified type in the default address space (address sp...
A set of analyses that are preserved following a run of a transformation pass.
static PreservedAnalyses none()
Convenience factory function for the empty preserved set.
static PreservedAnalyses all()
Construct a special preserved set that preserves all passes.
bool match(StringRef String, SmallVectorImpl< StringRef > *Matches=nullptr, std::string *Error=nullptr) const
matches - Match the regex against a given String.
void push_back(const T &Elt)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
StringRef - Represent a constant reference to a string, i.e.
std::pair< StringRef, StringRef > split(char Separator) const
Split into two substrings around the first occurrence of a separator character.
bool getAsInteger(unsigned Radix, T &Result) const
Parse the current string as an integer of the specified radix.
std::string str() const
str - Get the contents as an std::string.
constexpr bool empty() const
empty - Check if the string is empty.
char front() const
front - Get the first character in the string.
bool consume_front(StringRef Prefix)
Returns true if this StringRef has the given prefix and removes that prefix.
A switch()-like statement whose cases are string literals.
StringSwitch & Case(StringLiteral S, T Value)
Primary interface to the complete machine description for the target machine.
This function has undefined behavior.
self_iterator getIterator()
This class implements an extremely fast bulk output stream that can only output to a stream.
Interfaces for registering analysis passes, producing common pass manager configurations,...
@ C
The default llvm calling convention, compatible with C.
PointerTypeMap run(const Module &M)
Compute the PointerTypeMap for the module M.
This is an optimization pass for GlobalISel generic memory operations.
ModuleToFunctionPassAdaptor createModuleToFunctionPassAdaptor(FunctionPassT &&Pass, bool EagerlyInvalidate=false)
A function to deduce a function pass type and wrap it in the templated adaptor.
DevirtSCCRepeatedPass createDevirtSCCRepeatedPass(CGSCCPassT &&Pass, int MaxIterations)
A function to deduce a function pass type and wrap it in the templated adaptor.
std::error_code inconvertibleErrorCode()
The value returned by this function can be returned from convertToErrorCode for Error values where no...
OuterAnalysisManagerProxy< ModuleAnalysisManager, MachineFunction > ModuleAnalysisManagerMachineFunctionProxy
Provide the ModuleAnalysisManager to Function proxy.
OuterAnalysisManagerProxy< ModuleAnalysisManager, Function > ModuleAnalysisManagerFunctionProxy
Provide the ModuleAnalysisManager to Function proxy.
InnerAnalysisManagerProxy< MachineFunctionAnalysisManager, Module > MachineFunctionAnalysisManagerModuleProxy
OuterAnalysisManagerProxy< ModuleAnalysisManager, LazyCallGraph::SCC, LazyCallGraph & > ModuleAnalysisManagerCGSCCProxy
A proxy from a ModuleAnalysisManager to an SCC.
bool any_of(R &&range, UnaryPredicate P)
Provide wrappers to std::any_of which take ranges instead of having to pass begin/end explicitly.
ModuleToPostOrderCGSCCPassAdaptor createModuleToPostOrderCGSCCPassAdaptor(CGSCCPassT &&Pass)
A function to deduce a function pass type and wrap it in the templated adaptor.
auto formatv(bool Validate, const char *Fmt, Ts &&...Vals)
CGSCCToFunctionPassAdaptor createCGSCCToFunctionPassAdaptor(FunctionPassT &&Pass, bool EagerlyInvalidate=false, bool NoRerun=false)
A function to deduce a function pass type and wrap it in the templated adaptor.
InnerAnalysisManagerProxy< FunctionAnalysisManager, Module > FunctionAnalysisManagerModuleProxy
Provide the FunctionAnalysisManager to Module proxy.
FunctionToMachineFunctionPassAdaptor createFunctionToMachineFunctionPassAdaptor(MachineFunctionPassT &&Pass)
InnerAnalysisManagerProxy< MachineFunctionAnalysisManager, Function > MachineFunctionAnalysisManagerFunctionProxy
OuterAnalysisManagerProxy< FunctionAnalysisManager, Loop, LoopStandardAnalysisResults & > FunctionAnalysisManagerLoopProxy
A proxy from a FunctionAnalysisManager to a Loop.
cl::opt< bool > PrintPipelinePasses
Common option used by multiple tools to print pipeline passes.
OuterAnalysisManagerProxy< CGSCCAnalysisManager, Function > CGSCCAnalysisManagerFunctionProxy
A proxy from a CGSCCAnalysisManager to a Function.
std::enable_if_t< is_detected< HasRunOnLoopT, LoopPassT >::value, FunctionToLoopPassAdaptor > createFunctionToLoopPassAdaptor(LoopPassT &&Pass, bool UseMemorySSA=false, bool UseBlockFrequencyInfo=false, bool UseBranchProbabilityInfo=false)
A function to deduce a loop pass type and wrap it in the templated adaptor.
@ Detailed
Hash with opcode only.
@ CallTargetIgnored
Hash with opcode and operands.
A special type used by analysis passes to provide an address that identifies that particular analysis...
A set of parameters to control various transforms performed by GVN pass.
HardwareLoopOptions & setForceNested(bool Force)
HardwareLoopOptions & setDecrement(unsigned Count)
HardwareLoopOptions & setForceGuard(bool Force)
HardwareLoopOptions & setForce(bool Force)
HardwareLoopOptions & setCounterBitwidth(unsigned Width)
HardwareLoopOptions & setForcePhi(bool Force)
A set of parameters to control various transforms performed by IPSCCP pass.
A set of parameters used to control various transforms performed by the LoopUnroll pass.
LoopUnrollOptions & setPeeling(bool Peeling)
Enables or disables loop peeling.
LoopUnrollOptions & setOptLevel(int O)
LoopUnrollOptions & setPartial(bool Partial)
Enables or disables partial unrolling.
LoopUnrollOptions & setFullUnrollMaxCount(unsigned O)
LoopUnrollOptions & setUpperBound(bool UpperBound)
Enables or disables the use of trip count upper bound in loop unrolling.
LoopUnrollOptions & setRuntime(bool Runtime)
Enables or disables unrolling of loops with runtime trip count.
LoopUnrollOptions & setProfileBasedPeeling(int O)
LoopVectorizeOptions & setVectorizeOnlyWhenForced(bool Value)
LoopVectorizeOptions & setInterleaveOnlyWhenForced(bool Value)
A CRTP mix-in to automatically provide informational APIs needed for passes.
static StringRef name()
Gets the name of the pass we are mixed into.
This class manages callbacks registration, as well as provides a way for PassInstrumentation to pass ...
void registerClassToPassNameCallback(CallableT C)
RegAllocFilterFunc Filter