LLVM 19.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"
48#include "llvm/Analysis/Lint.h"
105#include "llvm/IR/DebugInfo.h"
106#include "llvm/IR/Dominators.h"
107#include "llvm/IR/PassManager.h"
108#include "llvm/IR/PrintPasses.h"
110#include "llvm/IR/Verifier.h"
114#include "llvm/Support/Debug.h"
117#include "llvm/Support/Regex.h"
298#include <optional>
299
300using namespace llvm;
301
303 "^(default|thinlto-pre-link|thinlto|lto-pre-link|lto)<(O[0123sz])>$");
304
305namespace llvm {
307 "print-pipeline-passes",
308 cl::desc("Print a '-passes' compatible string describing the pipeline "
309 "(best-effort only)."));
310} // namespace llvm
311
312AnalysisKey NoOpModuleAnalysis::Key;
313AnalysisKey NoOpCGSCCAnalysis::Key;
314AnalysisKey NoOpFunctionAnalysis::Key;
315AnalysisKey NoOpLoopAnalysis::Key;
316
317namespace {
318
319/// Whether or not we should populate a PassInstrumentationCallbacks's class to
320/// pass name map.
321///
322/// This is for optimization purposes so we don't populate it if we never use
323/// it. This should be updated if new pass instrumentation wants to use the map.
324/// We currently only use this for --print-before/after.
325bool shouldPopulateClassToPassNames() {
326 return PrintPipelinePasses || !printBeforePasses().empty() ||
327 !printAfterPasses().empty() || !isFilterPassesEmpty() ||
329}
330
331// A pass for testing -print-on-crash.
332// DO NOT USE THIS EXCEPT FOR TESTING!
333class TriggerCrashPass : public PassInfoMixin<TriggerCrashPass> {
334public:
336 abort();
337 return PreservedAnalyses::all();
338 }
339 static StringRef name() { return "TriggerCrashPass"; }
340};
341
342// A pass for testing message reporting of -verify-each failures.
343// DO NOT USE THIS EXCEPT FOR TESTING!
344class TriggerVerifierErrorPass
345 : public PassInfoMixin<TriggerVerifierErrorPass> {
346public:
348 // Intentionally break the Module by creating an alias without setting the
349 // aliasee.
350 auto *PtrTy = llvm::PointerType::getUnqual(M.getContext());
351 GlobalAlias::create(PtrTy, PtrTy->getAddressSpace(),
352 GlobalValue::LinkageTypes::InternalLinkage,
353 "__bad_alias", nullptr, &M);
355 }
356
358 // Intentionally break the Function by inserting a terminator
359 // instruction in the middle of a basic block.
360 BasicBlock &BB = F.getEntryBlock();
361 new UnreachableInst(F.getContext(), BB.getTerminator()->getIterator());
363 }
364
365 static StringRef name() { return "TriggerVerifierErrorPass"; }
366};
367
368} // namespace
369
371 std::optional<PGOOptions> PGOOpt,
373 : TM(TM), PTO(PTO), PGOOpt(PGOOpt), PIC(PIC) {
374 bool ShouldPopulateClassToPassNames = PIC && shouldPopulateClassToPassNames();
375 if (TM)
376 TM->registerPassBuilderCallbacks(*this, ShouldPopulateClassToPassNames);
377 if (ShouldPopulateClassToPassNames) {
378#define MODULE_PASS(NAME, CREATE_PASS) \
379 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
380#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
381 PIC->addClassToPassName(CLASS, NAME);
382#define MODULE_ANALYSIS(NAME, CREATE_PASS) \
383 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
384#define FUNCTION_PASS(NAME, CREATE_PASS) \
385 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
386#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
387 PIC->addClassToPassName(CLASS, NAME);
388#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
389 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
390#define LOOPNEST_PASS(NAME, CREATE_PASS) \
391 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
392#define LOOP_PASS(NAME, CREATE_PASS) \
393 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
394#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
395 PIC->addClassToPassName(CLASS, NAME);
396#define LOOP_ANALYSIS(NAME, CREATE_PASS) \
397 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
398#define CGSCC_PASS(NAME, CREATE_PASS) \
399 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
400#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
401 PIC->addClassToPassName(CLASS, NAME);
402#define CGSCC_ANALYSIS(NAME, CREATE_PASS) \
403 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
404#include "PassRegistry.def"
405
406#define MACHINE_FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
407 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
408#define MACHINE_FUNCTION_PASS(NAME, CREATE_PASS) \
409 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
410#include "llvm/Passes/MachinePassRegistry.def"
411 }
412}
413
415#define MODULE_ANALYSIS(NAME, CREATE_PASS) \
416 MAM.registerPass([&] { return CREATE_PASS; });
417#include "PassRegistry.def"
418
419 for (auto &C : ModuleAnalysisRegistrationCallbacks)
420 C(MAM);
421}
422
424#define CGSCC_ANALYSIS(NAME, CREATE_PASS) \
425 CGAM.registerPass([&] { return CREATE_PASS; });
426#include "PassRegistry.def"
427
428 for (auto &C : CGSCCAnalysisRegistrationCallbacks)
429 C(CGAM);
430}
431
433 // We almost always want the default alias analysis pipeline.
434 // If a user wants a different one, they can register their own before calling
435 // registerFunctionAnalyses().
436 FAM.registerPass([&] { return buildDefaultAAPipeline(); });
437
438#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
439 FAM.registerPass([&] { return CREATE_PASS; });
440#include "PassRegistry.def"
441
442 for (auto &C : FunctionAnalysisRegistrationCallbacks)
443 C(FAM);
444}
445
448
449#define MACHINE_FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
450 MFAM.registerPass([&] { return CREATE_PASS; });
451#include "llvm/Passes/MachinePassRegistry.def"
452
453 for (auto &C : MachineFunctionAnalysisRegistrationCallbacks)
454 C(MFAM);
455}
456
458#define LOOP_ANALYSIS(NAME, CREATE_PASS) \
459 LAM.registerPass([&] { return CREATE_PASS; });
460#include "PassRegistry.def"
461
462 for (auto &C : LoopAnalysisRegistrationCallbacks)
463 C(LAM);
464}
465
466static std::optional<int> parseRepeatPassName(StringRef Name) {
467 if (!Name.consume_front("repeat<") || !Name.consume_back(">"))
468 return std::nullopt;
469 int Count;
470 if (Name.getAsInteger(0, Count) || Count <= 0)
471 return std::nullopt;
472 return Count;
473}
474
475static std::optional<std::pair<bool, bool>>
477 std::pair<bool, bool> Params;
478 if (!Name.consume_front("function"))
479 return std::nullopt;
480 if (Name.empty())
481 return Params;
482 if (!Name.consume_front("<") || !Name.consume_back(">"))
483 return std::nullopt;
484 while (!Name.empty()) {
485 auto [Front, Back] = Name.split(';');
486 Name = Back;
487 if (Front == "eager-inv")
488 Params.first = true;
489 else if (Front == "no-rerun")
490 Params.second = true;
491 else
492 return std::nullopt;
493 }
494 return Params;
495}
496
497static std::optional<int> parseDevirtPassName(StringRef Name) {
498 if (!Name.consume_front("devirt<") || !Name.consume_back(">"))
499 return std::nullopt;
500 int Count;
501 if (Name.getAsInteger(0, Count) || Count < 0)
502 return std::nullopt;
503 return Count;
504}
505
506static std::optional<OptimizationLevel> parseOptLevel(StringRef S) {
508 .Case("O0", OptimizationLevel::O0)
514 .Default(std::nullopt);
515}
516
518 StringRef OptionName,
520 bool Result = false;
521 while (!Params.empty()) {
522 StringRef ParamName;
523 std::tie(ParamName, Params) = Params.split(';');
524
525 if (ParamName == OptionName) {
526 Result = true;
527 } else {
528 return make_error<StringError>(
529 formatv("invalid {1} pass parameter '{0}' ", ParamName, PassName)
530 .str(),
532 }
533 }
534 return Result;
535}
536
537namespace {
538
539/// Parser of parameters for HardwareLoops pass.
540Expected<HardwareLoopOptions> parseHardwareLoopOptions(StringRef Params) {
541 HardwareLoopOptions HardwareLoopOpts;
542
543 while (!Params.empty()) {
544 StringRef ParamName;
545 std::tie(ParamName, Params) = Params.split(';');
546 if (ParamName.consume_front("hardware-loop-decrement=")) {
547 int Count;
548 if (ParamName.getAsInteger(0, Count))
549 return make_error<StringError>(
550 formatv("invalid HardwareLoopPass parameter '{0}' ", ParamName).str(),
552 HardwareLoopOpts.setDecrement(Count);
553 continue;
554 }
555 if (ParamName.consume_front("hardware-loop-counter-bitwidth=")) {
556 int Count;
557 if (ParamName.getAsInteger(0, Count))
558 return make_error<StringError>(
559 formatv("invalid HardwareLoopPass parameter '{0}' ", ParamName).str(),
561 HardwareLoopOpts.setCounterBitwidth(Count);
562 continue;
563 }
564 if (ParamName == "force-hardware-loops") {
565 HardwareLoopOpts.setForce(true);
566 } else if (ParamName == "force-hardware-loop-phi") {
567 HardwareLoopOpts.setForcePhi(true);
568 } else if (ParamName == "force-nested-hardware-loop") {
569 HardwareLoopOpts.setForceNested(true);
570 } else if (ParamName == "force-hardware-loop-guard") {
571 HardwareLoopOpts.setForceGuard(true);
572 } else {
573 return make_error<StringError>(
574 formatv("invalid HardwarePass parameter '{0}' ", ParamName).str(),
576 }
577 }
578 return HardwareLoopOpts;
579}
580
581/// Parser of parameters for LoopUnroll pass.
582Expected<LoopUnrollOptions> parseLoopUnrollOptions(StringRef Params) {
583 LoopUnrollOptions UnrollOpts;
584 while (!Params.empty()) {
585 StringRef ParamName;
586 std::tie(ParamName, Params) = Params.split(';');
587 std::optional<OptimizationLevel> OptLevel = parseOptLevel(ParamName);
588 // Don't accept -Os/-Oz.
589 if (OptLevel && !OptLevel->isOptimizingForSize()) {
590 UnrollOpts.setOptLevel(OptLevel->getSpeedupLevel());
591 continue;
592 }
593 if (ParamName.consume_front("full-unroll-max=")) {
594 int Count;
595 if (ParamName.getAsInteger(0, Count))
596 return make_error<StringError>(
597 formatv("invalid LoopUnrollPass parameter '{0}' ", ParamName).str(),
599 UnrollOpts.setFullUnrollMaxCount(Count);
600 continue;
601 }
602
603 bool Enable = !ParamName.consume_front("no-");
604 if (ParamName == "partial") {
605 UnrollOpts.setPartial(Enable);
606 } else if (ParamName == "peeling") {
607 UnrollOpts.setPeeling(Enable);
608 } else if (ParamName == "profile-peeling") {
609 UnrollOpts.setProfileBasedPeeling(Enable);
610 } else if (ParamName == "runtime") {
611 UnrollOpts.setRuntime(Enable);
612 } else if (ParamName == "upperbound") {
613 UnrollOpts.setUpperBound(Enable);
614 } else {
615 return make_error<StringError>(
616 formatv("invalid LoopUnrollPass parameter '{0}' ", ParamName).str(),
618 }
619 }
620 return UnrollOpts;
621}
622
623Expected<bool> parseGlobalDCEPassOptions(StringRef Params) {
625 Params, "vfe-linkage-unit-visibility", "GlobalDCE");
626}
627
628Expected<bool> parseCGProfilePassOptions(StringRef Params) {
629 return PassBuilder::parseSinglePassOption(Params, "in-lto-post-link",
630 "CGProfile");
631}
632
633Expected<bool> parseInlinerPassOptions(StringRef Params) {
634 return PassBuilder::parseSinglePassOption(Params, "only-mandatory",
635 "InlinerPass");
636}
637
638Expected<bool> parseCoroSplitPassOptions(StringRef Params) {
639 return PassBuilder::parseSinglePassOption(Params, "reuse-storage",
640 "CoroSplitPass");
641}
642
643Expected<bool> parsePostOrderFunctionAttrsPassOptions(StringRef Params) {
645 Params, "skip-non-recursive-function-attrs", "PostOrderFunctionAttrs");
646}
647
648Expected<CFGuardPass::Mechanism> parseCFGuardPassOptions(StringRef Params) {
649 if (Params.empty())
651
652 auto [Param, RHS] = Params.split(';');
653 if (!RHS.empty())
654 return make_error<StringError>(
655 formatv("too many CFGuardPass parameters '{0}' ", Params).str(),
657
658 if (Param == "check")
660 if (Param == "dispatch")
662
663 return make_error<StringError>(
664 formatv("invalid CFGuardPass mechanism: '{0}' ", Param).str(),
666}
667
668Expected<bool> parseEarlyCSEPassOptions(StringRef Params) {
669 return PassBuilder::parseSinglePassOption(Params, "memssa", "EarlyCSE");
670}
671
672Expected<bool> parseEntryExitInstrumenterPassOptions(StringRef Params) {
673 return PassBuilder::parseSinglePassOption(Params, "post-inline",
674 "EntryExitInstrumenter");
675}
676
677Expected<bool> parseLoopExtractorPassOptions(StringRef Params) {
678 return PassBuilder::parseSinglePassOption(Params, "single", "LoopExtractor");
679}
680
681Expected<bool> parseLowerMatrixIntrinsicsPassOptions(StringRef Params) {
682 return PassBuilder::parseSinglePassOption(Params, "minimal",
683 "LowerMatrixIntrinsics");
684}
685
686Expected<AddressSanitizerOptions> parseASanPassOptions(StringRef Params) {
688 while (!Params.empty()) {
689 StringRef ParamName;
690 std::tie(ParamName, Params) = Params.split(';');
691
692 if (ParamName == "kernel") {
693 Result.CompileKernel = true;
694 } else {
695 return make_error<StringError>(
696 formatv("invalid AddressSanitizer pass parameter '{0}' ", ParamName)
697 .str(),
699 }
700 }
701 return Result;
702}
703
704Expected<HWAddressSanitizerOptions> parseHWASanPassOptions(StringRef Params) {
706 while (!Params.empty()) {
707 StringRef ParamName;
708 std::tie(ParamName, Params) = Params.split(';');
709
710 if (ParamName == "recover") {
711 Result.Recover = true;
712 } else if (ParamName == "kernel") {
713 Result.CompileKernel = true;
714 } else {
715 return make_error<StringError>(
716 formatv("invalid HWAddressSanitizer pass parameter '{0}' ", ParamName)
717 .str(),
719 }
720 }
721 return Result;
722}
723
724Expected<EmbedBitcodeOptions> parseEmbedBitcodePassOptions(StringRef Params) {
726 while (!Params.empty()) {
727 StringRef ParamName;
728 std::tie(ParamName, Params) = Params.split(';');
729
730 if (ParamName == "thinlto") {
731 Result.IsThinLTO = true;
732 } else if (ParamName == "emit-summary") {
733 Result.EmitLTOSummary = true;
734 } else {
735 return make_error<StringError>(
736 formatv("invalid EmbedBitcode pass parameter '{0}' ", ParamName)
737 .str(),
739 }
740 }
741 return Result;
742}
743
744Expected<MemorySanitizerOptions> parseMSanPassOptions(StringRef Params) {
746 while (!Params.empty()) {
747 StringRef ParamName;
748 std::tie(ParamName, Params) = Params.split(';');
749
750 if (ParamName == "recover") {
751 Result.Recover = true;
752 } else if (ParamName == "kernel") {
753 Result.Kernel = true;
754 } else if (ParamName.consume_front("track-origins=")) {
755 if (ParamName.getAsInteger(0, Result.TrackOrigins))
756 return make_error<StringError>(
757 formatv("invalid argument to MemorySanitizer pass track-origins "
758 "parameter: '{0}' ",
759 ParamName)
760 .str(),
762 } else if (ParamName == "eager-checks") {
763 Result.EagerChecks = true;
764 } else {
765 return make_error<StringError>(
766 formatv("invalid MemorySanitizer pass parameter '{0}' ", ParamName)
767 .str(),
769 }
770 }
771 return Result;
772}
773
774/// Parser of parameters for SimplifyCFG pass.
775Expected<SimplifyCFGOptions> parseSimplifyCFGOptions(StringRef Params) {
777 while (!Params.empty()) {
778 StringRef ParamName;
779 std::tie(ParamName, Params) = Params.split(';');
780
781 bool Enable = !ParamName.consume_front("no-");
782 if (ParamName == "speculate-blocks") {
783 Result.speculateBlocks(Enable);
784 } else if (ParamName == "simplify-cond-branch") {
785 Result.setSimplifyCondBranch(Enable);
786 } else if (ParamName == "forward-switch-cond") {
787 Result.forwardSwitchCondToPhi(Enable);
788 } else if (ParamName == "switch-range-to-icmp") {
789 Result.convertSwitchRangeToICmp(Enable);
790 } else if (ParamName == "switch-to-lookup") {
791 Result.convertSwitchToLookupTable(Enable);
792 } else if (ParamName == "keep-loops") {
793 Result.needCanonicalLoops(Enable);
794 } else if (ParamName == "hoist-common-insts") {
795 Result.hoistCommonInsts(Enable);
796 } else if (ParamName == "sink-common-insts") {
797 Result.sinkCommonInsts(Enable);
798 } else if (Enable && ParamName.consume_front("bonus-inst-threshold=")) {
799 APInt BonusInstThreshold;
800 if (ParamName.getAsInteger(0, BonusInstThreshold))
801 return make_error<StringError>(
802 formatv("invalid argument to SimplifyCFG pass bonus-threshold "
803 "parameter: '{0}' ",
804 ParamName).str(),
806 Result.bonusInstThreshold(BonusInstThreshold.getSExtValue());
807 } else {
808 return make_error<StringError>(
809 formatv("invalid SimplifyCFG pass parameter '{0}' ", ParamName).str(),
811 }
812 }
813 return Result;
814}
815
816Expected<InstCombineOptions> parseInstCombineOptions(StringRef Params) {
818 // When specifying "instcombine" in -passes enable fix-point verification by
819 // default, as this is what most tests should use.
820 Result.setVerifyFixpoint(true);
821 while (!Params.empty()) {
822 StringRef ParamName;
823 std::tie(ParamName, Params) = Params.split(';');
824
825 bool Enable = !ParamName.consume_front("no-");
826 if (ParamName == "use-loop-info") {
827 Result.setUseLoopInfo(Enable);
828 } else if (ParamName == "verify-fixpoint") {
829 Result.setVerifyFixpoint(Enable);
830 } else if (Enable && ParamName.consume_front("max-iterations=")) {
831 APInt MaxIterations;
832 if (ParamName.getAsInteger(0, MaxIterations))
833 return make_error<StringError>(
834 formatv("invalid argument to InstCombine pass max-iterations "
835 "parameter: '{0}' ",
836 ParamName).str(),
838 Result.setMaxIterations((unsigned)MaxIterations.getZExtValue());
839 } else {
840 return make_error<StringError>(
841 formatv("invalid InstCombine pass parameter '{0}' ", ParamName).str(),
843 }
844 }
845 return Result;
846}
847
848/// Parser of parameters for LoopVectorize pass.
849Expected<LoopVectorizeOptions> parseLoopVectorizeOptions(StringRef Params) {
851 while (!Params.empty()) {
852 StringRef ParamName;
853 std::tie(ParamName, Params) = Params.split(';');
854
855 bool Enable = !ParamName.consume_front("no-");
856 if (ParamName == "interleave-forced-only") {
858 } else if (ParamName == "vectorize-forced-only") {
860 } else {
861 return make_error<StringError>(
862 formatv("invalid LoopVectorize parameter '{0}' ", ParamName).str(),
864 }
865 }
866 return Opts;
867}
868
869Expected<std::pair<bool, bool>> parseLoopUnswitchOptions(StringRef Params) {
870 std::pair<bool, bool> Result = {false, true};
871 while (!Params.empty()) {
872 StringRef ParamName;
873 std::tie(ParamName, Params) = Params.split(';');
874
875 bool Enable = !ParamName.consume_front("no-");
876 if (ParamName == "nontrivial") {
877 Result.first = Enable;
878 } else if (ParamName == "trivial") {
879 Result.second = Enable;
880 } else {
881 return make_error<StringError>(
882 formatv("invalid LoopUnswitch pass parameter '{0}' ", ParamName)
883 .str(),
885 }
886 }
887 return Result;
888}
889
890Expected<LICMOptions> parseLICMOptions(StringRef Params) {
892 while (!Params.empty()) {
893 StringRef ParamName;
894 std::tie(ParamName, Params) = Params.split(';');
895
896 bool Enable = !ParamName.consume_front("no-");
897 if (ParamName == "allowspeculation") {
898 Result.AllowSpeculation = Enable;
899 } else {
900 return make_error<StringError>(
901 formatv("invalid LICM pass parameter '{0}' ", ParamName).str(),
903 }
904 }
905 return Result;
906}
907
908Expected<std::pair<bool, bool>> parseLoopRotateOptions(StringRef Params) {
909 std::pair<bool, bool> Result = {true, false};
910 while (!Params.empty()) {
911 StringRef ParamName;
912 std::tie(ParamName, Params) = Params.split(';');
913
914 bool Enable = !ParamName.consume_front("no-");
915 if (ParamName == "header-duplication") {
916 Result.first = Enable;
917 } else if (ParamName == "prepare-for-lto") {
918 Result.second = Enable;
919 } else {
920 return make_error<StringError>(
921 formatv("invalid LoopRotate pass parameter '{0}' ", ParamName).str(),
923 }
924 }
925 return Result;
926}
927
928Expected<bool> parseMergedLoadStoreMotionOptions(StringRef Params) {
929 bool Result = false;
930 while (!Params.empty()) {
931 StringRef ParamName;
932 std::tie(ParamName, Params) = Params.split(';');
933
934 bool Enable = !ParamName.consume_front("no-");
935 if (ParamName == "split-footer-bb") {
936 Result = Enable;
937 } else {
938 return make_error<StringError>(
939 formatv("invalid MergedLoadStoreMotion pass parameter '{0}' ",
940 ParamName)
941 .str(),
943 }
944 }
945 return Result;
946}
947
948Expected<GVNOptions> parseGVNOptions(StringRef Params) {
950 while (!Params.empty()) {
951 StringRef ParamName;
952 std::tie(ParamName, Params) = Params.split(';');
953
954 bool Enable = !ParamName.consume_front("no-");
955 if (ParamName == "pre") {
956 Result.setPRE(Enable);
957 } else if (ParamName == "load-pre") {
958 Result.setLoadPRE(Enable);
959 } else if (ParamName == "split-backedge-load-pre") {
960 Result.setLoadPRESplitBackedge(Enable);
961 } else if (ParamName == "memdep") {
962 Result.setMemDep(Enable);
963 } else {
964 return make_error<StringError>(
965 formatv("invalid GVN pass parameter '{0}' ", ParamName).str(),
967 }
968 }
969 return Result;
970}
971
972Expected<IPSCCPOptions> parseIPSCCPOptions(StringRef Params) {
974 while (!Params.empty()) {
975 StringRef ParamName;
976 std::tie(ParamName, Params) = Params.split(';');
977
978 bool Enable = !ParamName.consume_front("no-");
979 if (ParamName == "func-spec")
980 Result.setFuncSpec(Enable);
981 else
982 return make_error<StringError>(
983 formatv("invalid IPSCCP pass parameter '{0}' ", ParamName).str(),
985 }
986 return Result;
987}
988
989Expected<SROAOptions> parseSROAOptions(StringRef Params) {
990 if (Params.empty() || Params == "modify-cfg")
992 if (Params == "preserve-cfg")
994 return make_error<StringError>(
995 formatv("invalid SROA pass parameter '{0}' (either preserve-cfg or "
996 "modify-cfg can be specified)",
997 Params)
998 .str(),
1000}
1001
1003parseStackLifetimeOptions(StringRef Params) {
1005 while (!Params.empty()) {
1006 StringRef ParamName;
1007 std::tie(ParamName, Params) = Params.split(';');
1008
1009 if (ParamName == "may") {
1011 } else if (ParamName == "must") {
1013 } else {
1014 return make_error<StringError>(
1015 formatv("invalid StackLifetime parameter '{0}' ", ParamName).str(),
1017 }
1018 }
1019 return Result;
1020}
1021
1022Expected<bool> parseDependenceAnalysisPrinterOptions(StringRef Params) {
1023 return PassBuilder::parseSinglePassOption(Params, "normalized-results",
1024 "DependenceAnalysisPrinter");
1025}
1026
1027Expected<bool> parseSeparateConstOffsetFromGEPPassOptions(StringRef Params) {
1028 return PassBuilder::parseSinglePassOption(Params, "lower-gep",
1029 "SeparateConstOffsetFromGEP");
1030}
1031
1033parseFunctionSimplificationPipelineOptions(StringRef Params) {
1034 std::optional<OptimizationLevel> L = parseOptLevel(Params);
1035 if (!L || *L == OptimizationLevel::O0) {
1036 return make_error<StringError>(
1037 formatv("invalid function-simplification parameter '{0}' ", Params)
1038 .str(),
1040 };
1041 return *L;
1042}
1043
1044Expected<bool> parseMemorySSAPrinterPassOptions(StringRef Params) {
1045 return PassBuilder::parseSinglePassOption(Params, "no-ensure-optimized-uses",
1046 "MemorySSAPrinterPass");
1047}
1048
1049Expected<bool> parseSpeculativeExecutionPassOptions(StringRef Params) {
1050 return PassBuilder::parseSinglePassOption(Params, "only-if-divergent-target",
1051 "SpeculativeExecutionPass");
1052}
1053
1054Expected<std::string> parseMemProfUsePassOptions(StringRef Params) {
1055 std::string Result;
1056 while (!Params.empty()) {
1057 StringRef ParamName;
1058 std::tie(ParamName, Params) = Params.split(';');
1059
1060 if (ParamName.consume_front("profile-filename=")) {
1061 Result = ParamName.str();
1062 } else {
1063 return make_error<StringError>(
1064 formatv("invalid MemProfUse pass parameter '{0}' ", ParamName).str(),
1066 }
1067 }
1068 return Result;
1069}
1070
1071Expected<bool> parseStructuralHashPrinterPassOptions(StringRef Params) {
1072 return PassBuilder::parseSinglePassOption(Params, "detailed",
1073 "StructuralHashPrinterPass");
1074}
1075
1076Expected<bool> parseWinEHPrepareOptions(StringRef Params) {
1077 return PassBuilder::parseSinglePassOption(Params, "demote-catchswitch-only",
1078 "WinEHPreparePass");
1079}
1080
1081Expected<GlobalMergeOptions> parseGlobalMergeOptions(StringRef Params) {
1083 while (!Params.empty()) {
1084 StringRef ParamName;
1085 std::tie(ParamName, Params) = Params.split(';');
1086
1087 bool Enable = !ParamName.consume_front("no-");
1088 if (ParamName == "group-by-use")
1089 Result.GroupByUse = Enable;
1090 else if (ParamName == "ignore-single-use")
1091 Result.IgnoreSingleUse = Enable;
1092 else if (ParamName == "merge-const")
1093 Result.MergeConst = Enable;
1094 else if (ParamName == "merge-external")
1095 Result.MergeExternal = Enable;
1096 else if (ParamName.consume_front("max-offset=")) {
1097 if (ParamName.getAsInteger(0, Result.MaxOffset))
1098 return make_error<StringError>(
1099 formatv("invalid GlobalMergePass parameter '{0}' ", ParamName)
1100 .str(),
1102 }
1103 }
1104 return Result;
1105}
1106
1107} // namespace
1108
1109/// Tests whether a pass name starts with a valid prefix for a default pipeline
1110/// alias.
1112 return Name.starts_with("default") || Name.starts_with("thinlto") ||
1113 Name.starts_with("lto");
1114}
1115
1116/// Tests whether registered callbacks will accept a given pass name.
1117///
1118/// When parsing a pipeline text, the type of the outermost pipeline may be
1119/// omitted, in which case the type is automatically determined from the first
1120/// pass name in the text. This may be a name that is handled through one of the
1121/// callbacks. We check this through the oridinary parsing callbacks by setting
1122/// up a dummy PassManager in order to not force the client to also handle this
1123/// type of query.
1124template <typename PassManagerT, typename CallbacksT>
1125static bool callbacksAcceptPassName(StringRef Name, CallbacksT &Callbacks) {
1126 if (!Callbacks.empty()) {
1127 PassManagerT DummyPM;
1128 for (auto &CB : Callbacks)
1129 if (CB(Name, DummyPM, {}))
1130 return true;
1131 }
1132 return false;
1133}
1134
1135template <typename CallbacksT>
1136static bool isModulePassName(StringRef Name, CallbacksT &Callbacks) {
1137 // Manually handle aliases for pre-configured pipeline fragments.
1140
1141 StringRef NameNoBracket = Name.take_until([](char C) { return C == '<'; });
1142
1143 // Explicitly handle pass manager names.
1144 if (Name == "module")
1145 return true;
1146 if (Name == "cgscc")
1147 return true;
1148 if (NameNoBracket == "function")
1149 return true;
1150 if (Name == "coro-cond")
1151 return true;
1152
1153 // Explicitly handle custom-parsed pass names.
1155 return true;
1156
1157#define MODULE_PASS(NAME, CREATE_PASS) \
1158 if (Name == NAME) \
1159 return true;
1160#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1161 if (PassBuilder::checkParametrizedPassName(Name, NAME)) \
1162 return true;
1163#define MODULE_ANALYSIS(NAME, CREATE_PASS) \
1164 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \
1165 return true;
1166#include "PassRegistry.def"
1167
1168 return callbacksAcceptPassName<ModulePassManager>(Name, Callbacks);
1169}
1170
1171template <typename CallbacksT>
1172static bool isCGSCCPassName(StringRef Name, CallbacksT &Callbacks) {
1173 // Explicitly handle pass manager names.
1174 StringRef NameNoBracket = Name.take_until([](char C) { return C == '<'; });
1175 if (Name == "cgscc")
1176 return true;
1177 if (NameNoBracket == "function")
1178 return true;
1179
1180 // Explicitly handle custom-parsed pass names.
1182 return true;
1184 return true;
1185
1186#define CGSCC_PASS(NAME, CREATE_PASS) \
1187 if (Name == NAME) \
1188 return true;
1189#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1190 if (PassBuilder::checkParametrizedPassName(Name, NAME)) \
1191 return true;
1192#define CGSCC_ANALYSIS(NAME, CREATE_PASS) \
1193 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \
1194 return true;
1195#include "PassRegistry.def"
1196
1197 return callbacksAcceptPassName<CGSCCPassManager>(Name, Callbacks);
1198}
1199
1200template <typename CallbacksT>
1201static bool isFunctionPassName(StringRef Name, CallbacksT &Callbacks) {
1202 // Explicitly handle pass manager names.
1203 StringRef NameNoBracket = Name.take_until([](char C) { return C == '<'; });
1204 if (NameNoBracket == "function")
1205 return true;
1206 if (Name == "loop" || Name == "loop-mssa")
1207 return true;
1208
1209 // Explicitly handle custom-parsed pass names.
1211 return true;
1212
1213#define FUNCTION_PASS(NAME, CREATE_PASS) \
1214 if (Name == NAME) \
1215 return true;
1216#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1217 if (PassBuilder::checkParametrizedPassName(Name, NAME)) \
1218 return true;
1219#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
1220 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \
1221 return true;
1222#include "PassRegistry.def"
1223
1224 return callbacksAcceptPassName<FunctionPassManager>(Name, Callbacks);
1225}
1226
1227template <typename CallbacksT>
1228static bool isMachineFunctionPassName(StringRef Name, CallbacksT &Callbacks) {
1229 // Explicitly handle pass manager names.
1230 if (Name == "machine-function")
1231 return true;
1232
1233 // Explicitly handle custom-parsed pass names.
1235 return true;
1236
1237#define MACHINE_FUNCTION_PASS(NAME, CREATE_PASS) \
1238 if (Name == NAME) \
1239 return true;
1240#define MACHINE_FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
1241 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \
1242 return true;
1243
1244#include "llvm/Passes/MachinePassRegistry.def"
1245
1246 return callbacksAcceptPassName<MachineFunctionPassManager>(Name, Callbacks);
1247}
1248
1249template <typename CallbacksT>
1250static bool isLoopNestPassName(StringRef Name, CallbacksT &Callbacks,
1251 bool &UseMemorySSA) {
1252 UseMemorySSA = false;
1253
1254 // Explicitly handle custom-parsed pass names.
1256 return true;
1257
1259 UseMemorySSA = true;
1260 return true;
1261 }
1262
1263#define LOOPNEST_PASS(NAME, CREATE_PASS) \
1264 if (Name == NAME) \
1265 return true;
1266#include "PassRegistry.def"
1267
1268 return callbacksAcceptPassName<LoopPassManager>(Name, Callbacks);
1269}
1270
1271template <typename CallbacksT>
1272static bool isLoopPassName(StringRef Name, CallbacksT &Callbacks,
1273 bool &UseMemorySSA) {
1274 UseMemorySSA = false;
1275
1276 // Explicitly handle custom-parsed pass names.
1278 return true;
1279
1281 UseMemorySSA = true;
1282 return true;
1283 }
1284
1285#define LOOP_PASS(NAME, CREATE_PASS) \
1286 if (Name == NAME) \
1287 return true;
1288#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1289 if (PassBuilder::checkParametrizedPassName(Name, NAME)) \
1290 return true;
1291#define LOOP_ANALYSIS(NAME, CREATE_PASS) \
1292 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \
1293 return true;
1294#include "PassRegistry.def"
1295
1296 return callbacksAcceptPassName<LoopPassManager>(Name, Callbacks);
1297}
1298
1299std::optional<std::vector<PassBuilder::PipelineElement>>
1300PassBuilder::parsePipelineText(StringRef Text) {
1301 std::vector<PipelineElement> ResultPipeline;
1302
1303 SmallVector<std::vector<PipelineElement> *, 4> PipelineStack = {
1304 &ResultPipeline};
1305 for (;;) {
1306 std::vector<PipelineElement> &Pipeline = *PipelineStack.back();
1307 size_t Pos = Text.find_first_of(",()");
1308 Pipeline.push_back({Text.substr(0, Pos), {}});
1309
1310 // If we have a single terminating name, we're done.
1311 if (Pos == Text.npos)
1312 break;
1313
1314 char Sep = Text[Pos];
1315 Text = Text.substr(Pos + 1);
1316 if (Sep == ',')
1317 // Just a name ending in a comma, continue.
1318 continue;
1319
1320 if (Sep == '(') {
1321 // Push the inner pipeline onto the stack to continue processing.
1322 PipelineStack.push_back(&Pipeline.back().InnerPipeline);
1323 continue;
1324 }
1325
1326 assert(Sep == ')' && "Bogus separator!");
1327 // When handling the close parenthesis, we greedily consume them to avoid
1328 // empty strings in the pipeline.
1329 do {
1330 // If we try to pop the outer pipeline we have unbalanced parentheses.
1331 if (PipelineStack.size() == 1)
1332 return std::nullopt;
1333
1334 PipelineStack.pop_back();
1335 } while (Text.consume_front(")"));
1336
1337 // Check if we've finished parsing.
1338 if (Text.empty())
1339 break;
1340
1341 // Otherwise, the end of an inner pipeline always has to be followed by
1342 // a comma, and then we can continue.
1343 if (!Text.consume_front(","))
1344 return std::nullopt;
1345 }
1346
1347 if (PipelineStack.size() > 1)
1348 // Unbalanced paretheses.
1349 return std::nullopt;
1350
1351 assert(PipelineStack.back() == &ResultPipeline &&
1352 "Wrong pipeline at the bottom of the stack!");
1353 return {std::move(ResultPipeline)};
1354}
1355
1356Error PassBuilder::parseModulePass(ModulePassManager &MPM,
1357 const PipelineElement &E) {
1358 auto &Name = E.Name;
1359 auto &InnerPipeline = E.InnerPipeline;
1360
1361 // First handle complex passes like the pass managers which carry pipelines.
1362 if (!InnerPipeline.empty()) {
1363 if (Name == "module") {
1364 ModulePassManager NestedMPM;
1365 if (auto Err = parseModulePassPipeline(NestedMPM, InnerPipeline))
1366 return Err;
1367 MPM.addPass(std::move(NestedMPM));
1368 return Error::success();
1369 }
1370 if (Name == "coro-cond") {
1371 ModulePassManager NestedMPM;
1372 if (auto Err = parseModulePassPipeline(NestedMPM, InnerPipeline))
1373 return Err;
1374 MPM.addPass(CoroConditionalWrapper(std::move(NestedMPM)));
1375 return Error::success();
1376 }
1377 if (Name == "cgscc") {
1378 CGSCCPassManager CGPM;
1379 if (auto Err = parseCGSCCPassPipeline(CGPM, InnerPipeline))
1380 return Err;
1382 return Error::success();
1383 }
1384 if (Name == "machine-function") {
1386 if (auto Err = parseMachinePassPipeline(MFPM, InnerPipeline))
1387 return Err;
1389 return Error::success();
1390 }
1391 if (auto Params = parseFunctionPipelineName(Name)) {
1392 if (Params->second)
1393 return make_error<StringError>(
1394 "cannot have a no-rerun module to function adaptor",
1397 if (auto Err = parseFunctionPassPipeline(FPM, InnerPipeline))
1398 return Err;
1399 MPM.addPass(
1400 createModuleToFunctionPassAdaptor(std::move(FPM), Params->first));
1401 return Error::success();
1402 }
1403 if (auto Count = parseRepeatPassName(Name)) {
1404 ModulePassManager NestedMPM;
1405 if (auto Err = parseModulePassPipeline(NestedMPM, InnerPipeline))
1406 return Err;
1407 MPM.addPass(createRepeatedPass(*Count, std::move(NestedMPM)));
1408 return Error::success();
1409 }
1410
1411 for (auto &C : ModulePipelineParsingCallbacks)
1412 if (C(Name, MPM, InnerPipeline))
1413 return Error::success();
1414
1415 // Normal passes can't have pipelines.
1416 return make_error<StringError>(
1417 formatv("invalid use of '{0}' pass as module pipeline", Name).str(),
1419 ;
1420 }
1421
1422 // Manually handle aliases for pre-configured pipeline fragments.
1425 if (!DefaultAliasRegex.match(Name, &Matches))
1426 return make_error<StringError>(
1427 formatv("unknown default pipeline alias '{0}'", Name).str(),
1429
1430 assert(Matches.size() == 3 && "Must capture two matched strings!");
1431
1432 OptimizationLevel L = *parseOptLevel(Matches[2]);
1433
1434 // This is consistent with old pass manager invoked via opt, but
1435 // inconsistent with clang. Clang doesn't enable loop vectorization
1436 // but does enable slp vectorization at Oz.
1437 PTO.LoopVectorization =
1438 L.getSpeedupLevel() > 1 && L != OptimizationLevel::Oz;
1439 PTO.SLPVectorization =
1440 L.getSpeedupLevel() > 1 && L != OptimizationLevel::Oz;
1441
1442 if (Matches[1] == "default") {
1444 } else if (Matches[1] == "thinlto-pre-link") {
1446 } else if (Matches[1] == "thinlto") {
1448 } else if (Matches[1] == "lto-pre-link") {
1449 if (PTO.UnifiedLTO)
1450 // When UnifiedLTO is enabled, use the ThinLTO pre-link pipeline. This
1451 // avoids compile-time performance regressions and keeps the pre-link
1452 // LTO pipeline "unified" for both LTO modes.
1454 else
1456 } else {
1457 assert(Matches[1] == "lto" && "Not one of the matched options!");
1458 MPM.addPass(buildLTODefaultPipeline(L, nullptr));
1459 }
1460 return Error::success();
1461 }
1462
1463 // Finally expand the basic registered passes from the .inc file.
1464#define MODULE_PASS(NAME, CREATE_PASS) \
1465 if (Name == NAME) { \
1466 MPM.addPass(CREATE_PASS); \
1467 return Error::success(); \
1468 }
1469#define MODULE_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 MPM.addPass(CREATE_PASS(Params.get())); \
1475 return Error::success(); \
1476 }
1477#define MODULE_ANALYSIS(NAME, CREATE_PASS) \
1478 if (Name == "require<" NAME ">") { \
1479 MPM.addPass( \
1480 RequireAnalysisPass< \
1481 std::remove_reference_t<decltype(CREATE_PASS)>, Module>()); \
1482 return Error::success(); \
1483 } \
1484 if (Name == "invalidate<" NAME ">") { \
1485 MPM.addPass(InvalidateAnalysisPass< \
1486 std::remove_reference_t<decltype(CREATE_PASS)>>()); \
1487 return Error::success(); \
1488 }
1489#define CGSCC_PASS(NAME, CREATE_PASS) \
1490 if (Name == NAME) { \
1491 MPM.addPass(createModuleToPostOrderCGSCCPassAdaptor(CREATE_PASS)); \
1492 return Error::success(); \
1493 }
1494#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1495 if (checkParametrizedPassName(Name, NAME)) { \
1496 auto Params = parsePassParameters(PARSER, Name, NAME); \
1497 if (!Params) \
1498 return Params.takeError(); \
1499 MPM.addPass( \
1500 createModuleToPostOrderCGSCCPassAdaptor(CREATE_PASS(Params.get()))); \
1501 return Error::success(); \
1502 }
1503#define FUNCTION_PASS(NAME, CREATE_PASS) \
1504 if (Name == NAME) { \
1505 MPM.addPass(createModuleToFunctionPassAdaptor(CREATE_PASS)); \
1506 return Error::success(); \
1507 }
1508#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1509 if (checkParametrizedPassName(Name, NAME)) { \
1510 auto Params = parsePassParameters(PARSER, Name, NAME); \
1511 if (!Params) \
1512 return Params.takeError(); \
1513 MPM.addPass(createModuleToFunctionPassAdaptor(CREATE_PASS(Params.get()))); \
1514 return Error::success(); \
1515 }
1516#define LOOPNEST_PASS(NAME, CREATE_PASS) \
1517 if (Name == NAME) { \
1518 MPM.addPass(createModuleToFunctionPassAdaptor( \
1519 createFunctionToLoopPassAdaptor(CREATE_PASS, false, false))); \
1520 return Error::success(); \
1521 }
1522#define LOOP_PASS(NAME, CREATE_PASS) \
1523 if (Name == NAME) { \
1524 MPM.addPass(createModuleToFunctionPassAdaptor( \
1525 createFunctionToLoopPassAdaptor(CREATE_PASS, false, false))); \
1526 return Error::success(); \
1527 }
1528#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1529 if (checkParametrizedPassName(Name, NAME)) { \
1530 auto Params = parsePassParameters(PARSER, Name, NAME); \
1531 if (!Params) \
1532 return Params.takeError(); \
1533 MPM.addPass( \
1534 createModuleToFunctionPassAdaptor(createFunctionToLoopPassAdaptor( \
1535 CREATE_PASS(Params.get()), false, false))); \
1536 return Error::success(); \
1537 }
1538#include "PassRegistry.def"
1539
1540 for (auto &C : ModulePipelineParsingCallbacks)
1541 if (C(Name, MPM, InnerPipeline))
1542 return Error::success();
1543 return make_error<StringError>(
1544 formatv("unknown module pass '{0}'", Name).str(),
1546}
1547
1548Error PassBuilder::parseCGSCCPass(CGSCCPassManager &CGPM,
1549 const PipelineElement &E) {
1550 auto &Name = E.Name;
1551 auto &InnerPipeline = E.InnerPipeline;
1552
1553 // First handle complex passes like the pass managers which carry pipelines.
1554 if (!InnerPipeline.empty()) {
1555 if (Name == "cgscc") {
1556 CGSCCPassManager NestedCGPM;
1557 if (auto Err = parseCGSCCPassPipeline(NestedCGPM, InnerPipeline))
1558 return Err;
1559 // Add the nested pass manager with the appropriate adaptor.
1560 CGPM.addPass(std::move(NestedCGPM));
1561 return Error::success();
1562 }
1563 if (auto Params = parseFunctionPipelineName(Name)) {
1565 if (auto Err = parseFunctionPassPipeline(FPM, InnerPipeline))
1566 return Err;
1567 // Add the nested pass manager with the appropriate adaptor.
1569 std::move(FPM), Params->first, Params->second));
1570 return Error::success();
1571 }
1572 if (auto Count = parseRepeatPassName(Name)) {
1573 CGSCCPassManager NestedCGPM;
1574 if (auto Err = parseCGSCCPassPipeline(NestedCGPM, InnerPipeline))
1575 return Err;
1576 CGPM.addPass(createRepeatedPass(*Count, std::move(NestedCGPM)));
1577 return Error::success();
1578 }
1579 if (auto MaxRepetitions = parseDevirtPassName(Name)) {
1580 CGSCCPassManager NestedCGPM;
1581 if (auto Err = parseCGSCCPassPipeline(NestedCGPM, InnerPipeline))
1582 return Err;
1583 CGPM.addPass(
1584 createDevirtSCCRepeatedPass(std::move(NestedCGPM), *MaxRepetitions));
1585 return Error::success();
1586 }
1587
1588 for (auto &C : CGSCCPipelineParsingCallbacks)
1589 if (C(Name, CGPM, InnerPipeline))
1590 return Error::success();
1591
1592 // Normal passes can't have pipelines.
1593 return make_error<StringError>(
1594 formatv("invalid use of '{0}' pass as cgscc pipeline", Name).str(),
1596 }
1597
1598// Now expand the basic registered passes from the .inc file.
1599#define CGSCC_PASS(NAME, CREATE_PASS) \
1600 if (Name == NAME) { \
1601 CGPM.addPass(CREATE_PASS); \
1602 return Error::success(); \
1603 }
1604#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1605 if (checkParametrizedPassName(Name, NAME)) { \
1606 auto Params = parsePassParameters(PARSER, Name, NAME); \
1607 if (!Params) \
1608 return Params.takeError(); \
1609 CGPM.addPass(CREATE_PASS(Params.get())); \
1610 return Error::success(); \
1611 }
1612#define CGSCC_ANALYSIS(NAME, CREATE_PASS) \
1613 if (Name == "require<" NAME ">") { \
1614 CGPM.addPass(RequireAnalysisPass< \
1615 std::remove_reference_t<decltype(CREATE_PASS)>, \
1616 LazyCallGraph::SCC, CGSCCAnalysisManager, LazyCallGraph &, \
1617 CGSCCUpdateResult &>()); \
1618 return Error::success(); \
1619 } \
1620 if (Name == "invalidate<" NAME ">") { \
1621 CGPM.addPass(InvalidateAnalysisPass< \
1622 std::remove_reference_t<decltype(CREATE_PASS)>>()); \
1623 return Error::success(); \
1624 }
1625#define FUNCTION_PASS(NAME, CREATE_PASS) \
1626 if (Name == NAME) { \
1627 CGPM.addPass(createCGSCCToFunctionPassAdaptor(CREATE_PASS)); \
1628 return Error::success(); \
1629 }
1630#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1631 if (checkParametrizedPassName(Name, NAME)) { \
1632 auto Params = parsePassParameters(PARSER, Name, NAME); \
1633 if (!Params) \
1634 return Params.takeError(); \
1635 CGPM.addPass(createCGSCCToFunctionPassAdaptor(CREATE_PASS(Params.get()))); \
1636 return Error::success(); \
1637 }
1638#define LOOPNEST_PASS(NAME, CREATE_PASS) \
1639 if (Name == NAME) { \
1640 CGPM.addPass(createCGSCCToFunctionPassAdaptor( \
1641 createFunctionToLoopPassAdaptor(CREATE_PASS, false, false))); \
1642 return Error::success(); \
1643 }
1644#define LOOP_PASS(NAME, CREATE_PASS) \
1645 if (Name == NAME) { \
1646 CGPM.addPass(createCGSCCToFunctionPassAdaptor( \
1647 createFunctionToLoopPassAdaptor(CREATE_PASS, false, false))); \
1648 return Error::success(); \
1649 }
1650#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1651 if (checkParametrizedPassName(Name, NAME)) { \
1652 auto Params = parsePassParameters(PARSER, Name, NAME); \
1653 if (!Params) \
1654 return Params.takeError(); \
1655 CGPM.addPass( \
1656 createCGSCCToFunctionPassAdaptor(createFunctionToLoopPassAdaptor( \
1657 CREATE_PASS(Params.get()), false, false))); \
1658 return Error::success(); \
1659 }
1660#include "PassRegistry.def"
1661
1662 for (auto &C : CGSCCPipelineParsingCallbacks)
1663 if (C(Name, CGPM, InnerPipeline))
1664 return Error::success();
1665 return make_error<StringError>(
1666 formatv("unknown cgscc pass '{0}'", Name).str(),
1668}
1669
1670Error PassBuilder::parseFunctionPass(FunctionPassManager &FPM,
1671 const PipelineElement &E) {
1672 auto &Name = E.Name;
1673 auto &InnerPipeline = E.InnerPipeline;
1674
1675 // First handle complex passes like the pass managers which carry pipelines.
1676 if (!InnerPipeline.empty()) {
1677 if (Name == "function") {
1678 FunctionPassManager NestedFPM;
1679 if (auto Err = parseFunctionPassPipeline(NestedFPM, InnerPipeline))
1680 return Err;
1681 // Add the nested pass manager with the appropriate adaptor.
1682 FPM.addPass(std::move(NestedFPM));
1683 return Error::success();
1684 }
1685 if (Name == "loop" || Name == "loop-mssa") {
1686 LoopPassManager LPM;
1687 if (auto Err = parseLoopPassPipeline(LPM, InnerPipeline))
1688 return Err;
1689 // Add the nested pass manager with the appropriate adaptor.
1690 bool UseMemorySSA = (Name == "loop-mssa");
1691 bool UseBFI = llvm::any_of(InnerPipeline, [](auto Pipeline) {
1692 return Pipeline.Name.contains("simple-loop-unswitch");
1693 });
1694 bool UseBPI = llvm::any_of(InnerPipeline, [](auto Pipeline) {
1695 return Pipeline.Name == "loop-predication";
1696 });
1697 FPM.addPass(createFunctionToLoopPassAdaptor(std::move(LPM), UseMemorySSA,
1698 UseBFI, UseBPI));
1699 return Error::success();
1700 }
1701 if (auto Count = parseRepeatPassName(Name)) {
1702 FunctionPassManager NestedFPM;
1703 if (auto Err = parseFunctionPassPipeline(NestedFPM, InnerPipeline))
1704 return Err;
1705 FPM.addPass(createRepeatedPass(*Count, std::move(NestedFPM)));
1706 return Error::success();
1707 }
1708
1709 for (auto &C : FunctionPipelineParsingCallbacks)
1710 if (C(Name, FPM, InnerPipeline))
1711 return Error::success();
1712
1713 // Normal passes can't have pipelines.
1714 return make_error<StringError>(
1715 formatv("invalid use of '{0}' pass as function pipeline", Name).str(),
1717 }
1718
1719// Now expand the basic registered passes from the .inc file.
1720#define FUNCTION_PASS(NAME, CREATE_PASS) \
1721 if (Name == NAME) { \
1722 FPM.addPass(CREATE_PASS); \
1723 return Error::success(); \
1724 }
1725#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1726 if (checkParametrizedPassName(Name, NAME)) { \
1727 auto Params = parsePassParameters(PARSER, Name, NAME); \
1728 if (!Params) \
1729 return Params.takeError(); \
1730 FPM.addPass(CREATE_PASS(Params.get())); \
1731 return Error::success(); \
1732 }
1733#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
1734 if (Name == "require<" NAME ">") { \
1735 FPM.addPass( \
1736 RequireAnalysisPass< \
1737 std::remove_reference_t<decltype(CREATE_PASS)>, Function>()); \
1738 return Error::success(); \
1739 } \
1740 if (Name == "invalidate<" NAME ">") { \
1741 FPM.addPass(InvalidateAnalysisPass< \
1742 std::remove_reference_t<decltype(CREATE_PASS)>>()); \
1743 return Error::success(); \
1744 }
1745// FIXME: UseMemorySSA is set to false. Maybe we could do things like:
1746// bool UseMemorySSA = !("canon-freeze" || "loop-predication" ||
1747// "guard-widening");
1748// The risk is that it may become obsolete if we're not careful.
1749#define LOOPNEST_PASS(NAME, CREATE_PASS) \
1750 if (Name == NAME) { \
1751 FPM.addPass(createFunctionToLoopPassAdaptor(CREATE_PASS, false, false)); \
1752 return Error::success(); \
1753 }
1754#define LOOP_PASS(NAME, CREATE_PASS) \
1755 if (Name == NAME) { \
1756 FPM.addPass(createFunctionToLoopPassAdaptor(CREATE_PASS, false, false)); \
1757 return Error::success(); \
1758 }
1759#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1760 if (checkParametrizedPassName(Name, NAME)) { \
1761 auto Params = parsePassParameters(PARSER, Name, NAME); \
1762 if (!Params) \
1763 return Params.takeError(); \
1764 FPM.addPass(createFunctionToLoopPassAdaptor(CREATE_PASS(Params.get()), \
1765 false, false)); \
1766 return Error::success(); \
1767 }
1768#include "PassRegistry.def"
1769
1770 for (auto &C : FunctionPipelineParsingCallbacks)
1771 if (C(Name, FPM, InnerPipeline))
1772 return Error::success();
1773 return make_error<StringError>(
1774 formatv("unknown function pass '{0}'", Name).str(),
1776}
1777
1778Error PassBuilder::parseLoopPass(LoopPassManager &LPM,
1779 const PipelineElement &E) {
1780 StringRef Name = E.Name;
1781 auto &InnerPipeline = E.InnerPipeline;
1782
1783 // First handle complex passes like the pass managers which carry pipelines.
1784 if (!InnerPipeline.empty()) {
1785 if (Name == "loop") {
1786 LoopPassManager NestedLPM;
1787 if (auto Err = parseLoopPassPipeline(NestedLPM, InnerPipeline))
1788 return Err;
1789 // Add the nested pass manager with the appropriate adaptor.
1790 LPM.addPass(std::move(NestedLPM));
1791 return Error::success();
1792 }
1793 if (auto Count = parseRepeatPassName(Name)) {
1794 LoopPassManager NestedLPM;
1795 if (auto Err = parseLoopPassPipeline(NestedLPM, InnerPipeline))
1796 return Err;
1797 LPM.addPass(createRepeatedPass(*Count, std::move(NestedLPM)));
1798 return Error::success();
1799 }
1800
1801 for (auto &C : LoopPipelineParsingCallbacks)
1802 if (C(Name, LPM, InnerPipeline))
1803 return Error::success();
1804
1805 // Normal passes can't have pipelines.
1806 return make_error<StringError>(
1807 formatv("invalid use of '{0}' pass as loop pipeline", Name).str(),
1809 }
1810
1811// Now expand the basic registered passes from the .inc file.
1812#define LOOPNEST_PASS(NAME, CREATE_PASS) \
1813 if (Name == NAME) { \
1814 LPM.addPass(CREATE_PASS); \
1815 return Error::success(); \
1816 }
1817#define LOOP_PASS(NAME, CREATE_PASS) \
1818 if (Name == NAME) { \
1819 LPM.addPass(CREATE_PASS); \
1820 return Error::success(); \
1821 }
1822#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1823 if (checkParametrizedPassName(Name, NAME)) { \
1824 auto Params = parsePassParameters(PARSER, Name, NAME); \
1825 if (!Params) \
1826 return Params.takeError(); \
1827 LPM.addPass(CREATE_PASS(Params.get())); \
1828 return Error::success(); \
1829 }
1830#define LOOP_ANALYSIS(NAME, CREATE_PASS) \
1831 if (Name == "require<" NAME ">") { \
1832 LPM.addPass(RequireAnalysisPass< \
1833 std::remove_reference_t<decltype(CREATE_PASS)>, Loop, \
1834 LoopAnalysisManager, LoopStandardAnalysisResults &, \
1835 LPMUpdater &>()); \
1836 return Error::success(); \
1837 } \
1838 if (Name == "invalidate<" NAME ">") { \
1839 LPM.addPass(InvalidateAnalysisPass< \
1840 std::remove_reference_t<decltype(CREATE_PASS)>>()); \
1841 return Error::success(); \
1842 }
1843#include "PassRegistry.def"
1844
1845 for (auto &C : LoopPipelineParsingCallbacks)
1846 if (C(Name, LPM, InnerPipeline))
1847 return Error::success();
1848 return make_error<StringError>(formatv("unknown loop pass '{0}'", Name).str(),
1850}
1851
1852Error PassBuilder::parseMachinePass(MachineFunctionPassManager &MFPM,
1853 const PipelineElement &E) {
1854 StringRef Name = E.Name;
1855 if (!E.InnerPipeline.empty())
1856 return make_error<StringError>("invalid pipeline",
1858
1859#define MACHINE_MODULE_PASS(NAME, CREATE_PASS) \
1860 if (Name == NAME) { \
1861 MFPM.addPass(CREATE_PASS); \
1862 return Error::success(); \
1863 }
1864#define MACHINE_FUNCTION_PASS(NAME, CREATE_PASS) \
1865 if (Name == NAME) { \
1866 MFPM.addPass(CREATE_PASS); \
1867 return Error::success(); \
1868 }
1869#include "llvm/Passes/MachinePassRegistry.def"
1870
1871 for (auto &C : MachineFunctionPipelineParsingCallbacks)
1872 if (C(Name, MFPM, E.InnerPipeline))
1873 return Error::success();
1874 return make_error<StringError>(
1875 formatv("unknown machine pass '{0}'", Name).str(),
1877}
1878
1879bool PassBuilder::parseAAPassName(AAManager &AA, StringRef Name) {
1880#define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS) \
1881 if (Name == NAME) { \
1882 AA.registerModuleAnalysis< \
1883 std::remove_reference_t<decltype(CREATE_PASS)>>(); \
1884 return true; \
1885 }
1886#define FUNCTION_ALIAS_ANALYSIS(NAME, CREATE_PASS) \
1887 if (Name == NAME) { \
1888 AA.registerFunctionAnalysis< \
1889 std::remove_reference_t<decltype(CREATE_PASS)>>(); \
1890 return true; \
1891 }
1892#include "PassRegistry.def"
1893
1894 for (auto &C : AAParsingCallbacks)
1895 if (C(Name, AA))
1896 return true;
1897 return false;
1898}
1899
1900Error PassBuilder::parseMachinePassPipeline(
1902 for (const auto &Element : Pipeline) {
1903 if (auto Err = parseMachinePass(MFPM, Element))
1904 return Err;
1905 }
1906 return Error::success();
1907}
1908
1909Error PassBuilder::parseLoopPassPipeline(LoopPassManager &LPM,
1910 ArrayRef<PipelineElement> Pipeline) {
1911 for (const auto &Element : Pipeline) {
1912 if (auto Err = parseLoopPass(LPM, Element))
1913 return Err;
1914 }
1915 return Error::success();
1916}
1917
1918Error PassBuilder::parseFunctionPassPipeline(
1920 for (const auto &Element : Pipeline) {
1921 if (auto Err = parseFunctionPass(FPM, Element))
1922 return Err;
1923 }
1924 return Error::success();
1925}
1926
1927Error PassBuilder::parseCGSCCPassPipeline(CGSCCPassManager &CGPM,
1928 ArrayRef<PipelineElement> Pipeline) {
1929 for (const auto &Element : Pipeline) {
1930 if (auto Err = parseCGSCCPass(CGPM, Element))
1931 return Err;
1932 }
1933 return Error::success();
1934}
1935
1948 if (MFAM) {
1950 [&] { return MachineFunctionAnalysisManagerModuleProxy(*MFAM); });
1951 MFAM->registerPass(
1953 MFAM->registerPass(
1955 }
1956}
1957
1958Error PassBuilder::parseModulePassPipeline(ModulePassManager &MPM,
1959 ArrayRef<PipelineElement> Pipeline) {
1960 for (const auto &Element : Pipeline) {
1961 if (auto Err = parseModulePass(MPM, Element))
1962 return Err;
1963 }
1964 return Error::success();
1965}
1966
1967// Primary pass pipeline description parsing routine for a \c ModulePassManager
1968// FIXME: Should this routine accept a TargetMachine or require the caller to
1969// pre-populate the analysis managers with target-specific stuff?
1971 StringRef PipelineText) {
1972 auto Pipeline = parsePipelineText(PipelineText);
1973 if (!Pipeline || Pipeline->empty())
1974 return make_error<StringError>(
1975 formatv("invalid pipeline '{0}'", PipelineText).str(),
1977
1978 // If the first name isn't at the module layer, wrap the pipeline up
1979 // automatically.
1980 StringRef FirstName = Pipeline->front().Name;
1981
1982 if (!isModulePassName(FirstName, ModulePipelineParsingCallbacks)) {
1983 bool UseMemorySSA;
1984 if (isCGSCCPassName(FirstName, CGSCCPipelineParsingCallbacks)) {
1985 Pipeline = {{"cgscc", std::move(*Pipeline)}};
1986 } else if (isFunctionPassName(FirstName,
1987 FunctionPipelineParsingCallbacks)) {
1988 Pipeline = {{"function", std::move(*Pipeline)}};
1989 } else if (isLoopNestPassName(FirstName, LoopPipelineParsingCallbacks,
1990 UseMemorySSA)) {
1991 Pipeline = {{"function", {{UseMemorySSA ? "loop-mssa" : "loop",
1992 std::move(*Pipeline)}}}};
1993 } else if (isLoopPassName(FirstName, LoopPipelineParsingCallbacks,
1994 UseMemorySSA)) {
1995 Pipeline = {{"function", {{UseMemorySSA ? "loop-mssa" : "loop",
1996 std::move(*Pipeline)}}}};
1997 } else if (isMachineFunctionPassName(
1998 FirstName, MachineFunctionPipelineParsingCallbacks)) {
1999 Pipeline = {{"machine-function", std::move(*Pipeline)}};
2000 } else {
2001 for (auto &C : TopLevelPipelineParsingCallbacks)
2002 if (C(MPM, *Pipeline))
2003 return Error::success();
2004
2005 // Unknown pass or pipeline name!
2006 auto &InnerPipeline = Pipeline->front().InnerPipeline;
2007 return make_error<StringError>(
2008 formatv("unknown {0} name '{1}'",
2009 (InnerPipeline.empty() ? "pass" : "pipeline"), FirstName)
2010 .str(),
2012 }
2013 }
2014
2015 if (auto Err = parseModulePassPipeline(MPM, *Pipeline))
2016 return Err;
2017 return Error::success();
2018}
2019
2020// Primary pass pipeline description parsing routine for a \c CGSCCPassManager
2022 StringRef PipelineText) {
2023 auto Pipeline = parsePipelineText(PipelineText);
2024 if (!Pipeline || Pipeline->empty())
2025 return make_error<StringError>(
2026 formatv("invalid pipeline '{0}'", PipelineText).str(),
2028
2029 StringRef FirstName = Pipeline->front().Name;
2030 if (!isCGSCCPassName(FirstName, CGSCCPipelineParsingCallbacks))
2031 return make_error<StringError>(
2032 formatv("unknown cgscc pass '{0}' in pipeline '{1}'", FirstName,
2033 PipelineText)
2034 .str(),
2036
2037 if (auto Err = parseCGSCCPassPipeline(CGPM, *Pipeline))
2038 return Err;
2039 return Error::success();
2040}
2041
2042// Primary pass pipeline description parsing routine for a \c
2043// FunctionPassManager
2045 StringRef PipelineText) {
2046 auto Pipeline = parsePipelineText(PipelineText);
2047 if (!Pipeline || Pipeline->empty())
2048 return make_error<StringError>(
2049 formatv("invalid pipeline '{0}'", PipelineText).str(),
2051
2052 StringRef FirstName = Pipeline->front().Name;
2053 if (!isFunctionPassName(FirstName, FunctionPipelineParsingCallbacks))
2054 return make_error<StringError>(
2055 formatv("unknown function pass '{0}' in pipeline '{1}'", FirstName,
2056 PipelineText)
2057 .str(),
2059
2060 if (auto Err = parseFunctionPassPipeline(FPM, *Pipeline))
2061 return Err;
2062 return Error::success();
2063}
2064
2065// Primary pass pipeline description parsing routine for a \c LoopPassManager
2067 StringRef PipelineText) {
2068 auto Pipeline = parsePipelineText(PipelineText);
2069 if (!Pipeline || Pipeline->empty())
2070 return make_error<StringError>(
2071 formatv("invalid pipeline '{0}'", PipelineText).str(),
2073
2074 if (auto Err = parseLoopPassPipeline(CGPM, *Pipeline))
2075 return Err;
2076
2077 return Error::success();
2078}
2079
2081 StringRef PipelineText) {
2082 auto Pipeline = parsePipelineText(PipelineText);
2083 if (!Pipeline || Pipeline->empty())
2084 return make_error<StringError>(
2085 formatv("invalid machine pass pipeline '{0}'", PipelineText).str(),
2087
2088 if (auto Err = parseMachinePassPipeline(MFPM, *Pipeline))
2089 return Err;
2090
2091 return Error::success();
2092}
2093
2095 // If the pipeline just consists of the word 'default' just replace the AA
2096 // manager with our default one.
2097 if (PipelineText == "default") {
2099 return Error::success();
2100 }
2101
2102 while (!PipelineText.empty()) {
2104 std::tie(Name, PipelineText) = PipelineText.split(',');
2105 if (!parseAAPassName(AA, Name))
2106 return make_error<StringError>(
2107 formatv("unknown alias analysis name '{0}'", Name).str(),
2109 }
2110
2111 return Error::success();
2112}
2113
2115 OS << " " << PassName << "\n";
2116}
2118 raw_ostream &OS) {
2119 OS << " " << PassName << "<" << Params << ">\n";
2120}
2121
2123 // TODO: print pass descriptions when they are available
2124
2125 OS << "Module passes:\n";
2126#define MODULE_PASS(NAME, CREATE_PASS) printPassName(NAME, OS);
2127#include "PassRegistry.def"
2128
2129 OS << "Module passes with params:\n";
2130#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2131 printPassName(NAME, PARAMS, OS);
2132#include "PassRegistry.def"
2133
2134 OS << "Module analyses:\n";
2135#define MODULE_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
2136#include "PassRegistry.def"
2137
2138 OS << "Module alias analyses:\n";
2139#define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
2140#include "PassRegistry.def"
2141
2142 OS << "CGSCC passes:\n";
2143#define CGSCC_PASS(NAME, CREATE_PASS) printPassName(NAME, OS);
2144#include "PassRegistry.def"
2145
2146 OS << "CGSCC passes with params:\n";
2147#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2148 printPassName(NAME, PARAMS, OS);
2149#include "PassRegistry.def"
2150
2151 OS << "CGSCC analyses:\n";
2152#define CGSCC_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
2153#include "PassRegistry.def"
2154
2155 OS << "Function passes:\n";
2156#define FUNCTION_PASS(NAME, CREATE_PASS) printPassName(NAME, OS);
2157#include "PassRegistry.def"
2158
2159 OS << "Function passes with params:\n";
2160#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2161 printPassName(NAME, PARAMS, OS);
2162#include "PassRegistry.def"
2163
2164 OS << "Function analyses:\n";
2165#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
2166#include "PassRegistry.def"
2167
2168 OS << "Function alias analyses:\n";
2169#define FUNCTION_ALIAS_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
2170#include "PassRegistry.def"
2171
2172 OS << "LoopNest passes:\n";
2173#define LOOPNEST_PASS(NAME, CREATE_PASS) printPassName(NAME, OS);
2174#include "PassRegistry.def"
2175
2176 OS << "Loop passes:\n";
2177#define LOOP_PASS(NAME, CREATE_PASS) printPassName(NAME, OS);
2178#include "PassRegistry.def"
2179
2180 OS << "Loop passes with params:\n";
2181#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2182 printPassName(NAME, PARAMS, OS);
2183#include "PassRegistry.def"
2184
2185 OS << "Loop analyses:\n";
2186#define LOOP_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
2187#include "PassRegistry.def"
2188
2189 OS << "Machine module passes (WIP):\n";
2190#define MACHINE_MODULE_PASS(NAME, CREATE_PASS) printPassName(NAME, OS);
2191#include "llvm/Passes/MachinePassRegistry.def"
2192
2193 OS << "Machine function passes (WIP):\n";
2194#define MACHINE_FUNCTION_PASS(NAME, CREATE_PASS) printPassName(NAME, OS);
2195#include "llvm/Passes/MachinePassRegistry.def"
2196
2197 OS << "Machine function analyses (WIP):\n";
2198#define MACHINE_FUNCTION_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
2199#include "llvm/Passes/MachinePassRegistry.def"
2200}
2201
2203 const std::function<bool(ModulePassManager &, ArrayRef<PipelineElement>)>
2204 &C) {
2205 TopLevelPipelineParsingCallbacks.push_back(C);
2206}
AggressiveInstCombiner - Combine expression patterns to form expressions with fewer,...
This file implements a simple N^2 alias analysis accuracy evaluator.
Provides passes to inlining "always_inline" functions.
This is the interface for LLVM's primary stateless and local alias analysis.
This file provides the interface for LLVM's Call Graph Profile pass.
This header provides classes for managing passes over SCCs of the call graph.
This file provides interfaces used to build and manipulate a call graph, which is a very useful tool ...
Defines an IR pass for CodeGen Prepare.
This file declares an analysis pass that computes CycleInfo for LLVM IR, specialized from GenericCycl...
std::string Name
This file provides the interface for a simple, fast CSE pass.
This file provides a pass which clones the current module and runs the provided pass pipeline on the ...
Super simple passes to force specific function attrs from the commandline into the IR for debugging p...
Provides passes for computing function attributes based on interprocedural analyses.
This file provides the interface for the GCOV style profiler pass.
This file provides the interface for LLVM's Global Value Numbering pass which eliminates fully redund...
This is the interface for a simple mod/ref and alias analysis over globals.
Defines an IR pass for the creation of hardware loops.
AcceleratorCodeSelection - Identify all functions reachable from a kernel, removing those that are un...
This file defines passes to print out IR in various granularities.
Interfaces for passes which infer implicit function attributes from the name and signature of functio...
This file provides the primary interface to the instcombine pass.
Defines passes for running instruction simplification across chunks of IR.
This file provides the interface for LLVM's PGO Instrumentation lowering pass.
This file contains the declaration of the InterleavedAccessPass class, its corresponding pass name is...
See the comments on JumpThreadingPass.
Implements a lazy call graph analysis and related passes for the new pass manager.
This file defines the interface for the loop cache analysis.
This file provides the interface for LLVM's Loop Data Prefetching Pass.
This file implements the Loop Fusion pass.
This header defines the LoopLoadEliminationPass object.
This file defines the interface for the loop nest analysis.
This header provides classes for managing a pipeline of passes over loops in LLVM IR.
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
UseBFI
Definition: MachineLICM.cpp:88
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
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 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 isMachineFunctionPassName(StringRef Name, CallbacksT &Callbacks)
static std::optional< OptimizationLevel > parseOptLevel(StringRef S)
static bool isLoopPassName(StringRef Name, CallbacksT &Callbacks, bool &UseMemorySSA)
static std::optional< std::pair< bool, bool > > parseFunctionPipelineName(StringRef Name)
static bool isCGSCCPassName(StringRef Name, CallbacksT &Callbacks)
static void printPassName(StringRef PassName, raw_ostream &OS)
static bool isFunctionPassName(StringRef Name, CallbacksT &Callbacks)
static const Regex DefaultAliasRegex("^(default|thinlto-pre-link|thinlto|lto-pre-link|lto)<(O[0123sz])>$")
This 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...
This file provides the interface for the pass responsible for removing expensive ubsan checks.
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 (or, optionally, operations on smaller ve...
This is the interface for a metadata-based scoped no-alias analysis.
This file contains the declaration of the SelectOptimizePass class, its corresponding pass name is se...
This file provides the interface for the pass responsible for both simplifying and canonicalizing the...
This file implements the StringSwitch template, which mimics a switch() statement whose cases are str...
Target-Independent Code Generator Pass Configuration Options pass.
This pass exposes codegen information to IR-level passes.
This is the interface for a metadata-based TBAA.
Defines an IR pass for type promotion.
LLVM IR instance of the generic uniformity analysis.
static const char PassName[]
Value * RHS
A manager for alias analyses.
Class for arbitrary precision integers.
Definition: APInt.h:76
uint64_t getZExtValue() const
Get zero extended value.
Definition: APInt.h:1491
int64_t getSExtValue() const
Get sign extended value.
Definition: APInt.h:1513
A container for analyses that lazily runs them and caches their results.
Definition: PassManager.h:348
bool registerPass(PassBuilderT &&PassBuilder)
Register an analysis pass with the manager.
Definition: PassManager.h:562
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: ArrayRef.h:41
LLVM Basic Block Representation.
Definition: BasicBlock.h:60
const Instruction * getTerminator() const LLVM_READONLY
Returns the terminator instruction if the block is well formed or null if the block is not well forme...
Definition: BasicBlock.h:220
Lightweight error class with error context and mandatory checking.
Definition: Error.h:160
static ErrorSuccess success()
Create a success value.
Definition: Error.h:334
Tagged union holding either a T or a Error.
Definition: Error.h:474
static GlobalAlias * create(Type *Ty, unsigned AddressSpace, LinkageTypes Linkage, const Twine &Name, Constant *Aliasee, Module *Parent)
If a parent module is specified, the alias is automatically inserted into the end of the specified mo...
Definition: Globals.cpp:518
An analysis over an "outer" IR unit that provides access to an analysis manager over an "inner" IR un...
Definition: PassManager.h:658
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.
static bool checkParametrizedPassName(StringRef Name, StringRef PassName)
Definition: PassBuilder.h:629
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, MachineFunctionAnalysisManager *MFAM=nullptr)
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.
static Expected< bool > parseSinglePassOption(StringRef Params, StringRef OptionName, StringRef PassName)
Handle passes only accept one bool-valued parameter.
void registerMachineFunctionAnalyses(MachineFunctionAnalysisManager &MFAM)
Registers all available machine function analysis passes.
void registerParseTopLevelPipelineCallback(const std::function< bool(ModulePassManager &, ArrayRef< PipelineElement >)> &C)
Register a callback for a top-level pipeline entry.
ModulePassManager buildLTOPreLinkDefaultPipeline(OptimizationLevel Level)
Build a pre-link, LTO-targeting default optimization pipeline to a pass manager.
void registerFunctionAnalyses(FunctionAnalysisManager &FAM)
Registers all available function analysis passes.
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:273
Tunable parameters for passes in the default pipelines.
Definition: PassBuilder.h:42
bool SLPVectorization
Tuning option to enable/disable slp loop vectorization, set based on opt level.
Definition: PassBuilder.h:57
bool LoopVectorization
Tuning option to enable/disable loop vectorization, set based on opt level.
Definition: PassBuilder.h:53
static PointerType * getUnqual(Type *ElementType)
This constructs a pointer to an object of the specified type in the default address space (address sp...
Definition: DerivedTypes.h:662
A set of analyses that are preserved following a run of a transformation pass.
Definition: Analysis.h:109
static PreservedAnalyses none()
Convenience factory function for the empty preserved set.
Definition: Analysis.h:112
static PreservedAnalyses all()
Construct a special preserved set that preserves all passes.
Definition: Analysis.h:115
bool match(StringRef String, SmallVectorImpl< StringRef > *Matches=nullptr, std::string *Error=nullptr) const
matches - Match the regex against a given String.
Definition: Regex.cpp:83
size_t size() const
Definition: SmallVector.h:91
void push_back(const T &Elt)
Definition: SmallVector.h:426
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1209
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:696
bool getAsInteger(unsigned Radix, T &Result) const
Parse the current string as an integer of the specified radix.
Definition: StringRef.h:466
std::string str() const
str - Get the contents as an std::string.
Definition: StringRef.h:222
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:631
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:76
static bool hasLimitedCodeGenPipeline()
Returns true if one of the -start-after, -start-before, -stop-after or -stop-before options is set.
This function has undefined behavior.
self_iterator getIterator()
Definition: ilist_node.h:109
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,...
@ 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:943
RepeatedPass< PassT > createRepeatedPass(int Count, PassT &&P)
Definition: PassManager.h:1077
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:90
OuterAnalysisManagerProxy< ModuleAnalysisManager, MachineFunction > ModuleAnalysisManagerMachineFunctionProxy
Provide the ModuleAnalysisManager to Function proxy.
OuterAnalysisManagerProxy< ModuleAnalysisManager, Function > ModuleAnalysisManagerFunctionProxy
Provide the ModuleAnalysisManager to Function proxy.
Definition: PassManager.h:893
InnerAnalysisManagerProxy< MachineFunctionAnalysisManager, Module > MachineFunctionAnalysisManagerModuleProxy
OuterAnalysisManagerProxy< ModuleAnalysisManager, LazyCallGraph::SCC, LazyCallGraph & > ModuleAnalysisManagerCGSCCProxy
A proxy from a ModuleAnalysisManager to an SCC.
bool any_of(R &&range, UnaryPredicate P)
Provide wrappers to std::any_of which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1738
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:739
ModuleToMachineFunctionPassAdaptor createModuleToMachineFunctionPassAdaptor(MachineFunctionPassT &&Pass)
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 special type used by analysis passes to provide an address that identifies that particular analysis...
Definition: Analysis.h:26
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
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:91
static StringRef name()
Gets the name of the pass we are mixed into.
Definition: PassManager.h:93