LLVM 17.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
32#include "llvm/Analysis/DDG.h"
50#include "llvm/Analysis/Lint.h"
78#include "llvm/IR/DebugInfo.h"
79#include "llvm/IR/Dominators.h"
80#include "llvm/IR/PassManager.h"
81#include "llvm/IR/PrintPasses.h"
83#include "llvm/IR/Verifier.h"
86#include "llvm/Support/Debug.h"
89#include "llvm/Support/Regex.h"
262#include <optional>
263
264using namespace llvm;
265
267 "^(default|thinlto-pre-link|thinlto|lto-pre-link|lto)<(O[0123sz])>$");
268
269namespace llvm {
271 "print-pipeline-passes",
272 cl::desc("Print a '-passes' compatible string describing the pipeline "
273 "(best-effort only)."));
274} // namespace llvm
275
276namespace {
277
278// The following passes/analyses have custom names, otherwise their name will
279// include `(anonymous namespace)`. These are special since they are only for
280// testing purposes and don't live in a header file.
281
282/// No-op module pass which does nothing.
283struct NoOpModulePass : PassInfoMixin<NoOpModulePass> {
285 return PreservedAnalyses::all();
286 }
287
288 static StringRef name() { return "NoOpModulePass"; }
289};
290
291/// No-op module analysis.
292class NoOpModuleAnalysis : public AnalysisInfoMixin<NoOpModuleAnalysis> {
294 static AnalysisKey Key;
295
296public:
297 struct Result {};
298 Result run(Module &, ModuleAnalysisManager &) { return Result(); }
299 static StringRef name() { return "NoOpModuleAnalysis"; }
300};
301
302/// No-op CGSCC pass which does nothing.
303struct NoOpCGSCCPass : PassInfoMixin<NoOpCGSCCPass> {
306 return PreservedAnalyses::all();
307 }
308 static StringRef name() { return "NoOpCGSCCPass"; }
309};
310
311/// No-op CGSCC analysis.
312class NoOpCGSCCAnalysis : public AnalysisInfoMixin<NoOpCGSCCAnalysis> {
314 static AnalysisKey Key;
315
316public:
317 struct Result {};
319 return Result();
320 }
321 static StringRef name() { return "NoOpCGSCCAnalysis"; }
322};
323
324/// No-op function pass which does nothing.
325struct NoOpFunctionPass : PassInfoMixin<NoOpFunctionPass> {
327 return PreservedAnalyses::all();
328 }
329 static StringRef name() { return "NoOpFunctionPass"; }
330};
331
332/// No-op function analysis.
333class NoOpFunctionAnalysis : public AnalysisInfoMixin<NoOpFunctionAnalysis> {
335 static AnalysisKey Key;
336
337public:
338 struct Result {};
340 static StringRef name() { return "NoOpFunctionAnalysis"; }
341};
342
343/// No-op loop nest pass which does nothing.
344struct NoOpLoopNestPass : PassInfoMixin<NoOpLoopNestPass> {
347 return PreservedAnalyses::all();
348 }
349 static StringRef name() { return "NoOpLoopNestPass"; }
350};
351
352/// No-op loop pass which does nothing.
353struct NoOpLoopPass : PassInfoMixin<NoOpLoopPass> {
356 return PreservedAnalyses::all();
357 }
358 static StringRef name() { return "NoOpLoopPass"; }
359};
360
361/// No-op loop analysis.
362class NoOpLoopAnalysis : public AnalysisInfoMixin<NoOpLoopAnalysis> {
364 static AnalysisKey Key;
365
366public:
367 struct Result {};
369 return Result();
370 }
371 static StringRef name() { return "NoOpLoopAnalysis"; }
372};
373
374AnalysisKey NoOpModuleAnalysis::Key;
375AnalysisKey NoOpCGSCCAnalysis::Key;
376AnalysisKey NoOpFunctionAnalysis::Key;
377AnalysisKey NoOpLoopAnalysis::Key;
378
379/// Whether or not we should populate a PassInstrumentationCallbacks's class to
380/// pass name map.
381///
382/// This is for optimization purposes so we don't populate it if we never use
383/// it. This should be updated if new pass instrumentation wants to use the map.
384/// We currently only use this for --print-before/after.
385bool shouldPopulateClassToPassNames() {
386 return PrintPipelinePasses || !printBeforePasses().empty() ||
387 !printAfterPasses().empty() || !isFilterPassesEmpty();
388}
389
390// A pass for testing -print-on-crash.
391// DO NOT USE THIS EXCEPT FOR TESTING!
392class TriggerCrashPass : public PassInfoMixin<TriggerCrashPass> {
393public:
395 abort();
396 return PreservedAnalyses::all();
397 }
398 static StringRef name() { return "TriggerCrashPass"; }
399};
400
401} // namespace
402
404 std::optional<PGOOptions> PGOOpt,
406 : TM(TM), PTO(PTO), PGOOpt(PGOOpt), PIC(PIC) {
407 if (TM)
408 TM->registerPassBuilderCallbacks(*this);
409 if (PIC && shouldPopulateClassToPassNames()) {
410#define MODULE_PASS(NAME, CREATE_PASS) \
411 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
412#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
413 PIC->addClassToPassName(CLASS, NAME);
414#define MODULE_ANALYSIS(NAME, CREATE_PASS) \
415 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
416#define FUNCTION_PASS(NAME, CREATE_PASS) \
417 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
418#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
419 PIC->addClassToPassName(CLASS, NAME);
420#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
421 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
422#define LOOPNEST_PASS(NAME, CREATE_PASS) \
423 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
424#define LOOP_PASS(NAME, CREATE_PASS) \
425 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
426#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
427 PIC->addClassToPassName(CLASS, NAME);
428#define LOOP_ANALYSIS(NAME, CREATE_PASS) \
429 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
430#define CGSCC_PASS(NAME, CREATE_PASS) \
431 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
432#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
433 PIC->addClassToPassName(CLASS, NAME);
434#define CGSCC_ANALYSIS(NAME, CREATE_PASS) \
435 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
436#include "PassRegistry.def"
437 }
438}
439
441#define MODULE_ANALYSIS(NAME, CREATE_PASS) \
442 MAM.registerPass([&] { return CREATE_PASS; });
443#include "PassRegistry.def"
444
445 for (auto &C : ModuleAnalysisRegistrationCallbacks)
446 C(MAM);
447}
448
450#define CGSCC_ANALYSIS(NAME, CREATE_PASS) \
451 CGAM.registerPass([&] { return CREATE_PASS; });
452#include "PassRegistry.def"
453
454 for (auto &C : CGSCCAnalysisRegistrationCallbacks)
455 C(CGAM);
456}
457
459 // We almost always want the default alias analysis pipeline.
460 // If a user wants a different one, they can register their own before calling
461 // registerFunctionAnalyses().
462 FAM.registerPass([&] { return buildDefaultAAPipeline(); });
463
464#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
465 FAM.registerPass([&] { return CREATE_PASS; });
466#include "PassRegistry.def"
467
468 for (auto &C : FunctionAnalysisRegistrationCallbacks)
469 C(FAM);
470}
471
473#define LOOP_ANALYSIS(NAME, CREATE_PASS) \
474 LAM.registerPass([&] { return CREATE_PASS; });
475#include "PassRegistry.def"
476
477 for (auto &C : LoopAnalysisRegistrationCallbacks)
478 C(LAM);
479}
480
481static std::optional<int> parseRepeatPassName(StringRef Name) {
482 if (!Name.consume_front("repeat<") || !Name.consume_back(">"))
483 return std::nullopt;
484 int Count;
485 if (Name.getAsInteger(0, Count) || Count <= 0)
486 return std::nullopt;
487 return Count;
488}
489
490static std::optional<std::pair<bool, bool>>
492 std::pair<bool, bool> Params;
493 if (!Name.consume_front("function"))
494 return std::nullopt;
495 if (Name.empty())
496 return Params;
497 if (!Name.consume_front("<") || !Name.consume_back(">"))
498 return std::nullopt;
499 while (!Name.empty()) {
500 auto [Front, Back] = Name.split(';');
501 Name = Back;
502 if (Front == "eager-inv")
503 Params.first = true;
504 else if (Front == "no-rerun")
505 Params.second = true;
506 else
507 return std::nullopt;
508 }
509 return Params;
510}
511
512static std::optional<int> parseDevirtPassName(StringRef Name) {
513 if (!Name.consume_front("devirt<") || !Name.consume_back(">"))
514 return std::nullopt;
515 int Count;
516 if (Name.getAsInteger(0, Count) || Count < 0)
517 return std::nullopt;
518 return Count;
519}
520
522 if (!Name.consume_front(PassName))
523 return false;
524 // normal pass name w/o parameters == default parameters
525 if (Name.empty())
526 return true;
527 return Name.startswith("<") && Name.endswith(">");
528}
529
530namespace {
531
532/// This performs customized parsing of pass name with parameters.
533///
534/// We do not need parametrization of passes in textual pipeline very often,
535/// yet on a rare occasion ability to specify parameters right there can be
536/// useful.
537///
538/// \p Name - parameterized specification of a pass from a textual pipeline
539/// is a string in a form of :
540/// PassName '<' parameter-list '>'
541///
542/// Parameter list is being parsed by the parser callable argument, \p Parser,
543/// It takes a string-ref of parameters and returns either StringError or a
544/// parameter list in a form of a custom parameters type, all wrapped into
545/// Expected<> template class.
546///
547template <typename ParametersParseCallableT>
548auto parsePassParameters(ParametersParseCallableT &&Parser, StringRef Name,
549 StringRef PassName) -> decltype(Parser(StringRef{})) {
550 using ParametersT = typename decltype(Parser(StringRef{}))::value_type;
551
552 StringRef Params = Name;
553 if (!Params.consume_front(PassName)) {
554 assert(false &&
555 "unable to strip pass name from parametrized pass specification");
556 }
557 if (!Params.empty() &&
558 (!Params.consume_front("<") || !Params.consume_back(">"))) {
559 assert(false && "invalid format for parametrized pass name");
560 }
561
562 Expected<ParametersT> Result = Parser(Params);
563 assert((Result || Result.template errorIsA<StringError>()) &&
564 "Pass parameter parser can only return StringErrors.");
565 return Result;
566}
567
568/// Parser of parameters for HardwareLoops pass.
569Expected<HardwareLoopOptions> parseHardwareLoopOptions(StringRef Params) {
570 HardwareLoopOptions HardwareLoopOpts;
571
572 while (!Params.empty()) {
573 StringRef ParamName;
574 std::tie(ParamName, Params) = Params.split(';');
575 if (ParamName.consume_front("hardware-loop-decrement=")) {
576 int Count;
577 if (ParamName.getAsInteger(0, Count))
578 return make_error<StringError>(
579 formatv("invalid HardwareLoopPass parameter '{0}' ", ParamName).str(),
581 HardwareLoopOpts.setDecrement(Count);
582 continue;
583 }
584 if (ParamName.consume_front("hardware-loop-counter-bitwidth=")) {
585 int Count;
586 if (ParamName.getAsInteger(0, Count))
587 return make_error<StringError>(
588 formatv("invalid HardwareLoopPass parameter '{0}' ", ParamName).str(),
590 HardwareLoopOpts.setCounterBitwidth(Count);
591 continue;
592 }
593 if (ParamName == "force-hardware-loops") {
594 HardwareLoopOpts.setForce(true);
595 } else if (ParamName == "force-hardware-loop-phi") {
596 HardwareLoopOpts.setForcePhi(true);
597 } else if (ParamName == "force-nested-hardware-loop") {
598 HardwareLoopOpts.setForceNested(true);
599 } else if (ParamName == "force-hardware-loop-guard") {
600 HardwareLoopOpts.setForceGuard(true);
601 } else {
602 return make_error<StringError>(
603 formatv("invalid HardwarePass parameter '{0}' ", ParamName).str(),
605 }
606 }
607 return HardwareLoopOpts;
608}
609
610/// Parser of parameters for LoopUnroll pass.
611Expected<LoopUnrollOptions> parseLoopUnrollOptions(StringRef Params) {
612 LoopUnrollOptions UnrollOpts;
613 while (!Params.empty()) {
614 StringRef ParamName;
615 std::tie(ParamName, Params) = Params.split(';');
616 int OptLevel = StringSwitch<int>(ParamName)
617 .Case("O0", 0)
618 .Case("O1", 1)
619 .Case("O2", 2)
620 .Case("O3", 3)
621 .Default(-1);
622 if (OptLevel >= 0) {
623 UnrollOpts.setOptLevel(OptLevel);
624 continue;
625 }
626 if (ParamName.consume_front("full-unroll-max=")) {
627 int Count;
628 if (ParamName.getAsInteger(0, Count))
629 return make_error<StringError>(
630 formatv("invalid LoopUnrollPass parameter '{0}' ", ParamName).str(),
632 UnrollOpts.setFullUnrollMaxCount(Count);
633 continue;
634 }
635
636 bool Enable = !ParamName.consume_front("no-");
637 if (ParamName == "partial") {
638 UnrollOpts.setPartial(Enable);
639 } else if (ParamName == "peeling") {
640 UnrollOpts.setPeeling(Enable);
641 } else if (ParamName == "profile-peeling") {
642 UnrollOpts.setProfileBasedPeeling(Enable);
643 } else if (ParamName == "runtime") {
644 UnrollOpts.setRuntime(Enable);
645 } else if (ParamName == "upperbound") {
646 UnrollOpts.setUpperBound(Enable);
647 } else {
648 return make_error<StringError>(
649 formatv("invalid LoopUnrollPass parameter '{0}' ", ParamName).str(),
651 }
652 }
653 return UnrollOpts;
654}
655
656Expected<bool> parseSinglePassOption(StringRef Params, StringRef OptionName,
658 bool Result = false;
659 while (!Params.empty()) {
660 StringRef ParamName;
661 std::tie(ParamName, Params) = Params.split(';');
662
663 if (ParamName == OptionName) {
664 Result = true;
665 } else {
666 return make_error<StringError>(
667 formatv("invalid {1} pass parameter '{0}' ", ParamName, PassName)
668 .str(),
670 }
671 }
672 return Result;
673}
674
675Expected<bool> parseInlinerPassOptions(StringRef Params) {
676 return parseSinglePassOption(Params, "only-mandatory", "InlinerPass");
677}
678
679Expected<bool> parseCoroSplitPassOptions(StringRef Params) {
680 return parseSinglePassOption(Params, "reuse-storage", "CoroSplitPass");
681}
682
683Expected<bool> parsePostOrderFunctionAttrsPassOptions(StringRef Params) {
684 return parseSinglePassOption(Params, "skip-non-recursive",
685 "PostOrderFunctionAttrs");
686}
687
688Expected<bool> parseEarlyCSEPassOptions(StringRef Params) {
689 return parseSinglePassOption(Params, "memssa", "EarlyCSE");
690}
691
692Expected<bool> parseEntryExitInstrumenterPassOptions(StringRef Params) {
693 return parseSinglePassOption(Params, "post-inline", "EntryExitInstrumenter");
694}
695
696Expected<bool> parseLoopExtractorPassOptions(StringRef Params) {
697 return parseSinglePassOption(Params, "single", "LoopExtractor");
698}
699
700Expected<bool> parseLowerMatrixIntrinsicsPassOptions(StringRef Params) {
701 return parseSinglePassOption(Params, "minimal", "LowerMatrixIntrinsics");
702}
703
704Expected<AddressSanitizerOptions> parseASanPassOptions(StringRef Params) {
706 while (!Params.empty()) {
707 StringRef ParamName;
708 std::tie(ParamName, Params) = Params.split(';');
709
710 if (ParamName == "kernel") {
711 Result.CompileKernel = true;
712 } else {
713 return make_error<StringError>(
714 formatv("invalid AddressSanitizer pass parameter '{0}' ", ParamName)
715 .str(),
717 }
718 }
719 return Result;
720}
721
722Expected<HWAddressSanitizerOptions> parseHWASanPassOptions(StringRef Params) {
724 while (!Params.empty()) {
725 StringRef ParamName;
726 std::tie(ParamName, Params) = Params.split(';');
727
728 if (ParamName == "recover") {
729 Result.Recover = true;
730 } else if (ParamName == "kernel") {
731 Result.CompileKernel = true;
732 } else {
733 return make_error<StringError>(
734 formatv("invalid HWAddressSanitizer pass parameter '{0}' ", ParamName)
735 .str(),
737 }
738 }
739 return Result;
740}
741
742Expected<MemorySanitizerOptions> parseMSanPassOptions(StringRef Params) {
744 while (!Params.empty()) {
745 StringRef ParamName;
746 std::tie(ParamName, Params) = Params.split(';');
747
748 if (ParamName == "recover") {
749 Result.Recover = true;
750 } else if (ParamName == "kernel") {
751 Result.Kernel = true;
752 } else if (ParamName.consume_front("track-origins=")) {
753 if (ParamName.getAsInteger(0, Result.TrackOrigins))
754 return make_error<StringError>(
755 formatv("invalid argument to MemorySanitizer pass track-origins "
756 "parameter: '{0}' ",
757 ParamName)
758 .str(),
760 } else if (ParamName == "eager-checks") {
761 Result.EagerChecks = true;
762 } else {
763 return make_error<StringError>(
764 formatv("invalid MemorySanitizer pass parameter '{0}' ", ParamName)
765 .str(),
767 }
768 }
769 return Result;
770}
771
772/// Parser of parameters for SimplifyCFG pass.
773Expected<SimplifyCFGOptions> parseSimplifyCFGOptions(StringRef Params) {
775 while (!Params.empty()) {
776 StringRef ParamName;
777 std::tie(ParamName, Params) = Params.split(';');
778
779 bool Enable = !ParamName.consume_front("no-");
780 if (ParamName == "forward-switch-cond") {
781 Result.forwardSwitchCondToPhi(Enable);
782 } else if (ParamName == "switch-range-to-icmp") {
783 Result.convertSwitchRangeToICmp(Enable);
784 } else if (ParamName == "switch-to-lookup") {
785 Result.convertSwitchToLookupTable(Enable);
786 } else if (ParamName == "keep-loops") {
787 Result.needCanonicalLoops(Enable);
788 } else if (ParamName == "hoist-common-insts") {
789 Result.hoistCommonInsts(Enable);
790 } else if (ParamName == "sink-common-insts") {
791 Result.sinkCommonInsts(Enable);
792 } else if (Enable && ParamName.consume_front("bonus-inst-threshold=")) {
793 APInt BonusInstThreshold;
794 if (ParamName.getAsInteger(0, BonusInstThreshold))
795 return make_error<StringError>(
796 formatv("invalid argument to SimplifyCFG pass bonus-threshold "
797 "parameter: '{0}' ",
798 ParamName).str(),
800 Result.bonusInstThreshold(BonusInstThreshold.getSExtValue());
801 } else {
802 return make_error<StringError>(
803 formatv("invalid SimplifyCFG pass parameter '{0}' ", ParamName).str(),
805 }
806 }
807 return Result;
808}
809
810Expected<InstCombineOptions> parseInstCombineOptions(StringRef Params) {
812 while (!Params.empty()) {
813 StringRef ParamName;
814 std::tie(ParamName, Params) = Params.split(';');
815
816 bool Enable = !ParamName.consume_front("no-");
817 if (ParamName == "use-loop-info") {
818 Result.setUseLoopInfo(Enable);
819 } else if (Enable && ParamName.consume_front("max-iterations=")) {
820 APInt MaxIterations;
821 if (ParamName.getAsInteger(0, MaxIterations))
822 return make_error<StringError>(
823 formatv("invalid argument to InstCombine pass max-iterations "
824 "parameter: '{0}' ",
825 ParamName).str(),
827 Result.setMaxIterations((unsigned)MaxIterations.getZExtValue());
828 } else {
829 return make_error<StringError>(
830 formatv("invalid InstCombine pass parameter '{0}' ", ParamName).str(),
832 }
833 }
834 return Result;
835}
836
837/// Parser of parameters for LoopVectorize pass.
838Expected<LoopVectorizeOptions> parseLoopVectorizeOptions(StringRef Params) {
840 while (!Params.empty()) {
841 StringRef ParamName;
842 std::tie(ParamName, Params) = Params.split(';');
843
844 bool Enable = !ParamName.consume_front("no-");
845 if (ParamName == "interleave-forced-only") {
847 } else if (ParamName == "vectorize-forced-only") {
849 } else {
850 return make_error<StringError>(
851 formatv("invalid LoopVectorize parameter '{0}' ", ParamName).str(),
853 }
854 }
855 return Opts;
856}
857
858Expected<std::pair<bool, bool>> parseLoopUnswitchOptions(StringRef Params) {
859 std::pair<bool, bool> Result = {false, true};
860 while (!Params.empty()) {
861 StringRef ParamName;
862 std::tie(ParamName, Params) = Params.split(';');
863
864 bool Enable = !ParamName.consume_front("no-");
865 if (ParamName == "nontrivial") {
866 Result.first = Enable;
867 } else if (ParamName == "trivial") {
868 Result.second = Enable;
869 } else {
870 return make_error<StringError>(
871 formatv("invalid LoopUnswitch pass parameter '{0}' ", ParamName)
872 .str(),
874 }
875 }
876 return Result;
877}
878
879Expected<LICMOptions> parseLICMOptions(StringRef Params) {
881 while (!Params.empty()) {
882 StringRef ParamName;
883 std::tie(ParamName, Params) = Params.split(';');
884
885 bool Enable = !ParamName.consume_front("no-");
886 if (ParamName == "allowspeculation") {
887 Result.AllowSpeculation = Enable;
888 } else {
889 return make_error<StringError>(
890 formatv("invalid LICM pass parameter '{0}' ", ParamName).str(),
892 }
893 }
894 return Result;
895}
896
897Expected<bool> parseMergedLoadStoreMotionOptions(StringRef Params) {
898 bool Result = false;
899 while (!Params.empty()) {
900 StringRef ParamName;
901 std::tie(ParamName, Params) = Params.split(';');
902
903 bool Enable = !ParamName.consume_front("no-");
904 if (ParamName == "split-footer-bb") {
905 Result = Enable;
906 } else {
907 return make_error<StringError>(
908 formatv("invalid MergedLoadStoreMotion pass parameter '{0}' ",
909 ParamName)
910 .str(),
912 }
913 }
914 return Result;
915}
916
917Expected<GVNOptions> parseGVNOptions(StringRef Params) {
919 while (!Params.empty()) {
920 StringRef ParamName;
921 std::tie(ParamName, Params) = Params.split(';');
922
923 bool Enable = !ParamName.consume_front("no-");
924 if (ParamName == "pre") {
925 Result.setPRE(Enable);
926 } else if (ParamName == "load-pre") {
927 Result.setLoadPRE(Enable);
928 } else if (ParamName == "split-backedge-load-pre") {
929 Result.setLoadPRESplitBackedge(Enable);
930 } else if (ParamName == "memdep") {
931 Result.setMemDep(Enable);
932 } else {
933 return make_error<StringError>(
934 formatv("invalid GVN pass parameter '{0}' ", ParamName).str(),
936 }
937 }
938 return Result;
939}
940
941Expected<IPSCCPOptions> parseIPSCCPOptions(StringRef Params) {
943 while (!Params.empty()) {
944 StringRef ParamName;
945 std::tie(ParamName, Params) = Params.split(';');
946
947 bool Enable = !ParamName.consume_front("no-");
948 if (ParamName == "func-spec")
949 Result.setFuncSpec(Enable);
950 else
951 return make_error<StringError>(
952 formatv("invalid IPSCCP pass parameter '{0}' ", ParamName).str(),
954 }
955 return Result;
956}
957
958Expected<SROAOptions> parseSROAOptions(StringRef Params) {
959 if (Params.empty() || Params == "modify-cfg")
961 if (Params == "preserve-cfg")
963 return make_error<StringError>(
964 formatv("invalid SROA pass parameter '{0}' (either preserve-cfg or "
965 "modify-cfg can be specified)",
966 Params)
967 .str(),
969}
970
972parseStackLifetimeOptions(StringRef Params) {
974 while (!Params.empty()) {
975 StringRef ParamName;
976 std::tie(ParamName, Params) = Params.split(';');
977
978 if (ParamName == "may") {
980 } else if (ParamName == "must") {
982 } else {
983 return make_error<StringError>(
984 formatv("invalid StackLifetime parameter '{0}' ", ParamName).str(),
986 }
987 }
988 return Result;
989}
990
991Expected<bool> parseDependenceAnalysisPrinterOptions(StringRef Params) {
992 return parseSinglePassOption(Params, "normalized-results",
993 "DependenceAnalysisPrinter");
994}
995
996Expected<bool> parseSeparateConstOffsetFromGEPPassOptions(StringRef Params) {
997 return parseSinglePassOption(Params, "lower-gep",
998 "SeparateConstOffsetFromGEP");
999}
1000
1001} // namespace
1002
1003/// Tests whether a pass name starts with a valid prefix for a default pipeline
1004/// alias.
1006 return Name.startswith("default") || Name.startswith("thinlto") ||
1007 Name.startswith("lto");
1008}
1009
1010/// Tests whether registered callbacks will accept a given pass name.
1011///
1012/// When parsing a pipeline text, the type of the outermost pipeline may be
1013/// omitted, in which case the type is automatically determined from the first
1014/// pass name in the text. This may be a name that is handled through one of the
1015/// callbacks. We check this through the oridinary parsing callbacks by setting
1016/// up a dummy PassManager in order to not force the client to also handle this
1017/// type of query.
1018template <typename PassManagerT, typename CallbacksT>
1019static bool callbacksAcceptPassName(StringRef Name, CallbacksT &Callbacks) {
1020 if (!Callbacks.empty()) {
1021 PassManagerT DummyPM;
1022 for (auto &CB : Callbacks)
1023 if (CB(Name, DummyPM, {}))
1024 return true;
1025 }
1026 return false;
1027}
1028
1029template <typename CallbacksT>
1030static bool isModulePassName(StringRef Name, CallbacksT &Callbacks) {
1031 // Manually handle aliases for pre-configured pipeline fragments.
1034
1035 StringRef NameNoBracket = Name.take_until([](char C) { return C == '<'; });
1036
1037 // Explicitly handle pass manager names.
1038 if (Name == "module")
1039 return true;
1040 if (Name == "cgscc")
1041 return true;
1042 if (NameNoBracket == "function")
1043 return true;
1044 if (Name == "coro-cond")
1045 return true;
1046
1047 // Explicitly handle custom-parsed pass names.
1049 return true;
1050
1051#define MODULE_PASS(NAME, CREATE_PASS) \
1052 if (Name == NAME) \
1053 return true;
1054#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1055 if (checkParametrizedPassName(Name, NAME)) \
1056 return true;
1057#define MODULE_ANALYSIS(NAME, CREATE_PASS) \
1058 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \
1059 return true;
1060#include "PassRegistry.def"
1061
1062 return callbacksAcceptPassName<ModulePassManager>(Name, Callbacks);
1063}
1064
1065template <typename CallbacksT>
1066static bool isCGSCCPassName(StringRef Name, CallbacksT &Callbacks) {
1067 // Explicitly handle pass manager names.
1068 StringRef NameNoBracket = Name.take_until([](char C) { return C == '<'; });
1069 if (Name == "cgscc")
1070 return true;
1071 if (NameNoBracket == "function")
1072 return true;
1073
1074 // Explicitly handle custom-parsed pass names.
1076 return true;
1078 return true;
1079
1080#define CGSCC_PASS(NAME, CREATE_PASS) \
1081 if (Name == NAME) \
1082 return true;
1083#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1084 if (checkParametrizedPassName(Name, NAME)) \
1085 return true;
1086#define CGSCC_ANALYSIS(NAME, CREATE_PASS) \
1087 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \
1088 return true;
1089#include "PassRegistry.def"
1090
1091 return callbacksAcceptPassName<CGSCCPassManager>(Name, Callbacks);
1092}
1093
1094template <typename CallbacksT>
1095static bool isFunctionPassName(StringRef Name, CallbacksT &Callbacks) {
1096 // Explicitly handle pass manager names.
1097 StringRef NameNoBracket = Name.take_until([](char C) { return C == '<'; });
1098 if (NameNoBracket == "function")
1099 return true;
1100 if (Name == "loop" || Name == "loop-mssa")
1101 return true;
1102
1103 // Explicitly handle custom-parsed pass names.
1105 return true;
1106
1107#define FUNCTION_PASS(NAME, CREATE_PASS) \
1108 if (Name == NAME) \
1109 return true;
1110#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1111 if (checkParametrizedPassName(Name, NAME)) \
1112 return true;
1113#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
1114 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \
1115 return true;
1116#include "PassRegistry.def"
1117
1118 return callbacksAcceptPassName<FunctionPassManager>(Name, Callbacks);
1119}
1120
1121template <typename CallbacksT>
1122static bool isLoopNestPassName(StringRef Name, CallbacksT &Callbacks,
1123 bool &UseMemorySSA) {
1124 UseMemorySSA = false;
1125
1126 // Explicitly handle custom-parsed pass names.
1128 return true;
1129
1130 if (checkParametrizedPassName(Name, "lnicm")) {
1131 UseMemorySSA = true;
1132 return true;
1133 }
1134
1135#define LOOPNEST_PASS(NAME, CREATE_PASS) \
1136 if (Name == NAME) \
1137 return true;
1138#include "PassRegistry.def"
1139
1140 return callbacksAcceptPassName<LoopPassManager>(Name, Callbacks);
1141}
1142
1143template <typename CallbacksT>
1144static bool isLoopPassName(StringRef Name, CallbacksT &Callbacks,
1145 bool &UseMemorySSA) {
1146 UseMemorySSA = false;
1147
1148 // Explicitly handle custom-parsed pass names.
1150 return true;
1151
1152 if (checkParametrizedPassName(Name, "licm")) {
1153 UseMemorySSA = true;
1154 return true;
1155 }
1156
1157#define LOOP_PASS(NAME, CREATE_PASS) \
1158 if (Name == NAME) \
1159 return true;
1160#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1161 if (checkParametrizedPassName(Name, NAME)) \
1162 return true;
1163#define LOOP_ANALYSIS(NAME, CREATE_PASS) \
1164 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \
1165 return true;
1166#include "PassRegistry.def"
1167
1168 return callbacksAcceptPassName<LoopPassManager>(Name, Callbacks);
1169}
1170
1171std::optional<std::vector<PassBuilder::PipelineElement>>
1172PassBuilder::parsePipelineText(StringRef Text) {
1173 std::vector<PipelineElement> ResultPipeline;
1174
1175 SmallVector<std::vector<PipelineElement> *, 4> PipelineStack = {
1176 &ResultPipeline};
1177 for (;;) {
1178 std::vector<PipelineElement> &Pipeline = *PipelineStack.back();
1179 size_t Pos = Text.find_first_of(",()");
1180 Pipeline.push_back({Text.substr(0, Pos), {}});
1181
1182 // If we have a single terminating name, we're done.
1183 if (Pos == Text.npos)
1184 break;
1185
1186 char Sep = Text[Pos];
1187 Text = Text.substr(Pos + 1);
1188 if (Sep == ',')
1189 // Just a name ending in a comma, continue.
1190 continue;
1191
1192 if (Sep == '(') {
1193 // Push the inner pipeline onto the stack to continue processing.
1194 PipelineStack.push_back(&Pipeline.back().InnerPipeline);
1195 continue;
1196 }
1197
1198 assert(Sep == ')' && "Bogus separator!");
1199 // When handling the close parenthesis, we greedily consume them to avoid
1200 // empty strings in the pipeline.
1201 do {
1202 // If we try to pop the outer pipeline we have unbalanced parentheses.
1203 if (PipelineStack.size() == 1)
1204 return std::nullopt;
1205
1206 PipelineStack.pop_back();
1207 } while (Text.consume_front(")"));
1208
1209 // Check if we've finished parsing.
1210 if (Text.empty())
1211 break;
1212
1213 // Otherwise, the end of an inner pipeline always has to be followed by
1214 // a comma, and then we can continue.
1215 if (!Text.consume_front(","))
1216 return std::nullopt;
1217 }
1218
1219 if (PipelineStack.size() > 1)
1220 // Unbalanced paretheses.
1221 return std::nullopt;
1222
1223 assert(PipelineStack.back() == &ResultPipeline &&
1224 "Wrong pipeline at the bottom of the stack!");
1225 return {std::move(ResultPipeline)};
1226}
1227
1228Error PassBuilder::parseModulePass(ModulePassManager &MPM,
1229 const PipelineElement &E) {
1230 auto &Name = E.Name;
1231 auto &InnerPipeline = E.InnerPipeline;
1232
1233 // First handle complex passes like the pass managers which carry pipelines.
1234 if (!InnerPipeline.empty()) {
1235 if (Name == "module") {
1236 ModulePassManager NestedMPM;
1237 if (auto Err = parseModulePassPipeline(NestedMPM, InnerPipeline))
1238 return Err;
1239 MPM.addPass(std::move(NestedMPM));
1240 return Error::success();
1241 }
1242 if (Name == "coro-cond") {
1243 ModulePassManager NestedMPM;
1244 if (auto Err = parseModulePassPipeline(NestedMPM, InnerPipeline))
1245 return Err;
1246 MPM.addPass(CoroConditionalWrapper(std::move(NestedMPM)));
1247 return Error::success();
1248 }
1249 if (Name == "cgscc") {
1250 CGSCCPassManager CGPM;
1251 if (auto Err = parseCGSCCPassPipeline(CGPM, InnerPipeline))
1252 return Err;
1254 return Error::success();
1255 }
1256 if (auto Params = parseFunctionPipelineName(Name)) {
1257 if (Params->second)
1258 return make_error<StringError>(
1259 "cannot have a no-rerun module to function adaptor",
1262 if (auto Err = parseFunctionPassPipeline(FPM, InnerPipeline))
1263 return Err;
1264 MPM.addPass(
1265 createModuleToFunctionPassAdaptor(std::move(FPM), Params->first));
1266 return Error::success();
1267 }
1268 if (auto Count = parseRepeatPassName(Name)) {
1269 ModulePassManager NestedMPM;
1270 if (auto Err = parseModulePassPipeline(NestedMPM, InnerPipeline))
1271 return Err;
1272 MPM.addPass(createRepeatedPass(*Count, std::move(NestedMPM)));
1273 return Error::success();
1274 }
1275
1276 for (auto &C : ModulePipelineParsingCallbacks)
1277 if (C(Name, MPM, InnerPipeline))
1278 return Error::success();
1279
1280 // Normal passes can't have pipelines.
1281 return make_error<StringError>(
1282 formatv("invalid use of '{0}' pass as module pipeline", Name).str(),
1284 ;
1285 }
1286
1287 // Manually handle aliases for pre-configured pipeline fragments.
1290 if (!DefaultAliasRegex.match(Name, &Matches))
1291 return make_error<StringError>(
1292 formatv("unknown default pipeline alias '{0}'", Name).str(),
1294
1295 assert(Matches.size() == 3 && "Must capture two matched strings!");
1296
1304
1305 // This is consistent with old pass manager invoked via opt, but
1306 // inconsistent with clang. Clang doesn't enable loop vectorization
1307 // but does enable slp vectorization at Oz.
1308 PTO.LoopVectorization =
1309 L.getSpeedupLevel() > 1 && L != OptimizationLevel::Oz;
1310 PTO.SLPVectorization =
1311 L.getSpeedupLevel() > 1 && L != OptimizationLevel::Oz;
1312
1313 if (Matches[1] == "default") {
1315 } else if (Matches[1] == "thinlto-pre-link") {
1317 } else if (Matches[1] == "thinlto") {
1319 } else if (Matches[1] == "lto-pre-link") {
1321 } else {
1322 assert(Matches[1] == "lto" && "Not one of the matched options!");
1323 MPM.addPass(buildLTODefaultPipeline(L, nullptr));
1324 }
1325 return Error::success();
1326 }
1327
1328 // Finally expand the basic registered passes from the .inc file.
1329#define MODULE_PASS(NAME, CREATE_PASS) \
1330 if (Name == NAME) { \
1331 MPM.addPass(CREATE_PASS); \
1332 return Error::success(); \
1333 }
1334#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1335 if (checkParametrizedPassName(Name, NAME)) { \
1336 auto Params = parsePassParameters(PARSER, Name, NAME); \
1337 if (!Params) \
1338 return Params.takeError(); \
1339 MPM.addPass(CREATE_PASS(Params.get())); \
1340 return Error::success(); \
1341 }
1342#define MODULE_ANALYSIS(NAME, CREATE_PASS) \
1343 if (Name == "require<" NAME ">") { \
1344 MPM.addPass( \
1345 RequireAnalysisPass< \
1346 std::remove_reference_t<decltype(CREATE_PASS)>, Module>()); \
1347 return Error::success(); \
1348 } \
1349 if (Name == "invalidate<" NAME ">") { \
1350 MPM.addPass(InvalidateAnalysisPass< \
1351 std::remove_reference_t<decltype(CREATE_PASS)>>()); \
1352 return Error::success(); \
1353 }
1354#define CGSCC_PASS(NAME, CREATE_PASS) \
1355 if (Name == NAME) { \
1356 MPM.addPass(createModuleToPostOrderCGSCCPassAdaptor(CREATE_PASS)); \
1357 return Error::success(); \
1358 }
1359#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1360 if (checkParametrizedPassName(Name, NAME)) { \
1361 auto Params = parsePassParameters(PARSER, Name, NAME); \
1362 if (!Params) \
1363 return Params.takeError(); \
1364 MPM.addPass( \
1365 createModuleToPostOrderCGSCCPassAdaptor(CREATE_PASS(Params.get()))); \
1366 return Error::success(); \
1367 }
1368#define FUNCTION_PASS(NAME, CREATE_PASS) \
1369 if (Name == NAME) { \
1370 MPM.addPass(createModuleToFunctionPassAdaptor(CREATE_PASS)); \
1371 return Error::success(); \
1372 }
1373#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1374 if (checkParametrizedPassName(Name, NAME)) { \
1375 auto Params = parsePassParameters(PARSER, Name, NAME); \
1376 if (!Params) \
1377 return Params.takeError(); \
1378 MPM.addPass(createModuleToFunctionPassAdaptor(CREATE_PASS(Params.get()))); \
1379 return Error::success(); \
1380 }
1381#define LOOPNEST_PASS(NAME, CREATE_PASS) \
1382 if (Name == NAME) { \
1383 MPM.addPass(createModuleToFunctionPassAdaptor( \
1384 createFunctionToLoopPassAdaptor(CREATE_PASS, false, false))); \
1385 return Error::success(); \
1386 }
1387#define LOOP_PASS(NAME, CREATE_PASS) \
1388 if (Name == NAME) { \
1389 MPM.addPass(createModuleToFunctionPassAdaptor( \
1390 createFunctionToLoopPassAdaptor(CREATE_PASS, false, false))); \
1391 return Error::success(); \
1392 }
1393#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1394 if (checkParametrizedPassName(Name, NAME)) { \
1395 auto Params = parsePassParameters(PARSER, Name, NAME); \
1396 if (!Params) \
1397 return Params.takeError(); \
1398 MPM.addPass( \
1399 createModuleToFunctionPassAdaptor(createFunctionToLoopPassAdaptor( \
1400 CREATE_PASS(Params.get()), false, false))); \
1401 return Error::success(); \
1402 }
1403#include "PassRegistry.def"
1404
1405 for (auto &C : ModulePipelineParsingCallbacks)
1406 if (C(Name, MPM, InnerPipeline))
1407 return Error::success();
1408 return make_error<StringError>(
1409 formatv("unknown module pass '{0}'", Name).str(),
1411}
1412
1413Error PassBuilder::parseCGSCCPass(CGSCCPassManager &CGPM,
1414 const PipelineElement &E) {
1415 auto &Name = E.Name;
1416 auto &InnerPipeline = E.InnerPipeline;
1417
1418 // First handle complex passes like the pass managers which carry pipelines.
1419 if (!InnerPipeline.empty()) {
1420 if (Name == "cgscc") {
1421 CGSCCPassManager NestedCGPM;
1422 if (auto Err = parseCGSCCPassPipeline(NestedCGPM, InnerPipeline))
1423 return Err;
1424 // Add the nested pass manager with the appropriate adaptor.
1425 CGPM.addPass(std::move(NestedCGPM));
1426 return Error::success();
1427 }
1428 if (auto Params = parseFunctionPipelineName(Name)) {
1430 if (auto Err = parseFunctionPassPipeline(FPM, InnerPipeline))
1431 return Err;
1432 // Add the nested pass manager with the appropriate adaptor.
1434 std::move(FPM), Params->first, Params->second));
1435 return Error::success();
1436 }
1437 if (auto Count = parseRepeatPassName(Name)) {
1438 CGSCCPassManager NestedCGPM;
1439 if (auto Err = parseCGSCCPassPipeline(NestedCGPM, InnerPipeline))
1440 return Err;
1441 CGPM.addPass(createRepeatedPass(*Count, std::move(NestedCGPM)));
1442 return Error::success();
1443 }
1444 if (auto MaxRepetitions = parseDevirtPassName(Name)) {
1445 CGSCCPassManager NestedCGPM;
1446 if (auto Err = parseCGSCCPassPipeline(NestedCGPM, InnerPipeline))
1447 return Err;
1448 CGPM.addPass(
1449 createDevirtSCCRepeatedPass(std::move(NestedCGPM), *MaxRepetitions));
1450 return Error::success();
1451 }
1452
1453 for (auto &C : CGSCCPipelineParsingCallbacks)
1454 if (C(Name, CGPM, InnerPipeline))
1455 return Error::success();
1456
1457 // Normal passes can't have pipelines.
1458 return make_error<StringError>(
1459 formatv("invalid use of '{0}' pass as cgscc pipeline", Name).str(),
1461 }
1462
1463// Now expand the basic registered passes from the .inc file.
1464#define CGSCC_PASS(NAME, CREATE_PASS) \
1465 if (Name == NAME) { \
1466 CGPM.addPass(CREATE_PASS); \
1467 return Error::success(); \
1468 }
1469#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1470 if (checkParametrizedPassName(Name, NAME)) { \
1471 auto Params = parsePassParameters(PARSER, Name, NAME); \
1472 if (!Params) \
1473 return Params.takeError(); \
1474 CGPM.addPass(CREATE_PASS(Params.get())); \
1475 return Error::success(); \
1476 }
1477#define CGSCC_ANALYSIS(NAME, CREATE_PASS) \
1478 if (Name == "require<" NAME ">") { \
1479 CGPM.addPass(RequireAnalysisPass< \
1480 std::remove_reference_t<decltype(CREATE_PASS)>, \
1481 LazyCallGraph::SCC, CGSCCAnalysisManager, LazyCallGraph &, \
1482 CGSCCUpdateResult &>()); \
1483 return Error::success(); \
1484 } \
1485 if (Name == "invalidate<" NAME ">") { \
1486 CGPM.addPass(InvalidateAnalysisPass< \
1487 std::remove_reference_t<decltype(CREATE_PASS)>>()); \
1488 return Error::success(); \
1489 }
1490#define FUNCTION_PASS(NAME, CREATE_PASS) \
1491 if (Name == NAME) { \
1492 CGPM.addPass(createCGSCCToFunctionPassAdaptor(CREATE_PASS)); \
1493 return Error::success(); \
1494 }
1495#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1496 if (checkParametrizedPassName(Name, NAME)) { \
1497 auto Params = parsePassParameters(PARSER, Name, NAME); \
1498 if (!Params) \
1499 return Params.takeError(); \
1500 CGPM.addPass(createCGSCCToFunctionPassAdaptor(CREATE_PASS(Params.get()))); \
1501 return Error::success(); \
1502 }
1503#define LOOPNEST_PASS(NAME, CREATE_PASS) \
1504 if (Name == NAME) { \
1505 CGPM.addPass(createCGSCCToFunctionPassAdaptor( \
1506 createFunctionToLoopPassAdaptor(CREATE_PASS, false, false))); \
1507 return Error::success(); \
1508 }
1509#define LOOP_PASS(NAME, CREATE_PASS) \
1510 if (Name == NAME) { \
1511 CGPM.addPass(createCGSCCToFunctionPassAdaptor( \
1512 createFunctionToLoopPassAdaptor(CREATE_PASS, false, false))); \
1513 return Error::success(); \
1514 }
1515#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1516 if (checkParametrizedPassName(Name, NAME)) { \
1517 auto Params = parsePassParameters(PARSER, Name, NAME); \
1518 if (!Params) \
1519 return Params.takeError(); \
1520 CGPM.addPass( \
1521 createCGSCCToFunctionPassAdaptor(createFunctionToLoopPassAdaptor( \
1522 CREATE_PASS(Params.get()), false, false))); \
1523 return Error::success(); \
1524 }
1525#include "PassRegistry.def"
1526
1527 for (auto &C : CGSCCPipelineParsingCallbacks)
1528 if (C(Name, CGPM, InnerPipeline))
1529 return Error::success();
1530 return make_error<StringError>(
1531 formatv("unknown cgscc pass '{0}'", Name).str(),
1533}
1534
1535Error PassBuilder::parseFunctionPass(FunctionPassManager &FPM,
1536 const PipelineElement &E) {
1537 auto &Name = E.Name;
1538 auto &InnerPipeline = E.InnerPipeline;
1539
1540 // First handle complex passes like the pass managers which carry pipelines.
1541 if (!InnerPipeline.empty()) {
1542 if (Name == "function") {
1543 FunctionPassManager NestedFPM;
1544 if (auto Err = parseFunctionPassPipeline(NestedFPM, InnerPipeline))
1545 return Err;
1546 // Add the nested pass manager with the appropriate adaptor.
1547 FPM.addPass(std::move(NestedFPM));
1548 return Error::success();
1549 }
1550 if (Name == "loop" || Name == "loop-mssa") {
1551 LoopPassManager LPM;
1552 if (auto Err = parseLoopPassPipeline(LPM, InnerPipeline))
1553 return Err;
1554 // Add the nested pass manager with the appropriate adaptor.
1555 bool UseMemorySSA = (Name == "loop-mssa");
1556 bool UseBFI = llvm::any_of(InnerPipeline, [](auto Pipeline) {
1557 return Pipeline.Name.contains("simple-loop-unswitch");
1558 });
1559 bool UseBPI = llvm::any_of(InnerPipeline, [](auto Pipeline) {
1560 return Pipeline.Name == "loop-predication";
1561 });
1562 FPM.addPass(createFunctionToLoopPassAdaptor(std::move(LPM), UseMemorySSA,
1563 UseBFI, UseBPI));
1564 return Error::success();
1565 }
1566 if (auto Count = parseRepeatPassName(Name)) {
1567 FunctionPassManager NestedFPM;
1568 if (auto Err = parseFunctionPassPipeline(NestedFPM, InnerPipeline))
1569 return Err;
1570 FPM.addPass(createRepeatedPass(*Count, std::move(NestedFPM)));
1571 return Error::success();
1572 }
1573
1574 for (auto &C : FunctionPipelineParsingCallbacks)
1575 if (C(Name, FPM, InnerPipeline))
1576 return Error::success();
1577
1578 // Normal passes can't have pipelines.
1579 return make_error<StringError>(
1580 formatv("invalid use of '{0}' pass as function pipeline", Name).str(),
1582 }
1583
1584// Now expand the basic registered passes from the .inc file.
1585#define FUNCTION_PASS(NAME, CREATE_PASS) \
1586 if (Name == NAME) { \
1587 FPM.addPass(CREATE_PASS); \
1588 return Error::success(); \
1589 }
1590#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1591 if (checkParametrizedPassName(Name, NAME)) { \
1592 auto Params = parsePassParameters(PARSER, Name, NAME); \
1593 if (!Params) \
1594 return Params.takeError(); \
1595 FPM.addPass(CREATE_PASS(Params.get())); \
1596 return Error::success(); \
1597 }
1598#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
1599 if (Name == "require<" NAME ">") { \
1600 FPM.addPass( \
1601 RequireAnalysisPass< \
1602 std::remove_reference_t<decltype(CREATE_PASS)>, Function>()); \
1603 return Error::success(); \
1604 } \
1605 if (Name == "invalidate<" NAME ">") { \
1606 FPM.addPass(InvalidateAnalysisPass< \
1607 std::remove_reference_t<decltype(CREATE_PASS)>>()); \
1608 return Error::success(); \
1609 }
1610// FIXME: UseMemorySSA is set to false. Maybe we could do things like:
1611// bool UseMemorySSA = !("canon-freeze" || "loop-predication" ||
1612// "guard-widening");
1613// The risk is that it may become obsolete if we're not careful.
1614#define LOOPNEST_PASS(NAME, CREATE_PASS) \
1615 if (Name == NAME) { \
1616 FPM.addPass(createFunctionToLoopPassAdaptor(CREATE_PASS, false, false)); \
1617 return Error::success(); \
1618 }
1619#define LOOP_PASS(NAME, CREATE_PASS) \
1620 if (Name == NAME) { \
1621 FPM.addPass(createFunctionToLoopPassAdaptor(CREATE_PASS, false, false)); \
1622 return Error::success(); \
1623 }
1624#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1625 if (checkParametrizedPassName(Name, NAME)) { \
1626 auto Params = parsePassParameters(PARSER, Name, NAME); \
1627 if (!Params) \
1628 return Params.takeError(); \
1629 FPM.addPass(createFunctionToLoopPassAdaptor(CREATE_PASS(Params.get()), \
1630 false, false)); \
1631 return Error::success(); \
1632 }
1633#include "PassRegistry.def"
1634
1635 for (auto &C : FunctionPipelineParsingCallbacks)
1636 if (C(Name, FPM, InnerPipeline))
1637 return Error::success();
1638 return make_error<StringError>(
1639 formatv("unknown function pass '{0}'", Name).str(),
1641}
1642
1643Error PassBuilder::parseLoopPass(LoopPassManager &LPM,
1644 const PipelineElement &E) {
1645 StringRef Name = E.Name;
1646 auto &InnerPipeline = E.InnerPipeline;
1647
1648 // First handle complex passes like the pass managers which carry pipelines.
1649 if (!InnerPipeline.empty()) {
1650 if (Name == "loop") {
1651 LoopPassManager NestedLPM;
1652 if (auto Err = parseLoopPassPipeline(NestedLPM, InnerPipeline))
1653 return Err;
1654 // Add the nested pass manager with the appropriate adaptor.
1655 LPM.addPass(std::move(NestedLPM));
1656 return Error::success();
1657 }
1658 if (auto Count = parseRepeatPassName(Name)) {
1659 LoopPassManager NestedLPM;
1660 if (auto Err = parseLoopPassPipeline(NestedLPM, InnerPipeline))
1661 return Err;
1662 LPM.addPass(createRepeatedPass(*Count, std::move(NestedLPM)));
1663 return Error::success();
1664 }
1665
1666 for (auto &C : LoopPipelineParsingCallbacks)
1667 if (C(Name, LPM, InnerPipeline))
1668 return Error::success();
1669
1670 // Normal passes can't have pipelines.
1671 return make_error<StringError>(
1672 formatv("invalid use of '{0}' pass as loop pipeline", Name).str(),
1674 }
1675
1676// Now expand the basic registered passes from the .inc file.
1677#define LOOPNEST_PASS(NAME, CREATE_PASS) \
1678 if (Name == NAME) { \
1679 LPM.addPass(CREATE_PASS); \
1680 return Error::success(); \
1681 }
1682#define LOOP_PASS(NAME, CREATE_PASS) \
1683 if (Name == NAME) { \
1684 LPM.addPass(CREATE_PASS); \
1685 return Error::success(); \
1686 }
1687#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1688 if (checkParametrizedPassName(Name, NAME)) { \
1689 auto Params = parsePassParameters(PARSER, Name, NAME); \
1690 if (!Params) \
1691 return Params.takeError(); \
1692 LPM.addPass(CREATE_PASS(Params.get())); \
1693 return Error::success(); \
1694 }
1695#define LOOP_ANALYSIS(NAME, CREATE_PASS) \
1696 if (Name == "require<" NAME ">") { \
1697 LPM.addPass(RequireAnalysisPass< \
1698 std::remove_reference_t<decltype(CREATE_PASS)>, Loop, \
1699 LoopAnalysisManager, LoopStandardAnalysisResults &, \
1700 LPMUpdater &>()); \
1701 return Error::success(); \
1702 } \
1703 if (Name == "invalidate<" NAME ">") { \
1704 LPM.addPass(InvalidateAnalysisPass< \
1705 std::remove_reference_t<decltype(CREATE_PASS)>>()); \
1706 return Error::success(); \
1707 }
1708#include "PassRegistry.def"
1709
1710 for (auto &C : LoopPipelineParsingCallbacks)
1711 if (C(Name, LPM, InnerPipeline))
1712 return Error::success();
1713 return make_error<StringError>(formatv("unknown loop pass '{0}'", Name).str(),
1715}
1716
1717bool PassBuilder::parseAAPassName(AAManager &AA, StringRef Name) {
1718#define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS) \
1719 if (Name == NAME) { \
1720 AA.registerModuleAnalysis< \
1721 std::remove_reference_t<decltype(CREATE_PASS)>>(); \
1722 return true; \
1723 }
1724#define FUNCTION_ALIAS_ANALYSIS(NAME, CREATE_PASS) \
1725 if (Name == NAME) { \
1726 AA.registerFunctionAnalysis< \
1727 std::remove_reference_t<decltype(CREATE_PASS)>>(); \
1728 return true; \
1729 }
1730#include "PassRegistry.def"
1731
1732 for (auto &C : AAParsingCallbacks)
1733 if (C(Name, AA))
1734 return true;
1735 return false;
1736}
1737
1738Error PassBuilder::parseLoopPassPipeline(LoopPassManager &LPM,
1739 ArrayRef<PipelineElement> Pipeline) {
1740 for (const auto &Element : Pipeline) {
1741 if (auto Err = parseLoopPass(LPM, Element))
1742 return Err;
1743 }
1744 return Error::success();
1745}
1746
1747Error PassBuilder::parseFunctionPassPipeline(
1749 for (const auto &Element : Pipeline) {
1750 if (auto Err = parseFunctionPass(FPM, Element))
1751 return Err;
1752 }
1753 return Error::success();
1754}
1755
1756Error PassBuilder::parseCGSCCPassPipeline(CGSCCPassManager &CGPM,
1757 ArrayRef<PipelineElement> Pipeline) {
1758 for (const auto &Element : Pipeline) {
1759 if (auto Err = parseCGSCCPass(CGPM, Element))
1760 return Err;
1761 }
1762 return Error::success();
1763}
1764
1776}
1777
1778Error PassBuilder::parseModulePassPipeline(ModulePassManager &MPM,
1779 ArrayRef<PipelineElement> Pipeline) {
1780 for (const auto &Element : Pipeline) {
1781 if (auto Err = parseModulePass(MPM, Element))
1782 return Err;
1783 }
1784 return Error::success();
1785}
1786
1787// Primary pass pipeline description parsing routine for a \c ModulePassManager
1788// FIXME: Should this routine accept a TargetMachine or require the caller to
1789// pre-populate the analysis managers with target-specific stuff?
1791 StringRef PipelineText) {
1792 auto Pipeline = parsePipelineText(PipelineText);
1793 if (!Pipeline || Pipeline->empty())
1794 return make_error<StringError>(
1795 formatv("invalid pipeline '{0}'", PipelineText).str(),
1797
1798 // If the first name isn't at the module layer, wrap the pipeline up
1799 // automatically.
1800 StringRef FirstName = Pipeline->front().Name;
1801
1802 if (!isModulePassName(FirstName, ModulePipelineParsingCallbacks)) {
1803 bool UseMemorySSA;
1804 if (isCGSCCPassName(FirstName, CGSCCPipelineParsingCallbacks)) {
1805 Pipeline = {{"cgscc", std::move(*Pipeline)}};
1806 } else if (isFunctionPassName(FirstName,
1807 FunctionPipelineParsingCallbacks)) {
1808 Pipeline = {{"function", std::move(*Pipeline)}};
1809 } else if (isLoopNestPassName(FirstName, LoopPipelineParsingCallbacks,
1810 UseMemorySSA)) {
1811 Pipeline = {{"function", {{UseMemorySSA ? "loop-mssa" : "loop",
1812 std::move(*Pipeline)}}}};
1813 } else if (isLoopPassName(FirstName, LoopPipelineParsingCallbacks,
1814 UseMemorySSA)) {
1815 Pipeline = {{"function", {{UseMemorySSA ? "loop-mssa" : "loop",
1816 std::move(*Pipeline)}}}};
1817 } else {
1818 for (auto &C : TopLevelPipelineParsingCallbacks)
1819 if (C(MPM, *Pipeline))
1820 return Error::success();
1821
1822 // Unknown pass or pipeline name!
1823 auto &InnerPipeline = Pipeline->front().InnerPipeline;
1824 return make_error<StringError>(
1825 formatv("unknown {0} name '{1}'",
1826 (InnerPipeline.empty() ? "pass" : "pipeline"), FirstName)
1827 .str(),
1829 }
1830 }
1831
1832 if (auto Err = parseModulePassPipeline(MPM, *Pipeline))
1833 return Err;
1834 return Error::success();
1835}
1836
1837// Primary pass pipeline description parsing routine for a \c CGSCCPassManager
1839 StringRef PipelineText) {
1840 auto Pipeline = parsePipelineText(PipelineText);
1841 if (!Pipeline || Pipeline->empty())
1842 return make_error<StringError>(
1843 formatv("invalid pipeline '{0}'", PipelineText).str(),
1845
1846 StringRef FirstName = Pipeline->front().Name;
1847 if (!isCGSCCPassName(FirstName, CGSCCPipelineParsingCallbacks))
1848 return make_error<StringError>(
1849 formatv("unknown cgscc pass '{0}' in pipeline '{1}'", FirstName,
1850 PipelineText)
1851 .str(),
1853
1854 if (auto Err = parseCGSCCPassPipeline(CGPM, *Pipeline))
1855 return Err;
1856 return Error::success();
1857}
1858
1859// Primary pass pipeline description parsing routine for a \c
1860// FunctionPassManager
1862 StringRef PipelineText) {
1863 auto Pipeline = parsePipelineText(PipelineText);
1864 if (!Pipeline || Pipeline->empty())
1865 return make_error<StringError>(
1866 formatv("invalid pipeline '{0}'", PipelineText).str(),
1868
1869 StringRef FirstName = Pipeline->front().Name;
1870 if (!isFunctionPassName(FirstName, FunctionPipelineParsingCallbacks))
1871 return make_error<StringError>(
1872 formatv("unknown function pass '{0}' in pipeline '{1}'", FirstName,
1873 PipelineText)
1874 .str(),
1876
1877 if (auto Err = parseFunctionPassPipeline(FPM, *Pipeline))
1878 return Err;
1879 return Error::success();
1880}
1881
1882// Primary pass pipeline description parsing routine for a \c LoopPassManager
1884 StringRef PipelineText) {
1885 auto Pipeline = parsePipelineText(PipelineText);
1886 if (!Pipeline || Pipeline->empty())
1887 return make_error<StringError>(
1888 formatv("invalid pipeline '{0}'", PipelineText).str(),
1890
1891 if (auto Err = parseLoopPassPipeline(CGPM, *Pipeline))
1892 return Err;
1893
1894 return Error::success();
1895}
1896
1898 // If the pipeline just consists of the word 'default' just replace the AA
1899 // manager with our default one.
1900 if (PipelineText == "default") {
1902 return Error::success();
1903 }
1904
1905 while (!PipelineText.empty()) {
1907 std::tie(Name, PipelineText) = PipelineText.split(',');
1908 if (!parseAAPassName(AA, Name))
1909 return make_error<StringError>(
1910 formatv("unknown alias analysis name '{0}'", Name).str(),
1912 }
1913
1914 return Error::success();
1915}
1916
1918 OS << " " << PassName << "\n";
1919}
1921 raw_ostream &OS) {
1922 OS << " " << PassName << "<" << Params << ">\n";
1923}
1924
1926 // TODO: print pass descriptions when they are available
1927
1928 OS << "Module passes:\n";
1929#define MODULE_PASS(NAME, CREATE_PASS) printPassName(NAME, OS);
1930#include "PassRegistry.def"
1931
1932 OS << "Module passes with params:\n";
1933#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1934 printPassName(NAME, PARAMS, OS);
1935#include "PassRegistry.def"
1936
1937 OS << "Module analyses:\n";
1938#define MODULE_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
1939#include "PassRegistry.def"
1940
1941 OS << "Module alias analyses:\n";
1942#define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
1943#include "PassRegistry.def"
1944
1945 OS << "CGSCC passes:\n";
1946#define CGSCC_PASS(NAME, CREATE_PASS) printPassName(NAME, OS);
1947#include "PassRegistry.def"
1948
1949 OS << "CGSCC passes with params:\n";
1950#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1951 printPassName(NAME, PARAMS, OS);
1952#include "PassRegistry.def"
1953
1954 OS << "CGSCC analyses:\n";
1955#define CGSCC_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
1956#include "PassRegistry.def"
1957
1958 OS << "Function passes:\n";
1959#define FUNCTION_PASS(NAME, CREATE_PASS) printPassName(NAME, OS);
1960#include "PassRegistry.def"
1961
1962 OS << "Function passes with params:\n";
1963#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1964 printPassName(NAME, PARAMS, OS);
1965#include "PassRegistry.def"
1966
1967 OS << "Function analyses:\n";
1968#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
1969#include "PassRegistry.def"
1970
1971 OS << "Function alias analyses:\n";
1972#define FUNCTION_ALIAS_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
1973#include "PassRegistry.def"
1974
1975 OS << "LoopNest passes:\n";
1976#define LOOPNEST_PASS(NAME, CREATE_PASS) printPassName(NAME, OS);
1977#include "PassRegistry.def"
1978
1979 OS << "Loop passes:\n";
1980#define LOOP_PASS(NAME, CREATE_PASS) printPassName(NAME, OS);
1981#include "PassRegistry.def"
1982
1983 OS << "Loop passes with params:\n";
1984#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1985 printPassName(NAME, PARAMS, OS);
1986#include "PassRegistry.def"
1987
1988 OS << "Loop analyses:\n";
1989#define LOOP_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
1990#include "PassRegistry.def"
1991}
1992
1994 const std::function<bool(ModulePassManager &, ArrayRef<PipelineElement>)>
1995 &C) {
1996 TopLevelPipelineParsingCallbacks.push_back(C);
1997}
AggressiveInstCombiner - Combine expression patterns to form expressions with fewer,...
This file implements a simple N^2 alias analysis accuracy evaluator.
Provides passes to inlining "always_inline" functions.
This is the interface for LLVM's primary stateless and local alias analysis.
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
This file provides the interface for LLVM's Call Graph Profile pass.
This header provides classes for managing passes over SCCs of the call graph.
This file provides interfaces used to build and manipulate a call graph, which is a very useful tool ...
This file declares an analysis pass that computes CycleInfo for LLVM IR, specialized from GenericCycl...
std::string Name
This file provides the interface for a simple, fast CSE pass.
Super simple passes to force specific function attrs from the commandline into the IR for debugging p...
Provides passes for computing function attributes based on interprocedural analyses.
This file provides the interface for the GCOV style profiler pass.
This file provides the interface for LLVM's Global Value Numbering pass which eliminates fully redund...
This is the interface for a simple mod/ref and alias analysis over globals.
Defines an IR pass for the creation of hardware loops.
This file defines passes to print out IR in various granularities.
Interfaces for passes which infer implicit function attributes from the name and signature of functio...
This file provides the primary interface to the instcombine pass.
Defines passes for running instruction simplification across chunks of IR.
This file provides the interface for LLVM's PGO Instrumentation lowering pass.
See the comments on JumpThreadingPass.
Implements a lazy call graph analysis and related passes for the new pass manager.
This file defines the interface for the loop cache analysis.
This file provides the interface for LLVM's Loop Data Prefetching Pass.
This file implements the Loop Fusion pass.
This header defines the LoopLoadEliminationPass object.
This file defines the interface for the loop nest analysis.
This header provides classes for managing a pipeline of passes over loops in LLVM IR.
The header file for the LowerConstantIntrinsics pass as used by the new pass manager.
The header file for the LowerExpectIntrinsic pass as used by the new pass manager.
#define F(x, y, z)
Definition: MD5.cpp:55
#define G(x, y, z)
Definition: MD5.cpp:56
UseBFI
Definition: MachineLICM.cpp:83
This file exposes an interface to building/using memory SSA to walk memory instructions using a use/d...
This pass performs merges of loads and stores on both sides of a.
This is the interface to build a ModuleSummaryIndex for a module.
Contains a collection of routines for determining if a given instruction is guaranteed to execute if ...
This file provides the interface for LLVM's Global Value Numbering pass.
This file declares a simple ARC-aware AliasAnalysis using special knowledge of Objective C to enhance...
This file provides the interface for IR based instrumentation passes ( (profile-gen,...
CGSCCAnalysisManager CGAM
ModulePassManager MPM
LoopAnalysisManager LAM
FunctionAnalysisManager FAM
ModuleAnalysisManager MAM
const char LLVMTargetMachineRef TM
PassInstrumentationCallbacks PIC
static bool isModulePassName(StringRef Name, CallbacksT &Callbacks)
static bool callbacksAcceptPassName(StringRef Name, CallbacksT &Callbacks)
Tests whether registered callbacks will accept a given pass name.
static bool checkParametrizedPassName(StringRef Name, StringRef PassName)
static std::optional< int > parseDevirtPassName(StringRef Name)
static std::optional< int > parseRepeatPassName(StringRef Name)
static bool startsWithDefaultPipelineAliasPrefix(StringRef Name)
Tests whether a pass name starts with a valid prefix for a default pipeline alias.
static bool isLoopNestPassName(StringRef Name, CallbacksT &Callbacks, bool &UseMemorySSA)
static bool isLoopPassName(StringRef Name, CallbacksT &Callbacks, bool &UseMemorySSA)
static std::optional< std::pair< bool, bool > > parseFunctionPipelineName(StringRef Name)
static bool isCGSCCPassName(StringRef Name, CallbacksT &Callbacks)
static void printPassName(StringRef PassName, raw_ostream &OS)
static bool isFunctionPassName(StringRef Name, CallbacksT &Callbacks)
static const Regex DefaultAliasRegex("^(default|thinlto-pre-link|thinlto|lto-pre-link|lto)<(O[0123sz])>$")
This header defines various interfaces for pass management in LLVM.
This file implements the PredicateInfo analysis, which creates an Extended SSA form for operations us...
This file implements relative lookup table converter that converts lookup tables to relative lookup t...
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file provides the interface for LLVM's Scalar Replacement of Aggregates pass.
raw_pwrite_stream & OS
This file provides the interface for the pseudo probe implementation for AutoFDO.
This file provides the interface for the sampled PGO loader pass.
This is the interface for a SCEV-based alias analysis.
This pass converts vector operations into scalar operations, in order to expose optimization opportun...
This is the interface for a metadata-based scoped no-alias analysis.
This file provides the interface for the pass responsible for both simplifying and canonicalizing the...
This file implements the StringSwitch template, which mimics a switch() statement whose cases are str...
This pass exposes codegen information to IR-level passes.
@ Text
Definition: TextStubV5.cpp:112
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:75
uint64_t getZExtValue() const
Get zero extended value.
Definition: APInt.h:1494
int64_t getSExtValue() const
Get sign extended value.
Definition: APInt.h:1516
A container for analyses that lazily runs them and caches their results.
Definition: PassManager.h:620
bool registerPass(PassBuilderT &&PassBuilder)
Register an analysis pass with the manager.
Definition: PassManager.h:836
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: ArrayRef.h:41
Lightweight error class with error context and mandatory checking.
Definition: Error.h:156
static ErrorSuccess success()
Create a success value.
Definition: Error.h:330
Tagged union holding either a T or a Error.
Definition: Error.h:470
An analysis over an "outer" IR unit that provides access to an analysis manager over an "inner" IR un...
Definition: PassManager.h:933
This class provides an interface for updating the loop pass manager based on mutations to the loop ne...
An SCC of the call graph.
A lazily constructed view of the call graph of a module.
This class represents a loop nest and can be used to query its properties.
Represents a single loop in the control flow graph.
Definition: LoopInfo.h:547
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
static const OptimizationLevel O3
Optimize for fast execution as much as possible.
static const OptimizationLevel Oz
A very specialized mode that will optimize for code size at any and all costs.
static const OptimizationLevel O0
Disable as many optimizations as possible.
static const OptimizationLevel Os
Similar to O2 but tries to optimize for small code size instead of fast execution without triggering ...
static const OptimizationLevel O2
Optimize for fast execution as much as possible without triggering significant incremental compile ti...
static const OptimizationLevel O1
Optimize quickly without destroying debuggability.
void printPassNames(raw_ostream &OS)
Print pass names.
AAManager buildDefaultAAPipeline()
Build the default AAManager with the default alias analysis pipeline registered.
Error parseAAPipeline(AAManager &AA, StringRef PipelineText)
Parse a textual alias analysis pipeline into the provided AA manager.
ModulePassManager buildThinLTOPreLinkDefaultPipeline(OptimizationLevel Level)
Build a pre-link, ThinLTO-targeting default optimization pipeline to a pass manager.
PassBuilder(TargetMachine *TM=nullptr, PipelineTuningOptions PTO=PipelineTuningOptions(), std::optional< PGOOptions > PGOOpt=std::nullopt, PassInstrumentationCallbacks *PIC=nullptr)
void registerLoopAnalyses(LoopAnalysisManager &LAM)
Registers all available loop analysis passes.
void crossRegisterProxies(LoopAnalysisManager &LAM, FunctionAnalysisManager &FAM, CGSCCAnalysisManager &CGAM, ModuleAnalysisManager &MAM)
Cross register the analysis managers through their proxies.
ModulePassManager buildPerModuleDefaultPipeline(OptimizationLevel Level, bool LTOPreLink=false)
Build a per-module default optimization pipeline.
Error parsePassPipeline(ModulePassManager &MPM, StringRef PipelineText)
Parse a textual pass pipeline description into a ModulePassManager.
ModulePassManager buildLTODefaultPipeline(OptimizationLevel Level, ModuleSummaryIndex *ExportSummary)
Build an LTO default optimization pipeline to a pass manager.
ModulePassManager buildThinLTODefaultPipeline(OptimizationLevel Level, const ModuleSummaryIndex *ImportSummary)
Build an ThinLTO default optimization pipeline to a pass manager.
void registerModuleAnalyses(ModuleAnalysisManager &MAM)
Registers all available module analysis passes.
void registerCGSCCAnalyses(CGSCCAnalysisManager &CGAM)
Registers all available CGSCC analysis passes.
void registerParseTopLevelPipelineCallback(const std::function< bool(ModulePassManager &, ArrayRef< PipelineElement >)> &C)
Register a callback for a top-level pipeline entry.
ModulePassManager buildLTOPreLinkDefaultPipeline(OptimizationLevel Level)
Build a pre-link, LTO-targeting default optimization pipeline to a pass manager.
void registerFunctionAnalyses(FunctionAnalysisManager &FAM)
Registers all available function analysis passes.
This class manages callbacks registration, as well as provides a way for PassInstrumentation to pass ...
LLVM_ATTRIBUTE_MINSIZE std::enable_if_t< is_detected< HasRunOnLoopT, PassT >::value > addPass(PassT &&Pass)
LLVM_ATTRIBUTE_MINSIZE std::enable_if_t<!std::is_same< PassT, PassManager >::value > addPass(PassT &&Pass)
Definition: PassManager.h:544
Tunable parameters for passes in the default pipelines.
Definition: PassBuilder.h:41
bool SLPVectorization
Tuning option to enable/disable slp loop vectorization, set based on opt level.
Definition: PassBuilder.h:56
bool LoopVectorization
Tuning option to enable/disable loop vectorization, set based on opt level.
Definition: PassBuilder.h:52
A set of analyses that are preserved following a run of a transformation pass.
Definition: PassManager.h:152
static PreservedAnalyses all()
Construct a special preserved set that preserves all passes.
Definition: PassManager.h:158
bool match(StringRef String, SmallVectorImpl< StringRef > *Matches=nullptr, std::string *Error=nullptr) const
matches - Match the regex against a given String.
Definition: Regex.cpp:86
size_t size() const
Definition: SmallVector.h:91
void push_back(const T &Elt)
Definition: SmallVector.h:416
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1200
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
std::pair< StringRef, StringRef > split(char Separator) const
Split into two substrings around the first occurrence of a separator character.
Definition: StringRef.h:687
bool consume_back(StringRef Suffix)
Returns true if this StringRef has the given suffix and removes that suffix.
Definition: StringRef.h:642
bool getAsInteger(unsigned Radix, T &Result) const
Parse the current string as an integer of the specified radix.
Definition: StringRef.h:468
constexpr bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:134
char front() const
front - Get the first character in the string.
Definition: StringRef.h:140
bool consume_front(StringRef Prefix)
Returns true if this StringRef has the given prefix and removes that prefix.
Definition: StringRef.h:622
A switch()-like statement whose cases are string literals.
Definition: StringSwitch.h:44
StringSwitch & Case(StringLiteral S, T Value)
Definition: StringSwitch.h:69
R Default(T Value)
Definition: StringSwitch.h:182
Primary interface to the complete machine description for the target machine.
Definition: TargetMachine.h:78
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:52
Interfaces for registering analysis passes, producing common pass manager configurations,...
Key
PAL metadata keys.
@ C
The default llvm calling convention, compatible with C.
Definition: CallingConv.h:34
PointerTypeMap run(const Module &M)
Compute the PointerTypeMap for the module M.
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
auto formatv(const char *Fmt, Ts &&... Vals) -> formatv_object< decltype(std::make_tuple(detail::build_format_adapter(std::forward< Ts >(Vals))...))>
std::vector< std::string > printAfterPasses()
ModuleToFunctionPassAdaptor createModuleToFunctionPassAdaptor(FunctionPassT &&Pass, bool EagerlyInvalidate=false)
A function to deduce a function pass type and wrap it in the templated adaptor.
Definition: PassManager.h:1218
RepeatedPass< PassT > createRepeatedPass(int Count, PassT &&P)
Definition: PassManager.h:1353
DevirtSCCRepeatedPass createDevirtSCCRepeatedPass(CGSCCPassT &&Pass, int MaxIterations)
A function to deduce a function pass type and wrap it in the templated adaptor.
std::error_code inconvertibleErrorCode()
The value returned by this function can be returned from convertToErrorCode for Error values where no...
Definition: Error.cpp:79
OuterAnalysisManagerProxy< ModuleAnalysisManager, Function > ModuleAnalysisManagerFunctionProxy
Provide the ModuleAnalysisManager to Function proxy.
Definition: PassManager.h:1168
OuterAnalysisManagerProxy< ModuleAnalysisManager, LazyCallGraph::SCC, LazyCallGraph & > ModuleAnalysisManagerCGSCCProxy
A proxy from a ModuleAnalysisManager to an SCC.
bool any_of(R &&range, UnaryPredicate P)
Provide wrappers to std::any_of which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1826
std::vector< std::string > printBeforePasses()
ModuleToPostOrderCGSCCPassAdaptor createModuleToPostOrderCGSCCPassAdaptor(CGSCCPassT &&Pass)
A function to deduce a function pass type and wrap it in the templated adaptor.
CGSCCToFunctionPassAdaptor createCGSCCToFunctionPassAdaptor(FunctionPassT &&Pass, bool EagerlyInvalidate=false, bool NoRerun=false)
A function to deduce a function pass type and wrap it in the templated adaptor.
InnerAnalysisManagerProxy< FunctionAnalysisManager, Module > FunctionAnalysisManagerModuleProxy
Provide the FunctionAnalysisManager to Module proxy.
Definition: PassManager.h:1014
cl::opt< bool > PrintPipelinePasses("print-pipeline-passes", cl::desc("Print a '-passes' compatible string describing the pipeline " "(best-effort only)."))
OuterAnalysisManagerProxy< FunctionAnalysisManager, Loop, LoopStandardAnalysisResults & > FunctionAnalysisManagerLoopProxy
A proxy from a FunctionAnalysisManager to a Loop.
OuterAnalysisManagerProxy< CGSCCAnalysisManager, Function > CGSCCAnalysisManagerFunctionProxy
A proxy from a CGSCCAnalysisManager to a Function.
std::enable_if_t< is_detected< HasRunOnLoopT, LoopPassT >::value, FunctionToLoopPassAdaptor > createFunctionToLoopPassAdaptor(LoopPassT &&Pass, bool UseMemorySSA=false, bool UseBlockFrequencyInfo=false, bool UseBranchProbabilityInfo=false)
A function to deduce a loop pass type and wrap it in the templated adaptor.
bool isFilterPassesEmpty()
@ Enable
Enable colors.
A CRTP mix-in that provides informational APIs needed for analysis passes.
Definition: PassManager.h:394
A special type used by analysis passes to provide an address that identifies that particular analysis...
Definition: PassManager.h:69
Support structure for SCC passes to communicate updates the call graph back to the CGSCC pass manager...
A set of parameters to control various transforms performed by GVN pass.
Definition: GVN.h:74
HardwareLoopOptions & setForceNested(bool Force)
Definition: HardwareLoops.h:45
HardwareLoopOptions & setDecrement(unsigned Count)
Definition: HardwareLoops.h:29
HardwareLoopOptions & setForceGuard(bool Force)
Definition: HardwareLoops.h:49
HardwareLoopOptions & setForce(bool Force)
Definition: HardwareLoops.h:37
HardwareLoopOptions & setCounterBitwidth(unsigned Width)
Definition: HardwareLoops.h:33
HardwareLoopOptions & setForcePhi(bool Force)
Definition: HardwareLoops.h:41
A set of parameters to control various transforms performed by IPSCCP pass.
Definition: SCCP.h:35
The adaptor from a function pass to a loop pass computes these analyses and makes them available to t...
A set of parameters used to control various transforms performed by the LoopUnroll pass.
LoopUnrollOptions & setPeeling(bool Peeling)
Enables or disables loop peeling.
LoopUnrollOptions & setOptLevel(int O)
LoopUnrollOptions & setPartial(bool Partial)
Enables or disables partial unrolling.
LoopUnrollOptions & setFullUnrollMaxCount(unsigned O)
LoopUnrollOptions & setUpperBound(bool UpperBound)
Enables or disables the use of trip count upper bound in loop unrolling.
LoopUnrollOptions & setRuntime(bool Runtime)
Enables or disables unrolling of loops with runtime trip count.
LoopUnrollOptions & setProfileBasedPeeling(int O)
LoopVectorizeOptions & setVectorizeOnlyWhenForced(bool Value)
LoopVectorizeOptions & setInterleaveOnlyWhenForced(bool Value)
A CRTP mix-in to automatically provide informational APIs needed for passes.
Definition: PassManager.h:371
static StringRef name()
Gets the name of the pass we are mixed into.
Definition: PassManager.h:373