LLVM 21.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
33#include "llvm/Analysis/DDG.h"
53#include "llvm/Analysis/Lint.h"
146#include "llvm/IR/DebugInfo.h"
147#include "llvm/IR/Dominators.h"
148#include "llvm/IR/PassManager.h"
149#include "llvm/IR/PrintPasses.h"
151#include "llvm/IR/Verifier.h"
155#include "llvm/Support/Debug.h"
158#include "llvm/Support/Regex.h"
347#include <optional>
348
349using namespace llvm;
350
352 "^(default|thinlto-pre-link|thinlto|lto-pre-link|lto)<(O[0123sz])>$");
353
354namespace llvm {
356 "print-pipeline-passes",
357 cl::desc("Print a '-passes' compatible string describing the pipeline "
358 "(best-effort only)."));
359} // namespace llvm
360
361AnalysisKey NoOpModuleAnalysis::Key;
362AnalysisKey NoOpCGSCCAnalysis::Key;
363AnalysisKey NoOpFunctionAnalysis::Key;
364AnalysisKey NoOpLoopAnalysis::Key;
365
366namespace {
367
368// Passes for testing crashes.
369// DO NOT USE THIS EXCEPT FOR TESTING!
370class TriggerCrashModulePass : public PassInfoMixin<TriggerCrashModulePass> {
371public:
373 abort();
374 return PreservedAnalyses::all();
375 }
376 static StringRef name() { return "TriggerCrashModulePass"; }
377};
378
379class TriggerCrashFunctionPass
380 : public PassInfoMixin<TriggerCrashFunctionPass> {
381public:
383 abort();
384 return PreservedAnalyses::all();
385 }
386 static StringRef name() { return "TriggerCrashFunctionPass"; }
387};
388
389// A pass for testing message reporting of -verify-each failures.
390// DO NOT USE THIS EXCEPT FOR TESTING!
391class TriggerVerifierErrorPass
392 : public PassInfoMixin<TriggerVerifierErrorPass> {
393public:
395 // Intentionally break the Module by creating an alias without setting the
396 // aliasee.
397 auto *PtrTy = llvm::PointerType::getUnqual(M.getContext());
398 GlobalAlias::create(PtrTy, PtrTy->getAddressSpace(),
399 GlobalValue::LinkageTypes::InternalLinkage,
400 "__bad_alias", nullptr, &M);
402 }
403
405 // Intentionally break the Function by inserting a terminator
406 // instruction in the middle of a basic block.
407 BasicBlock &BB = F.getEntryBlock();
408 new UnreachableInst(F.getContext(), BB.getTerminator()->getIterator());
410 }
411
413 // Intentionally create a virtual register and set NoVRegs property.
414 auto &MRI = MF.getRegInfo();
415 MRI.createGenericVirtualRegister(LLT::scalar(8));
416 MF.getProperties().set(MachineFunctionProperties::Property::NoVRegs);
417 return PreservedAnalyses::all();
418 }
419
420 static StringRef name() { return "TriggerVerifierErrorPass"; }
421};
422
423// A pass requires all MachineFunctionProperties.
424// DO NOT USE THIS EXCEPT FOR TESTING!
425class RequireAllMachineFunctionPropertiesPass
426 : public PassInfoMixin<RequireAllMachineFunctionPropertiesPass> {
427public:
429 MFPropsModifier _(*this, MF);
431 }
432
433 static MachineFunctionProperties getRequiredProperties() {
435 MFProps.set(MachineFunctionProperties::Property::FailedISel);
436 MFProps.set(MachineFunctionProperties::Property::FailsVerification);
437 MFProps.set(MachineFunctionProperties::Property::IsSSA);
438 MFProps.set(MachineFunctionProperties::Property::Legalized);
439 MFProps.set(MachineFunctionProperties::Property::NoPHIs);
440 MFProps.set(MachineFunctionProperties::Property::NoVRegs);
441 MFProps.set(MachineFunctionProperties::Property::RegBankSelected);
442 MFProps.set(MachineFunctionProperties::Property::Selected);
443 MFProps.set(MachineFunctionProperties::Property::TiedOpsRewritten);
444 MFProps.set(MachineFunctionProperties::Property::TracksDebugUserValues);
445 MFProps.set(MachineFunctionProperties::Property::TracksLiveness);
446 return MFProps;
447 }
448 static StringRef name() { return "RequireAllMachineFunctionPropertiesPass"; }
449};
450
451} // namespace
452
454 std::optional<PGOOptions> PGOOpt,
456 : TM(TM), PTO(PTO), PGOOpt(PGOOpt), PIC(PIC) {
457 if (TM)
458 TM->registerPassBuilderCallbacks(*this);
459 if (PIC) {
461 // MSVC requires this to be captured if it's used inside decltype.
462 // Other compilers consider it an unused lambda capture.
463 (void)this;
464#define MODULE_PASS(NAME, CREATE_PASS) \
465 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
466#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
467 PIC->addClassToPassName(CLASS, NAME);
468#define MODULE_ANALYSIS(NAME, CREATE_PASS) \
469 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
470#define FUNCTION_PASS(NAME, CREATE_PASS) \
471 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
472#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
473 PIC->addClassToPassName(CLASS, NAME);
474#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
475 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
476#define LOOPNEST_PASS(NAME, CREATE_PASS) \
477 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
478#define LOOP_PASS(NAME, CREATE_PASS) \
479 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
480#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
481 PIC->addClassToPassName(CLASS, NAME);
482#define LOOP_ANALYSIS(NAME, CREATE_PASS) \
483 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
484#define CGSCC_PASS(NAME, CREATE_PASS) \
485 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
486#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
487 PIC->addClassToPassName(CLASS, NAME);
488#define CGSCC_ANALYSIS(NAME, CREATE_PASS) \
489 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
490#include "PassRegistry.def"
491
492#define MACHINE_FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
493 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
494#define MACHINE_FUNCTION_PASS(NAME, CREATE_PASS) \
495 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
496#define MACHINE_FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, \
497 PARAMS) \
498 PIC->addClassToPassName(CLASS, NAME);
499#include "llvm/Passes/MachinePassRegistry.def"
500 });
501 }
502}
503
505#define MODULE_ANALYSIS(NAME, CREATE_PASS) \
506 MAM.registerPass([&] { return CREATE_PASS; });
507#include "PassRegistry.def"
508
509 for (auto &C : ModuleAnalysisRegistrationCallbacks)
510 C(MAM);
511}
512
514#define CGSCC_ANALYSIS(NAME, CREATE_PASS) \
515 CGAM.registerPass([&] { return CREATE_PASS; });
516#include "PassRegistry.def"
517
518 for (auto &C : CGSCCAnalysisRegistrationCallbacks)
519 C(CGAM);
520}
521
523 // We almost always want the default alias analysis pipeline.
524 // If a user wants a different one, they can register their own before calling
525 // registerFunctionAnalyses().
526 FAM.registerPass([&] { return buildDefaultAAPipeline(); });
527
528#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
529 FAM.registerPass([&] { return CREATE_PASS; });
530#include "PassRegistry.def"
531
532 for (auto &C : FunctionAnalysisRegistrationCallbacks)
533 C(FAM);
534}
535
538
539#define MACHINE_FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
540 MFAM.registerPass([&] { return CREATE_PASS; });
541#include "llvm/Passes/MachinePassRegistry.def"
542
543 for (auto &C : MachineFunctionAnalysisRegistrationCallbacks)
544 C(MFAM);
545}
546
548#define LOOP_ANALYSIS(NAME, CREATE_PASS) \
549 LAM.registerPass([&] { return CREATE_PASS; });
550#include "PassRegistry.def"
551
552 for (auto &C : LoopAnalysisRegistrationCallbacks)
553 C(LAM);
554}
555
556static std::optional<std::pair<bool, bool>>
558 std::pair<bool, bool> Params;
559 if (!Name.consume_front("function"))
560 return std::nullopt;
561 if (Name.empty())
562 return Params;
563 if (!Name.consume_front("<") || !Name.consume_back(">"))
564 return std::nullopt;
565 while (!Name.empty()) {
566 auto [Front, Back] = Name.split(';');
567 Name = Back;
568 if (Front == "eager-inv")
569 Params.first = true;
570 else if (Front == "no-rerun")
571 Params.second = true;
572 else
573 return std::nullopt;
574 }
575 return Params;
576}
577
578static std::optional<int> parseDevirtPassName(StringRef Name) {
579 if (!Name.consume_front("devirt<") || !Name.consume_back(">"))
580 return std::nullopt;
581 int Count;
582 if (Name.getAsInteger(0, Count) || Count < 0)
583 return std::nullopt;
584 return Count;
585}
586
587static std::optional<OptimizationLevel> parseOptLevel(StringRef S) {
589 .Case("O0", OptimizationLevel::O0)
595 .Default(std::nullopt);
596}
597
599 StringRef OptionName,
601 bool Result = false;
602 while (!Params.empty()) {
603 StringRef ParamName;
604 std::tie(ParamName, Params) = Params.split(';');
605
606 if (ParamName == OptionName) {
607 Result = true;
608 } else {
609 return make_error<StringError>(
610 formatv("invalid {1} pass parameter '{0}' ", ParamName, PassName)
611 .str(),
613 }
614 }
615 return Result;
616}
617
618namespace {
619
620/// Parser of parameters for HardwareLoops pass.
621Expected<HardwareLoopOptions> parseHardwareLoopOptions(StringRef Params) {
622 HardwareLoopOptions HardwareLoopOpts;
623
624 while (!Params.empty()) {
625 StringRef ParamName;
626 std::tie(ParamName, Params) = Params.split(';');
627 if (ParamName.consume_front("hardware-loop-decrement=")) {
628 int Count;
629 if (ParamName.getAsInteger(0, Count))
630 return make_error<StringError>(
631 formatv("invalid HardwareLoopPass parameter '{0}' ", ParamName).str(),
633 HardwareLoopOpts.setDecrement(Count);
634 continue;
635 }
636 if (ParamName.consume_front("hardware-loop-counter-bitwidth=")) {
637 int Count;
638 if (ParamName.getAsInteger(0, Count))
639 return make_error<StringError>(
640 formatv("invalid HardwareLoopPass parameter '{0}' ", ParamName).str(),
642 HardwareLoopOpts.setCounterBitwidth(Count);
643 continue;
644 }
645 if (ParamName == "force-hardware-loops") {
646 HardwareLoopOpts.setForce(true);
647 } else if (ParamName == "force-hardware-loop-phi") {
648 HardwareLoopOpts.setForcePhi(true);
649 } else if (ParamName == "force-nested-hardware-loop") {
650 HardwareLoopOpts.setForceNested(true);
651 } else if (ParamName == "force-hardware-loop-guard") {
652 HardwareLoopOpts.setForceGuard(true);
653 } else {
654 return make_error<StringError>(
655 formatv("invalid HardwarePass parameter '{0}' ", ParamName).str(),
657 }
658 }
659 return HardwareLoopOpts;
660}
661
662/// Parser of parameters for LoopUnroll pass.
663Expected<LoopUnrollOptions> parseLoopUnrollOptions(StringRef Params) {
664 LoopUnrollOptions UnrollOpts;
665 while (!Params.empty()) {
666 StringRef ParamName;
667 std::tie(ParamName, Params) = Params.split(';');
668 std::optional<OptimizationLevel> OptLevel = parseOptLevel(ParamName);
669 // Don't accept -Os/-Oz.
670 if (OptLevel && !OptLevel->isOptimizingForSize()) {
671 UnrollOpts.setOptLevel(OptLevel->getSpeedupLevel());
672 continue;
673 }
674 if (ParamName.consume_front("full-unroll-max=")) {
675 int Count;
676 if (ParamName.getAsInteger(0, Count))
677 return make_error<StringError>(
678 formatv("invalid LoopUnrollPass parameter '{0}' ", ParamName).str(),
680 UnrollOpts.setFullUnrollMaxCount(Count);
681 continue;
682 }
683
684 bool Enable = !ParamName.consume_front("no-");
685 if (ParamName == "partial") {
686 UnrollOpts.setPartial(Enable);
687 } else if (ParamName == "peeling") {
688 UnrollOpts.setPeeling(Enable);
689 } else if (ParamName == "profile-peeling") {
690 UnrollOpts.setProfileBasedPeeling(Enable);
691 } else if (ParamName == "runtime") {
692 UnrollOpts.setRuntime(Enable);
693 } else if (ParamName == "upperbound") {
694 UnrollOpts.setUpperBound(Enable);
695 } else {
696 return make_error<StringError>(
697 formatv("invalid LoopUnrollPass parameter '{0}' ", ParamName).str(),
699 }
700 }
701 return UnrollOpts;
702}
703
704Expected<bool> parseGlobalDCEPassOptions(StringRef Params) {
706 Params, "vfe-linkage-unit-visibility", "GlobalDCE");
707}
708
709Expected<bool> parseCGProfilePassOptions(StringRef Params) {
710 return PassBuilder::parseSinglePassOption(Params, "in-lto-post-link",
711 "CGProfile");
712}
713
714Expected<bool> parseInlinerPassOptions(StringRef Params) {
715 return PassBuilder::parseSinglePassOption(Params, "only-mandatory",
716 "InlinerPass");
717}
718
719Expected<bool> parseCoroSplitPassOptions(StringRef Params) {
720 return PassBuilder::parseSinglePassOption(Params, "reuse-storage",
721 "CoroSplitPass");
722}
723
724Expected<bool> parsePostOrderFunctionAttrsPassOptions(StringRef Params) {
726 Params, "skip-non-recursive-function-attrs", "PostOrderFunctionAttrs");
727}
728
729Expected<CFGuardPass::Mechanism> parseCFGuardPassOptions(StringRef Params) {
730 if (Params.empty())
732
733 auto [Param, RHS] = Params.split(';');
734 if (!RHS.empty())
735 return make_error<StringError>(
736 formatv("too many CFGuardPass parameters '{0}' ", Params).str(),
738
739 if (Param == "check")
741 if (Param == "dispatch")
743
744 return make_error<StringError>(
745 formatv("invalid CFGuardPass mechanism: '{0}' ", Param).str(),
747}
748
749Expected<bool> parseEarlyCSEPassOptions(StringRef Params) {
750 return PassBuilder::parseSinglePassOption(Params, "memssa", "EarlyCSE");
751}
752
753Expected<bool> parseEntryExitInstrumenterPassOptions(StringRef Params) {
754 return PassBuilder::parseSinglePassOption(Params, "post-inline",
755 "EntryExitInstrumenter");
756}
757
758Expected<bool> parseLoopExtractorPassOptions(StringRef Params) {
759 return PassBuilder::parseSinglePassOption(Params, "single", "LoopExtractor");
760}
761
762Expected<bool> parseLowerMatrixIntrinsicsPassOptions(StringRef Params) {
763 return PassBuilder::parseSinglePassOption(Params, "minimal",
764 "LowerMatrixIntrinsics");
765}
766
767Expected<AddressSanitizerOptions> parseASanPassOptions(StringRef Params) {
769 while (!Params.empty()) {
770 StringRef ParamName;
771 std::tie(ParamName, Params) = Params.split(';');
772
773 if (ParamName == "kernel") {
774 Result.CompileKernel = true;
775 } else {
776 return make_error<StringError>(
777 formatv("invalid AddressSanitizer pass parameter '{0}' ", ParamName)
778 .str(),
780 }
781 }
782 return Result;
783}
784
785Expected<HWAddressSanitizerOptions> parseHWASanPassOptions(StringRef Params) {
787 while (!Params.empty()) {
788 StringRef ParamName;
789 std::tie(ParamName, Params) = Params.split(';');
790
791 if (ParamName == "recover") {
792 Result.Recover = true;
793 } else if (ParamName == "kernel") {
794 Result.CompileKernel = true;
795 } else {
796 return make_error<StringError>(
797 formatv("invalid HWAddressSanitizer pass parameter '{0}' ", ParamName)
798 .str(),
800 }
801 }
802 return Result;
803}
804
805Expected<EmbedBitcodeOptions> parseEmbedBitcodePassOptions(StringRef Params) {
807 while (!Params.empty()) {
808 StringRef ParamName;
809 std::tie(ParamName, Params) = Params.split(';');
810
811 if (ParamName == "thinlto") {
812 Result.IsThinLTO = true;
813 } else if (ParamName == "emit-summary") {
814 Result.EmitLTOSummary = true;
815 } else {
816 return make_error<StringError>(
817 formatv("invalid EmbedBitcode pass parameter '{0}' ", ParamName)
818 .str(),
820 }
821 }
822 return Result;
823}
824
826parseLowerAllowCheckPassOptions(StringRef Params) {
828 while (!Params.empty()) {
829 StringRef ParamName;
830 std::tie(ParamName, Params) = Params.split(';');
831
832 // Format is <cutoffs[1,2,3]=70000;cutoffs[5,6,8]=90000>
833 //
834 // Parsing allows duplicate indices (last one takes precedence).
835 // It would technically be in spec to specify
836 // cutoffs[0]=70000,cutoffs[1]=90000,cutoffs[0]=80000,...
837 if (ParamName.starts_with("cutoffs[")) {
838 StringRef IndicesStr;
839 StringRef CutoffStr;
840
841 std::tie(IndicesStr, CutoffStr) = ParamName.split("]=");
842 // cutoffs[1,2,3
843 // 70000
844
845 int cutoff;
846 if (CutoffStr.getAsInteger(0, cutoff))
847 return make_error<StringError>(
848 formatv("invalid LowerAllowCheck pass cutoffs parameter '{0}' "
849 "({1})",
850 CutoffStr, Params)
851 .str(),
853
854 if (!IndicesStr.consume_front("cutoffs[") || IndicesStr == "")
855 return make_error<StringError>(
856 formatv("invalid LowerAllowCheck pass index parameter '{0}' "
857 "({1})",
858 IndicesStr, CutoffStr)
859 .str(),
861
862 while (IndicesStr != "") {
863 StringRef firstIndexStr;
864 std::tie(firstIndexStr, IndicesStr) = IndicesStr.split('|');
865
866 unsigned int index;
867 if (firstIndexStr.getAsInteger(0, index))
868 return make_error<StringError>(
869 formatv("invalid LowerAllowCheck pass index parameter '{0}' "
870 "({1}) {2}",
871 firstIndexStr, IndicesStr)
872 .str(),
874
875 // In the common case (sequentially increasing indices), we will issue
876 // O(n) resize requests. We assume the underlying data structure has
877 // O(1) runtime for each added element.
878 if (index >= Result.cutoffs.size())
879 Result.cutoffs.resize(index + 1, 0);
880
881 Result.cutoffs[index] = cutoff;
882 }
883 } else {
884 return make_error<StringError>(
885 formatv("invalid LowerAllowCheck pass parameter '{0}' ", ParamName)
886 .str(),
888 }
889 }
890
891 return Result;
892}
893
894Expected<MemorySanitizerOptions> parseMSanPassOptions(StringRef Params) {
896 while (!Params.empty()) {
897 StringRef ParamName;
898 std::tie(ParamName, Params) = Params.split(';');
899
900 if (ParamName == "recover") {
901 Result.Recover = true;
902 } else if (ParamName == "kernel") {
903 Result.Kernel = true;
904 } else if (ParamName.consume_front("track-origins=")) {
905 if (ParamName.getAsInteger(0, Result.TrackOrigins))
906 return make_error<StringError>(
907 formatv("invalid argument to MemorySanitizer pass track-origins "
908 "parameter: '{0}' ",
909 ParamName)
910 .str(),
912 } else if (ParamName == "eager-checks") {
913 Result.EagerChecks = true;
914 } else {
915 return make_error<StringError>(
916 formatv("invalid MemorySanitizer pass parameter '{0}' ", ParamName)
917 .str(),
919 }
920 }
921 return Result;
922}
923
924/// Parser of parameters for SimplifyCFG pass.
925Expected<SimplifyCFGOptions> parseSimplifyCFGOptions(StringRef Params) {
927 while (!Params.empty()) {
928 StringRef ParamName;
929 std::tie(ParamName, Params) = Params.split(';');
930
931 bool Enable = !ParamName.consume_front("no-");
932 if (ParamName == "speculate-blocks") {
933 Result.speculateBlocks(Enable);
934 } else if (ParamName == "simplify-cond-branch") {
935 Result.setSimplifyCondBranch(Enable);
936 } else if (ParamName == "forward-switch-cond") {
937 Result.forwardSwitchCondToPhi(Enable);
938 } else if (ParamName == "switch-range-to-icmp") {
939 Result.convertSwitchRangeToICmp(Enable);
940 } else if (ParamName == "switch-to-lookup") {
941 Result.convertSwitchToLookupTable(Enable);
942 } else if (ParamName == "keep-loops") {
943 Result.needCanonicalLoops(Enable);
944 } else if (ParamName == "hoist-common-insts") {
945 Result.hoistCommonInsts(Enable);
946 } else if (ParamName == "hoist-loads-stores-with-cond-faulting") {
947 Result.hoistLoadsStoresWithCondFaulting(Enable);
948 } else if (ParamName == "sink-common-insts") {
949 Result.sinkCommonInsts(Enable);
950 } else if (ParamName == "speculate-unpredictables") {
951 Result.speculateUnpredictables(Enable);
952 } else if (Enable && ParamName.consume_front("bonus-inst-threshold=")) {
953 APInt BonusInstThreshold;
954 if (ParamName.getAsInteger(0, BonusInstThreshold))
955 return make_error<StringError>(
956 formatv("invalid argument to SimplifyCFG pass bonus-threshold "
957 "parameter: '{0}' ",
958 ParamName).str(),
960 Result.bonusInstThreshold(BonusInstThreshold.getSExtValue());
961 } else {
962 return make_error<StringError>(
963 formatv("invalid SimplifyCFG pass parameter '{0}' ", ParamName).str(),
965 }
966 }
967 return Result;
968}
969
970Expected<InstCombineOptions> parseInstCombineOptions(StringRef Params) {
972 // When specifying "instcombine" in -passes enable fix-point verification by
973 // default, as this is what most tests should use.
974 Result.setVerifyFixpoint(true);
975 while (!Params.empty()) {
976 StringRef ParamName;
977 std::tie(ParamName, Params) = Params.split(';');
978
979 bool Enable = !ParamName.consume_front("no-");
980 if (ParamName == "verify-fixpoint") {
981 Result.setVerifyFixpoint(Enable);
982 } else if (Enable && ParamName.consume_front("max-iterations=")) {
983 APInt MaxIterations;
984 if (ParamName.getAsInteger(0, MaxIterations))
985 return make_error<StringError>(
986 formatv("invalid argument to InstCombine pass max-iterations "
987 "parameter: '{0}' ",
988 ParamName).str(),
990 Result.setMaxIterations((unsigned)MaxIterations.getZExtValue());
991 } else {
992 return make_error<StringError>(
993 formatv("invalid InstCombine pass parameter '{0}' ", ParamName).str(),
995 }
996 }
997 return Result;
998}
999
1000/// Parser of parameters for LoopVectorize pass.
1001Expected<LoopVectorizeOptions> parseLoopVectorizeOptions(StringRef Params) {
1003 while (!Params.empty()) {
1004 StringRef ParamName;
1005 std::tie(ParamName, Params) = Params.split(';');
1006
1007 bool Enable = !ParamName.consume_front("no-");
1008 if (ParamName == "interleave-forced-only") {
1010 } else if (ParamName == "vectorize-forced-only") {
1012 } else {
1013 return make_error<StringError>(
1014 formatv("invalid LoopVectorize parameter '{0}' ", ParamName).str(),
1016 }
1017 }
1018 return Opts;
1019}
1020
1021Expected<std::pair<bool, bool>> parseLoopUnswitchOptions(StringRef Params) {
1022 std::pair<bool, bool> Result = {false, true};
1023 while (!Params.empty()) {
1024 StringRef ParamName;
1025 std::tie(ParamName, Params) = Params.split(';');
1026
1027 bool Enable = !ParamName.consume_front("no-");
1028 if (ParamName == "nontrivial") {
1029 Result.first = Enable;
1030 } else if (ParamName == "trivial") {
1031 Result.second = Enable;
1032 } else {
1033 return make_error<StringError>(
1034 formatv("invalid LoopUnswitch pass parameter '{0}' ", ParamName)
1035 .str(),
1037 }
1038 }
1039 return Result;
1040}
1041
1042Expected<LICMOptions> parseLICMOptions(StringRef Params) {
1044 while (!Params.empty()) {
1045 StringRef ParamName;
1046 std::tie(ParamName, Params) = Params.split(';');
1047
1048 bool Enable = !ParamName.consume_front("no-");
1049 if (ParamName == "allowspeculation") {
1050 Result.AllowSpeculation = Enable;
1051 } else {
1052 return make_error<StringError>(
1053 formatv("invalid LICM pass parameter '{0}' ", ParamName).str(),
1055 }
1056 }
1057 return Result;
1058}
1059
1060Expected<std::pair<bool, bool>> parseLoopRotateOptions(StringRef Params) {
1061 std::pair<bool, bool> Result = {true, false};
1062 while (!Params.empty()) {
1063 StringRef ParamName;
1064 std::tie(ParamName, Params) = Params.split(';');
1065
1066 bool Enable = !ParamName.consume_front("no-");
1067 if (ParamName == "header-duplication") {
1068 Result.first = Enable;
1069 } else if (ParamName == "prepare-for-lto") {
1070 Result.second = Enable;
1071 } else {
1072 return make_error<StringError>(
1073 formatv("invalid LoopRotate pass parameter '{0}' ", ParamName).str(),
1075 }
1076 }
1077 return Result;
1078}
1079
1080Expected<bool> parseMergedLoadStoreMotionOptions(StringRef Params) {
1081 bool Result = false;
1082 while (!Params.empty()) {
1083 StringRef ParamName;
1084 std::tie(ParamName, Params) = Params.split(';');
1085
1086 bool Enable = !ParamName.consume_front("no-");
1087 if (ParamName == "split-footer-bb") {
1088 Result = Enable;
1089 } else {
1090 return make_error<StringError>(
1091 formatv("invalid MergedLoadStoreMotion pass parameter '{0}' ",
1092 ParamName)
1093 .str(),
1095 }
1096 }
1097 return Result;
1098}
1099
1100Expected<GVNOptions> parseGVNOptions(StringRef Params) {
1102 while (!Params.empty()) {
1103 StringRef ParamName;
1104 std::tie(ParamName, Params) = Params.split(';');
1105
1106 bool Enable = !ParamName.consume_front("no-");
1107 if (ParamName == "pre") {
1108 Result.setPRE(Enable);
1109 } else if (ParamName == "load-pre") {
1110 Result.setLoadPRE(Enable);
1111 } else if (ParamName == "split-backedge-load-pre") {
1112 Result.setLoadPRESplitBackedge(Enable);
1113 } else if (ParamName == "memdep") {
1114 Result.setMemDep(Enable);
1115 } else if (ParamName == "memoryssa") {
1116 Result.setMemorySSA(Enable);
1117 } else {
1118 return make_error<StringError>(
1119 formatv("invalid GVN pass parameter '{0}' ", ParamName).str(),
1121 }
1122 }
1123 return Result;
1124}
1125
1126Expected<IPSCCPOptions> parseIPSCCPOptions(StringRef Params) {
1128 while (!Params.empty()) {
1129 StringRef ParamName;
1130 std::tie(ParamName, Params) = Params.split(';');
1131
1132 bool Enable = !ParamName.consume_front("no-");
1133 if (ParamName == "func-spec")
1134 Result.setFuncSpec(Enable);
1135 else
1136 return make_error<StringError>(
1137 formatv("invalid IPSCCP pass parameter '{0}' ", ParamName).str(),
1139 }
1140 return Result;
1141}
1142
1143Expected<ScalarizerPassOptions> parseScalarizerOptions(StringRef Params) {
1145 while (!Params.empty()) {
1146 StringRef ParamName;
1147 std::tie(ParamName, Params) = Params.split(';');
1148
1149 if (ParamName.consume_front("min-bits=")) {
1150 if (ParamName.getAsInteger(0, Result.ScalarizeMinBits)) {
1151 return make_error<StringError>(
1152 formatv("invalid argument to Scalarizer pass min-bits "
1153 "parameter: '{0}' ",
1154 ParamName)
1155 .str(),
1157 }
1158
1159 continue;
1160 }
1161
1162 bool Enable = !ParamName.consume_front("no-");
1163 if (ParamName == "load-store")
1164 Result.ScalarizeLoadStore = Enable;
1165 else if (ParamName == "variable-insert-extract")
1166 Result.ScalarizeVariableInsertExtract = Enable;
1167 else {
1168 return make_error<StringError>(
1169 formatv("invalid Scalarizer pass parameter '{0}' ", ParamName).str(),
1171 }
1172 }
1173
1174 return Result;
1175}
1176
1177Expected<SROAOptions> parseSROAOptions(StringRef Params) {
1178 if (Params.empty() || Params == "modify-cfg")
1180 if (Params == "preserve-cfg")
1182 return make_error<StringError>(
1183 formatv("invalid SROA pass parameter '{0}' (either preserve-cfg or "
1184 "modify-cfg can be specified)",
1185 Params)
1186 .str(),
1188}
1189
1191parseStackLifetimeOptions(StringRef Params) {
1193 while (!Params.empty()) {
1194 StringRef ParamName;
1195 std::tie(ParamName, Params) = Params.split(';');
1196
1197 if (ParamName == "may") {
1199 } else if (ParamName == "must") {
1201 } else {
1202 return make_error<StringError>(
1203 formatv("invalid StackLifetime parameter '{0}' ", ParamName).str(),
1205 }
1206 }
1207 return Result;
1208}
1209
1210Expected<bool> parseDependenceAnalysisPrinterOptions(StringRef Params) {
1211 return PassBuilder::parseSinglePassOption(Params, "normalized-results",
1212 "DependenceAnalysisPrinter");
1213}
1214
1215Expected<bool> parseSeparateConstOffsetFromGEPPassOptions(StringRef Params) {
1216 return PassBuilder::parseSinglePassOption(Params, "lower-gep",
1217 "SeparateConstOffsetFromGEP");
1218}
1219
1220Expected<bool> parseStructurizeCFGPassOptions(StringRef Params) {
1221 return PassBuilder::parseSinglePassOption(Params, "skip-uniform-regions",
1222 "StructurizeCFG");
1223}
1224
1226parseFunctionSimplificationPipelineOptions(StringRef Params) {
1227 std::optional<OptimizationLevel> L = parseOptLevel(Params);
1228 if (!L || *L == OptimizationLevel::O0) {
1229 return make_error<StringError>(
1230 formatv("invalid function-simplification parameter '{0}' ", Params)
1231 .str(),
1233 };
1234 return *L;
1235}
1236
1237Expected<bool> parseMemorySSAPrinterPassOptions(StringRef Params) {
1238 return PassBuilder::parseSinglePassOption(Params, "no-ensure-optimized-uses",
1239 "MemorySSAPrinterPass");
1240}
1241
1242Expected<bool> parseSpeculativeExecutionPassOptions(StringRef Params) {
1243 return PassBuilder::parseSinglePassOption(Params, "only-if-divergent-target",
1244 "SpeculativeExecutionPass");
1245}
1246
1247Expected<std::string> parseMemProfUsePassOptions(StringRef Params) {
1248 std::string Result;
1249 while (!Params.empty()) {
1250 StringRef ParamName;
1251 std::tie(ParamName, Params) = Params.split(';');
1252
1253 if (ParamName.consume_front("profile-filename=")) {
1254 Result = ParamName.str();
1255 } else {
1256 return make_error<StringError>(
1257 formatv("invalid MemProfUse pass parameter '{0}' ", ParamName).str(),
1259 }
1260 }
1261 return Result;
1262}
1263
1265parseStructuralHashPrinterPassOptions(StringRef Params) {
1266 if (Params.empty())
1268 if (Params == "detailed")
1270 if (Params == "call-target-ignored")
1272 return make_error<StringError>(
1273 formatv("invalid structural hash printer parameter '{0}' ", Params).str(),
1275}
1276
1277Expected<bool> parseWinEHPrepareOptions(StringRef Params) {
1278 return PassBuilder::parseSinglePassOption(Params, "demote-catchswitch-only",
1279 "WinEHPreparePass");
1280}
1281
1282Expected<GlobalMergeOptions> parseGlobalMergeOptions(StringRef Params) {
1284 while (!Params.empty()) {
1285 StringRef ParamName;
1286 std::tie(ParamName, Params) = Params.split(';');
1287
1288 bool Enable = !ParamName.consume_front("no-");
1289 if (ParamName == "group-by-use")
1290 Result.GroupByUse = Enable;
1291 else if (ParamName == "ignore-single-use")
1292 Result.IgnoreSingleUse = Enable;
1293 else if (ParamName == "merge-const")
1294 Result.MergeConst = Enable;
1295 else if (ParamName == "merge-external")
1296 Result.MergeExternal = Enable;
1297 else if (ParamName.consume_front("max-offset=")) {
1298 if (ParamName.getAsInteger(0, Result.MaxOffset))
1299 return make_error<StringError>(
1300 formatv("invalid GlobalMergePass parameter '{0}' ", ParamName)
1301 .str(),
1303 }
1304 }
1305 return Result;
1306}
1307
1308Expected<SmallVector<std::string, 0>> parseInternalizeGVs(StringRef Params) {
1309 SmallVector<std::string, 1> PreservedGVs;
1310 while (!Params.empty()) {
1311 StringRef ParamName;
1312 std::tie(ParamName, Params) = Params.split(';');
1313
1314 if (ParamName.consume_front("preserve-gv=")) {
1315 PreservedGVs.push_back(ParamName.str());
1316 } else {
1317 return make_error<StringError>(
1318 formatv("invalid Internalize pass parameter '{0}' ", ParamName).str(),
1320 }
1321 }
1322
1323 return Expected<SmallVector<std::string, 0>>(std::move(PreservedGVs));
1324}
1325
1327parseRegAllocFastPassOptions(PassBuilder &PB, StringRef Params) {
1329 while (!Params.empty()) {
1330 StringRef ParamName;
1331 std::tie(ParamName, Params) = Params.split(';');
1332
1333 if (ParamName.consume_front("filter=")) {
1334 std::optional<RegAllocFilterFunc> Filter =
1335 PB.parseRegAllocFilter(ParamName);
1336 if (!Filter) {
1337 return make_error<StringError>(
1338 formatv("invalid regallocfast register filter '{0}' ", ParamName)
1339 .str(),
1341 }
1342 Opts.Filter = *Filter;
1343 Opts.FilterName = ParamName;
1344 continue;
1345 }
1346
1347 if (ParamName == "no-clear-vregs") {
1348 Opts.ClearVRegs = false;
1349 continue;
1350 }
1351
1352 return make_error<StringError>(
1353 formatv("invalid regallocfast pass parameter '{0}' ", ParamName).str(),
1355 }
1356 return Opts;
1357}
1358
1360parseBoundsCheckingOptions(StringRef Params) {
1362 while (!Params.empty()) {
1363 StringRef ParamName;
1364 std::tie(ParamName, Params) = Params.split(';');
1365 if (ParamName == "trap") {
1366 Options.Rt = std::nullopt;
1367 } else if (ParamName == "rt") {
1368 Options.Rt = {
1369 /*MinRuntime=*/false,
1370 /*MayReturn=*/true,
1371 };
1372 } else if (ParamName == "rt-abort") {
1373 Options.Rt = {
1374 /*MinRuntime=*/false,
1375 /*MayReturn=*/false,
1376 };
1377 } else if (ParamName == "min-rt") {
1378 Options.Rt = {
1379 /*MinRuntime=*/true,
1380 /*MayReturn=*/true,
1381 };
1382 } else if (ParamName == "min-rt-abort") {
1383 Options.Rt = {
1384 /*MinRuntime=*/true,
1385 /*MayReturn=*/false,
1386 };
1387 } else if (ParamName == "merge") {
1388 Options.Merge = true;
1389 } else {
1390 StringRef ParamEQ;
1391 StringRef Val;
1392 std::tie(ParamEQ, Val) = ParamName.split('=');
1393 int8_t Id;
1394 if (ParamEQ == "guard" && !Val.getAsInteger(0, Id)) {
1395 Options.GuardKind = Id;
1396 } else {
1397 return make_error<StringError>(
1398 formatv("invalid BoundsChecking pass parameter '{0}' ", ParamName)
1399 .str(),
1401 }
1402 }
1403 }
1404 return Options;
1405}
1406
1407} // namespace
1408
1409/// Tests whether a pass name starts with a valid prefix for a default pipeline
1410/// alias.
1412 return Name.starts_with("default") || Name.starts_with("thinlto") ||
1413 Name.starts_with("lto");
1414}
1415
1416/// Tests whether registered callbacks will accept a given pass name.
1417///
1418/// When parsing a pipeline text, the type of the outermost pipeline may be
1419/// omitted, in which case the type is automatically determined from the first
1420/// pass name in the text. This may be a name that is handled through one of the
1421/// callbacks. We check this through the oridinary parsing callbacks by setting
1422/// up a dummy PassManager in order to not force the client to also handle this
1423/// type of query.
1424template <typename PassManagerT, typename CallbacksT>
1425static bool callbacksAcceptPassName(StringRef Name, CallbacksT &Callbacks) {
1426 if (!Callbacks.empty()) {
1427 PassManagerT DummyPM;
1428 for (auto &CB : Callbacks)
1429 if (CB(Name, DummyPM, {}))
1430 return true;
1431 }
1432 return false;
1433}
1434
1435template <typename CallbacksT>
1436static bool isModulePassName(StringRef Name, CallbacksT &Callbacks) {
1437 // Manually handle aliases for pre-configured pipeline fragments.
1440
1441 StringRef NameNoBracket = Name.take_until([](char C) { return C == '<'; });
1442
1443 // Explicitly handle pass manager names.
1444 if (Name == "module")
1445 return true;
1446 if (Name == "cgscc")
1447 return true;
1448 if (NameNoBracket == "function")
1449 return true;
1450 if (Name == "coro-cond")
1451 return true;
1452
1453#define MODULE_PASS(NAME, CREATE_PASS) \
1454 if (Name == NAME) \
1455 return true;
1456#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1457 if (PassBuilder::checkParametrizedPassName(Name, NAME)) \
1458 return true;
1459#define MODULE_ANALYSIS(NAME, CREATE_PASS) \
1460 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \
1461 return true;
1462#include "PassRegistry.def"
1463
1464 return callbacksAcceptPassName<ModulePassManager>(Name, Callbacks);
1465}
1466
1467template <typename CallbacksT>
1468static bool isCGSCCPassName(StringRef Name, CallbacksT &Callbacks) {
1469 // Explicitly handle pass manager names.
1470 StringRef NameNoBracket = Name.take_until([](char C) { return C == '<'; });
1471 if (Name == "cgscc")
1472 return true;
1473 if (NameNoBracket == "function")
1474 return true;
1475
1476 // Explicitly handle custom-parsed pass names.
1478 return true;
1479
1480#define CGSCC_PASS(NAME, CREATE_PASS) \
1481 if (Name == NAME) \
1482 return true;
1483#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1484 if (PassBuilder::checkParametrizedPassName(Name, NAME)) \
1485 return true;
1486#define CGSCC_ANALYSIS(NAME, CREATE_PASS) \
1487 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \
1488 return true;
1489#include "PassRegistry.def"
1490
1491 return callbacksAcceptPassName<CGSCCPassManager>(Name, Callbacks);
1492}
1493
1494template <typename CallbacksT>
1495static bool isFunctionPassName(StringRef Name, CallbacksT &Callbacks) {
1496 // Explicitly handle pass manager names.
1497 StringRef NameNoBracket = Name.take_until([](char C) { return C == '<'; });
1498 if (NameNoBracket == "function")
1499 return true;
1500 if (Name == "loop" || Name == "loop-mssa" || Name == "machine-function")
1501 return true;
1502
1503#define FUNCTION_PASS(NAME, CREATE_PASS) \
1504 if (Name == NAME) \
1505 return true;
1506#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1507 if (PassBuilder::checkParametrizedPassName(Name, NAME)) \
1508 return true;
1509#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
1510 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \
1511 return true;
1512#include "PassRegistry.def"
1513
1514 return callbacksAcceptPassName<FunctionPassManager>(Name, Callbacks);
1515}
1516
1517template <typename CallbacksT>
1518static bool isMachineFunctionPassName(StringRef Name, CallbacksT &Callbacks) {
1519 // Explicitly handle pass manager names.
1520 if (Name == "machine-function")
1521 return true;
1522
1523#define MACHINE_FUNCTION_PASS(NAME, CREATE_PASS) \
1524 if (Name == NAME) \
1525 return true;
1526#define MACHINE_FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, \
1527 PARAMS) \
1528 if (PassBuilder::checkParametrizedPassName(Name, NAME)) \
1529 return true;
1530
1531#define MACHINE_FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
1532 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \
1533 return true;
1534
1535#include "llvm/Passes/MachinePassRegistry.def"
1536
1537 return callbacksAcceptPassName<MachineFunctionPassManager>(Name, Callbacks);
1538}
1539
1540template <typename CallbacksT>
1541static bool isLoopNestPassName(StringRef Name, CallbacksT &Callbacks,
1542 bool &UseMemorySSA) {
1543 UseMemorySSA = false;
1544
1546 UseMemorySSA = true;
1547 return true;
1548 }
1549
1550#define LOOPNEST_PASS(NAME, CREATE_PASS) \
1551 if (Name == NAME) \
1552 return true;
1553#include "PassRegistry.def"
1554
1555 return callbacksAcceptPassName<LoopPassManager>(Name, Callbacks);
1556}
1557
1558template <typename CallbacksT>
1559static bool isLoopPassName(StringRef Name, CallbacksT &Callbacks,
1560 bool &UseMemorySSA) {
1561 UseMemorySSA = false;
1562
1564 UseMemorySSA = true;
1565 return true;
1566 }
1567
1568#define LOOP_PASS(NAME, CREATE_PASS) \
1569 if (Name == NAME) \
1570 return true;
1571#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1572 if (PassBuilder::checkParametrizedPassName(Name, NAME)) \
1573 return true;
1574#define LOOP_ANALYSIS(NAME, CREATE_PASS) \
1575 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \
1576 return true;
1577#include "PassRegistry.def"
1578
1579 return callbacksAcceptPassName<LoopPassManager>(Name, Callbacks);
1580}
1581
1582std::optional<std::vector<PassBuilder::PipelineElement>>
1583PassBuilder::parsePipelineText(StringRef Text) {
1584 std::vector<PipelineElement> ResultPipeline;
1585
1586 SmallVector<std::vector<PipelineElement> *, 4> PipelineStack = {
1587 &ResultPipeline};
1588 for (;;) {
1589 std::vector<PipelineElement> &Pipeline = *PipelineStack.back();
1590 size_t Pos = Text.find_first_of(",()");
1591 Pipeline.push_back({Text.substr(0, Pos), {}});
1592
1593 // If we have a single terminating name, we're done.
1594 if (Pos == Text.npos)
1595 break;
1596
1597 char Sep = Text[Pos];
1598 Text = Text.substr(Pos + 1);
1599 if (Sep == ',')
1600 // Just a name ending in a comma, continue.
1601 continue;
1602
1603 if (Sep == '(') {
1604 // Push the inner pipeline onto the stack to continue processing.
1605 PipelineStack.push_back(&Pipeline.back().InnerPipeline);
1606 continue;
1607 }
1608
1609 assert(Sep == ')' && "Bogus separator!");
1610 // When handling the close parenthesis, we greedily consume them to avoid
1611 // empty strings in the pipeline.
1612 do {
1613 // If we try to pop the outer pipeline we have unbalanced parentheses.
1614 if (PipelineStack.size() == 1)
1615 return std::nullopt;
1616
1617 PipelineStack.pop_back();
1618 } while (Text.consume_front(")"));
1619
1620 // Check if we've finished parsing.
1621 if (Text.empty())
1622 break;
1623
1624 // Otherwise, the end of an inner pipeline always has to be followed by
1625 // a comma, and then we can continue.
1626 if (!Text.consume_front(","))
1627 return std::nullopt;
1628 }
1629
1630 if (PipelineStack.size() > 1)
1631 // Unbalanced paretheses.
1632 return std::nullopt;
1633
1634 assert(PipelineStack.back() == &ResultPipeline &&
1635 "Wrong pipeline at the bottom of the stack!");
1636 return {std::move(ResultPipeline)};
1637}
1638
1639Error PassBuilder::parseModulePass(ModulePassManager &MPM,
1640 const PipelineElement &E) {
1641 auto &Name = E.Name;
1642 auto &InnerPipeline = E.InnerPipeline;
1643
1644 // First handle complex passes like the pass managers which carry pipelines.
1645 if (!InnerPipeline.empty()) {
1646 if (Name == "module") {
1647 ModulePassManager NestedMPM;
1648 if (auto Err = parseModulePassPipeline(NestedMPM, InnerPipeline))
1649 return Err;
1650 MPM.addPass(std::move(NestedMPM));
1651 return Error::success();
1652 }
1653 if (Name == "coro-cond") {
1654 ModulePassManager NestedMPM;
1655 if (auto Err = parseModulePassPipeline(NestedMPM, InnerPipeline))
1656 return Err;
1657 MPM.addPass(CoroConditionalWrapper(std::move(NestedMPM)));
1658 return Error::success();
1659 }
1660 if (Name == "cgscc") {
1661 CGSCCPassManager CGPM;
1662 if (auto Err = parseCGSCCPassPipeline(CGPM, InnerPipeline))
1663 return Err;
1665 return Error::success();
1666 }
1667 if (auto Params = parseFunctionPipelineName(Name)) {
1668 if (Params->second)
1669 return make_error<StringError>(
1670 "cannot have a no-rerun module to function adaptor",
1673 if (auto Err = parseFunctionPassPipeline(FPM, InnerPipeline))
1674 return Err;
1675 MPM.addPass(
1676 createModuleToFunctionPassAdaptor(std::move(FPM), Params->first));
1677 return Error::success();
1678 }
1679
1680 for (auto &C : ModulePipelineParsingCallbacks)
1681 if (C(Name, MPM, InnerPipeline))
1682 return Error::success();
1683
1684 // Normal passes can't have pipelines.
1685 return make_error<StringError>(
1686 formatv("invalid use of '{0}' pass as module pipeline", Name).str(),
1688 ;
1689 }
1690
1691 // Manually handle aliases for pre-configured pipeline fragments.
1694 if (!DefaultAliasRegex.match(Name, &Matches))
1695 return make_error<StringError>(
1696 formatv("unknown default pipeline alias '{0}'", Name).str(),
1698
1699 assert(Matches.size() == 3 && "Must capture two matched strings!");
1700
1701 OptimizationLevel L = *parseOptLevel(Matches[2]);
1702
1703 // This is consistent with old pass manager invoked via opt, but
1704 // inconsistent with clang. Clang doesn't enable loop vectorization
1705 // but does enable slp vectorization at Oz.
1706 PTO.LoopVectorization =
1707 L.getSpeedupLevel() > 1 && L != OptimizationLevel::Oz;
1708 PTO.SLPVectorization =
1709 L.getSpeedupLevel() > 1 && L != OptimizationLevel::Oz;
1710
1711 if (Matches[1] == "default") {
1713 } else if (Matches[1] == "thinlto-pre-link") {
1715 } else if (Matches[1] == "thinlto") {
1716 MPM.addPass(buildThinLTODefaultPipeline(L, nullptr));
1717 } else if (Matches[1] == "lto-pre-link") {
1718 if (PTO.UnifiedLTO)
1719 // When UnifiedLTO is enabled, use the ThinLTO pre-link pipeline. This
1720 // avoids compile-time performance regressions and keeps the pre-link
1721 // LTO pipeline "unified" for both LTO modes.
1723 else
1725 } else {
1726 assert(Matches[1] == "lto" && "Not one of the matched options!");
1727 MPM.addPass(buildLTODefaultPipeline(L, nullptr));
1728 }
1729 return Error::success();
1730 }
1731
1732 // Finally expand the basic registered passes from the .inc file.
1733#define MODULE_PASS(NAME, CREATE_PASS) \
1734 if (Name == NAME) { \
1735 MPM.addPass(CREATE_PASS); \
1736 return Error::success(); \
1737 }
1738#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1739 if (checkParametrizedPassName(Name, NAME)) { \
1740 auto Params = parsePassParameters(PARSER, Name, NAME); \
1741 if (!Params) \
1742 return Params.takeError(); \
1743 MPM.addPass(CREATE_PASS(Params.get())); \
1744 return Error::success(); \
1745 }
1746#define MODULE_ANALYSIS(NAME, CREATE_PASS) \
1747 if (Name == "require<" NAME ">") { \
1748 MPM.addPass( \
1749 RequireAnalysisPass< \
1750 std::remove_reference_t<decltype(CREATE_PASS)>, Module>()); \
1751 return Error::success(); \
1752 } \
1753 if (Name == "invalidate<" NAME ">") { \
1754 MPM.addPass(InvalidateAnalysisPass< \
1755 std::remove_reference_t<decltype(CREATE_PASS)>>()); \
1756 return Error::success(); \
1757 }
1758#define CGSCC_PASS(NAME, CREATE_PASS) \
1759 if (Name == NAME) { \
1760 MPM.addPass(createModuleToPostOrderCGSCCPassAdaptor(CREATE_PASS)); \
1761 return Error::success(); \
1762 }
1763#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1764 if (checkParametrizedPassName(Name, NAME)) { \
1765 auto Params = parsePassParameters(PARSER, Name, NAME); \
1766 if (!Params) \
1767 return Params.takeError(); \
1768 MPM.addPass( \
1769 createModuleToPostOrderCGSCCPassAdaptor(CREATE_PASS(Params.get()))); \
1770 return Error::success(); \
1771 }
1772#define FUNCTION_PASS(NAME, CREATE_PASS) \
1773 if (Name == NAME) { \
1774 MPM.addPass(createModuleToFunctionPassAdaptor(CREATE_PASS)); \
1775 return Error::success(); \
1776 }
1777#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1778 if (checkParametrizedPassName(Name, NAME)) { \
1779 auto Params = parsePassParameters(PARSER, Name, NAME); \
1780 if (!Params) \
1781 return Params.takeError(); \
1782 MPM.addPass(createModuleToFunctionPassAdaptor(CREATE_PASS(Params.get()))); \
1783 return Error::success(); \
1784 }
1785#define LOOPNEST_PASS(NAME, CREATE_PASS) \
1786 if (Name == NAME) { \
1787 MPM.addPass(createModuleToFunctionPassAdaptor( \
1788 createFunctionToLoopPassAdaptor(CREATE_PASS, false, false))); \
1789 return Error::success(); \
1790 }
1791#define LOOP_PASS(NAME, CREATE_PASS) \
1792 if (Name == NAME) { \
1793 MPM.addPass(createModuleToFunctionPassAdaptor( \
1794 createFunctionToLoopPassAdaptor(CREATE_PASS, false, false))); \
1795 return Error::success(); \
1796 }
1797#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1798 if (checkParametrizedPassName(Name, NAME)) { \
1799 auto Params = parsePassParameters(PARSER, Name, NAME); \
1800 if (!Params) \
1801 return Params.takeError(); \
1802 MPM.addPass( \
1803 createModuleToFunctionPassAdaptor(createFunctionToLoopPassAdaptor( \
1804 CREATE_PASS(Params.get()), false, false))); \
1805 return Error::success(); \
1806 }
1807#include "PassRegistry.def"
1808
1809 for (auto &C : ModulePipelineParsingCallbacks)
1810 if (C(Name, MPM, InnerPipeline))
1811 return Error::success();
1812 return make_error<StringError>(
1813 formatv("unknown module pass '{0}'", Name).str(),
1815}
1816
1817Error PassBuilder::parseCGSCCPass(CGSCCPassManager &CGPM,
1818 const PipelineElement &E) {
1819 auto &Name = E.Name;
1820 auto &InnerPipeline = E.InnerPipeline;
1821
1822 // First handle complex passes like the pass managers which carry pipelines.
1823 if (!InnerPipeline.empty()) {
1824 if (Name == "cgscc") {
1825 CGSCCPassManager NestedCGPM;
1826 if (auto Err = parseCGSCCPassPipeline(NestedCGPM, InnerPipeline))
1827 return Err;
1828 // Add the nested pass manager with the appropriate adaptor.
1829 CGPM.addPass(std::move(NestedCGPM));
1830 return Error::success();
1831 }
1832 if (auto Params = parseFunctionPipelineName(Name)) {
1834 if (auto Err = parseFunctionPassPipeline(FPM, InnerPipeline))
1835 return Err;
1836 // Add the nested pass manager with the appropriate adaptor.
1838 std::move(FPM), Params->first, Params->second));
1839 return Error::success();
1840 }
1841 if (auto MaxRepetitions = parseDevirtPassName(Name)) {
1842 CGSCCPassManager NestedCGPM;
1843 if (auto Err = parseCGSCCPassPipeline(NestedCGPM, InnerPipeline))
1844 return Err;
1845 CGPM.addPass(
1846 createDevirtSCCRepeatedPass(std::move(NestedCGPM), *MaxRepetitions));
1847 return Error::success();
1848 }
1849
1850 for (auto &C : CGSCCPipelineParsingCallbacks)
1851 if (C(Name, CGPM, InnerPipeline))
1852 return Error::success();
1853
1854 // Normal passes can't have pipelines.
1855 return make_error<StringError>(
1856 formatv("invalid use of '{0}' pass as cgscc pipeline", Name).str(),
1858 }
1859
1860// Now expand the basic registered passes from the .inc file.
1861#define CGSCC_PASS(NAME, CREATE_PASS) \
1862 if (Name == NAME) { \
1863 CGPM.addPass(CREATE_PASS); \
1864 return Error::success(); \
1865 }
1866#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1867 if (checkParametrizedPassName(Name, NAME)) { \
1868 auto Params = parsePassParameters(PARSER, Name, NAME); \
1869 if (!Params) \
1870 return Params.takeError(); \
1871 CGPM.addPass(CREATE_PASS(Params.get())); \
1872 return Error::success(); \
1873 }
1874#define CGSCC_ANALYSIS(NAME, CREATE_PASS) \
1875 if (Name == "require<" NAME ">") { \
1876 CGPM.addPass(RequireAnalysisPass< \
1877 std::remove_reference_t<decltype(CREATE_PASS)>, \
1878 LazyCallGraph::SCC, CGSCCAnalysisManager, LazyCallGraph &, \
1879 CGSCCUpdateResult &>()); \
1880 return Error::success(); \
1881 } \
1882 if (Name == "invalidate<" NAME ">") { \
1883 CGPM.addPass(InvalidateAnalysisPass< \
1884 std::remove_reference_t<decltype(CREATE_PASS)>>()); \
1885 return Error::success(); \
1886 }
1887#define FUNCTION_PASS(NAME, CREATE_PASS) \
1888 if (Name == NAME) { \
1889 CGPM.addPass(createCGSCCToFunctionPassAdaptor(CREATE_PASS)); \
1890 return Error::success(); \
1891 }
1892#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1893 if (checkParametrizedPassName(Name, NAME)) { \
1894 auto Params = parsePassParameters(PARSER, Name, NAME); \
1895 if (!Params) \
1896 return Params.takeError(); \
1897 CGPM.addPass(createCGSCCToFunctionPassAdaptor(CREATE_PASS(Params.get()))); \
1898 return Error::success(); \
1899 }
1900#define LOOPNEST_PASS(NAME, CREATE_PASS) \
1901 if (Name == NAME) { \
1902 CGPM.addPass(createCGSCCToFunctionPassAdaptor( \
1903 createFunctionToLoopPassAdaptor(CREATE_PASS, false, false))); \
1904 return Error::success(); \
1905 }
1906#define LOOP_PASS(NAME, CREATE_PASS) \
1907 if (Name == NAME) { \
1908 CGPM.addPass(createCGSCCToFunctionPassAdaptor( \
1909 createFunctionToLoopPassAdaptor(CREATE_PASS, false, false))); \
1910 return Error::success(); \
1911 }
1912#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1913 if (checkParametrizedPassName(Name, NAME)) { \
1914 auto Params = parsePassParameters(PARSER, Name, NAME); \
1915 if (!Params) \
1916 return Params.takeError(); \
1917 CGPM.addPass( \
1918 createCGSCCToFunctionPassAdaptor(createFunctionToLoopPassAdaptor( \
1919 CREATE_PASS(Params.get()), false, false))); \
1920 return Error::success(); \
1921 }
1922#include "PassRegistry.def"
1923
1924 for (auto &C : CGSCCPipelineParsingCallbacks)
1925 if (C(Name, CGPM, InnerPipeline))
1926 return Error::success();
1927 return make_error<StringError>(
1928 formatv("unknown cgscc pass '{0}'", Name).str(),
1930}
1931
1932Error PassBuilder::parseFunctionPass(FunctionPassManager &FPM,
1933 const PipelineElement &E) {
1934 auto &Name = E.Name;
1935 auto &InnerPipeline = E.InnerPipeline;
1936
1937 // First handle complex passes like the pass managers which carry pipelines.
1938 if (!InnerPipeline.empty()) {
1939 if (Name == "function") {
1940 FunctionPassManager NestedFPM;
1941 if (auto Err = parseFunctionPassPipeline(NestedFPM, InnerPipeline))
1942 return Err;
1943 // Add the nested pass manager with the appropriate adaptor.
1944 FPM.addPass(std::move(NestedFPM));
1945 return Error::success();
1946 }
1947 if (Name == "loop" || Name == "loop-mssa") {
1948 LoopPassManager LPM;
1949 if (auto Err = parseLoopPassPipeline(LPM, InnerPipeline))
1950 return Err;
1951 // Add the nested pass manager with the appropriate adaptor.
1952 bool UseMemorySSA = (Name == "loop-mssa");
1953 bool UseBFI = llvm::any_of(InnerPipeline, [](auto Pipeline) {
1954 return Pipeline.Name.contains("simple-loop-unswitch");
1955 });
1956 bool UseBPI = llvm::any_of(InnerPipeline, [](auto Pipeline) {
1957 return Pipeline.Name == "loop-predication";
1958 });
1959 FPM.addPass(createFunctionToLoopPassAdaptor(std::move(LPM), UseMemorySSA,
1960 UseBFI, UseBPI));
1961 return Error::success();
1962 }
1963 if (Name == "machine-function") {
1965 if (auto Err = parseMachinePassPipeline(MFPM, InnerPipeline))
1966 return Err;
1968 return Error::success();
1969 }
1970
1971 for (auto &C : FunctionPipelineParsingCallbacks)
1972 if (C(Name, FPM, InnerPipeline))
1973 return Error::success();
1974
1975 // Normal passes can't have pipelines.
1976 return make_error<StringError>(
1977 formatv("invalid use of '{0}' pass as function pipeline", Name).str(),
1979 }
1980
1981// Now expand the basic registered passes from the .inc file.
1982#define FUNCTION_PASS(NAME, CREATE_PASS) \
1983 if (Name == NAME) { \
1984 FPM.addPass(CREATE_PASS); \
1985 return Error::success(); \
1986 }
1987#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1988 if (checkParametrizedPassName(Name, NAME)) { \
1989 auto Params = parsePassParameters(PARSER, Name, NAME); \
1990 if (!Params) \
1991 return Params.takeError(); \
1992 FPM.addPass(CREATE_PASS(Params.get())); \
1993 return Error::success(); \
1994 }
1995#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
1996 if (Name == "require<" NAME ">") { \
1997 FPM.addPass( \
1998 RequireAnalysisPass< \
1999 std::remove_reference_t<decltype(CREATE_PASS)>, Function>()); \
2000 return Error::success(); \
2001 } \
2002 if (Name == "invalidate<" NAME ">") { \
2003 FPM.addPass(InvalidateAnalysisPass< \
2004 std::remove_reference_t<decltype(CREATE_PASS)>>()); \
2005 return Error::success(); \
2006 }
2007// FIXME: UseMemorySSA is set to false. Maybe we could do things like:
2008// bool UseMemorySSA = !("canon-freeze" || "loop-predication" ||
2009// "guard-widening");
2010// The risk is that it may become obsolete if we're not careful.
2011#define LOOPNEST_PASS(NAME, CREATE_PASS) \
2012 if (Name == NAME) { \
2013 FPM.addPass(createFunctionToLoopPassAdaptor(CREATE_PASS, false, false)); \
2014 return Error::success(); \
2015 }
2016#define LOOP_PASS(NAME, CREATE_PASS) \
2017 if (Name == NAME) { \
2018 FPM.addPass(createFunctionToLoopPassAdaptor(CREATE_PASS, false, false)); \
2019 return Error::success(); \
2020 }
2021#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2022 if (checkParametrizedPassName(Name, NAME)) { \
2023 auto Params = parsePassParameters(PARSER, Name, NAME); \
2024 if (!Params) \
2025 return Params.takeError(); \
2026 FPM.addPass(createFunctionToLoopPassAdaptor(CREATE_PASS(Params.get()), \
2027 false, false)); \
2028 return Error::success(); \
2029 }
2030#include "PassRegistry.def"
2031
2032 for (auto &C : FunctionPipelineParsingCallbacks)
2033 if (C(Name, FPM, InnerPipeline))
2034 return Error::success();
2035 return make_error<StringError>(
2036 formatv("unknown function pass '{0}'", Name).str(),
2038}
2039
2040Error PassBuilder::parseLoopPass(LoopPassManager &LPM,
2041 const PipelineElement &E) {
2042 StringRef Name = E.Name;
2043 auto &InnerPipeline = E.InnerPipeline;
2044
2045 // First handle complex passes like the pass managers which carry pipelines.
2046 if (!InnerPipeline.empty()) {
2047 if (Name == "loop") {
2048 LoopPassManager NestedLPM;
2049 if (auto Err = parseLoopPassPipeline(NestedLPM, InnerPipeline))
2050 return Err;
2051 // Add the nested pass manager with the appropriate adaptor.
2052 LPM.addPass(std::move(NestedLPM));
2053 return Error::success();
2054 }
2055
2056 for (auto &C : LoopPipelineParsingCallbacks)
2057 if (C(Name, LPM, InnerPipeline))
2058 return Error::success();
2059
2060 // Normal passes can't have pipelines.
2061 return make_error<StringError>(
2062 formatv("invalid use of '{0}' pass as loop pipeline", Name).str(),
2064 }
2065
2066// Now expand the basic registered passes from the .inc file.
2067#define LOOPNEST_PASS(NAME, CREATE_PASS) \
2068 if (Name == NAME) { \
2069 LPM.addPass(CREATE_PASS); \
2070 return Error::success(); \
2071 }
2072#define LOOP_PASS(NAME, CREATE_PASS) \
2073 if (Name == NAME) { \
2074 LPM.addPass(CREATE_PASS); \
2075 return Error::success(); \
2076 }
2077#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2078 if (checkParametrizedPassName(Name, NAME)) { \
2079 auto Params = parsePassParameters(PARSER, Name, NAME); \
2080 if (!Params) \
2081 return Params.takeError(); \
2082 LPM.addPass(CREATE_PASS(Params.get())); \
2083 return Error::success(); \
2084 }
2085#define LOOP_ANALYSIS(NAME, CREATE_PASS) \
2086 if (Name == "require<" NAME ">") { \
2087 LPM.addPass(RequireAnalysisPass< \
2088 std::remove_reference_t<decltype(CREATE_PASS)>, Loop, \
2089 LoopAnalysisManager, LoopStandardAnalysisResults &, \
2090 LPMUpdater &>()); \
2091 return Error::success(); \
2092 } \
2093 if (Name == "invalidate<" NAME ">") { \
2094 LPM.addPass(InvalidateAnalysisPass< \
2095 std::remove_reference_t<decltype(CREATE_PASS)>>()); \
2096 return Error::success(); \
2097 }
2098#include "PassRegistry.def"
2099
2100 for (auto &C : LoopPipelineParsingCallbacks)
2101 if (C(Name, LPM, InnerPipeline))
2102 return Error::success();
2103 return make_error<StringError>(formatv("unknown loop pass '{0}'", Name).str(),
2105}
2106
2107Error PassBuilder::parseMachinePass(MachineFunctionPassManager &MFPM,
2108 const PipelineElement &E) {
2109 StringRef Name = E.Name;
2110 if (!E.InnerPipeline.empty())
2111 return make_error<StringError>("invalid pipeline",
2113
2114#define MACHINE_MODULE_PASS(NAME, CREATE_PASS) \
2115 if (Name == NAME) { \
2116 MFPM.addPass(CREATE_PASS); \
2117 return Error::success(); \
2118 }
2119#define MACHINE_FUNCTION_PASS(NAME, CREATE_PASS) \
2120 if (Name == NAME) { \
2121 MFPM.addPass(CREATE_PASS); \
2122 return Error::success(); \
2123 }
2124#define MACHINE_FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, \
2125 PARAMS) \
2126 if (checkParametrizedPassName(Name, NAME)) { \
2127 auto Params = parsePassParameters(PARSER, Name, NAME); \
2128 if (!Params) \
2129 return Params.takeError(); \
2130 MFPM.addPass(CREATE_PASS(Params.get())); \
2131 return Error::success(); \
2132 }
2133#define MACHINE_FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
2134 if (Name == "require<" NAME ">") { \
2135 MFPM.addPass( \
2136 RequireAnalysisPass<std::remove_reference_t<decltype(CREATE_PASS)>, \
2137 MachineFunction>()); \
2138 return Error::success(); \
2139 } \
2140 if (Name == "invalidate<" NAME ">") { \
2141 MFPM.addPass(InvalidateAnalysisPass< \
2142 std::remove_reference_t<decltype(CREATE_PASS)>>()); \
2143 return Error::success(); \
2144 }
2145#include "llvm/Passes/MachinePassRegistry.def"
2146
2147 for (auto &C : MachineFunctionPipelineParsingCallbacks)
2148 if (C(Name, MFPM, E.InnerPipeline))
2149 return Error::success();
2150 return make_error<StringError>(
2151 formatv("unknown machine pass '{0}'", Name).str(),
2153}
2154
2155bool PassBuilder::parseAAPassName(AAManager &AA, StringRef Name) {
2156#define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS) \
2157 if (Name == NAME) { \
2158 AA.registerModuleAnalysis< \
2159 std::remove_reference_t<decltype(CREATE_PASS)>>(); \
2160 return true; \
2161 }
2162#define FUNCTION_ALIAS_ANALYSIS(NAME, CREATE_PASS) \
2163 if (Name == NAME) { \
2164 AA.registerFunctionAnalysis< \
2165 std::remove_reference_t<decltype(CREATE_PASS)>>(); \
2166 return true; \
2167 }
2168#include "PassRegistry.def"
2169
2170 for (auto &C : AAParsingCallbacks)
2171 if (C(Name, AA))
2172 return true;
2173 return false;
2174}
2175
2176Error PassBuilder::parseMachinePassPipeline(
2178 for (const auto &Element : Pipeline) {
2179 if (auto Err = parseMachinePass(MFPM, Element))
2180 return Err;
2181 }
2182 return Error::success();
2183}
2184
2185Error PassBuilder::parseLoopPassPipeline(LoopPassManager &LPM,
2186 ArrayRef<PipelineElement> Pipeline) {
2187 for (const auto &Element : Pipeline) {
2188 if (auto Err = parseLoopPass(LPM, Element))
2189 return Err;
2190 }
2191 return Error::success();
2192}
2193
2194Error PassBuilder::parseFunctionPassPipeline(
2196 for (const auto &Element : Pipeline) {
2197 if (auto Err = parseFunctionPass(FPM, Element))
2198 return Err;
2199 }
2200 return Error::success();
2201}
2202
2203Error PassBuilder::parseCGSCCPassPipeline(CGSCCPassManager &CGPM,
2204 ArrayRef<PipelineElement> Pipeline) {
2205 for (const auto &Element : Pipeline) {
2206 if (auto Err = parseCGSCCPass(CGPM, Element))
2207 return Err;
2208 }
2209 return Error::success();
2210}
2211
2224 if (MFAM) {
2226 [&] { return MachineFunctionAnalysisManagerModuleProxy(*MFAM); });
2228 [&] { return MachineFunctionAnalysisManagerFunctionProxy(*MFAM); });
2229 MFAM->registerPass(
2231 MFAM->registerPass(
2233 }
2234}
2235
2236Error PassBuilder::parseModulePassPipeline(ModulePassManager &MPM,
2237 ArrayRef<PipelineElement> Pipeline) {
2238 for (const auto &Element : Pipeline) {
2239 if (auto Err = parseModulePass(MPM, Element))
2240 return Err;
2241 }
2242 return Error::success();
2243}
2244
2245// Primary pass pipeline description parsing routine for a \c ModulePassManager
2246// FIXME: Should this routine accept a TargetMachine or require the caller to
2247// pre-populate the analysis managers with target-specific stuff?
2249 StringRef PipelineText) {
2250 auto Pipeline = parsePipelineText(PipelineText);
2251 if (!Pipeline || Pipeline->empty())
2252 return make_error<StringError>(
2253 formatv("invalid pipeline '{0}'", PipelineText).str(),
2255
2256 // If the first name isn't at the module layer, wrap the pipeline up
2257 // automatically.
2258 StringRef FirstName = Pipeline->front().Name;
2259
2260 if (!isModulePassName(FirstName, ModulePipelineParsingCallbacks)) {
2261 bool UseMemorySSA;
2262 if (isCGSCCPassName(FirstName, CGSCCPipelineParsingCallbacks)) {
2263 Pipeline = {{"cgscc", std::move(*Pipeline)}};
2264 } else if (isFunctionPassName(FirstName,
2265 FunctionPipelineParsingCallbacks)) {
2266 Pipeline = {{"function", std::move(*Pipeline)}};
2267 } else if (isLoopNestPassName(FirstName, LoopPipelineParsingCallbacks,
2268 UseMemorySSA)) {
2269 Pipeline = {{"function", {{UseMemorySSA ? "loop-mssa" : "loop",
2270 std::move(*Pipeline)}}}};
2271 } else if (isLoopPassName(FirstName, LoopPipelineParsingCallbacks,
2272 UseMemorySSA)) {
2273 Pipeline = {{"function", {{UseMemorySSA ? "loop-mssa" : "loop",
2274 std::move(*Pipeline)}}}};
2275 } else if (isMachineFunctionPassName(
2276 FirstName, MachineFunctionPipelineParsingCallbacks)) {
2277 Pipeline = {{"function", {{"machine-function", std::move(*Pipeline)}}}};
2278 } else {
2279 for (auto &C : TopLevelPipelineParsingCallbacks)
2280 if (C(MPM, *Pipeline))
2281 return Error::success();
2282
2283 // Unknown pass or pipeline name!
2284 auto &InnerPipeline = Pipeline->front().InnerPipeline;
2285 return make_error<StringError>(
2286 formatv("unknown {0} name '{1}'",
2287 (InnerPipeline.empty() ? "pass" : "pipeline"), FirstName)
2288 .str(),
2290 }
2291 }
2292
2293 if (auto Err = parseModulePassPipeline(MPM, *Pipeline))
2294 return Err;
2295 return Error::success();
2296}
2297
2298// Primary pass pipeline description parsing routine for a \c CGSCCPassManager
2300 StringRef PipelineText) {
2301 auto Pipeline = parsePipelineText(PipelineText);
2302 if (!Pipeline || Pipeline->empty())
2303 return make_error<StringError>(
2304 formatv("invalid pipeline '{0}'", PipelineText).str(),
2306
2307 StringRef FirstName = Pipeline->front().Name;
2308 if (!isCGSCCPassName(FirstName, CGSCCPipelineParsingCallbacks))
2309 return make_error<StringError>(
2310 formatv("unknown cgscc pass '{0}' in pipeline '{1}'", FirstName,
2311 PipelineText)
2312 .str(),
2314
2315 if (auto Err = parseCGSCCPassPipeline(CGPM, *Pipeline))
2316 return Err;
2317 return Error::success();
2318}
2319
2320// Primary pass pipeline description parsing routine for a \c
2321// FunctionPassManager
2323 StringRef PipelineText) {
2324 auto Pipeline = parsePipelineText(PipelineText);
2325 if (!Pipeline || Pipeline->empty())
2326 return make_error<StringError>(
2327 formatv("invalid pipeline '{0}'", PipelineText).str(),
2329
2330 StringRef FirstName = Pipeline->front().Name;
2331 if (!isFunctionPassName(FirstName, FunctionPipelineParsingCallbacks))
2332 return make_error<StringError>(
2333 formatv("unknown function pass '{0}' in pipeline '{1}'", FirstName,
2334 PipelineText)
2335 .str(),
2337
2338 if (auto Err = parseFunctionPassPipeline(FPM, *Pipeline))
2339 return Err;
2340 return Error::success();
2341}
2342
2343// Primary pass pipeline description parsing routine for a \c LoopPassManager
2345 StringRef PipelineText) {
2346 auto Pipeline = parsePipelineText(PipelineText);
2347 if (!Pipeline || Pipeline->empty())
2348 return make_error<StringError>(
2349 formatv("invalid pipeline '{0}'", PipelineText).str(),
2351
2352 if (auto Err = parseLoopPassPipeline(CGPM, *Pipeline))
2353 return Err;
2354
2355 return Error::success();
2356}
2357
2359 StringRef PipelineText) {
2360 auto Pipeline = parsePipelineText(PipelineText);
2361 if (!Pipeline || Pipeline->empty())
2362 return make_error<StringError>(
2363 formatv("invalid machine pass pipeline '{0}'", PipelineText).str(),
2365
2366 if (auto Err = parseMachinePassPipeline(MFPM, *Pipeline))
2367 return Err;
2368
2369 return Error::success();
2370}
2371
2373 // If the pipeline just consists of the word 'default' just replace the AA
2374 // manager with our default one.
2375 if (PipelineText == "default") {
2377 return Error::success();
2378 }
2379
2380 while (!PipelineText.empty()) {
2382 std::tie(Name, PipelineText) = PipelineText.split(',');
2383 if (!parseAAPassName(AA, Name))
2384 return make_error<StringError>(
2385 formatv("unknown alias analysis name '{0}'", Name).str(),
2387 }
2388
2389 return Error::success();
2390}
2391
2392std::optional<RegAllocFilterFunc>
2394 if (FilterName == "all")
2395 return nullptr;
2396 for (auto &C : RegClassFilterParsingCallbacks)
2397 if (auto F = C(FilterName))
2398 return F;
2399 return std::nullopt;
2400}
2401
2403 OS << " " << PassName << "\n";
2404}
2406 raw_ostream &OS) {
2407 OS << " " << PassName << "<" << Params << ">\n";
2408}
2409
2411 // TODO: print pass descriptions when they are available
2412
2413 OS << "Module passes:\n";
2414#define MODULE_PASS(NAME, CREATE_PASS) printPassName(NAME, OS);
2415#include "PassRegistry.def"
2416
2417 OS << "Module passes with params:\n";
2418#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2419 printPassName(NAME, PARAMS, OS);
2420#include "PassRegistry.def"
2421
2422 OS << "Module analyses:\n";
2423#define MODULE_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
2424#include "PassRegistry.def"
2425
2426 OS << "Module alias analyses:\n";
2427#define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
2428#include "PassRegistry.def"
2429
2430 OS << "CGSCC passes:\n";
2431#define CGSCC_PASS(NAME, CREATE_PASS) printPassName(NAME, OS);
2432#include "PassRegistry.def"
2433
2434 OS << "CGSCC passes with params:\n";
2435#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2436 printPassName(NAME, PARAMS, OS);
2437#include "PassRegistry.def"
2438
2439 OS << "CGSCC analyses:\n";
2440#define CGSCC_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
2441#include "PassRegistry.def"
2442
2443 OS << "Function passes:\n";
2444#define FUNCTION_PASS(NAME, CREATE_PASS) printPassName(NAME, OS);
2445#include "PassRegistry.def"
2446
2447 OS << "Function passes with params:\n";
2448#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2449 printPassName(NAME, PARAMS, OS);
2450#include "PassRegistry.def"
2451
2452 OS << "Function analyses:\n";
2453#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
2454#include "PassRegistry.def"
2455
2456 OS << "Function alias analyses:\n";
2457#define FUNCTION_ALIAS_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
2458#include "PassRegistry.def"
2459
2460 OS << "LoopNest passes:\n";
2461#define LOOPNEST_PASS(NAME, CREATE_PASS) printPassName(NAME, OS);
2462#include "PassRegistry.def"
2463
2464 OS << "Loop passes:\n";
2465#define LOOP_PASS(NAME, CREATE_PASS) printPassName(NAME, OS);
2466#include "PassRegistry.def"
2467
2468 OS << "Loop passes with params:\n";
2469#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2470 printPassName(NAME, PARAMS, OS);
2471#include "PassRegistry.def"
2472
2473 OS << "Loop analyses:\n";
2474#define LOOP_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
2475#include "PassRegistry.def"
2476
2477 OS << "Machine module passes (WIP):\n";
2478#define MACHINE_MODULE_PASS(NAME, CREATE_PASS) printPassName(NAME, OS);
2479#include "llvm/Passes/MachinePassRegistry.def"
2480
2481 OS << "Machine function passes (WIP):\n";
2482#define MACHINE_FUNCTION_PASS(NAME, CREATE_PASS) printPassName(NAME, OS);
2483#include "llvm/Passes/MachinePassRegistry.def"
2484
2485 OS << "Machine function analyses (WIP):\n";
2486#define MACHINE_FUNCTION_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
2487#include "llvm/Passes/MachinePassRegistry.def"
2488}
2489
2491 const std::function<bool(ModulePassManager &, ArrayRef<PipelineElement>)>
2492 &C) {
2493 TopLevelPipelineParsingCallbacks.push_back(C);
2494}
unsigned const MachineRegisterInfo * MRI
AggressiveInstCombiner - Combine expression patterns to form expressions with fewer,...
This file implements a simple N^2 alias analysis accuracy evaluator.
Provides passes to inlining "always_inline" functions.
This is the interface for LLVM's primary stateless and local alias analysis.
This file provides the interface for LLVM's Call Graph Profile pass.
This header provides classes for managing passes over SCCs of the call graph.
This file provides interfaces used to build and manipulate a call graph, which is a very useful tool ...
Defines an IR pass for CodeGen Prepare.
This file declares an analysis pass that computes CycleInfo for LLVM IR, specialized from GenericCycl...
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 ...
This file provides a pass manager that only runs its passes if the provided marker analysis has been ...
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.
#define _
AcceleratorCodeSelection - Identify all functions reachable from a kernel, removing those that are un...
This file defines passes to print out IR in various granularities.
This header defines various interfaces for pass management in LLVM.
Interfaces for passes which infer implicit function attributes from the name and signature of functio...
This file provides the primary interface to the instcombine pass.
Defines passes for running instruction simplification across chunks of IR.
This file provides the interface for LLVM's PGO Instrumentation lowering pass.
This file contains the declaration of the InterleavedAccessPass class, its corresponding pass name is...
See the comments on JumpThreadingPass.
static LVOptions Options
Definition: LVOptions.cpp:25
Implements a lazy call graph analysis and related passes for the new pass manager.
This file defines the interface for the loop cache analysis.
This file provides the interface for LLVM's Loop Data Prefetching Pass.
This file implements the Loop Fusion pass.
This header defines the LoopLoadEliminationPass object.
This file defines the interface for the loop nest analysis.
This header provides classes for managing a pipeline of passes over loops in LLVM IR.
This file provides the interface for the pass responsible for removing expensive ubsan checks.
The header file for the LowerConstantIntrinsics pass as used by the new pass manager.
The header file for the LowerExpectIntrinsic pass as used by the new pass manager.
#define F(x, y, z)
Definition: MD5.cpp:55
UseBFI
Definition: MachineLICM.cpp:89
===- MachineOptimizationRemarkEmitter.h - Opt Diagnostics -*- C++ -*-—===//
This file exposes an interface to building/using memory SSA to walk memory instructions using a use/d...
This pass performs merges of loads and stores on both sides of a.
This is the interface to build a ModuleSummaryIndex for a module.
Contains a collection of routines for determining if a given instruction is guaranteed to execute if ...
This file provides the interface for LLVM's Global Value Numbering pass.
This file declares a simple ARC-aware AliasAnalysis using special knowledge of Objective C to enhance...
This header enumerates the LLVM-provided high-level optimization levels.
This file provides the interface for IR based instrumentation passes ( (profile-gen,...
CGSCCAnalysisManager CGAM
LoopAnalysisManager LAM
FunctionAnalysisManager FAM
ModuleAnalysisManager MAM
PassInstrumentationCallbacks PIC
PassBuilder PB(Machine, PassOpts->PTO, std::nullopt, &PIC)
static bool isModulePassName(StringRef Name, CallbacksT &Callbacks)
static bool callbacksAcceptPassName(StringRef Name, CallbacksT &Callbacks)
Tests whether registered callbacks will accept a given pass name.
static std::optional< int > parseDevirtPassName(StringRef Name)
static bool startsWithDefaultPipelineAliasPrefix(StringRef Name)
Tests whether a pass name starts with a valid prefix for a default pipeline alias.
static bool isLoopNestPassName(StringRef Name, CallbacksT &Callbacks, bool &UseMemorySSA)
static bool isMachineFunctionPassName(StringRef Name, CallbacksT &Callbacks)
static std::optional< OptimizationLevel > parseOptLevel(StringRef S)
static bool isLoopPassName(StringRef Name, CallbacksT &Callbacks, bool &UseMemorySSA)
static std::optional< std::pair< bool, bool > > parseFunctionPipelineName(StringRef Name)
static bool isCGSCCPassName(StringRef Name, CallbacksT &Callbacks)
static void printPassName(StringRef PassName, raw_ostream &OS)
static bool isFunctionPassName(StringRef Name, CallbacksT &Callbacks)
static const Regex DefaultAliasRegex("^(default|thinlto-pre-link|thinlto|lto-pre-link|lto)<(O[0123sz])>$")
This file implements the PredicateInfo analysis, which creates an Extended SSA form for operations us...
This pass is required to take advantage of the interprocedural register allocation infrastructure.
This file implements relative lookup table converter that converts lookup tables to relative lookup t...
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file provides the interface for LLVM's Scalar Replacement of Aggregates pass.
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:78
uint64_t getZExtValue() const
Get zero extended value.
Definition: APInt.h:1520
int64_t getSExtValue() const
Get sign extended value.
Definition: APInt.h:1542
A container for analyses that lazily runs them and caches their results.
Definition: PassManager.h:253
bool registerPass(PassBuilderT &&PassBuilder)
Register an analysis pass with the manager.
Definition: PassManager.h:471
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:61
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:240
Lightweight error class with error context and mandatory checking.
Definition: Error.h:160
static ErrorSuccess success()
Create a success value.
Definition: Error.h:337
Tagged union holding either a T or a Error.
Definition: Error.h:481
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:557
An analysis over an "outer" IR unit that provides access to an analysis manager over an "inner" IR un...
Definition: PassManager.h:567
static constexpr LLT scalar(unsigned SizeInBits)
Get a low-level scalar or aggregate "bag of bits".
Definition: LowLevelType.h:42
An RAII based helper class to modify MachineFunctionProperties when running pass.
Properties which a MachineFunction may have at a given point in time.
MachineFunctionProperties & set(Property P)
MachineRegisterInfo & getRegInfo()
getRegInfo - Return information about the registers currently in use.
const MachineFunctionProperties & getProperties() const
Get the function properties.
A Module instance is used to store all the information related to an LLVM module.
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.
This class provides access to building LLVM's passes.
Definition: PassBuilder.h:105
void printPassNames(raw_ostream &OS)
Print pass names.
static bool checkParametrizedPassName(StringRef Name, StringRef PassName)
Definition: PassBuilder.h:663
AAManager buildDefaultAAPipeline()
Build the default AAManager with the default alias analysis pipeline registered.
Error parseAAPipeline(AAManager &AA, StringRef PipelineText)
Parse a textual alias analysis pipeline into the provided AA manager.
ModulePassManager buildThinLTOPreLinkDefaultPipeline(OptimizationLevel Level)
Build a pre-link, ThinLTO-targeting default optimization pipeline to a pass manager.
PassBuilder(TargetMachine *TM=nullptr, PipelineTuningOptions PTO=PipelineTuningOptions(), std::optional< PGOOptions > PGOOpt=std::nullopt, PassInstrumentationCallbacks *PIC=nullptr)
void registerLoopAnalyses(LoopAnalysisManager &LAM)
Registers all available loop analysis passes.
std::optional< RegAllocFilterFunc > parseRegAllocFilter(StringRef RegAllocFilterName)
Parse RegAllocFilterName to get RegAllocFilterFunc.
void crossRegisterProxies(LoopAnalysisManager &LAM, FunctionAnalysisManager &FAM, CGSCCAnalysisManager &CGAM, ModuleAnalysisManager &MAM, MachineFunctionAnalysisManager *MFAM=nullptr)
Cross register the analysis managers through their proxies.
ModulePassManager buildPerModuleDefaultPipeline(OptimizationLevel Level, ThinOrFullLTOPhase Phase=ThinOrFullLTOPhase::None)
Build a per-module default optimization pipeline.
Error parsePassPipeline(ModulePassManager &MPM, StringRef PipelineText)
Parse a textual pass pipeline description into a ModulePassManager.
ModulePassManager buildLTODefaultPipeline(OptimizationLevel Level, ModuleSummaryIndex *ExportSummary)
Build an LTO default optimization pipeline to a pass manager.
ModulePassManager buildThinLTODefaultPipeline(OptimizationLevel Level, const ModuleSummaryIndex *ImportSummary)
Build a ThinLTO default optimization pipeline to a pass manager.
void registerModuleAnalyses(ModuleAnalysisManager &MAM)
Registers all available module analysis passes.
void registerCGSCCAnalyses(CGSCCAnalysisManager &CGAM)
Registers all available CGSCC analysis passes.
static Expected< bool > parseSinglePassOption(StringRef Params, StringRef OptionName, StringRef PassName)
Handle passes only accept one bool-valued parameter.
void registerMachineFunctionAnalyses(MachineFunctionAnalysisManager &MFAM)
Registers all available machine function analysis passes.
void registerParseTopLevelPipelineCallback(const std::function< bool(ModulePassManager &, ArrayRef< PipelineElement >)> &C)
Register a callback for a top-level pipeline entry.
ModulePassManager buildLTOPreLinkDefaultPipeline(OptimizationLevel Level)
Build a pre-link, LTO-targeting default optimization pipeline to a pass manager.
void registerFunctionAnalyses(FunctionAnalysisManager &FAM)
Registers all available function analysis passes.
LLVM_ATTRIBUTE_MINSIZE std::enable_if_t< is_detected< HasRunOnLoopT, PassT >::value > addPass(PassT &&Pass)
LLVM_ATTRIBUTE_MINSIZE std::enable_if_t<!std::is_same_v< PassT, PassManager > > addPass(PassT &&Pass)
Definition: PassManager.h:195
Tunable parameters for passes in the default pipelines.
Definition: PassBuilder.h:43
bool SLPVectorization
Tuning option to enable/disable slp loop vectorization, set based on opt level.
Definition: PassBuilder.h:58
bool LoopVectorization
Tuning option to enable/disable loop vectorization, set based on opt level.
Definition: PassBuilder.h:54
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:686
A set of analyses that are preserved following a run of a transformation pass.
Definition: Analysis.h:111
static PreservedAnalyses none()
Convenience factory function for the empty preserved set.
Definition: Analysis.h:114
static PreservedAnalyses all()
Construct a special preserved set that preserves all passes.
Definition: Analysis.h:117
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:78
void push_back(const T &Elt)
Definition: SmallVector.h:413
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1196
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:51
std::pair< StringRef, StringRef > split(char Separator) const
Split into two substrings around the first occurrence of a separator character.
Definition: StringRef.h:700
bool getAsInteger(unsigned Radix, T &Result) const
Parse the current string as an integer of the specified radix.
Definition: StringRef.h:470
std::string str() const
str - Get the contents as an std::string.
Definition: StringRef.h:229
bool starts_with(StringRef Prefix) const
Check if this string starts with the given Prefix.
Definition: StringRef.h:265
constexpr bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:147
char front() const
front - Get the first character in the string.
Definition: StringRef.h:153
bool consume_front(StringRef Prefix)
Returns true if this StringRef has the given prefix and removes that prefix.
Definition: StringRef.h:635
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:80
This function has undefined behavior.
self_iterator getIterator()
Definition: ilist_node.h:132
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
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:852
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:98
OuterAnalysisManagerProxy< ModuleAnalysisManager, MachineFunction > ModuleAnalysisManagerMachineFunctionProxy
Provide the ModuleAnalysisManager to Function proxy.
OuterAnalysisManagerProxy< ModuleAnalysisManager, Function > ModuleAnalysisManagerFunctionProxy
Provide the ModuleAnalysisManager to Function proxy.
Definition: PassManager.h:802
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:1746
ModuleToPostOrderCGSCCPassAdaptor createModuleToPostOrderCGSCCPassAdaptor(CGSCCPassT &&Pass)
A function to deduce a function pass type and wrap it in the templated adaptor.
auto formatv(bool Validate, const char *Fmt, Ts &&...Vals)
CGSCCToFunctionPassAdaptor createCGSCCToFunctionPassAdaptor(FunctionPassT &&Pass, bool EagerlyInvalidate=false, bool NoRerun=false)
A function to deduce a function pass type and wrap it in the templated adaptor.
InnerAnalysisManagerProxy< FunctionAnalysisManager, Module > FunctionAnalysisManagerModuleProxy
Provide the FunctionAnalysisManager to Module proxy.
Definition: PassManager.h:648
FunctionToMachineFunctionPassAdaptor createFunctionToMachineFunctionPassAdaptor(MachineFunctionPassT &&Pass)
InnerAnalysisManagerProxy< MachineFunctionAnalysisManager, Function > MachineFunctionAnalysisManagerFunctionProxy
OuterAnalysisManagerProxy< FunctionAnalysisManager, Loop, LoopStandardAnalysisResults & > FunctionAnalysisManagerLoopProxy
A proxy from a FunctionAnalysisManager to a Loop.
cl::opt< bool > PrintPipelinePasses
Common option used by multiple tools to print pipeline passes.
OuterAnalysisManagerProxy< CGSCCAnalysisManager, Function > CGSCCAnalysisManagerFunctionProxy
A proxy from a CGSCCAnalysisManager to a Function.
std::enable_if_t< is_detected< HasRunOnLoopT, LoopPassT >::value, FunctionToLoopPassAdaptor > createFunctionToLoopPassAdaptor(LoopPassT &&Pass, bool UseMemorySSA=false, bool UseBlockFrequencyInfo=false, bool UseBranchProbabilityInfo=false)
A function to deduce a loop pass type and wrap it in the templated adaptor.
@ Detailed
Hash with opcode only.
@ CallTargetIgnored
Hash with opcode and operands.
@ Enable
Enable colors.
A special type used by analysis passes to provide an address that identifies that particular analysis...
Definition: Analysis.h:28
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:69
static StringRef name()
Gets the name of the pass we are mixed into.
Definition: PassManager.h:71
This class manages callbacks registration, as well as provides a way for PassInstrumentation to pass ...
RegAllocFilterFunc Filter
Definition: RegAllocFast.h:18