390 "print-pipeline-passes",
391 cl::desc(
"Print a '-passes' compatible string describing the pipeline "
392 "(best-effort only)."));
403class TriggerCrashModulePass :
public PassInfoMixin<TriggerCrashModulePass> {
409 static StringRef
name() {
return "TriggerCrashModulePass"; }
412class TriggerCrashFunctionPass
419 static StringRef
name() {
return "TriggerCrashFunctionPass"; }
424class TriggerVerifierErrorPass
430 auto *PtrTy = PointerType::getUnqual(
M.getContext());
432 GlobalValue::LinkageTypes::InternalLinkage,
433 "__bad_alias",
nullptr, &M);
453 static StringRef
name() {
return "TriggerVerifierErrorPass"; }
458class RequireAllMachineFunctionPropertiesPass
459 :
public PassInfoMixin<RequireAllMachineFunctionPropertiesPass> {
466 static MachineFunctionProperties getRequiredProperties() {
467 return MachineFunctionProperties()
469 .setFailsVerification()
474 .setRegBankSelected()
476 .setTiedOpsRewritten()
477 .setTracksDebugUserValues()
478 .setTracksLiveness();
480 static StringRef
name() {
return "RequireAllMachineFunctionPropertiesPass"; }
497 std::optional<OptimizationLevel> OptLevel =
parseOptLevel(S);
501 formatv(
"invalid optimization level '{}'", S).str(),
506 std::optional<PGOOptions> PGOOpt,
509 : TM(TM), PTO(PTO), PGOOpt(PGOOpt), PIC(PIC), FS(
std::
move(FS)) {
511 TM->registerPassBuilderCallbacks(*
this);
513 PIC->registerClassToPassNameCallback([
this, PIC]() {
517#define MODULE_PASS(NAME, CREATE_PASS) \
518 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
519#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
520 PIC->addClassToPassName(CLASS, NAME);
521#define MODULE_ANALYSIS(NAME, CREATE_PASS) \
522 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
523#define FUNCTION_PASS(NAME, CREATE_PASS) \
524 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
525#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
526 PIC->addClassToPassName(CLASS, NAME);
527#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
528 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
529#define LOOPNEST_PASS(NAME, CREATE_PASS) \
530 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
531#define LOOP_PASS(NAME, CREATE_PASS) \
532 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
533#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
534 PIC->addClassToPassName(CLASS, NAME);
535#define LOOP_ANALYSIS(NAME, CREATE_PASS) \
536 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
537#define CGSCC_PASS(NAME, CREATE_PASS) \
538 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
539#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
540 PIC->addClassToPassName(CLASS, NAME);
541#define CGSCC_ANALYSIS(NAME, CREATE_PASS) \
542 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
543#include "PassRegistry.def"
545#define MACHINE_FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
546 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
547#define MACHINE_FUNCTION_PASS(NAME, CREATE_PASS) \
548 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
549#define MACHINE_FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, \
551 PIC->addClassToPassName(CLASS, NAME);
552#include "llvm/Passes/MachinePassRegistry.def"
560#define MODULE_CALLBACK(NAME, INVOKE) \
561 if (PassBuilder::checkParametrizedPassName(Name, NAME)) { \
562 auto L = PassBuilder::parsePassParameters(parseOptLevelParam, Name, NAME); \
564 errs() << NAME ": " << toString(L.takeError()) << '\n'; \
567 INVOKE(PM, L.get()); \
570#include "PassRegistry.def"
578#define MODULE_LTO_CALLBACK(NAME, INVOKE) \
579 if (PassBuilder::checkParametrizedPassName(Name, NAME)) { \
580 auto L = PassBuilder::parsePassParameters(parseOptLevelParam, Name, NAME); \
582 errs() << NAME ": " << toString(L.takeError()) << '\n'; \
585 INVOKE(PM, L.get(), ThinOrFullLTOPhase::None); \
588#include "PassRegistry.def"
596#define FUNCTION_CALLBACK(NAME, INVOKE) \
597 if (PassBuilder::checkParametrizedPassName(Name, NAME)) { \
598 auto L = PassBuilder::parsePassParameters(parseOptLevelParam, Name, NAME); \
600 errs() << NAME ": " << toString(L.takeError()) << '\n'; \
603 INVOKE(PM, L.get()); \
606#include "PassRegistry.def"
614#define CGSCC_CALLBACK(NAME, INVOKE) \
615 if (PassBuilder::checkParametrizedPassName(Name, NAME)) { \
616 auto L = PassBuilder::parsePassParameters(parseOptLevelParam, Name, NAME); \
618 errs() << NAME ": " << toString(L.takeError()) << '\n'; \
621 INVOKE(PM, L.get()); \
624#include "PassRegistry.def"
632#define LOOP_CALLBACK(NAME, INVOKE) \
633 if (PassBuilder::checkParametrizedPassName(Name, NAME)) { \
634 auto L = PassBuilder::parsePassParameters(parseOptLevelParam, Name, NAME); \
636 errs() << NAME ": " << toString(L.takeError()) << '\n'; \
639 INVOKE(PM, L.get()); \
642#include "PassRegistry.def"
648#define MODULE_ANALYSIS(NAME, CREATE_PASS) \
649 MAM.registerPass([&] { return CREATE_PASS; });
650#include "PassRegistry.def"
652 for (
auto &
C : ModuleAnalysisRegistrationCallbacks)
657#define CGSCC_ANALYSIS(NAME, CREATE_PASS) \
658 CGAM.registerPass([&] { return CREATE_PASS; });
659#include "PassRegistry.def"
661 for (
auto &
C : CGSCCAnalysisRegistrationCallbacks)
671#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
672 if constexpr (std::is_constructible_v< \
673 std::remove_reference_t<decltype(CREATE_PASS)>, \
674 const TargetMachine &>) { \
676 FAM.registerPass([&] { return CREATE_PASS; }); \
678 FAM.registerPass([&] { return CREATE_PASS; }); \
680#include "PassRegistry.def"
682 for (
auto &
C : FunctionAnalysisRegistrationCallbacks)
689#define MACHINE_FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
690 MFAM.registerPass([&] { return CREATE_PASS; });
691#include "llvm/Passes/MachinePassRegistry.def"
693 for (
auto &
C : MachineFunctionAnalysisRegistrationCallbacks)
698#define LOOP_ANALYSIS(NAME, CREATE_PASS) \
699 LAM.registerPass([&] { return CREATE_PASS; });
700#include "PassRegistry.def"
702 for (
auto &
C : LoopAnalysisRegistrationCallbacks)
706static std::optional<std::pair<bool, bool>>
708 std::pair<bool, bool> Params;
709 if (!Name.consume_front(
"function"))
713 if (!Name.consume_front(
"<") || !Name.consume_back(
">"))
715 while (!Name.empty()) {
716 auto [Front, Back] = Name.split(
';');
718 if (Front ==
"eager-inv")
720 else if (Front ==
"no-rerun")
721 Params.second =
true;
729 if (!Name.consume_front(
"devirt<") || !Name.consume_back(
">"))
741 while (!Params.
empty()) {
743 std::tie(ParamName, Params) = Params.
split(
';');
745 if (ParamName == OptionName) {
762 while (!Params.
empty()) {
764 std::tie(ParamName, Params) = Params.
split(
';');
769 formatv(
"invalid HardwareLoopPass parameter '{}'", ParamName).str(),
774 if (ParamName.
consume_front(
"hardware-loop-counter-bitwidth=")) {
778 formatv(
"invalid HardwareLoopPass parameter '{}'", ParamName).str(),
783 if (ParamName ==
"force-hardware-loops") {
785 }
else if (ParamName ==
"force-hardware-loop-phi") {
787 }
else if (ParamName ==
"force-nested-hardware-loop") {
789 }
else if (ParamName ==
"force-hardware-loop-guard") {
793 formatv(
"invalid HardwarePass parameter '{}'", ParamName).str(),
797 return HardwareLoopOpts;
809 while (!Params.
empty()) {
811 std::tie(ParamName, Params) = Params.
split(
';');
812 std::optional<OptimizationLevel> OptLevel =
parseOptLevel(ParamName);
814 if (OptLevel && !OptLevel->isOptimizingForSize()) {
815 UnrollOpts.
setOptLevel(OptLevel->getSpeedupLevel());
822 formatv(
"invalid LoopUnrollPass parameter '{}'", ParamName).str(),
829 if (ParamName ==
"partial") {
831 }
else if (ParamName ==
"peeling") {
833 }
else if (ParamName ==
"profile-peeling") {
835 }
else if (ParamName ==
"runtime") {
837 }
else if (ParamName ==
"upperbound") {
841 formatv(
"invalid LoopUnrollPass parameter '{}'", ParamName).str(),
850 Params,
"vfe-linkage-unit-visibility",
"GlobalDCE");
870 Params,
"skip-non-recursive-function-attrs",
"PostOrderFunctionAttrs");
880 formatv(
"too many CFGuardPass parameters '{}'", Params).str(),
883 if (Param ==
"check")
885 if (Param ==
"dispatch")
889 formatv(
"invalid CFGuardPass mechanism: '{}'", Param).str(),
899 "EntryExitInstrumenter");
908 "LowerMatrixIntrinsics");
913 while (!Params.
empty()) {
915 std::tie(ParamName, Params) = Params.
split(
';');
918 if (ParamName ==
"preserve-order")
920 else if (ParamName ==
"rename-all")
922 else if (ParamName ==
"fold-all")
924 else if (ParamName ==
"reorder-operands")
928 formatv(
"invalid normalize pass parameter '{}'", ParamName).str(),
938 while (!Params.
empty()) {
940 std::tie(ParamName, Params) = Params.
split(
';');
942 if (ParamName ==
"kernel") {
943 Result.CompileKernel =
true;
944 }
else if (ParamName ==
"use-after-scope") {
945 Result.UseAfterScope =
true;
948 formatv(
"invalid AddressSanitizer pass parameter '{}'", ParamName)
958 while (!Params.
empty()) {
960 std::tie(ParamName, Params) = Params.
split(
';');
962 if (ParamName ==
"recover") {
964 }
else if (ParamName ==
"kernel") {
965 Result.CompileKernel =
true;
968 formatv(
"invalid HWAddressSanitizer pass parameter '{}'", ParamName)
978 while (!Params.
empty()) {
980 std::tie(ParamName, Params) = Params.
split(
';');
982 if (ParamName ==
"thinlto") {
984 }
else if (ParamName ==
"emit-summary") {
985 Result.EmitLTOSummary =
true;
988 formatv(
"invalid EmbedBitcode pass parameter '{}'", ParamName).str(),
996parseLowerAllowCheckPassOptions(
StringRef Params) {
998 while (!Params.
empty()) {
1000 std::tie(ParamName, Params) = Params.
split(
';');
1011 std::tie(IndicesStr, CutoffStr) = ParamName.
split(
"]=");
1018 formatv(
"invalid LowerAllowCheck pass cutoffs parameter '{}' ({})",
1023 if (!IndicesStr.
consume_front(
"cutoffs[") || IndicesStr ==
"")
1025 formatv(
"invalid LowerAllowCheck pass index parameter '{}' ({})",
1026 IndicesStr, CutoffStr)
1030 while (IndicesStr !=
"") {
1032 std::tie(firstIndexStr, IndicesStr) = IndicesStr.
split(
'|');
1038 "invalid LowerAllowCheck pass index parameter '{}' ({}) {}",
1039 firstIndexStr, IndicesStr)
1046 if (index >=
Result.cutoffs.size())
1047 Result.cutoffs.resize(index + 1, 0);
1049 Result.cutoffs[index] = cutoff;
1051 }
else if (ParamName.
starts_with(
"runtime_check")) {
1053 std::tie(std::ignore, ValueString) = ParamName.
split(
"=");
1057 formatv(
"invalid LowerAllowCheck pass runtime_check parameter '{}' "
1059 ValueString, Params)
1063 Result.runtime_check = runtime_check;
1066 formatv(
"invalid LowerAllowCheck pass parameter '{}'", ParamName)
1077 while (!Params.
empty()) {
1079 std::tie(ParamName, Params) = Params.
split(
';');
1081 if (ParamName ==
"recover") {
1083 }
else if (ParamName ==
"kernel") {
1088 formatv(
"invalid argument to MemorySanitizer pass track-origins "
1093 }
else if (ParamName ==
"eager-checks") {
1094 Result.EagerChecks =
true;
1097 formatv(
"invalid MemorySanitizer pass parameter '{}'", ParamName)
1107 while (!Params.
empty()) {
1109 std::tie(ParamName, Params) = Params.
split(
';');
1116 formatv(
"invalid argument to AllocToken pass mode "
1123 formatv(
"invalid AllocToken pass parameter '{}'", ParamName).str(),
1133 while (!Params.
empty()) {
1135 std::tie(ParamName, Params) = Params.
split(
';');
1138 if (ParamName ==
"speculate-blocks") {
1140 }
else if (ParamName ==
"simplify-cond-branch") {
1142 }
else if (ParamName ==
"forward-switch-cond") {
1144 }
else if (ParamName ==
"switch-range-to-icmp") {
1146 }
else if (ParamName ==
"switch-to-arithmetic") {
1148 }
else if (ParamName ==
"switch-to-lookup") {
1150 }
else if (ParamName ==
"keep-loops") {
1152 }
else if (ParamName ==
"hoist-common-insts") {
1154 }
else if (ParamName ==
"hoist-loads-stores-with-cond-faulting") {
1156 }
else if (ParamName ==
"sink-common-insts") {
1158 }
else if (ParamName ==
"speculate-unpredictables") {
1161 APInt BonusInstThreshold;
1164 formatv(
"invalid argument to SimplifyCFG pass bonus-threshold "
1172 formatv(
"invalid SimplifyCFG pass parameter '{}'", ParamName).str(),
1183 Result.setVerifyFixpoint(
true);
1184 while (!Params.
empty()) {
1186 std::tie(ParamName, Params) = Params.
split(
';');
1189 if (ParamName ==
"verify-fixpoint") {
1192 APInt MaxIterations;
1195 formatv(
"invalid argument to InstCombine pass max-iterations "
1203 formatv(
"invalid InstCombine pass parameter '{}'", ParamName).str(),
1213 while (!Params.
empty()) {
1215 std::tie(ParamName, Params) = Params.
split(
';');
1218 if (ParamName ==
"interleave-forced-only") {
1220 }
else if (ParamName ==
"vectorize-forced-only") {
1224 formatv(
"invalid LoopVectorize parameter '{}'", ParamName).str(),
1232 std::pair<bool, bool>
Result = {
false,
true};
1233 while (!Params.
empty()) {
1235 std::tie(ParamName, Params) = Params.
split(
';');
1238 if (ParamName ==
"nontrivial") {
1240 }
else if (ParamName ==
"trivial") {
1244 formatv(
"invalid LoopUnswitch pass parameter '{}'", ParamName).str(),
1253 while (!Params.
empty()) {
1255 std::tie(ParamName, Params) = Params.
split(
';');
1258 if (ParamName ==
"allowspeculation") {
1262 formatv(
"invalid LICM pass parameter '{}'", ParamName).str(),
1270 std::pair<bool, bool>
Result = {
true,
false};
1271 while (!Params.
empty()) {
1273 std::tie(ParamName, Params) = Params.
split(
';');
1276 if (ParamName ==
"header-duplication") {
1278 }
else if (ParamName ==
"prepare-for-lto") {
1282 formatv(
"invalid LoopRotate pass parameter '{}'", ParamName).str(),
1291 while (!Params.
empty()) {
1293 std::tie(ParamName, Params) = Params.
split(
';');
1296 if (ParamName ==
"split-footer-bb") {
1300 formatv(
"invalid MergedLoadStoreMotion pass parameter '{}'",
1311 while (!Params.
empty()) {
1313 std::tie(ParamName, Params) = Params.
split(
';');
1316 if (ParamName ==
"pre") {
1318 }
else if (ParamName ==
"load-pre") {
1320 }
else if (ParamName ==
"split-backedge-load-pre") {
1322 }
else if (ParamName ==
"memdep") {
1326 }
else if (ParamName ==
"memoryssa") {
1332 formatv(
"invalid GVN pass parameter '{}'", ParamName).str(),
1341 while (!Params.
empty()) {
1343 std::tie(ParamName, Params) = Params.
split(
';');
1346 if (ParamName ==
"func-spec")
1350 formatv(
"invalid IPSCCP pass parameter '{}'", ParamName).str(),
1358 while (!Params.
empty()) {
1360 std::tie(ParamName, Params) = Params.
split(
';');
1365 formatv(
"invalid argument to Scalarizer pass min-bits "
1376 if (ParamName ==
"load-store")
1378 else if (ParamName ==
"variable-insert-extract")
1382 formatv(
"invalid Scalarizer pass parameter '{}'", ParamName).str(),
1391 if (Params.
empty() || Params ==
"modify-cfg")
1393 if (Params ==
"preserve-cfg")
1396 formatv(
"invalid SROA pass parameter '{}' (either preserve-cfg or "
1397 "modify-cfg can be specified)",
1404parseStackLifetimeOptions(
StringRef Params) {
1406 while (!Params.
empty()) {
1408 std::tie(ParamName, Params) = Params.
split(
';');
1410 if (ParamName ==
"may") {
1412 }
else if (ParamName ==
"must") {
1416 formatv(
"invalid StackLifetime parameter '{}'", ParamName).str(),
1425 "DependenceAnalysisPrinter");
1430 "SeparateConstOffsetFromGEP");
1439parseFunctionSimplificationPipelineOptions(
StringRef Params) {
1443 formatv(
"invalid function-simplification parameter '{}'", Params).str(),
1451 "MemorySSAPrinterPass");
1456 "SpeculativeExecutionPass");
1461 while (!Params.
empty()) {
1463 std::tie(ParamName, Params) = Params.
split(
';');
1469 formatv(
"invalid MemProfUse pass parameter '{}'", ParamName).str(),
1477parseStructuralHashPrinterPassOptions(
StringRef Params) {
1480 if (Params ==
"detailed")
1482 if (Params ==
"call-target-ignored")
1485 formatv(
"invalid structural hash printer parameter '{}'", Params).str(),
1491 "WinEHPreparePass");
1496 while (!Params.
empty()) {
1498 std::tie(ParamName, Params) = Params.
split(
';');
1501 if (ParamName ==
"group-by-use")
1503 else if (ParamName ==
"ignore-single-use")
1505 else if (ParamName ==
"merge-const")
1507 else if (ParamName ==
"merge-const-aggressive")
1509 else if (ParamName ==
"merge-external")
1514 formatv(
"invalid GlobalMergePass parameter '{}'", ParamName).str(),
1518 formatv(
"invalid global-merge pass parameter '{}'", Params).str(),
1527 while (!Params.
empty()) {
1529 std::tie(ParamName, Params) = Params.
split(
';');
1535 formatv(
"invalid Internalize pass parameter '{}'", ParamName).str(),
1546 while (!Params.
empty()) {
1548 std::tie(ParamName, Params) = Params.
split(
';');
1551 std::optional<RegAllocFilterFunc>
Filter =
1555 formatv(
"invalid regallocfast register filter '{}'", ParamName)
1564 if (ParamName ==
"no-clear-vregs") {
1570 formatv(
"invalid regallocfast pass parameter '{}'", ParamName).str(),
1577parseBoundsCheckingOptions(
StringRef Params) {
1579 while (!Params.
empty()) {
1581 std::tie(ParamName, Params) = Params.
split(
';');
1582 if (ParamName ==
"trap") {
1584 }
else if (ParamName ==
"rt") {
1589 }
else if (ParamName ==
"rt-abort") {
1594 }
else if (ParamName ==
"min-rt") {
1599 }
else if (ParamName ==
"min-rt-abort") {
1604 }
else if (ParamName ==
"merge") {
1609 std::tie(ParamEQ, Val) = ParamName.
split(
'=');
1615 formatv(
"invalid BoundsChecking pass parameter '{}'", ParamName)
1632 if (!
Prefix.empty() || Digit.getAsInteger(10,
N))
1634 Param.str().c_str());
1637 if (!
Level.has_value())
1639 "invalid optimization level for expand-fp pass: %s",
1640 Digit.str().c_str());
1647 if (Params.
empty() || Params ==
"all")
1648 return RAGreedyPass::Options();
1652 return RAGreedyPass::Options{*
Filter, Params};
1655 formatv(
"invalid regallocgreedy register filter '{}'", Params).str(),
1661 "MachineSinkingPass");
1665 bool AllowTailMerge =
true;
1666 if (!Params.
empty()) {
1668 if (Params !=
"tail-merge")
1670 formatv(
"invalid MachineBlockPlacementPass parameter '{}'", Params)
1674 return AllowTailMerge;
1678 bool ClearVirtRegs =
true;
1679 if (!Params.
empty()) {
1681 if (Params !=
"clear-vregs")
1683 formatv(
"invalid VirtRegRewriter pass parameter '{}'", Params).str(),
1686 return ClearVirtRegs;
1689struct FatLTOOptions {
1690 OptimizationLevel OptLevel;
1691 bool ThinLTO =
false;
1692 bool EmitSummary =
false;
1697 bool HaveOptLevel =
false;
1698 while (!Params.
empty()) {
1700 std::tie(ParamName, Params) = Params.
split(
';');
1702 if (ParamName ==
"thinlto") {
1704 }
else if (ParamName ==
"emit-summary") {
1705 Result.EmitSummary =
true;
1706 }
else if (std::optional<OptimizationLevel> OptLevel =
1708 Result.OptLevel = *OptLevel;
1709 HaveOptLevel =
true;
1712 formatv(
"invalid fatlto-pre-link pass parameter '{}'", ParamName)
1719 "missing optimization level for fatlto-pre-link pipeline",
1734template <
typename PassManagerT,
typename CallbacksT>
1736 if (!Callbacks.empty()) {
1737 PassManagerT DummyPM;
1738 for (
auto &CB : Callbacks)
1739 if (CB(Name, DummyPM, {}))
1745template <
typename CallbacksT>
1747 StringRef NameNoBracket = Name.take_until([](
char C) {
return C ==
'<'; });
1750 if (Name ==
"module")
1752 if (Name ==
"cgscc")
1754 if (NameNoBracket ==
"function")
1756 if (Name ==
"coro-cond")
1759#define MODULE_PASS(NAME, CREATE_PASS) \
1762#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1763 if (PassBuilder::checkParametrizedPassName(Name, NAME)) \
1765#define MODULE_ANALYSIS(NAME, CREATE_PASS) \
1766 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \
1768#include "PassRegistry.def"
1773template <
typename CallbacksT>
1776 StringRef NameNoBracket = Name.take_until([](
char C) {
return C ==
'<'; });
1777 if (Name ==
"cgscc")
1779 if (NameNoBracket ==
"function")
1786#define CGSCC_PASS(NAME, CREATE_PASS) \
1789#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1790 if (PassBuilder::checkParametrizedPassName(Name, NAME)) \
1792#define CGSCC_ANALYSIS(NAME, CREATE_PASS) \
1793 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \
1795#include "PassRegistry.def"
1800template <
typename CallbacksT>
1803 StringRef NameNoBracket = Name.take_until([](
char C) {
return C ==
'<'; });
1804 if (NameNoBracket ==
"function")
1806 if (Name ==
"loop" || Name ==
"loop-mssa" || Name ==
"machine-function")
1809#define FUNCTION_PASS(NAME, CREATE_PASS) \
1812#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1813 if (PassBuilder::checkParametrizedPassName(Name, NAME)) \
1815#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
1816 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \
1818#include "PassRegistry.def"
1823template <
typename CallbacksT>
1826 if (Name ==
"machine-function")
1829#define MACHINE_FUNCTION_PASS(NAME, CREATE_PASS) \
1832#define MACHINE_FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, \
1834 if (PassBuilder::checkParametrizedPassName(Name, NAME)) \
1837#define MACHINE_FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
1838 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \
1841#include "llvm/Passes/MachinePassRegistry.def"
1846template <
typename CallbacksT>
1848 bool &UseMemorySSA) {
1849 UseMemorySSA =
false;
1852 UseMemorySSA =
true;
1856#define LOOPNEST_PASS(NAME, CREATE_PASS) \
1859#include "PassRegistry.def"
1864template <
typename CallbacksT>
1866 bool &UseMemorySSA) {
1867 UseMemorySSA =
false;
1870 UseMemorySSA =
true;
1874#define LOOP_PASS(NAME, CREATE_PASS) \
1877#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1878 if (PassBuilder::checkParametrizedPassName(Name, NAME)) \
1880#define LOOP_ANALYSIS(NAME, CREATE_PASS) \
1881 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \
1883#include "PassRegistry.def"
1888std::optional<std::vector<PassBuilder::PipelineElement>>
1889PassBuilder::parsePipelineText(
StringRef Text) {
1890 std::vector<PipelineElement> ResultPipeline;
1895 std::vector<PipelineElement> &Pipeline = *PipelineStack.
back();
1896 size_t Pos =
Text.find_first_of(
",()");
1897 Pipeline.push_back({
Text.substr(0, Pos), {}});
1900 if (Pos ==
Text.npos)
1903 char Sep =
Text[Pos];
1911 PipelineStack.
push_back(&Pipeline.back().InnerPipeline);
1915 assert(Sep ==
')' &&
"Bogus separator!");
1920 if (PipelineStack.
size() == 1)
1921 return std::nullopt;
1924 }
while (
Text.consume_front(
")"));
1932 if (!
Text.consume_front(
","))
1933 return std::nullopt;
1936 if (PipelineStack.
size() > 1)
1938 return std::nullopt;
1940 assert(PipelineStack.
back() == &ResultPipeline &&
1941 "Wrong pipeline at the bottom of the stack!");
1942 return {std::move(ResultPipeline)};
1955 const PipelineElement &
E) {
1956 auto &
Name =
E.Name;
1957 auto &InnerPipeline =
E.InnerPipeline;
1960 if (!InnerPipeline.empty()) {
1961 if (Name ==
"module") {
1963 if (
auto Err = parseModulePassPipeline(NestedMPM, InnerPipeline))
1965 MPM.
addPass(std::move(NestedMPM));
1968 if (Name ==
"coro-cond") {
1970 if (
auto Err = parseModulePassPipeline(NestedMPM, InnerPipeline))
1972 MPM.
addPass(CoroConditionalWrapper(std::move(NestedMPM)));
1975 if (Name ==
"cgscc") {
1977 if (
auto Err = parseCGSCCPassPipeline(CGPM, InnerPipeline))
1985 "cannot have a no-rerun module to function adaptor",
1988 if (
auto Err = parseFunctionPassPipeline(FPM, InnerPipeline))
1995 for (
auto &
C : ModulePipelineParsingCallbacks)
1996 if (
C(Name, MPM, InnerPipeline))
2001 formatv(
"invalid use of '{}' pass as module pipeline", Name).str(),
2007#define MODULE_PASS(NAME, CREATE_PASS) \
2008 if (Name == NAME) { \
2009 MPM.addPass(CREATE_PASS); \
2010 return Error::success(); \
2012#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2013 if (checkParametrizedPassName(Name, NAME)) { \
2014 auto Params = parsePassParameters(PARSER, Name, NAME); \
2016 return Params.takeError(); \
2017 MPM.addPass(CREATE_PASS(Params.get())); \
2018 return Error::success(); \
2020#define MODULE_ANALYSIS(NAME, CREATE_PASS) \
2021 if (Name == "require<" NAME ">") { \
2023 RequireAnalysisPass< \
2024 std::remove_reference_t<decltype(CREATE_PASS)>, Module>()); \
2025 return Error::success(); \
2027 if (Name == "invalidate<" NAME ">") { \
2028 MPM.addPass(InvalidateAnalysisPass< \
2029 std::remove_reference_t<decltype(CREATE_PASS)>>()); \
2030 return Error::success(); \
2032#define CGSCC_PASS(NAME, CREATE_PASS) \
2033 if (Name == NAME) { \
2034 MPM.addPass(createModuleToPostOrderCGSCCPassAdaptor(CREATE_PASS)); \
2035 return Error::success(); \
2037#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2038 if (checkParametrizedPassName(Name, NAME)) { \
2039 auto Params = parsePassParameters(PARSER, Name, NAME); \
2041 return Params.takeError(); \
2043 createModuleToPostOrderCGSCCPassAdaptor(CREATE_PASS(Params.get()))); \
2044 return Error::success(); \
2046#define FUNCTION_PASS(NAME, CREATE_PASS) \
2047 if (Name == NAME) { \
2048 if constexpr (std::is_constructible_v< \
2049 std::remove_reference_t<decltype(CREATE_PASS)>, \
2050 const TargetMachine &>) { \
2052 return make_error<StringError>( \
2053 formatv("pass '{0}' requires TargetMachine", Name).str(), \
2054 inconvertibleErrorCode()); \
2056 MPM.addPass(createModuleToFunctionPassAdaptor(CREATE_PASS)); \
2057 return Error::success(); \
2059#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2060 if (checkParametrizedPassName(Name, NAME)) { \
2061 auto Params = parsePassParameters(PARSER, Name, NAME); \
2063 return Params.takeError(); \
2064 auto CreatePass = CREATE_PASS; \
2065 if constexpr (std::is_constructible_v< \
2066 std::remove_reference_t<decltype(CreatePass( \
2068 const TargetMachine &, \
2069 std::remove_reference_t<decltype(Params.get())>>) { \
2071 return make_error<StringError>( \
2072 formatv("pass '{0}' requires TargetMachine", Name).str(), \
2073 inconvertibleErrorCode()); \
2076 MPM.addPass(createModuleToFunctionPassAdaptor(CREATE_PASS(Params.get()))); \
2077 return Error::success(); \
2079#define LOOPNEST_PASS(NAME, CREATE_PASS) \
2080 if (Name == NAME) { \
2081 MPM.addPass(createModuleToFunctionPassAdaptor( \
2082 createFunctionToLoopPassAdaptor(CREATE_PASS, false))); \
2083 return Error::success(); \
2085#define LOOP_PASS(NAME, CREATE_PASS) \
2086 if (Name == NAME) { \
2087 MPM.addPass(createModuleToFunctionPassAdaptor( \
2088 createFunctionToLoopPassAdaptor(CREATE_PASS, false))); \
2089 return Error::success(); \
2091#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2092 if (checkParametrizedPassName(Name, NAME)) { \
2093 auto Params = parsePassParameters(PARSER, Name, NAME); \
2095 return Params.takeError(); \
2096 MPM.addPass(createModuleToFunctionPassAdaptor( \
2097 createFunctionToLoopPassAdaptor(CREATE_PASS(Params.get()), false))); \
2098 return Error::success(); \
2100#include "PassRegistry.def"
2102 for (
auto &
C : ModulePipelineParsingCallbacks)
2103 if (
C(Name, MPM, InnerPipeline))
2106 formatv(
"unknown module pass '{}'", Name).str(),
2111 const PipelineElement &
E) {
2112 auto &
Name =
E.Name;
2113 auto &InnerPipeline =
E.InnerPipeline;
2116 if (!InnerPipeline.empty()) {
2117 if (Name ==
"cgscc") {
2119 if (
auto Err = parseCGSCCPassPipeline(NestedCGPM, InnerPipeline))
2122 CGPM.
addPass(std::move(NestedCGPM));
2127 if (
auto Err = parseFunctionPassPipeline(FPM, InnerPipeline))
2131 std::move(FPM), Params->first, Params->second));
2136 if (
auto Err = parseCGSCCPassPipeline(NestedCGPM, InnerPipeline))
2143 for (
auto &
C : CGSCCPipelineParsingCallbacks)
2144 if (
C(Name, CGPM, InnerPipeline))
2149 formatv(
"invalid use of '{}' pass as cgscc pipeline", Name).str(),
2154#define CGSCC_PASS(NAME, CREATE_PASS) \
2155 if (Name == NAME) { \
2156 CGPM.addPass(CREATE_PASS); \
2157 return Error::success(); \
2159#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2160 if (checkParametrizedPassName(Name, NAME)) { \
2161 auto Params = parsePassParameters(PARSER, Name, NAME); \
2163 return Params.takeError(); \
2164 CGPM.addPass(CREATE_PASS(Params.get())); \
2165 return Error::success(); \
2167#define CGSCC_ANALYSIS(NAME, CREATE_PASS) \
2168 if (Name == "require<" NAME ">") { \
2169 CGPM.addPass(RequireAnalysisPass< \
2170 std::remove_reference_t<decltype(CREATE_PASS)>, \
2171 LazyCallGraph::SCC, CGSCCAnalysisManager, LazyCallGraph &, \
2172 CGSCCUpdateResult &>()); \
2173 return Error::success(); \
2175 if (Name == "invalidate<" NAME ">") { \
2176 CGPM.addPass(InvalidateAnalysisPass< \
2177 std::remove_reference_t<decltype(CREATE_PASS)>>()); \
2178 return Error::success(); \
2180#define FUNCTION_PASS(NAME, CREATE_PASS) \
2181 if (Name == NAME) { \
2182 if constexpr (std::is_constructible_v< \
2183 std::remove_reference_t<decltype(CREATE_PASS)>, \
2184 const TargetMachine &>) { \
2186 return make_error<StringError>( \
2187 formatv("pass '{0}' requires TargetMachine", Name).str(), \
2188 inconvertibleErrorCode()); \
2190 CGPM.addPass(createCGSCCToFunctionPassAdaptor(CREATE_PASS)); \
2191 return Error::success(); \
2193#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2194 if (checkParametrizedPassName(Name, NAME)) { \
2195 auto Params = parsePassParameters(PARSER, Name, NAME); \
2197 return Params.takeError(); \
2198 auto CreatePass = CREATE_PASS; \
2199 if constexpr (std::is_constructible_v< \
2200 std::remove_reference_t<decltype(CreatePass( \
2202 const TargetMachine &, \
2203 std::remove_reference_t<decltype(Params.get())>>) { \
2205 return make_error<StringError>( \
2206 formatv("pass '{0}' requires TargetMachine", Name).str(), \
2207 inconvertibleErrorCode()); \
2210 CGPM.addPass(createCGSCCToFunctionPassAdaptor(CREATE_PASS(Params.get()))); \
2211 return Error::success(); \
2213#define LOOPNEST_PASS(NAME, CREATE_PASS) \
2214 if (Name == NAME) { \
2215 CGPM.addPass(createCGSCCToFunctionPassAdaptor( \
2216 createFunctionToLoopPassAdaptor(CREATE_PASS, false))); \
2217 return Error::success(); \
2219#define LOOP_PASS(NAME, CREATE_PASS) \
2220 if (Name == NAME) { \
2221 CGPM.addPass(createCGSCCToFunctionPassAdaptor( \
2222 createFunctionToLoopPassAdaptor(CREATE_PASS, false))); \
2223 return Error::success(); \
2225#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2226 if (checkParametrizedPassName(Name, NAME)) { \
2227 auto Params = parsePassParameters(PARSER, Name, NAME); \
2229 return Params.takeError(); \
2230 CGPM.addPass(createCGSCCToFunctionPassAdaptor( \
2231 createFunctionToLoopPassAdaptor(CREATE_PASS(Params.get()), false))); \
2232 return Error::success(); \
2234#include "PassRegistry.def"
2236 for (
auto &
C : CGSCCPipelineParsingCallbacks)
2237 if (
C(Name, CGPM, InnerPipeline))
2244 const PipelineElement &
E) {
2245 auto &
Name =
E.Name;
2246 auto &InnerPipeline =
E.InnerPipeline;
2249 if (!InnerPipeline.empty()) {
2250 if (Name ==
"function") {
2252 if (
auto Err = parseFunctionPassPipeline(NestedFPM, InnerPipeline))
2255 FPM.
addPass(std::move(NestedFPM));
2258 if (Name ==
"loop" || Name ==
"loop-mssa") {
2260 if (
auto Err = parseLoopPassPipeline(LPM, InnerPipeline))
2263 bool UseMemorySSA = (
Name ==
"loop-mssa");
2268 if (Name ==
"machine-function") {
2270 if (
auto Err = parseMachinePassPipeline(MFPM, InnerPipeline))
2276 for (
auto &
C : FunctionPipelineParsingCallbacks)
2277 if (
C(Name, FPM, InnerPipeline))
2282 formatv(
"invalid use of '{}' pass as function pipeline", Name).str(),
2287#define FUNCTION_PASS(NAME, CREATE_PASS) \
2288 if (Name == NAME) { \
2289 if constexpr (std::is_constructible_v< \
2290 std::remove_reference_t<decltype(CREATE_PASS)>, \
2291 const TargetMachine &>) { \
2293 return make_error<StringError>( \
2294 formatv("pass '{0}' requires TargetMachine", Name).str(), \
2295 inconvertibleErrorCode()); \
2297 FPM.addPass(CREATE_PASS); \
2298 return Error::success(); \
2300#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2301 if (checkParametrizedPassName(Name, NAME)) { \
2302 auto Params = parsePassParameters(PARSER, Name, NAME); \
2304 return Params.takeError(); \
2305 auto CreatePass = CREATE_PASS; \
2306 if constexpr (std::is_constructible_v< \
2307 std::remove_reference_t<decltype(CreatePass( \
2309 const TargetMachine &, \
2310 std::remove_reference_t<decltype(Params.get())>>) { \
2312 return make_error<StringError>( \
2313 formatv("pass '{0}' requires TargetMachine", Name).str(), \
2314 inconvertibleErrorCode()); \
2317 FPM.addPass(CREATE_PASS(Params.get())); \
2318 return Error::success(); \
2320#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
2321 if (Name == "require<" NAME ">") { \
2322 if constexpr (std::is_constructible_v< \
2323 std::remove_reference_t<decltype(CREATE_PASS)>, \
2324 const TargetMachine &>) { \
2326 return make_error<StringError>( \
2327 formatv("pass '{0}' requires TargetMachine", Name).str(), \
2328 inconvertibleErrorCode()); \
2331 RequireAnalysisPass<std::remove_reference_t<decltype(CREATE_PASS)>, \
2333 return Error::success(); \
2335 if (Name == "invalidate<" NAME ">") { \
2336 FPM.addPass(InvalidateAnalysisPass< \
2337 std::remove_reference_t<decltype(CREATE_PASS)>>()); \
2338 return Error::success(); \
2344#define LOOPNEST_PASS(NAME, CREATE_PASS) \
2345 if (Name == NAME) { \
2346 FPM.addPass(createFunctionToLoopPassAdaptor(CREATE_PASS, false)); \
2347 return Error::success(); \
2349#define LOOP_PASS(NAME, CREATE_PASS) \
2350 if (Name == NAME) { \
2351 FPM.addPass(createFunctionToLoopPassAdaptor(CREATE_PASS, false)); \
2352 return Error::success(); \
2354#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2355 if (checkParametrizedPassName(Name, NAME)) { \
2356 auto Params = parsePassParameters(PARSER, Name, NAME); \
2358 return Params.takeError(); \
2360 createFunctionToLoopPassAdaptor(CREATE_PASS(Params.get()), false)); \
2361 return Error::success(); \
2363#include "PassRegistry.def"
2365 for (
auto &
C : FunctionPipelineParsingCallbacks)
2366 if (
C(Name, FPM, InnerPipeline))
2369 formatv(
"unknown function pass '{}'", Name).str(),
2374 const PipelineElement &
E) {
2375 StringRef
Name =
E.Name;
2376 auto &InnerPipeline =
E.InnerPipeline;
2379 if (!InnerPipeline.empty()) {
2380 if (Name ==
"loop") {
2382 if (
auto Err = parseLoopPassPipeline(NestedLPM, InnerPipeline))
2385 LPM.addPass(std::move(NestedLPM));
2389 for (
auto &
C : LoopPipelineParsingCallbacks)
2390 if (
C(Name, LPM, InnerPipeline))
2395 formatv(
"invalid use of '{}' pass as loop pipeline", Name).str(),
2400#define LOOPNEST_PASS(NAME, CREATE_PASS) \
2401 if (Name == NAME) { \
2402 LPM.addPass(CREATE_PASS); \
2403 return Error::success(); \
2405#define LOOP_PASS(NAME, CREATE_PASS) \
2406 if (Name == NAME) { \
2407 LPM.addPass(CREATE_PASS); \
2408 return Error::success(); \
2410#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2411 if (checkParametrizedPassName(Name, NAME)) { \
2412 auto Params = parsePassParameters(PARSER, Name, NAME); \
2414 return Params.takeError(); \
2415 LPM.addPass(CREATE_PASS(Params.get())); \
2416 return Error::success(); \
2418#define LOOP_ANALYSIS(NAME, CREATE_PASS) \
2419 if (Name == "require<" NAME ">") { \
2420 LPM.addPass(RequireAnalysisPass< \
2421 std::remove_reference_t<decltype(CREATE_PASS)>, Loop, \
2422 LoopAnalysisManager, LoopStandardAnalysisResults &, \
2424 return Error::success(); \
2426 if (Name == "invalidate<" NAME ">") { \
2427 LPM.addPass(InvalidateAnalysisPass< \
2428 std::remove_reference_t<decltype(CREATE_PASS)>>()); \
2429 return Error::success(); \
2431#include "PassRegistry.def"
2433 for (
auto &
C : LoopPipelineParsingCallbacks)
2434 if (
C(Name, LPM, InnerPipeline))
2441 const PipelineElement &
E) {
2442 StringRef
Name =
E.Name;
2444 if (!
E.InnerPipeline.empty()) {
2445 if (
E.Name ==
"machine-function") {
2447 if (
auto Err = parseMachinePassPipeline(NestedPM,
E.InnerPipeline))
2449 MFPM.
addPass(std::move(NestedPM));
2456#define MACHINE_MODULE_PASS(NAME, CREATE_PASS) \
2457 if (Name == NAME) { \
2458 MFPM.addPass(CREATE_PASS); \
2459 return Error::success(); \
2461#define MACHINE_FUNCTION_PASS(NAME, CREATE_PASS) \
2462 if (Name == NAME) { \
2463 MFPM.addPass(CREATE_PASS); \
2464 return Error::success(); \
2466#define MACHINE_FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, \
2468 if (checkParametrizedPassName(Name, NAME)) { \
2469 auto Params = parsePassParameters(PARSER, Name, NAME); \
2471 return Params.takeError(); \
2472 MFPM.addPass(CREATE_PASS(Params.get())); \
2473 return Error::success(); \
2475#define MACHINE_FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
2476 if (Name == "require<" NAME ">") { \
2478 RequireAnalysisPass<std::remove_reference_t<decltype(CREATE_PASS)>, \
2479 MachineFunction>()); \
2480 return Error::success(); \
2482 if (Name == "invalidate<" NAME ">") { \
2483 MFPM.addPass(InvalidateAnalysisPass< \
2484 std::remove_reference_t<decltype(CREATE_PASS)>>()); \
2485 return Error::success(); \
2487#include "llvm/Passes/MachinePassRegistry.def"
2489 for (
auto &
C : MachineFunctionPipelineParsingCallbacks)
2490 if (
C(Name, MFPM,
E.InnerPipeline))
2493 formatv(
"unknown machine pass '{}'", Name).str(),
2498#define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS) \
2499 if (Name == NAME) { \
2500 AA.registerModuleAnalysis< \
2501 std::remove_reference_t<decltype(CREATE_PASS)>>(); \
2504#define FUNCTION_ALIAS_ANALYSIS(NAME, CREATE_PASS) \
2505 if (Name == NAME) { \
2506 AA.registerFunctionAnalysis< \
2507 std::remove_reference_t<decltype(CREATE_PASS)>>(); \
2510#include "PassRegistry.def"
2512 for (
auto &
C : AAParsingCallbacks)
2518Error PassBuilder::parseMachinePassPipeline(
2520 for (
const auto &Element : Pipeline) {
2521 if (
auto Err = parseMachinePass(MFPM, Element))
2529 for (
const auto &Element : Pipeline) {
2530 if (
auto Err = parseLoopPass(LPM, Element))
2536Error PassBuilder::parseFunctionPassPipeline(
2538 for (
const auto &Element : Pipeline) {
2539 if (
auto Err = parseFunctionPass(FPM, Element))
2547 for (
const auto &Element : Pipeline) {
2548 if (
auto Err = parseCGSCCPass(CGPM, Element))
2580 for (
const auto &Element : Pipeline) {
2581 if (
auto Err = parseModulePass(MPM, Element))
2592 auto Pipeline = parsePipelineText(PipelineText);
2593 if (!Pipeline || Pipeline->empty())
2595 formatv(
"invalid pipeline '{}'", PipelineText).str(),
2605 Pipeline = {{
"cgscc", std::move(*Pipeline)}};
2607 FunctionPipelineParsingCallbacks)) {
2608 Pipeline = {{
"function", std::move(*Pipeline)}};
2611 Pipeline = {{
"function", {{UseMemorySSA ?
"loop-mssa" :
"loop",
2612 std::move(*Pipeline)}}}};
2613 }
else if (
isLoopPassName(FirstName, LoopPipelineParsingCallbacks,
2615 Pipeline = {{
"function", {{UseMemorySSA ?
"loop-mssa" :
"loop",
2616 std::move(*Pipeline)}}}};
2618 FirstName, MachineFunctionPipelineParsingCallbacks)) {
2619 Pipeline = {{
"function", {{
"machine-function", std::move(*Pipeline)}}}};
2621 for (
auto &
C : TopLevelPipelineParsingCallbacks)
2622 if (
C(MPM, *Pipeline))
2626 auto &InnerPipeline = Pipeline->front().InnerPipeline;
2628 formatv(
"unknown {} name '{}'",
2629 (InnerPipeline.empty() ?
"pass" :
"pipeline"), FirstName)
2635 if (
auto Err = parseModulePassPipeline(MPM, *Pipeline))
2643 auto Pipeline = parsePipelineText(PipelineText);
2644 if (!Pipeline || Pipeline->empty())
2646 formatv(
"invalid pipeline '{}'", PipelineText).str(),
2652 formatv(
"unknown cgscc pass '{}' in pipeline '{}'", FirstName,
2657 if (
auto Err = parseCGSCCPassPipeline(CGPM, *Pipeline))
2666 auto Pipeline = parsePipelineText(PipelineText);
2667 if (!Pipeline || Pipeline->empty())
2669 formatv(
"invalid pipeline '{}'", PipelineText).str(),
2675 formatv(
"unknown function pass '{}' in pipeline '{}'", FirstName,
2680 if (
auto Err = parseFunctionPassPipeline(FPM, *Pipeline))
2688 auto Pipeline = parsePipelineText(PipelineText);
2689 if (!Pipeline || Pipeline->empty())
2691 formatv(
"invalid pipeline '{}'", PipelineText).str(),
2694 if (
auto Err = parseLoopPassPipeline(CGPM, *Pipeline))
2702 auto Pipeline = parsePipelineText(PipelineText);
2703 if (!Pipeline || Pipeline->empty())
2705 formatv(
"invalid machine pass pipeline '{}'", PipelineText).str(),
2708 if (
auto Err = parseMachinePassPipeline(MFPM, *Pipeline))
2717 if (PipelineText ==
"default") {
2722 while (!PipelineText.
empty()) {
2724 std::tie(Name, PipelineText) = PipelineText.
split(
',');
2725 if (!parseAAPassName(
AA, Name))
2727 formatv(
"unknown alias analysis name '{}'", Name).str(),
2734std::optional<RegAllocFilterFunc>
2736 if (FilterName ==
"all")
2738 for (
auto &
C : RegClassFilterParsingCallbacks)
2739 if (
auto F =
C(FilterName))
2741 return std::nullopt;
2749 OS <<
" " <<
PassName <<
"<" << Params <<
">\n";
2755 OS <<
"Module passes:\n";
2756#define MODULE_PASS(NAME, CREATE_PASS) printPassName(NAME, OS);
2757#include "PassRegistry.def"
2759 OS <<
"Module passes with params:\n";
2760#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2761 printPassName(NAME, PARAMS, OS);
2762#include "PassRegistry.def"
2764 OS <<
"Module analyses:\n";
2765#define MODULE_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
2766#include "PassRegistry.def"
2768 OS <<
"Module alias analyses:\n";
2769#define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
2770#include "PassRegistry.def"
2772 OS <<
"CGSCC passes:\n";
2773#define CGSCC_PASS(NAME, CREATE_PASS) printPassName(NAME, OS);
2774#include "PassRegistry.def"
2776 OS <<
"CGSCC passes with params:\n";
2777#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2778 printPassName(NAME, PARAMS, OS);
2779#include "PassRegistry.def"
2781 OS <<
"CGSCC analyses:\n";
2782#define CGSCC_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
2783#include "PassRegistry.def"
2785 OS <<
"Function passes:\n";
2786#define FUNCTION_PASS(NAME, CREATE_PASS) printPassName(NAME, OS);
2787#include "PassRegistry.def"
2789 OS <<
"Function passes with params:\n";
2790#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2791 printPassName(NAME, PARAMS, OS);
2792#include "PassRegistry.def"
2794 OS <<
"Function analyses:\n";
2795#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
2796#include "PassRegistry.def"
2798 OS <<
"Function alias analyses:\n";
2799#define FUNCTION_ALIAS_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
2800#include "PassRegistry.def"
2802 OS <<
"LoopNest passes:\n";
2803#define LOOPNEST_PASS(NAME, CREATE_PASS) printPassName(NAME, OS);
2804#include "PassRegistry.def"
2806 OS <<
"Loop passes:\n";
2807#define LOOP_PASS(NAME, CREATE_PASS) printPassName(NAME, OS);
2808#include "PassRegistry.def"
2810 OS <<
"Loop passes with params:\n";
2811#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2812 printPassName(NAME, PARAMS, OS);
2813#include "PassRegistry.def"
2815 OS <<
"Loop analyses:\n";
2816#define LOOP_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
2817#include "PassRegistry.def"
2819 OS <<
"Machine module passes (WIP):\n";
2820#define MACHINE_MODULE_PASS(NAME, CREATE_PASS) printPassName(NAME, OS);
2821#include "llvm/Passes/MachinePassRegistry.def"
2823 OS <<
"Machine function passes (WIP):\n";
2824#define MACHINE_FUNCTION_PASS(NAME, CREATE_PASS) printPassName(NAME, OS);
2825#include "llvm/Passes/MachinePassRegistry.def"
2827 OS <<
"Machine function analyses (WIP):\n";
2828#define MACHINE_FUNCTION_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
2829#include "llvm/Passes/MachinePassRegistry.def"
2835 TopLevelPipelineParsingCallbacks.push_back(
C);
unsigned const MachineRegisterInfo * MRI
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
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 ...
Defines an IR pass for CodeGen Prepare.
This file declares an analysis pass that computes CycleInfo for LLVM IR, specialized from GenericCycl...
Analysis that tracks defined/used subregister lanes across COPY instructions and instructions that ge...
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.
Provides analysis for querying information about KnownBits during GISel passes.
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 the IR2Vec vocabulary analysis(IR2VecVocabAnalysis), the core ir2vec::Embedder inte...
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.
Machine Check Debug Module
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
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 isLoopNestPassName(StringRef Name, CallbacksT &Callbacks, bool &UseMemorySSA)
static bool isMachineFunctionPassName(StringRef Name, CallbacksT &Callbacks)
static Expected< OptimizationLevel > parseOptLevelParam(StringRef S)
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 void setupOptionsForPipelineAlias(PipelineTuningOptions &PTO, OptimizationLevel L)
This file implements the PredicateInfo analysis, which creates an Extended SSA form for operations us...
static cl::opt< RegAllocEvictionAdvisorAnalysisLegacy::AdvisorMode > Mode("regalloc-enable-advisor", cl::Hidden, cl::init(RegAllocEvictionAdvisorAnalysisLegacy::AdvisorMode::Default), cl::desc("Enable regalloc advisor mode"), cl::values(clEnumValN(RegAllocEvictionAdvisorAnalysisLegacy::AdvisorMode::Default, "default", "Default"), clEnumValN(RegAllocEvictionAdvisorAnalysisLegacy::AdvisorMode::Release, "release", "precompiled"), clEnumValN(RegAllocEvictionAdvisorAnalysisLegacy::AdvisorMode::Development, "development", "for training")))
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...
This file provides the interface for LLVM's Scalar Replacement of Aggregates pass.
This file provides the interface for the pseudo probe implementation for AutoFDO.
This file provides the interface for the sampled PGO loader pass.
This is the interface for a SCEV-based alias analysis.
This pass converts vector operations into scalar operations (or, optionally, operations on smaller ve...
This is the interface for a metadata-based scoped no-alias analysis.
This file contains the declaration of the SelectOptimizePass class, its corresponding pass name is se...
This file provides the interface for the pass responsible for both simplifying and canonicalizing the...
This file implements the StringSwitch template, which mimics a switch() statement whose cases are str...
Target-Independent Code Generator Pass Configuration Options pass.
This is the interface for a metadata-based TBAA.
static const char PassName[]
A manager for alias analyses.
Class for arbitrary precision integers.
uint64_t getZExtValue() const
Get zero extended value.
int64_t getSExtValue() const
Get sign extended value.
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),...
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 LLVM_ABI 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...
A smart pointer to a reference-counted object that inherits from RefCountedBase or ThreadSafeRefCount...
static constexpr LLT scalar(unsigned SizeInBits)
Get a low-level scalar or aggregate "bag of bits".
MachineRegisterInfo & getRegInfo()
getRegInfo - Return information about the registers currently in use.
const MachineFunctionProperties & getProperties() const
Get the function properties.
static LLVM_ABI const OptimizationLevel O3
Optimize for fast execution as much as possible.
static LLVM_ABI const OptimizationLevel Oz
A very specialized mode that will optimize for code size at any and all costs.
static LLVM_ABI const OptimizationLevel O0
Disable as many optimizations as possible.
static LLVM_ABI const OptimizationLevel Os
Similar to O2 but tries to optimize for small code size instead of fast execution without triggering ...
static LLVM_ABI const OptimizationLevel O2
Optimize for fast execution as much as possible without triggering significant incremental compile ti...
static LLVM_ABI const OptimizationLevel O1
Optimize quickly without destroying debuggability.
This class provides access to building LLVM's passes.
LLVM_ABI void printPassNames(raw_ostream &OS)
Print pass names.
static bool checkParametrizedPassName(StringRef Name, StringRef PassName)
LLVM_ABI AAManager buildDefaultAAPipeline()
Build the default AAManager with the default alias analysis pipeline registered.
LLVM_ABI Error parseAAPipeline(AAManager &AA, StringRef PipelineText)
Parse a textual alias analysis pipeline into the provided AA manager.
LLVM_ABI void registerLoopAnalyses(LoopAnalysisManager &LAM)
Registers all available loop analysis passes.
LLVM_ABI std::optional< RegAllocFilterFunc > parseRegAllocFilter(StringRef RegAllocFilterName)
Parse RegAllocFilterName to get RegAllocFilterFunc.
LLVM_ABI void crossRegisterProxies(LoopAnalysisManager &LAM, FunctionAnalysisManager &FAM, CGSCCAnalysisManager &CGAM, ModuleAnalysisManager &MAM, MachineFunctionAnalysisManager *MFAM=nullptr)
Cross register the analysis managers through their proxies.
LLVM_ABI PassBuilder(TargetMachine *TM=nullptr, PipelineTuningOptions PTO=PipelineTuningOptions(), std::optional< PGOOptions > PGOOpt=std::nullopt, PassInstrumentationCallbacks *PIC=nullptr, IntrusiveRefCntPtr< vfs::FileSystem > FS=vfs::getRealFileSystem())
LLVM_ABI Error parsePassPipeline(ModulePassManager &MPM, StringRef PipelineText)
Parse a textual pass pipeline description into a ModulePassManager.
void registerPipelineParsingCallback(const std::function< bool(StringRef Name, CGSCCPassManager &, ArrayRef< PipelineElement >)> &C)
{{@ Register pipeline parsing callbacks with this pass builder instance.
LLVM_ABI void registerModuleAnalyses(ModuleAnalysisManager &MAM)
Registers all available module analysis passes.
LLVM_ABI void registerCGSCCAnalyses(CGSCCAnalysisManager &CGAM)
Registers all available CGSCC analysis passes.
static LLVM_ABI Expected< bool > parseSinglePassOption(StringRef Params, StringRef OptionName, StringRef PassName)
Handle passes only accept one bool-valued parameter.
LLVM_ABI void registerMachineFunctionAnalyses(MachineFunctionAnalysisManager &MFAM)
Registers all available machine function analysis passes.
LLVM_ABI void registerParseTopLevelPipelineCallback(const std::function< bool(ModulePassManager &, ArrayRef< PipelineElement >)> &C)
Register a callback for a top-level pipeline entry.
LLVM_ABI 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<!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 PreservedAnalyses none()
Convenience factory function for the empty preserved set.
static PreservedAnalyses all()
Construct a special preserved set that preserves all passes.
void push_back(const T &Elt)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
StringRef - Represent a constant reference to a string, i.e.
std::pair< StringRef, StringRef > split(char Separator) const
Split into two substrings around the first occurrence of a separator character.
bool getAsInteger(unsigned Radix, T &Result) const
Parse the current string as an integer of the specified radix.
std::string str() const
str - Get the contents as an std::string.
bool starts_with(StringRef Prefix) const
Check if this string starts with the given Prefix.
constexpr bool empty() const
empty - Check if the string is empty.
char front() const
front - Get the first character in the string.
bool consume_front(StringRef Prefix)
Returns true if this StringRef has the given prefix and removes that prefix.
A switch()-like statement whose cases are string literals.
StringSwitch & Case(StringLiteral S, T Value)
Primary interface to the complete machine description for the target machine.
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,...
Abstract Attribute helper functions.
@ C
The default llvm calling convention, compatible with C.
std::optional< CodeGenOptLevel > getLevel(int OL)
Get the Level identified by the integer OL.
@ BasicBlock
Various leaf nodes.
PointerTypeMap run(const Module &M)
Compute the PointerTypeMap for the module M.
This is an optimization pass for GlobalISel generic memory operations.
OuterAnalysisManagerProxy< CGSCCAnalysisManager, Function > CGSCCAnalysisManagerFunctionProxy
A proxy from a CGSCCAnalysisManager to a Function.
OuterAnalysisManagerProxy< ModuleAnalysisManager, MachineFunction > ModuleAnalysisManagerMachineFunctionProxy
Provide the ModuleAnalysisManager to Function proxy.
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.
OuterAnalysisManagerProxy< ModuleAnalysisManager, Function > ModuleAnalysisManagerFunctionProxy
Provide the ModuleAnalysisManager to Function proxy.
LLVM_ABI std::error_code inconvertibleErrorCode()
The value returned by this function can be returned from convertToErrorCode for Error values where no...
InnerAnalysisManagerProxy< FunctionAnalysisManager, Module > FunctionAnalysisManagerModuleProxy
Provide the FunctionAnalysisManager to Module proxy.
InnerAnalysisManagerProxy< LoopAnalysisManager, Function > LoopAnalysisManagerFunctionProxy
A proxy from a LoopAnalysisManager to a Function.
AnalysisManager< MachineFunction > MachineFunctionAnalysisManager
Error createStringError(std::error_code EC, char const *Fmt, const Ts &... Vals)
Create formatted StringError object.
PassManager< LazyCallGraph::SCC, CGSCCAnalysisManager, LazyCallGraph &, CGSCCUpdateResult & > CGSCCPassManager
The CGSCC pass manager.
AnalysisManager< LazyCallGraph::SCC, LazyCallGraph & > CGSCCAnalysisManager
The CGSCC analysis manager.
AnalysisManager< Loop, LoopStandardAnalysisResults & > LoopAnalysisManager
The loop analysis manager.
PassManager< Loop, LoopAnalysisManager, LoopStandardAnalysisResults &, LPMUpdater & > LoopPassManager
The Loop pass manager.
ModuleToPostOrderCGSCCPassAdaptor createModuleToPostOrderCGSCCPassAdaptor(CGSCCPassT &&Pass)
A function to deduce a function pass type and wrap it in the templated adaptor.
LLVM_ABI cl::opt< bool > PrintPipelinePasses
Common option used by multiple tools to print pipeline passes.
auto formatv(bool Validate, const char *Fmt, Ts &&...Vals)
FunctionToLoopPassAdaptor createFunctionToLoopPassAdaptor(LoopPassT &&Pass, bool UseMemorySSA=false)
A function to deduce a loop 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.
FunctionToMachineFunctionPassAdaptor createFunctionToMachineFunctionPassAdaptor(MachineFunctionPassT &&Pass)
PassManager< Module > ModulePassManager
Convenience typedef for a pass manager over modules.
FunctionAddr VTableAddr Count
class LLVM_GSL_OWNER SmallVector
Forward declaration of SmallVector so that calculateSmallVectorDefaultInlinedElements can reference s...
InnerAnalysisManagerProxy< MachineFunctionAnalysisManager, Function > MachineFunctionAnalysisManagerFunctionProxy
OuterAnalysisManagerProxy< FunctionAnalysisManager, Loop, LoopStandardAnalysisResults & > FunctionAnalysisManagerLoopProxy
A proxy from a FunctionAnalysisManager to a Loop.
Error make_error(ArgTs &&... Args)
Make a Error instance representing failure using the given error info type.
OuterAnalysisManagerProxy< ModuleAnalysisManager, LazyCallGraph::SCC, LazyCallGraph & > ModuleAnalysisManagerCGSCCProxy
A proxy from a ModuleAnalysisManager to an SCC.
InnerAnalysisManagerProxy< MachineFunctionAnalysisManager, Module > MachineFunctionAnalysisManagerModuleProxy
InnerAnalysisManagerProxy< CGSCCAnalysisManager, Module > CGSCCAnalysisManagerModuleProxy
A proxy from a CGSCCAnalysisManager to a Module.
PassManager< Function > FunctionPassManager
Convenience typedef for a pass manager over functions.
MFPropsModifier(PassT &P, MachineFunction &MF) -> MFPropsModifier< PassT >
OutputIt move(R &&Range, OutputIt Out)
Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.
PassManager< MachineFunction > MachineFunctionPassManager
Convenience typedef for a pass manager over functions.
AnalysisManager< Function > FunctionAnalysisManager
Convenience typedef for the Function analysis manager.
LLVM_ABI std::optional< AllocTokenMode > getAllocTokenModeFromString(StringRef Name)
Returns the AllocTokenMode from its canonical string name; if an invalid name was provided returns nu...
@ Detailed
Hash with opcode only.
@ CallTargetIgnored
Hash with opcode and operands.
AnalysisManager< Module > ModuleAnalysisManager
Convenience typedef for the Module analysis manager.
Implement std::hash so that hash_code can be used in STL containers.
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.
RegAllocFilterFunc Filter