LLVM 24.0.0git
PassBuilder.cpp
Go to the documentation of this file.
1//===- Parsing and selection of pass pipelines ----------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8/// \file
9///
10/// This file provides the implementation of the PassBuilder based on our
11/// static pass registry as well as related functionality. It also provides
12/// helpers to aid in analyzing, debugging, and testing passes and pass
13/// pipelines.
14///
15//===----------------------------------------------------------------------===//
16
18#include "PassesOptions.h"
34#include "llvm/Analysis/DDG.h"
56#include "llvm/Analysis/Lint.h"
131#include "llvm/CodeGen/KCFI.h"
139#include "llvm/CodeGen/MIR2Vec.h"
169#include "llvm/CodeGen/PEI.h"
217#include "llvm/IR/DebugInfo.h"
218#include "llvm/IR/Dominators.h"
219#include "llvm/IR/PassManager.h"
221#include "llvm/IR/Verifier.h"
225#include "llvm/Support/CodeGen.h"
226#include "llvm/Support/Debug.h"
227#include "llvm/Support/Error.h"
231#include "llvm/Support/Regex.h"
428#include <optional>
429
430using namespace llvm;
431
432std::optional<PrintPipelinePassesFormat>
434 return Opts.print_pipeline_passes;
435}
436
439 switch (Format) {
441 OS << Pipeline;
442 break;
444 int IndentLevel = 0;
445 for (char C : Pipeline) {
446 switch (C) {
447 case '(':
448 ++IndentLevel;
449 OS << formatv("\n{0}", fmt_repeat(" ", IndentLevel));
450 break;
451 case ')':
452 --IndentLevel;
453 assert(IndentLevel >= 0 && "Invalid pipeline string!");
454 break;
455 case ',':
456 OS << formatv("\n{0}", fmt_repeat(" ", IndentLevel));
457 break;
458 default:
459 OS << C;
460 }
461 }
462 break;
463 }
464 }
465}
466
467AnalysisKey NoOpModuleAnalysis::Key;
468AnalysisKey NoOpCGSCCAnalysis::Key;
469AnalysisKey NoOpFunctionAnalysis::Key;
470AnalysisKey NoOpLoopAnalysis::Key;
471
472namespace {
473
474bool applyMIRDebugify(DIBuilder &DIB, Function &F, ModuleAnalysisManager &AM) {
477 .getManager();
478
480 DIB, F, [&](Function &Func) -> MachineFunction * {
482 FAM.getCachedResult<MachineFunctionAnalysis>(Func);
483 return MFA ? &MFA->getMF() : nullptr;
484 });
485}
486
487// A pass for testing message reporting of -verify-each failures.
488// DO NOT USE THIS EXCEPT FOR TESTING!
489class TriggerVerifierErrorPass
490 : public OptionalPassInfoMixin<TriggerVerifierErrorPass> {
491public:
492 PreservedAnalyses run(Module &M, ModuleAnalysisManager &) {
493 // Intentionally break the Module by creating an alias without setting the
494 // aliasee.
495 auto *PtrTy = PointerType::getUnqual(M.getContext());
496 GlobalAlias::create(PtrTy, PtrTy->getAddressSpace(),
497 GlobalValue::LinkageTypes::InternalLinkage,
498 "__bad_alias", nullptr, &M);
500 }
501
502 PreservedAnalyses run(Function &F, FunctionAnalysisManager &) {
503 // Intentionally break the Function by inserting a terminator
504 // instruction in the middle of a basic block.
505 BasicBlock &BB = F.getEntryBlock();
506 new UnreachableInst(F.getContext(), BB.getTerminator()->getIterator());
508 }
509
510 PreservedAnalyses run(MachineFunction &MF, MachineFunctionAnalysisManager &) {
511 // Intentionally create a virtual register and set NoVRegs property.
512 auto &MRI = MF.getRegInfo();
514 MF.getProperties().setNoVRegs();
515 return PreservedAnalyses::all();
516 }
517
518 static StringRef name() { return "TriggerVerifierErrorPass"; }
519};
520
521// A pass requires all MachineFunctionProperties.
522// DO NOT USE THIS EXCEPT FOR TESTING!
523class RequireAllMachineFunctionPropertiesPass
524 : public OptionalPassInfoMixin<RequireAllMachineFunctionPropertiesPass> {
525public:
526 PreservedAnalyses run(MachineFunction &MF, MachineFunctionAnalysisManager &) {
527 MFPropsModifier _(*this, MF);
529 }
530
531 static MachineFunctionProperties getRequiredProperties() {
532 return MachineFunctionProperties()
533 .setFailedISel()
534 .setFailsVerification()
535 .setIsSSA()
536 .setLegalized()
537 .setNoPHIs()
538 .setNoVRegs()
539 .setRegBankSelected()
540 .setSelected()
541 .setTiedOpsRewritten()
542 .setTracksDebugUserValues()
543 .setTracksLiveness();
544 }
545 static StringRef name() { return "RequireAllMachineFunctionPropertiesPass"; }
546};
547
548} // namespace
549
550static std::optional<OptimizationLevel> parseOptLevel(StringRef S) {
551 if (S == "Os" || S == "Oz")
553 Twine("The optimization level \"") + S +
554 "\" is no longer supported. Use O2 in conjunction with the " +
555 (S == "Os" ? "optsize" : "minsize") + " attribute instead.");
556
558 .Case("O0", OptimizationLevel::O0)
562 .Default(std::nullopt);
563}
564
566 std::optional<OptimizationLevel> OptLevel = parseOptLevel(S);
567 if (OptLevel)
568 return *OptLevel;
570 formatv("invalid optimization level '{}'", S).str(),
572}
573
575 std::optional<PipelineTuningOptions> PTO,
576 std::optional<PGOOptions> PGOOpt,
579 : Context(Context), Opts(getPassesOptions(Context)), TM(TM),
580 PTO(PTO.value_or(PipelineTuningOptions())
581 .resolve(Context.getLibraryOptions())),
582 PGOOpt(PGOOpt), PIC(PIC), FS(std::move(FS)) {
583 if (TM)
584 TM->registerPassBuilderCallbacks(*this);
585 if (PIC) {
586 PIC->registerClassToPassNameCallback([this, PIC]() {
587 // MSVC requires this to be captured if it's used inside decltype.
588 // Other compilers consider it an unused lambda capture.
589 (void)this;
590#define MODULE_PASS(NAME, CREATE_PASS) \
591 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
592#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
593 PIC->addClassToPassName(CLASS, NAME);
594#define MODULE_ANALYSIS(NAME, CREATE_PASS) \
595 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
596#define FUNCTION_PASS(NAME, CREATE_PASS) \
597 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
598#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
599 PIC->addClassToPassName(CLASS, NAME);
600#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
601 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
602#define LOOPNEST_PASS(NAME, CREATE_PASS) \
603 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
604#define LOOP_PASS(NAME, CREATE_PASS) \
605 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
606#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
607 PIC->addClassToPassName(CLASS, NAME);
608#define LOOP_ANALYSIS(NAME, CREATE_PASS) \
609 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
610#define CGSCC_PASS(NAME, CREATE_PASS) \
611 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
612#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
613 PIC->addClassToPassName(CLASS, NAME);
614#define CGSCC_ANALYSIS(NAME, CREATE_PASS) \
615 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
616#include "PassRegistry.def"
617
618#define MACHINE_FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
619 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
620#define MACHINE_FUNCTION_PASS(NAME, CREATE_PASS) \
621 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
622#define MACHINE_FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, \
623 PARAMS) \
624 PIC->addClassToPassName(CLASS, NAME);
625#include "llvm/Passes/MachinePassRegistry.def"
626 });
627 }
628
629 // Module-level callbacks without LTO phase
631 [this](StringRef Name, ModulePassManager &PM,
633#define MODULE_CALLBACK(NAME, INVOKE) \
634 if (PassBuilder::checkParametrizedPassName(Name, NAME)) { \
635 auto L = PassBuilder::parsePassParameters(parseOptLevelParam, Name, NAME); \
636 if (!L) { \
637 errs() << NAME ": " << toString(L.takeError()) << '\n'; \
638 return false; \
639 } \
640 INVOKE(PM, L.get()); \
641 return true; \
642 }
643#include "PassRegistry.def"
644 return false;
645 });
646
647 // Module-level callbacks with LTO phase (use Phase::None for string API)
649 [this](StringRef Name, ModulePassManager &PM,
651#define MODULE_LTO_CALLBACK(NAME, INVOKE) \
652 if (PassBuilder::checkParametrizedPassName(Name, NAME)) { \
653 auto L = PassBuilder::parsePassParameters(parseOptLevelParam, Name, NAME); \
654 if (!L) { \
655 errs() << NAME ": " << toString(L.takeError()) << '\n'; \
656 return false; \
657 } \
658 INVOKE(PM, L.get(), ThinOrFullLTOPhase::None); \
659 return true; \
660 }
661#include "PassRegistry.def"
662 return false;
663 });
664
665 // Function-level callbacks
667 [this](StringRef Name, FunctionPassManager &PM,
669#define FUNCTION_CALLBACK(NAME, INVOKE) \
670 if (PassBuilder::checkParametrizedPassName(Name, NAME)) { \
671 auto L = PassBuilder::parsePassParameters(parseOptLevelParam, Name, NAME); \
672 if (!L) { \
673 errs() << NAME ": " << toString(L.takeError()) << '\n'; \
674 return false; \
675 } \
676 INVOKE(PM, L.get()); \
677 return true; \
678 }
679#include "PassRegistry.def"
680 return false;
681 });
682
683 // CGSCC-level callbacks
685 [this](StringRef Name, CGSCCPassManager &PM,
687#define CGSCC_CALLBACK(NAME, INVOKE) \
688 if (PassBuilder::checkParametrizedPassName(Name, NAME)) { \
689 auto L = PassBuilder::parsePassParameters(parseOptLevelParam, Name, NAME); \
690 if (!L) { \
691 errs() << NAME ": " << toString(L.takeError()) << '\n'; \
692 return false; \
693 } \
694 INVOKE(PM, L.get()); \
695 return true; \
696 }
697#include "PassRegistry.def"
698 return false;
699 });
700
701 // Loop-level callbacks
703 [this](StringRef Name, LoopPassManager &PM,
705#define LOOP_CALLBACK(NAME, INVOKE) \
706 if (PassBuilder::checkParametrizedPassName(Name, NAME)) { \
707 auto L = PassBuilder::parsePassParameters(parseOptLevelParam, Name, NAME); \
708 if (!L) { \
709 errs() << NAME ": " << toString(L.takeError()) << '\n'; \
710 return false; \
711 } \
712 INVOKE(PM, L.get()); \
713 return true; \
714 }
715#include "PassRegistry.def"
716 return false;
717 });
718}
719
721#define MODULE_ANALYSIS(NAME, CREATE_PASS) \
722 MAM.registerPass([&] { return CREATE_PASS; });
723#include "PassRegistry.def"
724
725 for (auto &C : ModuleAnalysisRegistrationCallbacks)
726 C(MAM);
727}
728
730#define CGSCC_ANALYSIS(NAME, CREATE_PASS) \
731 CGAM.registerPass([&] { return CREATE_PASS; });
732#include "PassRegistry.def"
733
734 for (auto &C : CGSCCAnalysisRegistrationCallbacks)
735 C(CGAM);
736}
737
739 // We almost always want the default alias analysis pipeline.
740 // If a user wants a different one, they can register their own before calling
741 // registerFunctionAnalyses().
742 FAM.registerPass([&] { return buildDefaultAAPipeline(); });
743
744#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
745 if constexpr (std::is_constructible_v< \
746 std::remove_reference_t<decltype(CREATE_PASS)>, \
747 const TargetMachine &>) { \
748 if (TM) \
749 FAM.registerPass([&] { return CREATE_PASS; }); \
750 } else { \
751 FAM.registerPass([&] { return CREATE_PASS; }); \
752 }
753#include "PassRegistry.def"
754
755 for (auto &C : FunctionAnalysisRegistrationCallbacks)
756 C(FAM);
757}
758
761
762#define MACHINE_FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
763 MFAM.registerPass([&] { return CREATE_PASS; });
764#include "llvm/Passes/MachinePassRegistry.def"
765
766 for (auto &C : MachineFunctionAnalysisRegistrationCallbacks)
767 C(MFAM);
768}
769
771#define LOOP_ANALYSIS(NAME, CREATE_PASS) \
772 LAM.registerPass([&] { return CREATE_PASS; });
773#include "PassRegistry.def"
774
775 for (auto &C : LoopAnalysisRegistrationCallbacks)
776 C(LAM);
777}
778
779static std::optional<std::pair<bool, bool>>
781 std::pair<bool, bool> Params;
782 if (!Name.consume_front("function"))
783 return std::nullopt;
784 if (Name.empty())
785 return Params;
786 if (!Name.consume_front("<") || !Name.consume_back(">"))
787 return std::nullopt;
788 while (!Name.empty()) {
789 auto [Front, Back] = Name.split(';');
790 Name = Back;
791 if (Front == "eager-inv")
792 Params.first = true;
793 else if (Front == "no-rerun")
794 Params.second = true;
795 else
796 return std::nullopt;
797 }
798 return Params;
799}
800
801static std::optional<int> parseDevirtPassName(StringRef Name) {
802 if (!Name.consume_front("devirt<") || !Name.consume_back(">"))
803 return std::nullopt;
804 int Count;
805 if (Name.getAsInteger(0, Count) || Count < 0)
806 return std::nullopt;
807 return Count;
808}
809
811 StringRef OptionName,
813 bool Result = false;
814 while (!Params.empty()) {
815 StringRef ParamName;
816 std::tie(ParamName, Params) = Params.split(';');
817
818 if (ParamName == OptionName) {
819 Result = true;
820 } else {
822 formatv("invalid {} pass parameter '{}'", PassName, ParamName).str(),
824 }
825 }
826 return Result;
827}
828
829namespace {
830
831/// Parser of parameters for HardwareLoops pass.
832Expected<HardwareLoopOptions> parseHardwareLoopOptions(StringRef Params) {
833 HardwareLoopOptions HardwareLoopOpts;
834
835 while (!Params.empty()) {
836 StringRef ParamName;
837 std::tie(ParamName, Params) = Params.split(';');
838 if (ParamName.consume_front("hardware-loop-decrement=")) {
839 int Count;
840 if (ParamName.getAsInteger(0, Count))
842 formatv("invalid HardwareLoopPass parameter '{}'", ParamName).str(),
844 HardwareLoopOpts.setDecrement(Count);
845 continue;
846 }
847 if (ParamName.consume_front("hardware-loop-counter-bitwidth=")) {
848 int Count;
849 if (ParamName.getAsInteger(0, Count))
851 formatv("invalid HardwareLoopPass parameter '{}'", ParamName).str(),
853 HardwareLoopOpts.setCounterBitwidth(Count);
854 continue;
855 }
856 if (ParamName == "force-hardware-loops") {
857 HardwareLoopOpts.setForce(true);
858 } else if (ParamName == "force-hardware-loop-phi") {
859 HardwareLoopOpts.setForcePhi(true);
860 } else if (ParamName == "force-nested-hardware-loop") {
861 HardwareLoopOpts.setForceNested(true);
862 } else if (ParamName == "force-hardware-loop-guard") {
863 HardwareLoopOpts.setForceGuard(true);
864 } else {
866 formatv("invalid HardwarePass parameter '{}'", ParamName).str(),
868 }
869 }
870 return HardwareLoopOpts;
871}
872
873/// Parser of parameters for Lint pass.
874Expected<bool> parseLintOptions(StringRef Params) {
875 return PassBuilder::parseSinglePassOption(Params, "abort-on-error",
876 "LintPass");
877}
878
879/// Parser of parameters for FunctionPropertiesStatistics pass.
880Expected<bool> parseFunctionPropertiesStatisticsOptions(StringRef Params) {
881 return PassBuilder::parseSinglePassOption(Params, "pre-opt",
882 "FunctionPropertiesStatisticsPass");
883}
884
885/// Parser of parameters for InstCount pass.
886Expected<bool> parseInstCountOptions(StringRef Params) {
887 return PassBuilder::parseSinglePassOption(Params, "pre-opt", "InstCountPass");
888}
889
890Expected<bool> parseInferAddressSpacesPassOptions(StringRef Params) {
892 Params, "assume-default-is-flat-addrspace", "InferAddressSpacesPass");
893}
894
895/// Parser of parameters for LoopUnroll pass.
896Expected<LoopUnrollOptions> parseLoopUnrollOptions(StringRef Params) {
897 LoopUnrollOptions UnrollOpts;
898 while (!Params.empty()) {
899 StringRef ParamName;
900 std::tie(ParamName, Params) = Params.split(';');
901 std::optional<OptimizationLevel> OptLevel = parseOptLevel(ParamName);
902 if (OptLevel) {
903 UnrollOpts.setOptLevel(static_cast<int>(*OptLevel));
904 continue;
905 }
906 if (ParamName.consume_front("full-unroll-max=")) {
907 int Count;
908 if (ParamName.getAsInteger(0, Count))
910 formatv("invalid LoopUnrollPass parameter '{}'", ParamName).str(),
912 UnrollOpts.setFullUnrollMaxCount(Count);
913 continue;
914 }
915
916 bool Enable = !ParamName.consume_front("no-");
917 if (ParamName == "partial") {
918 UnrollOpts.setPartial(Enable);
919 } else if (ParamName == "peeling") {
920 UnrollOpts.setPeeling(Enable);
921 } else if (ParamName == "profile-peeling") {
922 UnrollOpts.setProfileBasedPeeling(Enable);
923 } else if (ParamName == "runtime") {
924 UnrollOpts.setRuntime(Enable);
925 } else if (ParamName == "upperbound") {
926 UnrollOpts.setUpperBound(Enable);
927 } else if (ParamName == "prepare-for-lto") {
928 UnrollOpts.setPrepareForLTO(Enable);
929 } else {
931 formatv("invalid LoopUnrollPass parameter '{}'", ParamName).str(),
933 }
934 }
935 return UnrollOpts;
936}
937
938Expected<bool> parseGlobalDCEPassOptions(StringRef Params) {
940 Params, "vfe-linkage-unit-visibility", "GlobalDCE");
941}
942
943Expected<bool> parseCGProfilePassOptions(StringRef Params) {
944 return PassBuilder::parseSinglePassOption(Params, "in-lto-post-link",
945 "CGProfile");
946}
947
948Expected<bool> parseInlinerPassOptions(StringRef Params) {
949 return PassBuilder::parseSinglePassOption(Params, "only-mandatory",
950 "InlinerPass");
951}
952
953Expected<bool> parseCoroSplitPassOptions(StringRef Params) {
954 return PassBuilder::parseSinglePassOption(Params, "reuse-storage",
955 "CoroSplitPass");
956}
957
958Expected<bool> parsePostOrderFunctionAttrsPassOptions(StringRef Params) {
960 Params, "skip-non-recursive-function-attrs", "PostOrderFunctionAttrs");
961}
962
963Expected<bool> parseEarlyCSEPassOptions(StringRef Params) {
964 return PassBuilder::parseSinglePassOption(Params, "memssa", "EarlyCSE");
965}
966
967Expected<bool> parseEntryExitInstrumenterPassOptions(StringRef Params) {
968 return PassBuilder::parseSinglePassOption(Params, "post-inline",
969 "EntryExitInstrumenter");
970}
971
972Expected<bool> parseDropUnnecessaryAssumesPassOptions(StringRef Params) {
973 return PassBuilder::parseSinglePassOption(Params, "drop-deref",
974 "DropUnnecessaryAssumes");
975}
976
977Expected<bool> parseLowerMatrixIntrinsicsPassOptions(StringRef Params) {
978 return PassBuilder::parseSinglePassOption(Params, "minimal",
979 "LowerMatrixIntrinsics");
980}
981
982Expected<IRNormalizerOptions> parseIRNormalizerPassOptions(StringRef Params) {
984 while (!Params.empty()) {
985 StringRef ParamName;
986 std::tie(ParamName, Params) = Params.split(';');
987
988 bool Enable = !ParamName.consume_front("no-");
989 if (ParamName == "preserve-order")
990 Result.PreserveOrder = Enable;
991 else if (ParamName == "rename-all")
992 Result.RenameAll = Enable;
993 else if (ParamName == "fold-all") // FIXME: Name mismatch
994 Result.FoldPreOutputs = Enable;
995 else if (ParamName == "reorder-operands")
996 Result.ReorderOperands = Enable;
997 else {
999 formatv("invalid normalize pass parameter '{}'", ParamName).str(),
1001 }
1002 }
1003
1004 return Result;
1005}
1006
1007Expected<AddressSanitizerOptions> parseASanPassOptions(StringRef Params) {
1009 while (!Params.empty()) {
1010 StringRef ParamName;
1011 std::tie(ParamName, Params) = Params.split(';');
1012
1013 if (ParamName == "kernel") {
1014 Result.CompileKernel = true;
1015 } else if (ParamName == "use-after-scope") {
1016 Result.UseAfterScope = true;
1017 } else {
1019 formatv("invalid AddressSanitizer pass parameter '{}'", ParamName)
1020 .str(),
1022 }
1023 }
1024 return Result;
1025}
1026
1027Expected<HWAddressSanitizerOptions> parseHWASanPassOptions(StringRef Params) {
1029 while (!Params.empty()) {
1030 StringRef ParamName;
1031 std::tie(ParamName, Params) = Params.split(';');
1032
1033 if (ParamName == "recover") {
1034 Result.Recover = true;
1035 } else if (ParamName == "kernel") {
1036 Result.CompileKernel = true;
1037 } else {
1039 formatv("invalid HWAddressSanitizer pass parameter '{}'", ParamName)
1040 .str(),
1042 }
1043 }
1044 return Result;
1045}
1046
1048parseDropTypeTestsPassOptions(StringRef Params) {
1050 while (!Params.empty()) {
1051 StringRef ParamName;
1052 std::tie(ParamName, Params) = Params.split(';');
1053
1054 if (ParamName == "all") {
1056 } else if (ParamName == "assume") {
1058 } else {
1060 formatv("invalid DropTypeTestsPass parameter '{}'", ParamName).str(),
1062 }
1063 }
1064 return Result;
1065}
1066
1067Expected<EmbedBitcodeOptions> parseEmbedBitcodePassOptions(StringRef Params) {
1069 while (!Params.empty()) {
1070 StringRef ParamName;
1071 std::tie(ParamName, Params) = Params.split(';');
1072
1073 if (ParamName == "thinlto") {
1074 Result.IsThinLTO = true;
1075 } else if (ParamName == "emit-summary") {
1076 Result.EmitLTOSummary = true;
1077 } else {
1079 formatv("invalid EmbedBitcode pass parameter '{}'", ParamName).str(),
1081 }
1082 }
1083 return Result;
1084}
1085
1087parseLowerAllowCheckPassOptions(StringRef Params) {
1089 while (!Params.empty()) {
1090 StringRef ParamName;
1091 std::tie(ParamName, Params) = Params.split(';');
1092
1093 // Format is <cutoffs[1,2,3]=70000;cutoffs[5,6,8]=90000>
1094 //
1095 // Parsing allows duplicate indices (last one takes precedence).
1096 // It would technically be in spec to specify
1097 // cutoffs[0]=70000,cutoffs[1]=90000,cutoffs[0]=80000,...
1098 if (ParamName.starts_with("cutoffs[")) {
1099 StringRef IndicesStr;
1100 StringRef CutoffStr;
1101
1102 std::tie(IndicesStr, CutoffStr) = ParamName.split("]=");
1103 // cutoffs[1,2,3
1104 // 70000
1105
1106 int cutoff;
1107 if (CutoffStr.getAsInteger(0, cutoff))
1109 formatv("invalid LowerAllowCheck pass cutoffs parameter '{}' ({})",
1110 CutoffStr, Params)
1111 .str(),
1113
1114 if (!IndicesStr.consume_front("cutoffs[") || IndicesStr == "")
1116 formatv("invalid LowerAllowCheck pass index parameter '{}' ({})",
1117 IndicesStr, CutoffStr)
1118 .str(),
1120
1121 while (IndicesStr != "") {
1122 StringRef firstIndexStr;
1123 std::tie(firstIndexStr, IndicesStr) = IndicesStr.split('|');
1124
1125 unsigned int index;
1126 if (firstIndexStr.getAsInteger(0, index))
1128 formatv(
1129 "invalid LowerAllowCheck pass index parameter '{}' ({}) {}",
1130 firstIndexStr, IndicesStr)
1131 .str(),
1133
1134 // In the common case (sequentially increasing indices), we will issue
1135 // O(n) resize requests. We assume the underlying data structure has
1136 // O(1) runtime for each added element.
1137 if (index >= Result.cutoffs.size())
1138 Result.cutoffs.resize(index + 1, 0);
1139
1140 Result.cutoffs[index] = cutoff;
1141 }
1142 } else if (ParamName.starts_with("runtime_check")) {
1143 StringRef ValueString;
1144 std::tie(std::ignore, ValueString) = ParamName.split("=");
1145 int runtime_check;
1146 if (ValueString.getAsInteger(0, runtime_check)) {
1148 formatv("invalid LowerAllowCheck pass runtime_check parameter '{}' "
1149 "({})",
1150 ValueString, Params)
1151 .str(),
1153 }
1154 Result.runtime_check = runtime_check;
1155 } else {
1157 formatv("invalid LowerAllowCheck pass parameter '{}'", ParamName)
1158 .str(),
1160 }
1161 }
1162
1163 return Result;
1164}
1165
1166Expected<MemorySanitizerOptions> parseMSanPassOptions(StringRef Params) {
1168 while (!Params.empty()) {
1169 StringRef ParamName;
1170 std::tie(ParamName, Params) = Params.split(';');
1171
1172 if (ParamName == "recover") {
1173 Result.Recover = true;
1174 } else if (ParamName == "kernel") {
1175 Result.Kernel = true;
1176 } else if (ParamName.consume_front("track-origins=")) {
1177 if (ParamName.getAsInteger(0, Result.TrackOrigins))
1179 formatv("invalid argument to MemorySanitizer pass track-origins "
1180 "parameter: '{}'",
1181 ParamName)
1182 .str(),
1184 } else if (ParamName == "eager-checks") {
1185 Result.EagerChecks = true;
1186 } else {
1188 formatv("invalid MemorySanitizer pass parameter '{}'", ParamName)
1189 .str(),
1191 }
1192 }
1193 return Result;
1194}
1195
1196Expected<AllocTokenOptions> parseAllocTokenPassOptions(StringRef Params) {
1198 while (!Params.empty()) {
1199 StringRef ParamName;
1200 std::tie(ParamName, Params) = Params.split(';');
1201
1202 if (ParamName.consume_front("mode=")) {
1203 if (auto Mode = getAllocTokenModeFromString(ParamName))
1204 Result.Mode = *Mode;
1205 else
1207 formatv("invalid argument to AllocToken pass mode "
1208 "parameter: '{}'",
1209 ParamName)
1210 .str(),
1212 } else {
1214 formatv("invalid AllocToken pass parameter '{}'", ParamName).str(),
1216 }
1217 }
1218 return Result;
1219}
1220
1221/// Parser of parameters for SimplifyCFG pass.
1222Expected<SimplifyCFGOptions> parseSimplifyCFGOptions(StringRef Params) {
1224 while (!Params.empty()) {
1225 StringRef ParamName;
1226 std::tie(ParamName, Params) = Params.split(';');
1227
1228 bool Enable = !ParamName.consume_front("no-");
1229 if (ParamName == "speculate-blocks") {
1230 Result.speculateBlocks(Enable);
1231 } else if (ParamName == "simplify-cond-branch") {
1232 Result.setSimplifyCondBranch(Enable);
1233 } else if (ParamName == "forward-switch-cond") {
1234 Result.forwardSwitchCondToPhi(Enable);
1235 } else if (ParamName == "switch-range-to-icmp") {
1236 Result.convertSwitchRangeToICmp(Enable);
1237 } else if (ParamName == "switch-to-arithmetic") {
1238 Result.convertSwitchToArithmetic(Enable);
1239 } else if (ParamName == "switch-to-lookup") {
1240 Result.convertSwitchToLookupTable(Enable);
1241 } else if (ParamName == "keep-loops") {
1242 Result.needCanonicalLoops(Enable);
1243 } else if (ParamName == "hoist-common-insts") {
1244 Result.hoistCommonInsts(Enable);
1245 } else if (ParamName == "hoist-loads-stores-with-cond-faulting") {
1246 Result.hoistLoadsStoresWithCondFaulting(Enable);
1247 } else if (ParamName == "sink-common-insts") {
1248 Result.sinkCommonInsts(Enable);
1249 } else if (ParamName == "speculate-unpredictables") {
1250 Result.speculateUnpredictables(Enable);
1251 } else if (Enable && ParamName.consume_front("bonus-inst-threshold=")) {
1252 APInt BonusInstThreshold;
1253 if (ParamName.getAsInteger(0, BonusInstThreshold))
1255 formatv("invalid argument to SimplifyCFG pass bonus-threshold "
1256 "parameter: '{}'",
1257 ParamName)
1258 .str(),
1260 Result.bonusInstThreshold(BonusInstThreshold.getSExtValue());
1261 } else {
1263 formatv("invalid SimplifyCFG pass parameter '{}'", ParamName).str(),
1265 }
1266 }
1267 return Result;
1268}
1269
1270Expected<InstCombineOptions> parseInstCombineOptions(StringRef Params) {
1272 // When specifying "instcombine" in -passes enable fix-point verification by
1273 // default, as this is what most tests should use.
1274 Result.setVerifyFixpoint(true);
1275 while (!Params.empty()) {
1276 StringRef ParamName;
1277 std::tie(ParamName, Params) = Params.split(';');
1278
1279 bool Enable = !ParamName.consume_front("no-");
1280 if (ParamName == "verify-fixpoint") {
1281 Result.setVerifyFixpoint(Enable);
1282 } else if (Enable && ParamName.consume_front("max-iterations=")) {
1283 APInt MaxIterations;
1284 if (ParamName.getAsInteger(0, MaxIterations))
1286 formatv("invalid argument to InstCombine pass max-iterations "
1287 "parameter: '{}'",
1288 ParamName)
1289 .str(),
1291 Result.setMaxIterations((unsigned)MaxIterations.getZExtValue());
1292 } else {
1294 formatv("invalid InstCombine pass parameter '{}'", ParamName).str(),
1296 }
1297 }
1298 return Result;
1299}
1300
1301/// Parser of parameters for LoopVectorize pass.
1302Expected<LoopVectorizeOptions> parseLoopVectorizeOptions(StringRef Params) {
1304 while (!Params.empty()) {
1305 StringRef ParamName;
1306 std::tie(ParamName, Params) = Params.split(';');
1307
1308 bool Enable = !ParamName.consume_front("no-");
1309 if (ParamName == "interleave-forced-only") {
1311 } else if (ParamName == "vectorize-forced-only") {
1313 } else {
1315 formatv("invalid LoopVectorize parameter '{}'", ParamName).str(),
1317 }
1318 }
1319 return Opts;
1320}
1321
1322Expected<std::pair<bool, bool>> parseLoopUnswitchOptions(StringRef Params) {
1323 std::pair<bool, bool> Result = {false, true};
1324 while (!Params.empty()) {
1325 StringRef ParamName;
1326 std::tie(ParamName, Params) = Params.split(';');
1327
1328 bool Enable = !ParamName.consume_front("no-");
1329 if (ParamName == "nontrivial") {
1330 Result.first = Enable;
1331 } else if (ParamName == "trivial") {
1332 Result.second = Enable;
1333 } else {
1335 formatv("invalid LoopUnswitch pass parameter '{}'", ParamName).str(),
1337 }
1338 }
1339 return Result;
1340}
1341
1342Expected<LICMOptions> parseLICMOptions(StringRef Params) {
1344 while (!Params.empty()) {
1345 StringRef ParamName;
1346 std::tie(ParamName, Params) = Params.split(';');
1347
1348 bool Enable = !ParamName.consume_front("no-");
1349 if (ParamName == "allowspeculation") {
1350 Result.AllowSpeculation = Enable;
1351 } else {
1353 formatv("invalid LICM pass parameter '{}'", ParamName).str(),
1355 }
1356 }
1357 return Result;
1358}
1359
1360struct LoopRotateOptions {
1361 bool EnableHeaderDuplication = true;
1362 bool PrepareForLTO = false;
1363 bool CheckExitCount = false;
1364};
1365
1366Expected<LoopRotateOptions> parseLoopRotateOptions(StringRef Params) {
1367 LoopRotateOptions Result;
1368 while (!Params.empty()) {
1369 StringRef ParamName;
1370 std::tie(ParamName, Params) = Params.split(';');
1371
1372 bool Enable = !ParamName.consume_front("no-");
1373 if (ParamName == "header-duplication") {
1374 Result.EnableHeaderDuplication = Enable;
1375 } else if (ParamName == "prepare-for-lto") {
1376 Result.PrepareForLTO = Enable;
1377 } else if (ParamName == "check-exit-count") {
1378 Result.CheckExitCount = Enable;
1379 } else {
1381 formatv("invalid LoopRotate pass parameter '{}'", ParamName).str(),
1383 }
1384 }
1385 return Result;
1386}
1387
1388Expected<bool> parseMergedLoadStoreMotionOptions(StringRef Params) {
1389 bool Result = false;
1390 while (!Params.empty()) {
1391 StringRef ParamName;
1392 std::tie(ParamName, Params) = Params.split(';');
1393
1394 bool Enable = !ParamName.consume_front("no-");
1395 if (ParamName == "split-footer-bb") {
1396 Result = Enable;
1397 } else {
1399 formatv("invalid MergedLoadStoreMotion pass parameter '{}'",
1400 ParamName)
1401 .str(),
1403 }
1404 }
1405 return Result;
1406}
1407
1408Expected<GVNOptions> parseGVNOptions(StringRef Params) {
1410 while (!Params.empty()) {
1411 StringRef ParamName;
1412 std::tie(ParamName, Params) = Params.split(';');
1413
1414 bool Enable = !ParamName.consume_front("no-");
1415 if (ParamName == "scalar-pre") {
1416 Result.setScalarPRE(Enable);
1417 } else if (ParamName == "load-pre") {
1418 Result.setLoadPRE(Enable);
1419 } else if (ParamName == "split-backedge-load-pre") {
1420 Result.setLoadPRESplitBackedge(Enable);
1421 } else if (ParamName == "memdep") {
1422 // MemDep and MemorySSA are mutually exclusive.
1423 Result.setMemDep(Enable);
1424 Result.setMemorySSA(!Enable);
1425 } else if (ParamName == "memoryssa") {
1426 // MemDep and MemorySSA are mutually exclusive.
1427 Result.setMemorySSA(Enable);
1428 Result.setMemDep(!Enable);
1429 } else {
1431 formatv("invalid GVN pass parameter '{}'", ParamName).str(),
1433 }
1434 }
1435 return Result;
1436}
1437
1438Expected<IPSCCPOptions> parseIPSCCPOptions(StringRef Params) {
1440 while (!Params.empty()) {
1441 StringRef ParamName;
1442 std::tie(ParamName, Params) = Params.split(';');
1443
1444 bool Enable = !ParamName.consume_front("no-");
1445 if (ParamName == "func-spec")
1446 Result.setFuncSpec(Enable);
1447 else
1449 formatv("invalid IPSCCP pass parameter '{}'", ParamName).str(),
1451 }
1452 return Result;
1453}
1454
1455Expected<ScalarizerPassOptions> parseScalarizerOptions(StringRef Params) {
1457 while (!Params.empty()) {
1458 StringRef ParamName;
1459 std::tie(ParamName, Params) = Params.split(';');
1460
1461 if (ParamName.consume_front("min-bits=")) {
1462 if (ParamName.getAsInteger(0, Result.ScalarizeMinBits)) {
1464 formatv("invalid argument to Scalarizer pass min-bits "
1465 "parameter: '{}'",
1466 ParamName)
1467 .str(),
1469 }
1470
1471 continue;
1472 }
1473
1474 bool Enable = !ParamName.consume_front("no-");
1475 if (ParamName == "load-store")
1476 Result.ScalarizeLoadStore = Enable;
1477 else if (ParamName == "variable-insert-extract")
1478 Result.ScalarizeVariableInsertExtract = Enable;
1479 else {
1481 formatv("invalid Scalarizer pass parameter '{}'", ParamName).str(),
1483 }
1484 }
1485
1486 return Result;
1487}
1488
1489Expected<SROAOptions> parseSROAOptions(StringRef Params) {
1491 bool SawCFGOption = false;
1492 while (!Params.empty()) {
1493 StringRef ParamName;
1494 std::tie(ParamName, Params) = Params.split(';');
1495
1496 if (ParamName == "modify-cfg") {
1497 if (SawCFGOption)
1498 return make_error<StringError>("multiple SROA CFG options specified",
1501 SawCFGOption = true;
1502 } else if (ParamName == "preserve-cfg") {
1503 if (SawCFGOption)
1504 return make_error<StringError>("multiple SROA CFG options specified",
1507 SawCFGOption = true;
1508 } else if (ParamName == "aggregate-to-vector") {
1509 Result.AggregateToVector = true;
1510 } else {
1512 formatv("invalid SROA pass parameter '{}' (expected preserve-cfg, "
1513 "modify-cfg, or aggregate-to-vector)",
1514 ParamName)
1515 .str(),
1517 }
1518 }
1519 return Result;
1520}
1521
1523parseStackLifetimeOptions(StringRef Params) {
1525 while (!Params.empty()) {
1526 StringRef ParamName;
1527 std::tie(ParamName, Params) = Params.split(';');
1528
1529 if (ParamName == "may") {
1531 } else if (ParamName == "must") {
1533 } else {
1535 formatv("invalid StackLifetime parameter '{}'", ParamName).str(),
1537 }
1538 }
1539 return Result;
1540}
1541
1542Expected<bool> parseDependenceAnalysisPrinterOptions(StringRef Params) {
1543 return PassBuilder::parseSinglePassOption(Params, "normalized-results",
1544 "DependenceAnalysisPrinter");
1545}
1546
1547Expected<bool> parseSeparateConstOffsetFromGEPPassOptions(StringRef Params) {
1548 return PassBuilder::parseSinglePassOption(Params, "lower-gep",
1549 "SeparateConstOffsetFromGEP");
1550}
1551
1552Expected<bool> parseStructurizeCFGPassOptions(StringRef Params) {
1553 return PassBuilder::parseSinglePassOption(Params, "skip-uniform-regions",
1554 "StructurizeCFG");
1555}
1556
1558parseFunctionSimplificationPipelineOptions(StringRef Params) {
1559 std::optional<OptimizationLevel> L = parseOptLevel(Params);
1560 if (!L || *L == OptimizationLevel::O0) {
1562 formatv("invalid function-simplification parameter '{}'", Params).str(),
1564 };
1565 return *L;
1566}
1567
1568Expected<bool> parseMemorySSAPrinterPassOptions(StringRef Params) {
1569 return PassBuilder::parseSinglePassOption(Params, "no-ensure-optimized-uses",
1570 "MemorySSAPrinterPass");
1571}
1572
1573Expected<bool> parseSpeculativeExecutionPassOptions(StringRef Params) {
1574 return PassBuilder::parseSinglePassOption(Params, "only-if-divergent-target",
1575 "SpeculativeExecutionPass");
1576}
1577
1578Expected<std::string> parseMemProfUsePassOptions(StringRef Params) {
1579 std::string Result;
1580 while (!Params.empty()) {
1581 StringRef ParamName;
1582 std::tie(ParamName, Params) = Params.split(';');
1583
1584 if (ParamName.consume_front("profile-filename=")) {
1585 Result = ParamName.str();
1586 } else {
1588 formatv("invalid MemProfUse pass parameter '{}'", ParamName).str(),
1590 }
1591 }
1592 return Result;
1593}
1594
1596parseStructuralHashPrinterPassOptions(StringRef Params) {
1597 if (Params.empty())
1599 if (Params == "detailed")
1601 if (Params == "call-target-ignored")
1604 formatv("invalid structural hash printer parameter '{}'", Params).str(),
1606}
1607
1608Expected<GlobalMergeOptions> parseGlobalMergeOptions(StringRef Params) {
1610 while (!Params.empty()) {
1611 StringRef ParamName;
1612 std::tie(ParamName, Params) = Params.split(';');
1613
1614 bool Enable = !ParamName.consume_front("no-");
1615 if (ParamName == "group-by-use")
1616 Result.GroupByUse = Enable;
1617 else if (ParamName == "ignore-single-use")
1618 Result.IgnoreSingleUse = Enable;
1619 else if (ParamName == "merge-const")
1620 Result.MergeConstantGlobals = Enable;
1621 else if (ParamName == "merge-const-aggressive")
1622 Result.MergeConstAggressive = Enable;
1623 else if (ParamName == "merge-external")
1624 Result.MergeExternal = Enable;
1625 else if (ParamName.consume_front("max-offset=")) {
1626 if (ParamName.getAsInteger(0, Result.MaxOffset))
1628 formatv("invalid GlobalMergePass parameter '{}'", ParamName).str(),
1630 } else {
1632 formatv("invalid global-merge pass parameter '{}'", Params).str(),
1634 }
1635 }
1636 return Result;
1637}
1638
1639Expected<SmallVector<std::string, 0>> parseInternalizeGVs(StringRef Params) {
1640 SmallVector<std::string, 1> PreservedGVs;
1641 while (!Params.empty()) {
1642 StringRef ParamName;
1643 std::tie(ParamName, Params) = Params.split(';');
1644
1645 if (ParamName.consume_front("preserve-gv=")) {
1646 PreservedGVs.push_back(ParamName.str());
1647 } else {
1649 formatv("invalid Internalize pass parameter '{}'", ParamName).str(),
1651 }
1652 }
1653
1654 return Expected<SmallVector<std::string, 0>>(std::move(PreservedGVs));
1655}
1656
1658parseRegAllocFastPassOptions(PassBuilder &PB, StringRef Params) {
1660 while (!Params.empty()) {
1661 StringRef ParamName;
1662 std::tie(ParamName, Params) = Params.split(';');
1663
1664 if (ParamName.consume_front("filter=")) {
1665 std::optional<RegAllocFilterFunc> Filter =
1666 PB.parseRegAllocFilter(ParamName);
1667 if (!Filter) {
1669 formatv("invalid regallocfast register filter '{}'", ParamName)
1670 .str(),
1672 }
1673 Opts.Filter = *Filter;
1674 Opts.FilterName = ParamName;
1675 continue;
1676 }
1677
1678 if (ParamName == "no-clear-vregs") {
1679 Opts.ClearVRegs = false;
1680 continue;
1681 }
1682
1684 formatv("invalid regallocfast pass parameter '{}'", ParamName).str(),
1686 }
1687 return Opts;
1688}
1689
1691parseBoundsCheckingOptions(StringRef Params) {
1693 while (!Params.empty()) {
1694 StringRef ParamName;
1695 std::tie(ParamName, Params) = Params.split(';');
1696 if (ParamName == "trap") {
1697 Options.Rt = std::nullopt;
1698 } else if (ParamName == "rt") {
1699 Options.Rt = {
1700 /*MinRuntime=*/false,
1701 /*MayReturn=*/true,
1702 /*HandlerPreserveAllRegs=*/false,
1703 };
1704 } else if (ParamName == "rt-abort") {
1705 Options.Rt = {
1706 /*MinRuntime=*/false,
1707 /*MayReturn=*/false,
1708 /*HandlerPreserveAllRegs=*/false,
1709 };
1710 } else if (ParamName == "min-rt") {
1711 Options.Rt = {
1712 /*MinRuntime=*/true,
1713 /*MayReturn=*/true,
1714 /*HandlerPreserveAllRegs=*/false,
1715 };
1716 } else if (ParamName == "min-rt-abort") {
1717 Options.Rt = {
1718 /*MinRuntime=*/true,
1719 /*MayReturn=*/false,
1720 /*HandlerPreserveAllRegs=*/false,
1721 };
1722 } else if (ParamName == "merge") {
1723 Options.Merge = true;
1724 } else if (ParamName == "handler-preserve-all-regs") {
1725 if (Options.Rt)
1726 Options.Rt->HandlerPreserveAllRegs = true;
1727 } else {
1728 StringRef ParamEQ;
1729 StringRef Val;
1730 std::tie(ParamEQ, Val) = ParamName.split('=');
1731 int8_t Id;
1732 if (ParamEQ == "guard" && !Val.getAsInteger(0, Id)) {
1733 Options.GuardKind = Id;
1734 } else {
1736 formatv("invalid BoundsChecking pass parameter '{}'", ParamName)
1737 .str(),
1739 }
1740 }
1741 }
1742 return Options;
1743}
1744
1745Expected<CodeGenOptLevel> parseExpandIRInstsOptions(StringRef Param) {
1746 if (Param.empty())
1747 return CodeGenOptLevel::None;
1748
1749 // Parse a CodeGenOptLevel, e.g. "O1", "O2", "O3".
1750 auto [Prefix, Digit] = Param.split('O');
1751
1752 uint8_t N;
1753 if (!Prefix.empty() || Digit.getAsInteger(10, N))
1754 return createStringError("invalid expand-ir-insts pass parameter '%s'",
1755 Param.str().c_str());
1756
1757 std::optional<CodeGenOptLevel> Level = CodeGenOpt::getLevel(N);
1758 if (!Level.has_value())
1759 return createStringError(
1760 "invalid optimization level for expand-ir-insts pass: %s",
1761 Digit.str().c_str());
1762
1763 return *Level;
1764}
1765
1767parseRegAllocGreedyFilterFunc(PassBuilder &PB, StringRef Params) {
1768 if (Params.empty() || Params == "all")
1769 return RAGreedyPass::Options();
1770
1771 std::optional<RegAllocFilterFunc> Filter = PB.parseRegAllocFilter(Params);
1772 if (Filter)
1773 return RAGreedyPass::Options{*Filter, Params};
1774
1776 formatv("invalid regallocgreedy register filter '{}'", Params).str(),
1778}
1779
1780Expected<bool> parseMachineSinkingPassOptions(StringRef Params) {
1781 return PassBuilder::parseSinglePassOption(Params, "enable-sink-fold",
1782 "MachineSinkingPass");
1783}
1784
1785Expected<bool> parseMachineBlockPlacementPassOptions(StringRef Params) {
1786 bool AllowTailMerge = true;
1787 if (!Params.empty()) {
1788 AllowTailMerge = !Params.consume_front("no-");
1789 if (Params != "tail-merge")
1791 formatv("invalid MachineBlockPlacementPass parameter '{}'", Params)
1792 .str(),
1794 }
1795 return AllowTailMerge;
1796}
1797
1798Expected<bool> parseVirtRegRewriterPassOptions(StringRef Params) {
1799 bool ClearVirtRegs = true;
1800 if (!Params.empty()) {
1801 ClearVirtRegs = !Params.consume_front("no-");
1802 if (Params != "clear-vregs")
1804 formatv("invalid VirtRegRewriter pass parameter '{}'", Params).str(),
1806 }
1807 return ClearVirtRegs;
1808}
1809
1810struct FatLTOOptions {
1811 OptimizationLevel OptLevel;
1812 bool ThinLTO = false;
1813 bool EmitSummary = false;
1814};
1815
1816Expected<FatLTOOptions> parseFatLTOOptions(StringRef Params) {
1817 FatLTOOptions Result;
1818 bool HaveOptLevel = false;
1819 while (!Params.empty()) {
1820 StringRef ParamName;
1821 std::tie(ParamName, Params) = Params.split(';');
1822
1823 if (ParamName == "thinlto") {
1824 Result.ThinLTO = true;
1825 } else if (ParamName == "emit-summary") {
1826 Result.EmitSummary = true;
1827 } else if (std::optional<OptimizationLevel> OptLevel =
1828 parseOptLevel(ParamName)) {
1829 Result.OptLevel = *OptLevel;
1830 HaveOptLevel = true;
1831 } else {
1833 formatv("invalid fatlto-pre-link pass parameter '{}'", ParamName)
1834 .str(),
1836 }
1837 }
1838 if (!HaveOptLevel)
1840 "missing optimization level for fatlto-pre-link pipeline",
1842 return Result;
1843}
1844
1845} // namespace
1846
1847/// Tests whether registered callbacks will accept a given pass name.
1848///
1849/// When parsing a pipeline text, the type of the outermost pipeline may be
1850/// omitted, in which case the type is automatically determined from the first
1851/// pass name in the text. This may be a name that is handled through one of the
1852/// callbacks. We check this through the oridinary parsing callbacks by setting
1853/// up a dummy PassManager in order to not force the client to also handle this
1854/// type of query.
1855template <typename PassManagerT, typename CallbacksT>
1856static bool callbacksAcceptPassName(StringRef Name, CallbacksT &Callbacks) {
1857 if (!Callbacks.empty()) {
1858 PassManagerT DummyPM;
1859 for (auto &CB : Callbacks)
1860 if (CB(Name, DummyPM, {}))
1861 return true;
1862 }
1863 return false;
1864}
1865
1866template <typename CallbacksT>
1867static bool isModulePassName(StringRef Name, CallbacksT &Callbacks) {
1868 StringRef NameNoBracket = Name.take_until([](char C) { return C == '<'; });
1869
1870 // Explicitly handle pass manager names.
1871 if (Name == "module")
1872 return true;
1873 if (Name == "cgscc")
1874 return true;
1875 if (NameNoBracket == "function")
1876 return true;
1877 if (Name == "coro-cond")
1878 return true;
1879
1880#define MODULE_PASS(NAME, CREATE_PASS) \
1881 if (Name == NAME) \
1882 return true;
1883#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1884 if (PassBuilder::checkParametrizedPassName(Name, NAME)) \
1885 return true;
1886#define MODULE_ANALYSIS(NAME, CREATE_PASS) \
1887 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \
1888 return true;
1889#include "PassRegistry.def"
1890
1891 return callbacksAcceptPassName<ModulePassManager>(Name, Callbacks);
1892}
1893
1894template <typename CallbacksT>
1895static bool isCGSCCPassName(StringRef Name, CallbacksT &Callbacks) {
1896 // Explicitly handle pass manager names.
1897 StringRef NameNoBracket = Name.take_until([](char C) { return C == '<'; });
1898 if (Name == "cgscc")
1899 return true;
1900 if (NameNoBracket == "function")
1901 return true;
1902
1903 // Explicitly handle custom-parsed pass names.
1904 if (parseDevirtPassName(Name))
1905 return true;
1906
1907#define CGSCC_PASS(NAME, CREATE_PASS) \
1908 if (Name == NAME) \
1909 return true;
1910#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1911 if (PassBuilder::checkParametrizedPassName(Name, NAME)) \
1912 return true;
1913#define CGSCC_ANALYSIS(NAME, CREATE_PASS) \
1914 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \
1915 return true;
1916#include "PassRegistry.def"
1917
1918 return callbacksAcceptPassName<CGSCCPassManager>(Name, Callbacks);
1919}
1920
1921template <typename CallbacksT>
1922static bool isFunctionPassName(StringRef Name, CallbacksT &Callbacks) {
1923 // Explicitly handle pass manager names.
1924 StringRef NameNoBracket = Name.take_until([](char C) { return C == '<'; });
1925 if (NameNoBracket == "function")
1926 return true;
1927 if (Name == "loop" || Name == "loop-mssa" || Name == "machine-function")
1928 return true;
1929
1930#define FUNCTION_PASS(NAME, CREATE_PASS) \
1931 if (Name == NAME) \
1932 return true;
1933#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1934 if (PassBuilder::checkParametrizedPassName(Name, NAME)) \
1935 return true;
1936#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
1937 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \
1938 return true;
1939#include "PassRegistry.def"
1940
1941 return callbacksAcceptPassName<FunctionPassManager>(Name, Callbacks);
1942}
1943
1944template <typename CallbacksT>
1945static bool isMachineFunctionPassName(StringRef Name, CallbacksT &Callbacks) {
1946 // Explicitly handle pass manager names.
1947 if (Name == "machine-function")
1948 return true;
1949
1950#define MACHINE_FUNCTION_PASS(NAME, CREATE_PASS) \
1951 if (Name == NAME) \
1952 return true;
1953#define MACHINE_FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, \
1954 PARAMS) \
1955 if (PassBuilder::checkParametrizedPassName(Name, NAME)) \
1956 return true;
1957
1958#define MACHINE_FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
1959 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \
1960 return true;
1961
1962#include "llvm/Passes/MachinePassRegistry.def"
1963
1965}
1966
1967template <typename CallbacksT>
1968static bool isLoopNestPassName(StringRef Name, CallbacksT &Callbacks,
1969 bool &UseMemorySSA) {
1970 UseMemorySSA = false;
1971
1972 if (PassBuilder::checkParametrizedPassName(Name, "lnicm")) {
1973 UseMemorySSA = true;
1974 return true;
1975 }
1976
1977#define LOOPNEST_PASS(NAME, CREATE_PASS) \
1978 if (Name == NAME) \
1979 return true;
1980#include "PassRegistry.def"
1981
1982 return callbacksAcceptPassName<LoopPassManager>(Name, Callbacks);
1983}
1984
1985template <typename CallbacksT>
1986static bool isLoopPassName(StringRef Name, CallbacksT &Callbacks,
1987 bool &UseMemorySSA) {
1988 UseMemorySSA = false;
1989
1990 if (PassBuilder::checkParametrizedPassName(Name, "licm")) {
1991 UseMemorySSA = true;
1992 return true;
1993 }
1994
1995#define LOOP_PASS(NAME, CREATE_PASS) \
1996 if (Name == NAME) \
1997 return true;
1998#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1999 if (PassBuilder::checkParametrizedPassName(Name, NAME)) \
2000 return true;
2001#define LOOP_ANALYSIS(NAME, CREATE_PASS) \
2002 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \
2003 return true;
2004#include "PassRegistry.def"
2005
2006 return callbacksAcceptPassName<LoopPassManager>(Name, Callbacks);
2007}
2008
2009std::optional<std::vector<PassBuilder::PipelineElement>>
2010PassBuilder::parsePipelineText(StringRef Text) {
2011 std::vector<PipelineElement> ResultPipeline;
2012
2013 SmallVector<std::vector<PipelineElement> *, 4> PipelineStack = {
2014 &ResultPipeline};
2015 for (;;) {
2016 std::vector<PipelineElement> &Pipeline = *PipelineStack.back();
2017 size_t Pos = Text.find_first_of(",()");
2018 Pipeline.push_back({Text.substr(0, Pos), {}});
2019
2020 // If we have a single terminating name, we're done.
2021 if (Pos == Text.npos)
2022 break;
2023
2024 char Sep = Text[Pos];
2025 Text = Text.substr(Pos + 1);
2026 if (Sep == ',')
2027 // Just a name ending in a comma, continue.
2028 continue;
2029
2030 if (Sep == '(') {
2031 // Push the inner pipeline onto the stack to continue processing.
2032 PipelineStack.push_back(&Pipeline.back().InnerPipeline);
2033 continue;
2034 }
2035
2036 assert(Sep == ')' && "Bogus separator!");
2037 // When handling the close parenthesis, we greedily consume them to avoid
2038 // empty strings in the pipeline.
2039 do {
2040 // If we try to pop the outer pipeline we have unbalanced parentheses.
2041 if (PipelineStack.size() == 1)
2042 return std::nullopt;
2043
2044 PipelineStack.pop_back();
2045 } while (Text.consume_front(")"));
2046
2047 // Check if we've finished parsing.
2048 if (Text.empty())
2049 break;
2050
2051 // Otherwise, the end of an inner pipeline always has to be followed by
2052 // a comma, and then we can continue.
2053 if (!Text.consume_front(","))
2054 return std::nullopt;
2055 }
2056
2057 if (PipelineStack.size() > 1)
2058 // Unbalanced paretheses.
2059 return std::nullopt;
2060
2061 assert(PipelineStack.back() == &ResultPipeline &&
2062 "Wrong pipeline at the bottom of the stack!");
2063 return {std::move(ResultPipeline)};
2064}
2065
2071
2072Error PassBuilder::parseModulePass(ModulePassManager &MPM,
2073 const PipelineElement &E) {
2074 auto &Name = E.Name;
2075 auto &InnerPipeline = E.InnerPipeline;
2076
2077 // First handle complex passes like the pass managers which carry pipelines.
2078 if (!InnerPipeline.empty()) {
2079 if (Name == "module") {
2080 ModulePassManager NestedMPM;
2081 if (auto Err = parseModulePassPipeline(NestedMPM, InnerPipeline))
2082 return Err;
2083 MPM.addPass(std::move(NestedMPM));
2084 return Error::success();
2085 }
2086 if (Name == "coro-cond") {
2087 ModulePassManager NestedMPM;
2088 if (auto Err = parseModulePassPipeline(NestedMPM, InnerPipeline))
2089 return Err;
2090 MPM.addPass(CoroConditionalWrapper(std::move(NestedMPM)));
2091 return Error::success();
2092 }
2093 if (Name == "cgscc") {
2094 CGSCCPassManager CGPM;
2095 if (auto Err = parseCGSCCPassPipeline(CGPM, InnerPipeline))
2096 return Err;
2098 return Error::success();
2099 }
2100 if (auto Params = parseFunctionPipelineName(Name)) {
2101 if (Params->second)
2103 "cannot have a no-rerun module to function adaptor",
2106 if (auto Err = parseFunctionPassPipeline(FPM, InnerPipeline))
2107 return Err;
2108 MPM.addPass(
2109 createModuleToFunctionPassAdaptor(std::move(FPM), Params->first));
2110 return Error::success();
2111 }
2112
2113 for (auto &C : ModulePipelineParsingCallbacks)
2114 if (C(Name, MPM, InnerPipeline))
2115 return Error::success();
2116
2117 // Normal passes can't have pipelines.
2119 formatv("invalid use of '{}' pass as module pipeline", Name).str(),
2121 ;
2122 }
2123
2124 // Finally expand the basic registered passes from the .inc file.
2125#define MODULE_PASS(NAME, CREATE_PASS) \
2126 if (Name == NAME) { \
2127 MPM.addPass(CREATE_PASS); \
2128 return Error::success(); \
2129 }
2130#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2131 if (checkParametrizedPassName(Name, NAME)) { \
2132 auto Params = parsePassParameters(PARSER, Name, NAME); \
2133 if (!Params) \
2134 return Params.takeError(); \
2135 MPM.addPass(CREATE_PASS(Params.get())); \
2136 return Error::success(); \
2137 }
2138#define MODULE_ANALYSIS(NAME, CREATE_PASS) \
2139 if (Name == "require<" NAME ">") { \
2140 MPM.addPass( \
2141 RequireAnalysisPass< \
2142 std::remove_reference_t<decltype(CREATE_PASS)>, Module>()); \
2143 return Error::success(); \
2144 } \
2145 if (Name == "invalidate<" NAME ">") { \
2146 MPM.addPass(InvalidateAnalysisPass< \
2147 std::remove_reference_t<decltype(CREATE_PASS)>>()); \
2148 return Error::success(); \
2149 }
2150#define CGSCC_PASS(NAME, CREATE_PASS) \
2151 if (Name == NAME) { \
2152 MPM.addPass(createModuleToPostOrderCGSCCPassAdaptor(CREATE_PASS)); \
2153 return Error::success(); \
2154 }
2155#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2156 if (checkParametrizedPassName(Name, NAME)) { \
2157 auto Params = parsePassParameters(PARSER, Name, NAME); \
2158 if (!Params) \
2159 return Params.takeError(); \
2160 MPM.addPass( \
2161 createModuleToPostOrderCGSCCPassAdaptor(CREATE_PASS(Params.get()))); \
2162 return Error::success(); \
2163 }
2164#define FUNCTION_PASS(NAME, CREATE_PASS) \
2165 if (Name == NAME) { \
2166 if constexpr (std::is_constructible_v< \
2167 std::remove_reference_t<decltype(CREATE_PASS)>, \
2168 const TargetMachine &>) { \
2169 if (!TM) \
2170 return make_error<StringError>( \
2171 formatv("pass '{0}' requires TargetMachine", Name).str(), \
2172 inconvertibleErrorCode()); \
2173 } \
2174 MPM.addPass(createModuleToFunctionPassAdaptor(CREATE_PASS)); \
2175 return Error::success(); \
2176 }
2177#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2178 if (checkParametrizedPassName(Name, NAME)) { \
2179 auto Params = parsePassParameters(PARSER, Name, NAME); \
2180 if (!Params) \
2181 return Params.takeError(); \
2182 auto CreatePass = CREATE_PASS; \
2183 if constexpr (std::is_constructible_v< \
2184 std::remove_reference_t<decltype(CreatePass( \
2185 Params.get()))>, \
2186 const TargetMachine &, \
2187 std::remove_reference_t<decltype(Params.get())>>) { \
2188 if (!TM) { \
2189 return make_error<StringError>( \
2190 formatv("pass '{0}' requires TargetMachine", Name).str(), \
2191 inconvertibleErrorCode()); \
2192 } \
2193 } \
2194 MPM.addPass(createModuleToFunctionPassAdaptor(CREATE_PASS(Params.get()))); \
2195 return Error::success(); \
2196 }
2197#define LOOPNEST_PASS(NAME, CREATE_PASS) \
2198 if (Name == NAME) { \
2199 MPM.addPass(createModuleToFunctionPassAdaptor( \
2200 createFunctionToLoopPassAdaptor(CREATE_PASS, false))); \
2201 return Error::success(); \
2202 }
2203#define LOOP_PASS(NAME, CREATE_PASS) \
2204 if (Name == NAME) { \
2205 MPM.addPass(createModuleToFunctionPassAdaptor( \
2206 createFunctionToLoopPassAdaptor(CREATE_PASS, false))); \
2207 return Error::success(); \
2208 }
2209#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2210 if (checkParametrizedPassName(Name, NAME)) { \
2211 auto Params = parsePassParameters(PARSER, Name, NAME); \
2212 if (!Params) \
2213 return Params.takeError(); \
2214 MPM.addPass(createModuleToFunctionPassAdaptor( \
2215 createFunctionToLoopPassAdaptor(CREATE_PASS(Params.get()), false))); \
2216 return Error::success(); \
2217 }
2218#include "PassRegistry.def"
2219
2220 for (auto &C : ModulePipelineParsingCallbacks)
2221 if (C(Name, MPM, InnerPipeline))
2222 return Error::success();
2224 formatv("unknown module pass '{}'", Name).str(),
2226}
2227
2228Error PassBuilder::parseCGSCCPass(CGSCCPassManager &CGPM,
2229 const PipelineElement &E) {
2230 auto &Name = E.Name;
2231 auto &InnerPipeline = E.InnerPipeline;
2232
2233 // First handle complex passes like the pass managers which carry pipelines.
2234 if (!InnerPipeline.empty()) {
2235 if (Name == "cgscc") {
2236 CGSCCPassManager NestedCGPM;
2237 if (auto Err = parseCGSCCPassPipeline(NestedCGPM, InnerPipeline))
2238 return Err;
2239 // Add the nested pass manager with the appropriate adaptor.
2240 CGPM.addPass(std::move(NestedCGPM));
2241 return Error::success();
2242 }
2243 if (auto Params = parseFunctionPipelineName(Name)) {
2245 if (auto Err = parseFunctionPassPipeline(FPM, InnerPipeline))
2246 return Err;
2247 // Add the nested pass manager with the appropriate adaptor.
2249 std::move(FPM), Params->first, Params->second));
2250 return Error::success();
2251 }
2252 if (auto MaxRepetitions = parseDevirtPassName(Name)) {
2253 CGSCCPassManager NestedCGPM;
2254 if (auto Err = parseCGSCCPassPipeline(NestedCGPM, InnerPipeline))
2255 return Err;
2256 CGPM.addPass(
2257 createDevirtSCCRepeatedPass(std::move(NestedCGPM), *MaxRepetitions));
2258 return Error::success();
2259 }
2260
2261 for (auto &C : CGSCCPipelineParsingCallbacks)
2262 if (C(Name, CGPM, InnerPipeline))
2263 return Error::success();
2264
2265 // Normal passes can't have pipelines.
2267 formatv("invalid use of '{}' pass as cgscc pipeline", Name).str(),
2269 }
2270
2271// Now expand the basic registered passes from the .inc file.
2272#define CGSCC_PASS(NAME, CREATE_PASS) \
2273 if (Name == NAME) { \
2274 CGPM.addPass(CREATE_PASS); \
2275 return Error::success(); \
2276 }
2277#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2278 if (checkParametrizedPassName(Name, NAME)) { \
2279 auto Params = parsePassParameters(PARSER, Name, NAME); \
2280 if (!Params) \
2281 return Params.takeError(); \
2282 CGPM.addPass(CREATE_PASS(Params.get())); \
2283 return Error::success(); \
2284 }
2285#define CGSCC_ANALYSIS(NAME, CREATE_PASS) \
2286 if (Name == "require<" NAME ">") { \
2287 CGPM.addPass(RequireAnalysisPass< \
2288 std::remove_reference_t<decltype(CREATE_PASS)>, \
2289 LazyCallGraph::SCC, CGSCCAnalysisManager, LazyCallGraph &, \
2290 CGSCCUpdateResult &>()); \
2291 return Error::success(); \
2292 } \
2293 if (Name == "invalidate<" NAME ">") { \
2294 CGPM.addPass(InvalidateAnalysisPass< \
2295 std::remove_reference_t<decltype(CREATE_PASS)>>()); \
2296 return Error::success(); \
2297 }
2298#define FUNCTION_PASS(NAME, CREATE_PASS) \
2299 if (Name == NAME) { \
2300 if constexpr (std::is_constructible_v< \
2301 std::remove_reference_t<decltype(CREATE_PASS)>, \
2302 const TargetMachine &>) { \
2303 if (!TM) \
2304 return make_error<StringError>( \
2305 formatv("pass '{0}' requires TargetMachine", Name).str(), \
2306 inconvertibleErrorCode()); \
2307 } \
2308 CGPM.addPass(createCGSCCToFunctionPassAdaptor(CREATE_PASS)); \
2309 return Error::success(); \
2310 }
2311#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2312 if (checkParametrizedPassName(Name, NAME)) { \
2313 auto Params = parsePassParameters(PARSER, Name, NAME); \
2314 if (!Params) \
2315 return Params.takeError(); \
2316 auto CreatePass = CREATE_PASS; \
2317 if constexpr (std::is_constructible_v< \
2318 std::remove_reference_t<decltype(CreatePass( \
2319 Params.get()))>, \
2320 const TargetMachine &, \
2321 std::remove_reference_t<decltype(Params.get())>>) { \
2322 if (!TM) { \
2323 return make_error<StringError>( \
2324 formatv("pass '{0}' requires TargetMachine", Name).str(), \
2325 inconvertibleErrorCode()); \
2326 } \
2327 } \
2328 CGPM.addPass(createCGSCCToFunctionPassAdaptor(CREATE_PASS(Params.get()))); \
2329 return Error::success(); \
2330 }
2331#define LOOPNEST_PASS(NAME, CREATE_PASS) \
2332 if (Name == NAME) { \
2333 CGPM.addPass(createCGSCCToFunctionPassAdaptor( \
2334 createFunctionToLoopPassAdaptor(CREATE_PASS, false))); \
2335 return Error::success(); \
2336 }
2337#define LOOP_PASS(NAME, CREATE_PASS) \
2338 if (Name == NAME) { \
2339 CGPM.addPass(createCGSCCToFunctionPassAdaptor( \
2340 createFunctionToLoopPassAdaptor(CREATE_PASS, false))); \
2341 return Error::success(); \
2342 }
2343#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2344 if (checkParametrizedPassName(Name, NAME)) { \
2345 auto Params = parsePassParameters(PARSER, Name, NAME); \
2346 if (!Params) \
2347 return Params.takeError(); \
2348 CGPM.addPass(createCGSCCToFunctionPassAdaptor( \
2349 createFunctionToLoopPassAdaptor(CREATE_PASS(Params.get()), false))); \
2350 return Error::success(); \
2351 }
2352#include "PassRegistry.def"
2353
2354 for (auto &C : CGSCCPipelineParsingCallbacks)
2355 if (C(Name, CGPM, InnerPipeline))
2356 return Error::success();
2357 return make_error<StringError>(formatv("unknown cgscc pass '{}'", Name).str(),
2359}
2360
2361Error PassBuilder::parseFunctionPass(FunctionPassManager &FPM,
2362 const PipelineElement &E) {
2363 auto &Name = E.Name;
2364 auto &InnerPipeline = E.InnerPipeline;
2365
2366 // First handle complex passes like the pass managers which carry pipelines.
2367 if (!InnerPipeline.empty()) {
2368 if (Name == "function") {
2369 FunctionPassManager NestedFPM;
2370 if (auto Err = parseFunctionPassPipeline(NestedFPM, InnerPipeline))
2371 return Err;
2372 // Add the nested pass manager with the appropriate adaptor.
2373 FPM.addPass(std::move(NestedFPM));
2374 return Error::success();
2375 }
2376 if (Name == "loop" || Name == "loop-mssa") {
2377 LoopPassManager LPM;
2378 if (auto Err = parseLoopPassPipeline(LPM, InnerPipeline))
2379 return Err;
2380 // Add the nested pass manager with the appropriate adaptor.
2381 bool UseMemorySSA = (Name == "loop-mssa");
2382 FPM.addPass(
2383 createFunctionToLoopPassAdaptor(std::move(LPM), UseMemorySSA));
2384 return Error::success();
2385 }
2386 if (Name == "machine-function") {
2388 if (auto Err = parseMachinePassPipeline(MFPM, InnerPipeline))
2389 return Err;
2391 return Error::success();
2392 }
2393
2394 for (auto &C : FunctionPipelineParsingCallbacks)
2395 if (C(Name, FPM, InnerPipeline))
2396 return Error::success();
2397
2398 // Normal passes can't have pipelines.
2400 formatv("invalid use of '{}' pass as function pipeline", Name).str(),
2402 }
2403
2404// Now expand the basic registered passes from the .inc file.
2405#define FUNCTION_PASS(NAME, CREATE_PASS) \
2406 if (Name == NAME) { \
2407 if constexpr (std::is_constructible_v< \
2408 std::remove_reference_t<decltype(CREATE_PASS)>, \
2409 const TargetMachine &>) { \
2410 if (!TM) \
2411 return make_error<StringError>( \
2412 formatv("pass '{0}' requires TargetMachine", Name).str(), \
2413 inconvertibleErrorCode()); \
2414 } \
2415 FPM.addPass(CREATE_PASS); \
2416 return Error::success(); \
2417 }
2418#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2419 if (checkParametrizedPassName(Name, NAME)) { \
2420 auto Params = parsePassParameters(PARSER, Name, NAME); \
2421 if (!Params) \
2422 return Params.takeError(); \
2423 auto CreatePass = CREATE_PASS; \
2424 if constexpr (std::is_constructible_v< \
2425 std::remove_reference_t<decltype(CreatePass( \
2426 Params.get()))>, \
2427 const TargetMachine &, \
2428 std::remove_reference_t<decltype(Params.get())>>) { \
2429 if (!TM) { \
2430 return make_error<StringError>( \
2431 formatv("pass '{0}' requires TargetMachine", Name).str(), \
2432 inconvertibleErrorCode()); \
2433 } \
2434 } \
2435 FPM.addPass(CREATE_PASS(Params.get())); \
2436 return Error::success(); \
2437 }
2438#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
2439 if (Name == "require<" NAME ">") { \
2440 if constexpr (std::is_constructible_v< \
2441 std::remove_reference_t<decltype(CREATE_PASS)>, \
2442 const TargetMachine &>) { \
2443 if (!TM) \
2444 return make_error<StringError>( \
2445 formatv("pass '{0}' requires TargetMachine", Name).str(), \
2446 inconvertibleErrorCode()); \
2447 } \
2448 FPM.addPass( \
2449 RequireAnalysisPass<std::remove_reference_t<decltype(CREATE_PASS)>, \
2450 Function>()); \
2451 return Error::success(); \
2452 } \
2453 if (Name == "invalidate<" NAME ">") { \
2454 FPM.addPass(InvalidateAnalysisPass< \
2455 std::remove_reference_t<decltype(CREATE_PASS)>>()); \
2456 return Error::success(); \
2457 }
2458// FIXME: UseMemorySSA is set to false. Maybe we could do things like:
2459// bool UseMemorySSA = !("canon-freeze" || "loop-predication" ||
2460// "guard-widening");
2461// The risk is that it may become obsolete if we're not careful.
2462#define LOOPNEST_PASS(NAME, CREATE_PASS) \
2463 if (Name == NAME) { \
2464 FPM.addPass(createFunctionToLoopPassAdaptor(CREATE_PASS, false)); \
2465 return Error::success(); \
2466 }
2467#define LOOP_PASS(NAME, CREATE_PASS) \
2468 if (Name == NAME) { \
2469 FPM.addPass(createFunctionToLoopPassAdaptor(CREATE_PASS, false)); \
2470 return Error::success(); \
2471 }
2472#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2473 if (checkParametrizedPassName(Name, NAME)) { \
2474 auto Params = parsePassParameters(PARSER, Name, NAME); \
2475 if (!Params) \
2476 return Params.takeError(); \
2477 FPM.addPass( \
2478 createFunctionToLoopPassAdaptor(CREATE_PASS(Params.get()), false)); \
2479 return Error::success(); \
2480 }
2481#include "PassRegistry.def"
2482
2483 for (auto &C : FunctionPipelineParsingCallbacks)
2484 if (C(Name, FPM, InnerPipeline))
2485 return Error::success();
2487 formatv("unknown function pass '{}'", Name).str(),
2489}
2490
2491Error PassBuilder::parseLoopPass(LoopPassManager &LPM,
2492 const PipelineElement &E) {
2493 StringRef Name = E.Name;
2494 auto &InnerPipeline = E.InnerPipeline;
2495
2496 // First handle complex passes like the pass managers which carry pipelines.
2497 if (!InnerPipeline.empty()) {
2498 if (Name == "loop") {
2499 LoopPassManager NestedLPM;
2500 if (auto Err = parseLoopPassPipeline(NestedLPM, InnerPipeline))
2501 return Err;
2502 // Add the nested pass manager with the appropriate adaptor.
2503 LPM.addPass(std::move(NestedLPM));
2504 return Error::success();
2505 }
2506
2507 for (auto &C : LoopPipelineParsingCallbacks)
2508 if (C(Name, LPM, InnerPipeline))
2509 return Error::success();
2510
2511 // Normal passes can't have pipelines.
2513 formatv("invalid use of '{}' pass as loop pipeline", Name).str(),
2515 }
2516
2517// Now expand the basic registered passes from the .inc file.
2518#define LOOPNEST_PASS(NAME, CREATE_PASS) \
2519 if (Name == NAME) { \
2520 LPM.addPass(CREATE_PASS); \
2521 return Error::success(); \
2522 }
2523#define LOOP_PASS(NAME, CREATE_PASS) \
2524 if (Name == NAME) { \
2525 LPM.addPass(CREATE_PASS); \
2526 return Error::success(); \
2527 }
2528#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2529 if (checkParametrizedPassName(Name, NAME)) { \
2530 auto Params = parsePassParameters(PARSER, Name, NAME); \
2531 if (!Params) \
2532 return Params.takeError(); \
2533 LPM.addPass(CREATE_PASS(Params.get())); \
2534 return Error::success(); \
2535 }
2536#define LOOP_ANALYSIS(NAME, CREATE_PASS) \
2537 if (Name == "require<" NAME ">") { \
2538 LPM.addPass(RequireAnalysisPass< \
2539 std::remove_reference_t<decltype(CREATE_PASS)>, Loop, \
2540 LoopAnalysisManager, LoopStandardAnalysisResults &, \
2541 LPMUpdater &>()); \
2542 return Error::success(); \
2543 } \
2544 if (Name == "invalidate<" NAME ">") { \
2545 LPM.addPass(InvalidateAnalysisPass< \
2546 std::remove_reference_t<decltype(CREATE_PASS)>>()); \
2547 return Error::success(); \
2548 }
2549#include "PassRegistry.def"
2550
2551 for (auto &C : LoopPipelineParsingCallbacks)
2552 if (C(Name, LPM, InnerPipeline))
2553 return Error::success();
2554 return make_error<StringError>(formatv("unknown loop pass '{}'", Name).str(),
2556}
2557
2558Error PassBuilder::parseMachinePass(MachineFunctionPassManager &MFPM,
2559 const PipelineElement &E) {
2560 StringRef Name = E.Name;
2561 // Handle any nested pass managers.
2562 if (!E.InnerPipeline.empty()) {
2563 if (E.Name == "machine-function") {
2565 if (auto Err = parseMachinePassPipeline(NestedPM, E.InnerPipeline))
2566 return Err;
2567 MFPM.addPass(std::move(NestedPM));
2568 return Error::success();
2569 }
2570 return make_error<StringError>("invalid pipeline",
2572 }
2573
2574#define MACHINE_MODULE_PASS(NAME, CREATE_PASS) \
2575 if (Name == NAME) { \
2576 MFPM.addPass(CREATE_PASS); \
2577 return Error::success(); \
2578 }
2579#define MACHINE_FUNCTION_PASS(NAME, CREATE_PASS) \
2580 if (Name == NAME) { \
2581 MFPM.addPass(CREATE_PASS); \
2582 return Error::success(); \
2583 }
2584#define MACHINE_FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, \
2585 PARAMS) \
2586 if (checkParametrizedPassName(Name, NAME)) { \
2587 auto Params = parsePassParameters(PARSER, Name, NAME); \
2588 if (!Params) \
2589 return Params.takeError(); \
2590 MFPM.addPass(CREATE_PASS(Params.get())); \
2591 return Error::success(); \
2592 }
2593#define MACHINE_FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
2594 if (Name == "require<" NAME ">") { \
2595 MFPM.addPass( \
2596 RequireAnalysisPass<std::remove_reference_t<decltype(CREATE_PASS)>, \
2597 MachineFunction>()); \
2598 return Error::success(); \
2599 } \
2600 if (Name == "invalidate<" NAME ">") { \
2601 MFPM.addPass(InvalidateAnalysisPass< \
2602 std::remove_reference_t<decltype(CREATE_PASS)>>()); \
2603 return Error::success(); \
2604 }
2605#include "llvm/Passes/MachinePassRegistry.def"
2606
2607 for (auto &C : MachineFunctionPipelineParsingCallbacks)
2608 if (C(Name, MFPM, E.InnerPipeline))
2609 return Error::success();
2611 formatv("unknown machine pass '{}'", Name).str(),
2613}
2614
2615bool PassBuilder::parseAAPassName(AAManager &AA, StringRef Name) {
2616#define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS) \
2617 if (Name == NAME) { \
2618 AA.registerModuleAnalysis< \
2619 std::remove_reference_t<decltype(CREATE_PASS)>>(); \
2620 return true; \
2621 }
2622#define FUNCTION_ALIAS_ANALYSIS(NAME, CREATE_PASS) \
2623 if (Name == NAME) { \
2624 AA.registerFunctionAnalysis< \
2625 std::remove_reference_t<decltype(CREATE_PASS)>>(); \
2626 return true; \
2627 }
2628#include "PassRegistry.def"
2629
2630 for (auto &C : AAParsingCallbacks)
2631 if (C(Name, AA))
2632 return true;
2633 return false;
2634}
2635
2636Error PassBuilder::parseMachinePassPipeline(
2638 for (const auto &Element : Pipeline) {
2639 if (auto Err = parseMachinePass(MFPM, Element))
2640 return Err;
2641 }
2642 return Error::success();
2643}
2644
2645Error PassBuilder::parseLoopPassPipeline(LoopPassManager &LPM,
2646 ArrayRef<PipelineElement> Pipeline) {
2647 for (const auto &Element : Pipeline) {
2648 if (auto Err = parseLoopPass(LPM, Element))
2649 return Err;
2650 }
2651 return Error::success();
2652}
2653
2654Error PassBuilder::parseFunctionPassPipeline(
2656 for (const auto &Element : Pipeline) {
2657 if (auto Err = parseFunctionPass(FPM, Element))
2658 return Err;
2659 }
2660 return Error::success();
2661}
2662
2663Error PassBuilder::parseCGSCCPassPipeline(CGSCCPassManager &CGPM,
2664 ArrayRef<PipelineElement> Pipeline) {
2665 for (const auto &Element : Pipeline) {
2666 if (auto Err = parseCGSCCPass(CGPM, Element))
2667 return Err;
2668 }
2669 return Error::success();
2670}
2671
2677 MAM.registerPass([&] { return FunctionAnalysisManagerModuleProxy(FAM); });
2678 MAM.registerPass([&] { return CGSCCAnalysisManagerModuleProxy(CGAM); });
2679 CGAM.registerPass([&] { return ModuleAnalysisManagerCGSCCProxy(MAM); });
2680 FAM.registerPass([&] { return CGSCCAnalysisManagerFunctionProxy(CGAM); });
2681 FAM.registerPass([&] { return ModuleAnalysisManagerFunctionProxy(MAM); });
2682 FAM.registerPass([&] { return LoopAnalysisManagerFunctionProxy(LAM); });
2683 LAM.registerPass([&] { return FunctionAnalysisManagerLoopProxy(FAM); });
2684 if (MFAM) {
2685 MAM.registerPass(
2686 [&] { return MachineFunctionAnalysisManagerModuleProxy(*MFAM); });
2687 FAM.registerPass(
2688 [&] { return MachineFunctionAnalysisManagerFunctionProxy(*MFAM); });
2689 MFAM->registerPass(
2691 MFAM->registerPass(
2693 }
2694}
2695
2696Error PassBuilder::parseModulePassPipeline(ModulePassManager &MPM,
2697 ArrayRef<PipelineElement> Pipeline) {
2698 for (const auto &Element : Pipeline) {
2699 if (auto Err = parseModulePass(MPM, Element))
2700 return Err;
2701 }
2702 return Error::success();
2703}
2704
2705// Primary pass pipeline description parsing routine for a \c ModulePassManager
2706// FIXME: Should this routine accept a TargetMachine or require the caller to
2707// pre-populate the analysis managers with target-specific stuff?
2709 StringRef PipelineText) {
2710 auto Pipeline = parsePipelineText(PipelineText);
2711 if (!Pipeline || Pipeline->empty())
2713 formatv("invalid pipeline '{}'", PipelineText).str(),
2715
2716 // If the first name isn't at the module layer, wrap the pipeline up
2717 // automatically.
2718 StringRef FirstName = Pipeline->front().Name;
2719
2720 if (!isModulePassName(FirstName, ModulePipelineParsingCallbacks)) {
2721 bool UseMemorySSA;
2722 if (isCGSCCPassName(FirstName, CGSCCPipelineParsingCallbacks)) {
2723 Pipeline = {{"cgscc", std::move(*Pipeline)}};
2724 } else if (isFunctionPassName(FirstName,
2725 FunctionPipelineParsingCallbacks)) {
2726 Pipeline = {{"function", std::move(*Pipeline)}};
2727 } else if (isLoopNestPassName(FirstName, LoopPipelineParsingCallbacks,
2728 UseMemorySSA)) {
2729 Pipeline = {{"function", {{UseMemorySSA ? "loop-mssa" : "loop",
2730 std::move(*Pipeline)}}}};
2731 } else if (isLoopPassName(FirstName, LoopPipelineParsingCallbacks,
2732 UseMemorySSA)) {
2733 Pipeline = {{"function", {{UseMemorySSA ? "loop-mssa" : "loop",
2734 std::move(*Pipeline)}}}};
2735 } else if (isMachineFunctionPassName(
2736 FirstName, MachineFunctionPipelineParsingCallbacks)) {
2737 Pipeline = {{"function", {{"machine-function", std::move(*Pipeline)}}}};
2738 } else {
2739 for (auto &C : TopLevelPipelineParsingCallbacks)
2740 if (C(MPM, *Pipeline))
2741 return Error::success();
2742
2743 // Unknown pass or pipeline name!
2744 auto &InnerPipeline = Pipeline->front().InnerPipeline;
2746 formatv("unknown {} name '{}'",
2747 (InnerPipeline.empty() ? "pass" : "pipeline"), FirstName)
2748 .str(),
2750 }
2751 }
2752
2753 if (auto Err = parseModulePassPipeline(MPM, *Pipeline))
2754 return Err;
2755 return Error::success();
2756}
2757
2758// Primary pass pipeline description parsing routine for a \c CGSCCPassManager
2760 StringRef PipelineText) {
2761 auto Pipeline = parsePipelineText(PipelineText);
2762 if (!Pipeline || Pipeline->empty())
2764 formatv("invalid pipeline '{}'", PipelineText).str(),
2766
2767 StringRef FirstName = Pipeline->front().Name;
2768 if (!isCGSCCPassName(FirstName, CGSCCPipelineParsingCallbacks))
2770 formatv("unknown cgscc pass '{}' in pipeline '{}'", FirstName,
2771 PipelineText)
2772 .str(),
2774
2775 if (auto Err = parseCGSCCPassPipeline(CGPM, *Pipeline))
2776 return Err;
2777 return Error::success();
2778}
2779
2780// Primary pass pipeline description parsing routine for a \c
2781// FunctionPassManager
2783 StringRef PipelineText) {
2784 auto Pipeline = parsePipelineText(PipelineText);
2785 if (!Pipeline || Pipeline->empty())
2787 formatv("invalid pipeline '{}'", PipelineText).str(),
2789
2790 StringRef FirstName = Pipeline->front().Name;
2791 if (!isFunctionPassName(FirstName, FunctionPipelineParsingCallbacks))
2793 formatv("unknown function pass '{}' in pipeline '{}'", FirstName,
2794 PipelineText)
2795 .str(),
2797
2798 if (auto Err = parseFunctionPassPipeline(FPM, *Pipeline))
2799 return Err;
2800 return Error::success();
2801}
2802
2803// Primary pass pipeline description parsing routine for a \c LoopPassManager
2805 StringRef PipelineText) {
2806 auto Pipeline = parsePipelineText(PipelineText);
2807 if (!Pipeline || Pipeline->empty())
2809 formatv("invalid pipeline '{}'", PipelineText).str(),
2811
2812 if (auto Err = parseLoopPassPipeline(CGPM, *Pipeline))
2813 return Err;
2814
2815 return Error::success();
2816}
2817
2819 StringRef PipelineText) {
2820 auto Pipeline = parsePipelineText(PipelineText);
2821 if (!Pipeline || Pipeline->empty())
2823 formatv("invalid machine pass pipeline '{}'", PipelineText).str(),
2825
2826 if (auto Err = parseMachinePassPipeline(MFPM, *Pipeline))
2827 return Err;
2828
2829 return Error::success();
2830}
2831
2833 // If the pipeline just consists of the word 'default' just replace the AA
2834 // manager with our default one.
2835 if (PipelineText == "default") {
2837 return Error::success();
2838 }
2839
2840 while (!PipelineText.empty()) {
2841 StringRef Name;
2842 std::tie(Name, PipelineText) = PipelineText.split(',');
2843 if (!parseAAPassName(AA, Name))
2845 formatv("unknown alias analysis name '{}'", Name).str(),
2847 }
2848
2849 return Error::success();
2850}
2851
2852std::optional<RegAllocFilterFunc>
2854 if (FilterName == "all")
2855 return nullptr;
2856 for (auto &C : RegClassFilterParsingCallbacks)
2857 if (auto F = C(FilterName))
2858 return F;
2859 return std::nullopt;
2860}
2861
2863 raw_ostream &OS) {
2864 for (StringRef PassName : PassNames)
2865 OS << " " << PassName << '\n';
2866}
2867
2868LLVM_ATTRIBUTE_NOINLINE static void
2870 auto I = PassNames.begin();
2871 auto End = PassNames.end();
2872 while (I != End) {
2873 StringRef Name = *I;
2874 ++I;
2875 assert(I != End);
2876 StringRef Params = *I;
2877 ++I;
2878 OS << " " << Name << '<' << Params << ">\n";
2879 }
2880}
2881
2883 // TODO: print pass descriptions when they are available
2884
2885 OS << "Module passes:\n";
2886 static constexpr char ModulePassNames[] = {"\0"
2887#define MODULE_PASS(NAME, CREATE_PASS) NAME "\0"
2888#include "PassRegistry.def"
2889 };
2890 printPassNameList(StringTable(ModulePassNames), OS);
2891
2892 OS << "Module passes with params:\n";
2893 static constexpr char ModulePassNamesWithParams[] = {"\0"
2894#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2895 NAME "\0" PARAMS "\0"
2896#include "PassRegistry.def"
2897 };
2898 printPassNameListWithParams(StringTable(ModulePassNamesWithParams), OS);
2899
2900 OS << "Module analyses:\n";
2901 static constexpr char ModuleAnalysisNames[] = {"\0"
2902#define MODULE_ANALYSIS(NAME, CREATE_PASS) NAME "\0"
2903#include "PassRegistry.def"
2904 };
2905 printPassNameList(StringTable(ModuleAnalysisNames), OS);
2906
2907 OS << "Module alias analyses:\n";
2908 static constexpr char ModuleAliasAnalysisNames[] = {"\0"
2909#define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS) NAME "\0"
2910#include "PassRegistry.def"
2911 };
2912 printPassNameList(StringTable(ModuleAliasAnalysisNames), OS);
2913
2914 OS << "CGSCC passes:\n";
2915 static constexpr char CGSCCPassNames[] = {"\0"
2916#define CGSCC_PASS(NAME, CREATE_PASS) NAME "\0"
2917#include "PassRegistry.def"
2918 };
2919 printPassNameList(StringTable(CGSCCPassNames), OS);
2920
2921 OS << "CGSCC passes with params:\n";
2922 static constexpr char CGSCCPassNamesWithParams[] = {"\0"
2923#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2924 NAME "\0" PARAMS "\0"
2925#include "PassRegistry.def"
2926 };
2927 printPassNameListWithParams(StringTable(CGSCCPassNamesWithParams), OS);
2928
2929 OS << "CGSCC analyses:\n";
2930 static constexpr char CGSCCAnalysisNames[] = {"\0"
2931#define CGSCC_ANALYSIS(NAME, CREATE_PASS) NAME "\0"
2932#include "PassRegistry.def"
2933 };
2934 printPassNameList(StringTable(CGSCCAnalysisNames), OS);
2935
2936 OS << "Function passes:\n";
2937 static constexpr char FunctionPassNames[] = {"\0"
2938#define FUNCTION_PASS(NAME, CREATE_PASS) NAME "\0"
2939#include "PassRegistry.def"
2940 };
2941 printPassNameList(StringTable(FunctionPassNames), OS);
2942
2943 OS << "Function passes with params:\n";
2944 static constexpr char FunctionPassNamesWithParams[] = {"\0"
2945#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2946 NAME "\0" PARAMS "\0"
2947#include "PassRegistry.def"
2948 };
2949 printPassNameListWithParams(StringTable(FunctionPassNamesWithParams), OS);
2950
2951 OS << "Function analyses:\n";
2952 static constexpr char FunctionAnalysisNames[] = {"\0"
2953#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) NAME "\0"
2954#include "PassRegistry.def"
2955 };
2956 printPassNameList(StringTable(FunctionAnalysisNames), OS);
2957
2958 OS << "Function alias analyses:\n";
2959 static constexpr char FunctionAliasAnalysisNames[] = {"\0"
2960#define FUNCTION_ALIAS_ANALYSIS(NAME, CREATE_PASS) NAME "\0"
2961#include "PassRegistry.def"
2962 };
2963 printPassNameList(StringTable(FunctionAliasAnalysisNames), OS);
2964
2965 OS << "LoopNest passes:\n";
2966 static constexpr char LoopNestPassNames[] = {"\0"
2967#define LOOPNEST_PASS(NAME, CREATE_PASS) NAME "\0"
2968#include "PassRegistry.def"
2969 };
2970 printPassNameList(StringTable(LoopNestPassNames), OS);
2971
2972 OS << "Loop passes:\n";
2973 static constexpr char LoopPassNames[] = {"\0"
2974#define LOOP_PASS(NAME, CREATE_PASS) NAME "\0"
2975#include "PassRegistry.def"
2976 };
2977 printPassNameList(StringTable(LoopPassNames), OS);
2978
2979 OS << "Loop passes with params:\n";
2980 static constexpr char LoopPassNamesWithParams[] = {"\0"
2981#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2982 NAME "\0" PARAMS "\0"
2983#include "PassRegistry.def"
2984 };
2985 printPassNameListWithParams(StringTable(LoopPassNamesWithParams), OS);
2986
2987 OS << "Loop analyses:\n";
2988 static constexpr char LoopAnalysisNames[] = {"\0"
2989#define LOOP_ANALYSIS(NAME, CREATE_PASS) NAME "\0"
2990#include "PassRegistry.def"
2991 };
2992 printPassNameList(StringTable(LoopAnalysisNames), OS);
2993
2994 OS << "Machine module passes (WIP):\n";
2995 static constexpr char MachineModulePassNames[] = {"\0"
2996#define MACHINE_MODULE_PASS(NAME, CREATE_PASS) NAME "\0"
2997#include "llvm/Passes/MachinePassRegistry.def"
2998 };
2999 printPassNameList(StringTable(MachineModulePassNames), OS);
3000
3001 OS << "Machine function passes (WIP):\n";
3002 static constexpr char MachineFunctionPassNames[] = {"\0"
3003#define MACHINE_FUNCTION_PASS(NAME, CREATE_PASS) NAME "\0"
3004#include "llvm/Passes/MachinePassRegistry.def"
3005 };
3006 printPassNameList(StringTable(MachineFunctionPassNames), OS);
3007
3008 OS << "Machine function analyses (WIP):\n";
3009 static constexpr char MachineFunctionAnalysisNames[] = {"\0"
3010#define MACHINE_FUNCTION_ANALYSIS(NAME, CREATE_PASS) NAME "\0"
3011#include "llvm/Passes/MachinePassRegistry.def"
3012 };
3013 printPassNameList(StringTable(MachineFunctionAnalysisNames), OS);
3014}
3015
3017 const std::function<bool(ModulePassManager &, ArrayRef<PipelineElement>)>
3018 &C) {
3019 TopLevelPipelineParsingCallbacks.push_back(C);
3020}
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.
This file contains the declaration of the BreakFalseDepsPass class, used to identify and avoid false ...
static GCRegistry::Add< ShadowStackGC > C("shadow-stack", "Very portable GC for uncooperative code generators")
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
Contains definition of the base CFIFixup pass.
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.
Provides analysis for continuously CSEing during GISel passes.
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 contains the declaration of the MachineKCFI class, which is a Machine Pass that implements ...
#define LLVM_ATTRIBUTE_NOINLINE
LLVM_ATTRIBUTE_NOINLINE - On compilers where we have a directive to do so, mark a method "not for inl...
Definition Compiler.h:366
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 the GVNHoist pass.
This file provides the interface for the GVNSink 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.
#define _
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 file declares the IRTranslator pass.
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.
static LVOptions Options
Definition LVOptions.cpp:25
Implements a lazy call graph analysis and related passes for the new pass manager.
This file provides the interface for LLVM's Logical Scalar Replacement of Aggregates pass.
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.
#define F(x, y, z)
Definition MD5.cpp:54
#define I(x, y, z)
Definition MD5.cpp:57
This file defines the MIR2Vec framework for generating Machine IR embeddings.
Machine Check Debug Module
This file contains the declaration of the CheckDebugMachineModulePass class, used by the new pass man...
Machine IR instance of the generic uniformity analysis.
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
LoopAnalysisManager LAM
FunctionAnalysisManager FAM
ModuleAnalysisManager MAM
PassBuilder PB(Mod->getContext(), Machine, PassOpts->PTO, std::nullopt, &PIC)
if(PassOpts->AAPipeline)
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 LLVM_ATTRIBUTE_NOINLINE void printPassNameList(StringTable PassNames, raw_ostream &OS)
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 LLVM_ATTRIBUTE_NOINLINE void printPassNameListWithParams(StringTable PassNames, 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...
MachineRegisterInfo & MRI
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 file describes the interface of the MachineFunctionPass responsible for assigning the generic vi...
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 contains the declaration of the ResetMachineFunctionPass class.
This file provides the interface for LLVM's Scalar Replacement of Aggregates pass.
static const char * name
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...
This pass strips convergence intrinsics and operand bundles as those are only useful when modifying t...
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.
Defines an IR pass for type promotion.
LLVM IR instance of the generic uniformity analysis.
static const char PassName[]
A manager for alias analyses.
Class for arbitrary precision integers.
Definition APInt.h:78
uint64_t getZExtValue() const
Get zero extended value.
Definition APInt.h:1560
int64_t getSExtValue() const
Get sign extended value.
Definition APInt.h:1582
bool registerPass(PassBuilderT &&PassBuilder)
Register an analysis pass with the manager.
PassT::Result & getResult(IRUnitT &IR, ExtraArgTs... ExtraArgs)
Get the result of an analysis pass for a given IR unit.
Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition ArrayRef.h:40
const Instruction * getTerminator() const LLVM_READONLY
Returns the terminator instruction; assumes that the block is well-formed.
Definition BasicBlock.h:237
Lightweight error class with error context and mandatory checking.
Definition Error.h:159
static ErrorSuccess success()
Create a success value.
Definition Error.h:336
Tagged union holding either a T or a Error.
Definition Error.h:485
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...
Definition Globals.cpp:692
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".
This is an important class for using LLVM in a threaded context.
Definition LLVMContext.h:76
This analysis create MachineFunction for given Function.
MachineRegisterInfo & getRegInfo()
getRegInfo - Return information about the registers currently in use.
const MachineFunctionProperties & getProperties() const
Get the function properties.
LLVM_ABI Register createGenericVirtualRegister(LLT Ty, StringRef Name="")
Create and return a new generic virtual register with low-level type Ty.
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 Error parsePassPipeline(ModulePassManager &MPM, StringRef PipelineText)
Parse a textual pass pipeline description into a ModulePassManager.
LLVM_ABI PassBuilder(LLVMContext &Context, TargetMachine *TM=nullptr, std::optional< PipelineTuningOptions > PTO=std::nullopt, std::optional< PGOOptions > PGOOpt=std::nullopt, PassInstrumentationCallbacks *PIC=nullptr, IntrusiveRefCntPtr< vfs::FileSystem > FS=vfs::getRealFileSystem())
The pipelines read the library options of Context, which must outlive the PassBuilder.
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 std::optional< PrintPipelinePassesFormat > getPrintPipelinePasses() const
The format -print-pipeline-passes requests, or std::nullopt if it is not given.
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.
Definition PassBuilder.h:48
bool SLPVectorization
Tuning option to enable/disable slp loop vectorization, set based on opt level.
Definition PassBuilder.h:63
bool LoopVectorization
Tuning option to enable/disable loop vectorization, set based on opt level.
Definition PassBuilder.h:59
static PreservedAnalyses none()
Convenience factory function for the empty preserved set.
Definition Analysis.h:115
static PreservedAnalyses all()
Construct a special preserved set that preserves all passes.
Definition Analysis.h:118
void push_back(const T &Elt)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Represent a constant reference to a string, i.e.
Definition StringRef.h:56
std::pair< StringRef, StringRef > split(char Separator) const
Split into two substrings around the first occurrence of a separator character.
Definition StringRef.h:736
bool getAsInteger(unsigned Radix, T &Result) const
Parse the current string as an integer of the specified radix.
Definition StringRef.h:490
std::string str() const
Get the contents as an std::string.
Definition StringRef.h:222
bool starts_with(StringRef Prefix) const
Check if this string starts with the given Prefix.
Definition StringRef.h:258
constexpr bool empty() const
Check if the string is empty.
Definition StringRef.h:141
char front() const
Get the first character in the string.
Definition StringRef.h:147
bool consume_front(char Prefix)
Returns true if this StringRef has the given prefix and removes that prefix.
Definition StringRef.h:661
A switch()-like statement whose cases are string literals.
StringSwitch & Case(StringLiteral S, T Value)
A table of densely packed, null-terminated strings indexed by offset.
Definition StringTable.h:34
constexpr Iterator begin() const
constexpr Iterator end() const
Primary interface to the complete machine description for the target machine.
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition Twine.h:82
self_iterator getIterator()
Definition ilist_node.h:123
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition raw_ostream.h:53
Interfaces for registering analysis passes, producing common pass manager configurations,...
Abstract Attribute helper functions.
Definition Attributor.h:166
std::optional< CodeGenOptLevel > getLevel(int OL)
Get the Level identified by the integer OL.
Definition CodeGen.h:291
@ BasicBlock
Various leaf nodes.
Definition ISDOpcodes.h:83
PointerTypeMap run(const Module &M)
Compute the PointerTypeMap for the module M.
DropTestKind
Specifies how to drop type tests.
@ All
Drop only llvm.assumes using type test value.
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...
Definition Error.cpp:94
InnerAnalysisManagerProxy< FunctionAnalysisManager, Module > FunctionAnalysisManagerModuleProxy
Provide the FunctionAnalysisManager to Module proxy.
@ O1
Optimize quickly without destroying debuggability.
@ O0
Disable as many optimizations as possible.
@ O3
Optimize for fast execution as much as possible.
@ O2
Optimize for fast execution as much as possible without triggering significant incremental compile ti...
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.
Definition Error.h:1321
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.
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.
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.
Definition Error.h:340
support::detail::RepeatAdapter< T > fmt_repeat(T &&Item, size_t Count)
OuterAnalysisManagerProxy< ModuleAnalysisManager, LazyCallGraph::SCC, LazyCallGraph & > ModuleAnalysisManagerCGSCCProxy
A proxy from a ModuleAnalysisManager to an SCC.
InnerAnalysisManagerProxy< MachineFunctionAnalysisManager, Module > MachineFunctionAnalysisManagerModuleProxy
RelativeUniformCounterPtr ValuesPtrExpr VTableAddr Count
Definition InstrProf.h:145
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 >
LLVM_ABI void printFormattedPipelinePasses(raw_ostream &OS, StringRef Pipeline, PrintPipelinePassesFormat Format=PrintPipelinePassesFormat::Text)
OutputIt move(R &&Range, OutputIt Out)
Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.
Definition STLExtras.h:1933
PassManager< MachineFunction > MachineFunctionPassManager
Convenience typedef for a pass manager over functions.
LLVM_ABI bool applyDebugifyMetadataToMachineFunction(DIBuilder &DIB, Function &F, llvm::function_ref< MachineFunction *(Function &)> GetMF)
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...
@ End
Run the machine verifier once, at the end of the pipeline.
Definition CodeGen.h:320
const PassesOptions & getPassesOptions(const LLVMContext &C)
PrintPipelinePassesFormat
@ Detailed
Hash with opcode only.
@ CallTargetIgnored
Hash with opcode and operands.
AnalysisManager< Module > ModuleAnalysisManager
Convenience typedef for the Module analysis manager.
Definition MIRParser.h:39
@ Enable
Enable colors.
Definition WithColor.h:47
LLVM_ABI void reportFatalUsageError(Error Err)
Report a fatal error that does not indicate a bug in LLVM.
Definition Error.cpp:177
Implement std::hash so that hash_code can be used in STL containers.
Definition BitVector.h:879
#define N
A special type used by analysis passes to provide an address that identifies that particular analysis...
Definition Analysis.h:29
A set of parameters to control various transforms performed by GVN pass.
Definition GVN.h:34
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.
Definition SCCP.h:35
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 & setPrepareForLTO(bool V)
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 for passes that can be skipped.