LLVM 20.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"
52#include "llvm/Analysis/Lint.h"
145#include "llvm/IR/DebugInfo.h"
146#include "llvm/IR/Dominators.h"
147#include "llvm/IR/PassManager.h"
148#include "llvm/IR/PrintPasses.h"
150#include "llvm/IR/Verifier.h"
154#include "llvm/Support/Debug.h"
157#include "llvm/Support/Regex.h"
346#include <optional>
347
348using namespace llvm;
349
351 "^(default|thinlto-pre-link|thinlto|lto-pre-link|lto)<(O[0123sz])>$");
352
353namespace llvm {
355 "print-pipeline-passes",
356 cl::desc("Print a '-passes' compatible string describing the pipeline "
357 "(best-effort only)."));
358} // namespace llvm
359
360AnalysisKey NoOpModuleAnalysis::Key;
361AnalysisKey NoOpCGSCCAnalysis::Key;
362AnalysisKey NoOpFunctionAnalysis::Key;
363AnalysisKey NoOpLoopAnalysis::Key;
364
365namespace {
366
367// Passes for testing crashes.
368// DO NOT USE THIS EXCEPT FOR TESTING!
369class TriggerCrashModulePass : public PassInfoMixin<TriggerCrashModulePass> {
370public:
372 abort();
373 return PreservedAnalyses::all();
374 }
375 static StringRef name() { return "TriggerCrashModulePass"; }
376};
377
378class TriggerCrashFunctionPass
379 : public PassInfoMixin<TriggerCrashFunctionPass> {
380public:
382 abort();
383 return PreservedAnalyses::all();
384 }
385 static StringRef name() { return "TriggerCrashFunctionPass"; }
386};
387
388// A pass for testing message reporting of -verify-each failures.
389// DO NOT USE THIS EXCEPT FOR TESTING!
390class TriggerVerifierErrorPass
391 : public PassInfoMixin<TriggerVerifierErrorPass> {
392public:
394 // Intentionally break the Module by creating an alias without setting the
395 // aliasee.
396 auto *PtrTy = llvm::PointerType::getUnqual(M.getContext());
397 GlobalAlias::create(PtrTy, PtrTy->getAddressSpace(),
398 GlobalValue::LinkageTypes::InternalLinkage,
399 "__bad_alias", nullptr, &M);
401 }
402
404 // Intentionally break the Function by inserting a terminator
405 // instruction in the middle of a basic block.
406 BasicBlock &BB = F.getEntryBlock();
407 new UnreachableInst(F.getContext(), BB.getTerminator()->getIterator());
409 }
410
412 // Intentionally create a virtual register and set NoVRegs property.
413 auto &MRI = MF.getRegInfo();
414 MRI.createGenericVirtualRegister(LLT::scalar(8));
415 MF.getProperties().set(MachineFunctionProperties::Property::NoVRegs);
416 return PreservedAnalyses::all();
417 }
418
419 static StringRef name() { return "TriggerVerifierErrorPass"; }
420};
421
422// A pass requires all MachineFunctionProperties.
423// DO NOT USE THIS EXCEPT FOR TESTING!
424class RequireAllMachineFunctionPropertiesPass
425 : public PassInfoMixin<RequireAllMachineFunctionPropertiesPass> {
426public:
428 MFPropsModifier _(*this, MF);
430 }
431
432 static MachineFunctionProperties getRequiredProperties() {
434 MFProps.set(MachineFunctionProperties::Property::FailedISel);
435 MFProps.set(MachineFunctionProperties::Property::FailsVerification);
436 MFProps.set(MachineFunctionProperties::Property::IsSSA);
437 MFProps.set(MachineFunctionProperties::Property::Legalized);
438 MFProps.set(MachineFunctionProperties::Property::NoPHIs);
439 MFProps.set(MachineFunctionProperties::Property::NoVRegs);
440 MFProps.set(MachineFunctionProperties::Property::RegBankSelected);
441 MFProps.set(MachineFunctionProperties::Property::Selected);
442 MFProps.set(MachineFunctionProperties::Property::TiedOpsRewritten);
443 MFProps.set(MachineFunctionProperties::Property::TracksDebugUserValues);
444 MFProps.set(MachineFunctionProperties::Property::TracksLiveness);
445 return MFProps;
446 }
447 static StringRef name() { return "RequireAllMachineFunctionPropertiesPass"; }
448};
449
450} // namespace
451
453 std::optional<PGOOptions> PGOOpt,
455 : TM(TM), PTO(PTO), PGOOpt(PGOOpt), PIC(PIC) {
456 if (TM)
457 TM->registerPassBuilderCallbacks(*this);
458 if (PIC) {
460 // MSVC requires this to be captured if it's used inside decltype.
461 // Other compilers consider it an unused lambda capture.
462 (void)this;
463#define MODULE_PASS(NAME, CREATE_PASS) \
464 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
465#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
466 PIC->addClassToPassName(CLASS, NAME);
467#define MODULE_ANALYSIS(NAME, CREATE_PASS) \
468 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
469#define FUNCTION_PASS(NAME, CREATE_PASS) \
470 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
471#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
472 PIC->addClassToPassName(CLASS, NAME);
473#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
474 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
475#define LOOPNEST_PASS(NAME, CREATE_PASS) \
476 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
477#define LOOP_PASS(NAME, CREATE_PASS) \
478 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
479#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
480 PIC->addClassToPassName(CLASS, NAME);
481#define LOOP_ANALYSIS(NAME, CREATE_PASS) \
482 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
483#define CGSCC_PASS(NAME, CREATE_PASS) \
484 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
485#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
486 PIC->addClassToPassName(CLASS, NAME);
487#define CGSCC_ANALYSIS(NAME, CREATE_PASS) \
488 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
489#include "PassRegistry.def"
490
491#define MACHINE_FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
492 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
493#define MACHINE_FUNCTION_PASS(NAME, CREATE_PASS) \
494 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
495#define MACHINE_FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, \
496 PARAMS) \
497 PIC->addClassToPassName(CLASS, NAME);
498#include "llvm/Passes/MachinePassRegistry.def"
499 });
500 }
501}
502
504#define MODULE_ANALYSIS(NAME, CREATE_PASS) \
505 MAM.registerPass([&] { return CREATE_PASS; });
506#include "PassRegistry.def"
507
508 for (auto &C : ModuleAnalysisRegistrationCallbacks)
509 C(MAM);
510}
511
513#define CGSCC_ANALYSIS(NAME, CREATE_PASS) \
514 CGAM.registerPass([&] { return CREATE_PASS; });
515#include "PassRegistry.def"
516
517 for (auto &C : CGSCCAnalysisRegistrationCallbacks)
518 C(CGAM);
519}
520
522 // We almost always want the default alias analysis pipeline.
523 // If a user wants a different one, they can register their own before calling
524 // registerFunctionAnalyses().
525 FAM.registerPass([&] { return buildDefaultAAPipeline(); });
526
527#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
528 FAM.registerPass([&] { return CREATE_PASS; });
529#include "PassRegistry.def"
530
531 for (auto &C : FunctionAnalysisRegistrationCallbacks)
532 C(FAM);
533}
534
537
538#define MACHINE_FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
539 MFAM.registerPass([&] { return CREATE_PASS; });
540#include "llvm/Passes/MachinePassRegistry.def"
541
542 for (auto &C : MachineFunctionAnalysisRegistrationCallbacks)
543 C(MFAM);
544}
545
547#define LOOP_ANALYSIS(NAME, CREATE_PASS) \
548 LAM.registerPass([&] { return CREATE_PASS; });
549#include "PassRegistry.def"
550
551 for (auto &C : LoopAnalysisRegistrationCallbacks)
552 C(LAM);
553}
554
555static std::optional<std::pair<bool, bool>>
557 std::pair<bool, bool> Params;
558 if (!Name.consume_front("function"))
559 return std::nullopt;
560 if (Name.empty())
561 return Params;
562 if (!Name.consume_front("<") || !Name.consume_back(">"))
563 return std::nullopt;
564 while (!Name.empty()) {
565 auto [Front, Back] = Name.split(';');
566 Name = Back;
567 if (Front == "eager-inv")
568 Params.first = true;
569 else if (Front == "no-rerun")
570 Params.second = true;
571 else
572 return std::nullopt;
573 }
574 return Params;
575}
576
577static std::optional<int> parseDevirtPassName(StringRef Name) {
578 if (!Name.consume_front("devirt<") || !Name.consume_back(">"))
579 return std::nullopt;
580 int Count;
581 if (Name.getAsInteger(0, Count) || Count < 0)
582 return std::nullopt;
583 return Count;
584}
585
586static std::optional<OptimizationLevel> parseOptLevel(StringRef S) {
588 .Case("O0", OptimizationLevel::O0)
594 .Default(std::nullopt);
595}
596
598 StringRef OptionName,
600 bool Result = false;
601 while (!Params.empty()) {
602 StringRef ParamName;
603 std::tie(ParamName, Params) = Params.split(';');
604
605 if (ParamName == OptionName) {
606 Result = true;
607 } else {
608 return make_error<StringError>(
609 formatv("invalid {1} pass parameter '{0}' ", ParamName, PassName)
610 .str(),
612 }
613 }
614 return Result;
615}
616
617namespace {
618
619/// Parser of parameters for HardwareLoops pass.
620Expected<HardwareLoopOptions> parseHardwareLoopOptions(StringRef Params) {
621 HardwareLoopOptions HardwareLoopOpts;
622
623 while (!Params.empty()) {
624 StringRef ParamName;
625 std::tie(ParamName, Params) = Params.split(';');
626 if (ParamName.consume_front("hardware-loop-decrement=")) {
627 int Count;
628 if (ParamName.getAsInteger(0, Count))
629 return make_error<StringError>(
630 formatv("invalid HardwareLoopPass parameter '{0}' ", ParamName).str(),
632 HardwareLoopOpts.setDecrement(Count);
633 continue;
634 }
635 if (ParamName.consume_front("hardware-loop-counter-bitwidth=")) {
636 int Count;
637 if (ParamName.getAsInteger(0, Count))
638 return make_error<StringError>(
639 formatv("invalid HardwareLoopPass parameter '{0}' ", ParamName).str(),
641 HardwareLoopOpts.setCounterBitwidth(Count);
642 continue;
643 }
644 if (ParamName == "force-hardware-loops") {
645 HardwareLoopOpts.setForce(true);
646 } else if (ParamName == "force-hardware-loop-phi") {
647 HardwareLoopOpts.setForcePhi(true);
648 } else if (ParamName == "force-nested-hardware-loop") {
649 HardwareLoopOpts.setForceNested(true);
650 } else if (ParamName == "force-hardware-loop-guard") {
651 HardwareLoopOpts.setForceGuard(true);
652 } else {
653 return make_error<StringError>(
654 formatv("invalid HardwarePass parameter '{0}' ", ParamName).str(),
656 }
657 }
658 return HardwareLoopOpts;
659}
660
661/// Parser of parameters for LoopUnroll pass.
662Expected<LoopUnrollOptions> parseLoopUnrollOptions(StringRef Params) {
663 LoopUnrollOptions UnrollOpts;
664 while (!Params.empty()) {
665 StringRef ParamName;
666 std::tie(ParamName, Params) = Params.split(';');
667 std::optional<OptimizationLevel> OptLevel = parseOptLevel(ParamName);
668 // Don't accept -Os/-Oz.
669 if (OptLevel && !OptLevel->isOptimizingForSize()) {
670 UnrollOpts.setOptLevel(OptLevel->getSpeedupLevel());
671 continue;
672 }
673 if (ParamName.consume_front("full-unroll-max=")) {
674 int Count;
675 if (ParamName.getAsInteger(0, Count))
676 return make_error<StringError>(
677 formatv("invalid LoopUnrollPass parameter '{0}' ", ParamName).str(),
679 UnrollOpts.setFullUnrollMaxCount(Count);
680 continue;
681 }
682
683 bool Enable = !ParamName.consume_front("no-");
684 if (ParamName == "partial") {
685 UnrollOpts.setPartial(Enable);
686 } else if (ParamName == "peeling") {
687 UnrollOpts.setPeeling(Enable);
688 } else if (ParamName == "profile-peeling") {
689 UnrollOpts.setProfileBasedPeeling(Enable);
690 } else if (ParamName == "runtime") {
691 UnrollOpts.setRuntime(Enable);
692 } else if (ParamName == "upperbound") {
693 UnrollOpts.setUpperBound(Enable);
694 } else {
695 return make_error<StringError>(
696 formatv("invalid LoopUnrollPass parameter '{0}' ", ParamName).str(),
698 }
699 }
700 return UnrollOpts;
701}
702
703Expected<bool> parseGlobalDCEPassOptions(StringRef Params) {
705 Params, "vfe-linkage-unit-visibility", "GlobalDCE");
706}
707
708Expected<bool> parseCGProfilePassOptions(StringRef Params) {
709 return PassBuilder::parseSinglePassOption(Params, "in-lto-post-link",
710 "CGProfile");
711}
712
713Expected<bool> parseInlinerPassOptions(StringRef Params) {
714 return PassBuilder::parseSinglePassOption(Params, "only-mandatory",
715 "InlinerPass");
716}
717
718Expected<bool> parseCoroSplitPassOptions(StringRef Params) {
719 return PassBuilder::parseSinglePassOption(Params, "reuse-storage",
720 "CoroSplitPass");
721}
722
723Expected<bool> parsePostOrderFunctionAttrsPassOptions(StringRef Params) {
725 Params, "skip-non-recursive-function-attrs", "PostOrderFunctionAttrs");
726}
727
728Expected<CFGuardPass::Mechanism> parseCFGuardPassOptions(StringRef Params) {
729 if (Params.empty())
731
732 auto [Param, RHS] = Params.split(';');
733 if (!RHS.empty())
734 return make_error<StringError>(
735 formatv("too many CFGuardPass parameters '{0}' ", Params).str(),
737
738 if (Param == "check")
740 if (Param == "dispatch")
742
743 return make_error<StringError>(
744 formatv("invalid CFGuardPass mechanism: '{0}' ", Param).str(),
746}
747
748Expected<bool> parseEarlyCSEPassOptions(StringRef Params) {
749 return PassBuilder::parseSinglePassOption(Params, "memssa", "EarlyCSE");
750}
751
752Expected<bool> parseEntryExitInstrumenterPassOptions(StringRef Params) {
753 return PassBuilder::parseSinglePassOption(Params, "post-inline",
754 "EntryExitInstrumenter");
755}
756
757Expected<bool> parseLoopExtractorPassOptions(StringRef Params) {
758 return PassBuilder::parseSinglePassOption(Params, "single", "LoopExtractor");
759}
760
761Expected<bool> parseLowerMatrixIntrinsicsPassOptions(StringRef Params) {
762 return PassBuilder::parseSinglePassOption(Params, "minimal",
763 "LowerMatrixIntrinsics");
764}
765
766Expected<AddressSanitizerOptions> parseASanPassOptions(StringRef Params) {
768 while (!Params.empty()) {
769 StringRef ParamName;
770 std::tie(ParamName, Params) = Params.split(';');
771
772 if (ParamName == "kernel") {
773 Result.CompileKernel = true;
774 } else {
775 return make_error<StringError>(
776 formatv("invalid AddressSanitizer pass parameter '{0}' ", ParamName)
777 .str(),
779 }
780 }
781 return Result;
782}
783
784Expected<HWAddressSanitizerOptions> parseHWASanPassOptions(StringRef Params) {
786 while (!Params.empty()) {
787 StringRef ParamName;
788 std::tie(ParamName, Params) = Params.split(';');
789
790 if (ParamName == "recover") {
791 Result.Recover = true;
792 } else if (ParamName == "kernel") {
793 Result.CompileKernel = true;
794 } else {
795 return make_error<StringError>(
796 formatv("invalid HWAddressSanitizer pass parameter '{0}' ", ParamName)
797 .str(),
799 }
800 }
801 return Result;
802}
803
804Expected<EmbedBitcodeOptions> parseEmbedBitcodePassOptions(StringRef Params) {
806 while (!Params.empty()) {
807 StringRef ParamName;
808 std::tie(ParamName, Params) = Params.split(';');
809
810 if (ParamName == "thinlto") {
811 Result.IsThinLTO = true;
812 } else if (ParamName == "emit-summary") {
813 Result.EmitLTOSummary = true;
814 } else {
815 return make_error<StringError>(
816 formatv("invalid EmbedBitcode pass parameter '{0}' ", ParamName)
817 .str(),
819 }
820 }
821 return Result;
822}
823
824Expected<MemorySanitizerOptions> parseMSanPassOptions(StringRef Params) {
826 while (!Params.empty()) {
827 StringRef ParamName;
828 std::tie(ParamName, Params) = Params.split(';');
829
830 if (ParamName == "recover") {
831 Result.Recover = true;
832 } else if (ParamName == "kernel") {
833 Result.Kernel = true;
834 } else if (ParamName.consume_front("track-origins=")) {
835 if (ParamName.getAsInteger(0, Result.TrackOrigins))
836 return make_error<StringError>(
837 formatv("invalid argument to MemorySanitizer pass track-origins "
838 "parameter: '{0}' ",
839 ParamName)
840 .str(),
842 } else if (ParamName == "eager-checks") {
843 Result.EagerChecks = true;
844 } else {
845 return make_error<StringError>(
846 formatv("invalid MemorySanitizer pass parameter '{0}' ", ParamName)
847 .str(),
849 }
850 }
851 return Result;
852}
853
854/// Parser of parameters for SimplifyCFG pass.
855Expected<SimplifyCFGOptions> parseSimplifyCFGOptions(StringRef Params) {
857 while (!Params.empty()) {
858 StringRef ParamName;
859 std::tie(ParamName, Params) = Params.split(';');
860
861 bool Enable = !ParamName.consume_front("no-");
862 if (ParamName == "speculate-blocks") {
863 Result.speculateBlocks(Enable);
864 } else if (ParamName == "simplify-cond-branch") {
865 Result.setSimplifyCondBranch(Enable);
866 } else if (ParamName == "forward-switch-cond") {
867 Result.forwardSwitchCondToPhi(Enable);
868 } else if (ParamName == "switch-range-to-icmp") {
869 Result.convertSwitchRangeToICmp(Enable);
870 } else if (ParamName == "switch-to-lookup") {
871 Result.convertSwitchToLookupTable(Enable);
872 } else if (ParamName == "keep-loops") {
873 Result.needCanonicalLoops(Enable);
874 } else if (ParamName == "hoist-common-insts") {
875 Result.hoistCommonInsts(Enable);
876 } else if (ParamName == "hoist-loads-stores-with-cond-faulting") {
877 Result.hoistLoadsStoresWithCondFaulting(Enable);
878 } else if (ParamName == "sink-common-insts") {
879 Result.sinkCommonInsts(Enable);
880 } else if (ParamName == "speculate-unpredictables") {
881 Result.speculateUnpredictables(Enable);
882 } else if (Enable && ParamName.consume_front("bonus-inst-threshold=")) {
883 APInt BonusInstThreshold;
884 if (ParamName.getAsInteger(0, BonusInstThreshold))
885 return make_error<StringError>(
886 formatv("invalid argument to SimplifyCFG pass bonus-threshold "
887 "parameter: '{0}' ",
888 ParamName).str(),
890 Result.bonusInstThreshold(BonusInstThreshold.getSExtValue());
891 } else {
892 return make_error<StringError>(
893 formatv("invalid SimplifyCFG pass parameter '{0}' ", ParamName).str(),
895 }
896 }
897 return Result;
898}
899
900Expected<InstCombineOptions> parseInstCombineOptions(StringRef Params) {
902 // When specifying "instcombine" in -passes enable fix-point verification by
903 // default, as this is what most tests should use.
904 Result.setVerifyFixpoint(true);
905 while (!Params.empty()) {
906 StringRef ParamName;
907 std::tie(ParamName, Params) = Params.split(';');
908
909 bool Enable = !ParamName.consume_front("no-");
910 if (ParamName == "verify-fixpoint") {
911 Result.setVerifyFixpoint(Enable);
912 } else if (Enable && ParamName.consume_front("max-iterations=")) {
913 APInt MaxIterations;
914 if (ParamName.getAsInteger(0, MaxIterations))
915 return make_error<StringError>(
916 formatv("invalid argument to InstCombine pass max-iterations "
917 "parameter: '{0}' ",
918 ParamName).str(),
920 Result.setMaxIterations((unsigned)MaxIterations.getZExtValue());
921 } else {
922 return make_error<StringError>(
923 formatv("invalid InstCombine pass parameter '{0}' ", ParamName).str(),
925 }
926 }
927 return Result;
928}
929
930/// Parser of parameters for LoopVectorize pass.
931Expected<LoopVectorizeOptions> parseLoopVectorizeOptions(StringRef Params) {
933 while (!Params.empty()) {
934 StringRef ParamName;
935 std::tie(ParamName, Params) = Params.split(';');
936
937 bool Enable = !ParamName.consume_front("no-");
938 if (ParamName == "interleave-forced-only") {
940 } else if (ParamName == "vectorize-forced-only") {
942 } else {
943 return make_error<StringError>(
944 formatv("invalid LoopVectorize parameter '{0}' ", ParamName).str(),
946 }
947 }
948 return Opts;
949}
950
951Expected<std::pair<bool, bool>> parseLoopUnswitchOptions(StringRef Params) {
952 std::pair<bool, bool> Result = {false, true};
953 while (!Params.empty()) {
954 StringRef ParamName;
955 std::tie(ParamName, Params) = Params.split(';');
956
957 bool Enable = !ParamName.consume_front("no-");
958 if (ParamName == "nontrivial") {
959 Result.first = Enable;
960 } else if (ParamName == "trivial") {
961 Result.second = Enable;
962 } else {
963 return make_error<StringError>(
964 formatv("invalid LoopUnswitch pass parameter '{0}' ", ParamName)
965 .str(),
967 }
968 }
969 return Result;
970}
971
972Expected<LICMOptions> parseLICMOptions(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 == "allowspeculation") {
980 Result.AllowSpeculation = Enable;
981 } else {
982 return make_error<StringError>(
983 formatv("invalid LICM pass parameter '{0}' ", ParamName).str(),
985 }
986 }
987 return Result;
988}
989
990Expected<std::pair<bool, bool>> parseLoopRotateOptions(StringRef Params) {
991 std::pair<bool, bool> Result = {true, false};
992 while (!Params.empty()) {
993 StringRef ParamName;
994 std::tie(ParamName, Params) = Params.split(';');
995
996 bool Enable = !ParamName.consume_front("no-");
997 if (ParamName == "header-duplication") {
998 Result.first = Enable;
999 } else if (ParamName == "prepare-for-lto") {
1000 Result.second = Enable;
1001 } else {
1002 return make_error<StringError>(
1003 formatv("invalid LoopRotate pass parameter '{0}' ", ParamName).str(),
1005 }
1006 }
1007 return Result;
1008}
1009
1010Expected<bool> parseMergedLoadStoreMotionOptions(StringRef Params) {
1011 bool Result = false;
1012 while (!Params.empty()) {
1013 StringRef ParamName;
1014 std::tie(ParamName, Params) = Params.split(';');
1015
1016 bool Enable = !ParamName.consume_front("no-");
1017 if (ParamName == "split-footer-bb") {
1018 Result = Enable;
1019 } else {
1020 return make_error<StringError>(
1021 formatv("invalid MergedLoadStoreMotion pass parameter '{0}' ",
1022 ParamName)
1023 .str(),
1025 }
1026 }
1027 return Result;
1028}
1029
1030Expected<GVNOptions> parseGVNOptions(StringRef Params) {
1032 while (!Params.empty()) {
1033 StringRef ParamName;
1034 std::tie(ParamName, Params) = Params.split(';');
1035
1036 bool Enable = !ParamName.consume_front("no-");
1037 if (ParamName == "pre") {
1038 Result.setPRE(Enable);
1039 } else if (ParamName == "load-pre") {
1040 Result.setLoadPRE(Enable);
1041 } else if (ParamName == "split-backedge-load-pre") {
1042 Result.setLoadPRESplitBackedge(Enable);
1043 } else if (ParamName == "memdep") {
1044 Result.setMemDep(Enable);
1045 } else {
1046 return make_error<StringError>(
1047 formatv("invalid GVN pass parameter '{0}' ", ParamName).str(),
1049 }
1050 }
1051 return Result;
1052}
1053
1054Expected<IPSCCPOptions> parseIPSCCPOptions(StringRef Params) {
1056 while (!Params.empty()) {
1057 StringRef ParamName;
1058 std::tie(ParamName, Params) = Params.split(';');
1059
1060 bool Enable = !ParamName.consume_front("no-");
1061 if (ParamName == "func-spec")
1062 Result.setFuncSpec(Enable);
1063 else
1064 return make_error<StringError>(
1065 formatv("invalid IPSCCP pass parameter '{0}' ", ParamName).str(),
1067 }
1068 return Result;
1069}
1070
1071Expected<ScalarizerPassOptions> parseScalarizerOptions(StringRef Params) {
1073 while (!Params.empty()) {
1074 StringRef ParamName;
1075 std::tie(ParamName, Params) = Params.split(';');
1076
1077 if (ParamName.consume_front("min-bits=")) {
1078 if (ParamName.getAsInteger(0, Result.ScalarizeMinBits)) {
1079 return make_error<StringError>(
1080 formatv("invalid argument to Scalarizer pass min-bits "
1081 "parameter: '{0}' ",
1082 ParamName)
1083 .str(),
1085 }
1086
1087 continue;
1088 }
1089
1090 bool Enable = !ParamName.consume_front("no-");
1091 if (ParamName == "load-store")
1092 Result.ScalarizeLoadStore = Enable;
1093 else if (ParamName == "variable-insert-extract")
1094 Result.ScalarizeVariableInsertExtract = Enable;
1095 else {
1096 return make_error<StringError>(
1097 formatv("invalid Scalarizer pass parameter '{0}' ", ParamName).str(),
1099 }
1100 }
1101
1102 return Result;
1103}
1104
1105Expected<SROAOptions> parseSROAOptions(StringRef Params) {
1106 if (Params.empty() || Params == "modify-cfg")
1108 if (Params == "preserve-cfg")
1110 return make_error<StringError>(
1111 formatv("invalid SROA pass parameter '{0}' (either preserve-cfg or "
1112 "modify-cfg can be specified)",
1113 Params)
1114 .str(),
1116}
1117
1119parseStackLifetimeOptions(StringRef Params) {
1121 while (!Params.empty()) {
1122 StringRef ParamName;
1123 std::tie(ParamName, Params) = Params.split(';');
1124
1125 if (ParamName == "may") {
1127 } else if (ParamName == "must") {
1129 } else {
1130 return make_error<StringError>(
1131 formatv("invalid StackLifetime parameter '{0}' ", ParamName).str(),
1133 }
1134 }
1135 return Result;
1136}
1137
1138Expected<bool> parseDependenceAnalysisPrinterOptions(StringRef Params) {
1139 return PassBuilder::parseSinglePassOption(Params, "normalized-results",
1140 "DependenceAnalysisPrinter");
1141}
1142
1143Expected<bool> parseSeparateConstOffsetFromGEPPassOptions(StringRef Params) {
1144 return PassBuilder::parseSinglePassOption(Params, "lower-gep",
1145 "SeparateConstOffsetFromGEP");
1146}
1147
1148Expected<bool> parseStructurizeCFGPassOptions(StringRef Params) {
1149 return PassBuilder::parseSinglePassOption(Params, "skip-uniform-regions",
1150 "StructurizeCFG");
1151}
1152
1154parseFunctionSimplificationPipelineOptions(StringRef Params) {
1155 std::optional<OptimizationLevel> L = parseOptLevel(Params);
1156 if (!L || *L == OptimizationLevel::O0) {
1157 return make_error<StringError>(
1158 formatv("invalid function-simplification parameter '{0}' ", Params)
1159 .str(),
1161 };
1162 return *L;
1163}
1164
1165Expected<bool> parseMemorySSAPrinterPassOptions(StringRef Params) {
1166 return PassBuilder::parseSinglePassOption(Params, "no-ensure-optimized-uses",
1167 "MemorySSAPrinterPass");
1168}
1169
1170Expected<bool> parseSpeculativeExecutionPassOptions(StringRef Params) {
1171 return PassBuilder::parseSinglePassOption(Params, "only-if-divergent-target",
1172 "SpeculativeExecutionPass");
1173}
1174
1175Expected<std::string> parseMemProfUsePassOptions(StringRef Params) {
1176 std::string Result;
1177 while (!Params.empty()) {
1178 StringRef ParamName;
1179 std::tie(ParamName, Params) = Params.split(';');
1180
1181 if (ParamName.consume_front("profile-filename=")) {
1182 Result = ParamName.str();
1183 } else {
1184 return make_error<StringError>(
1185 formatv("invalid MemProfUse pass parameter '{0}' ", ParamName).str(),
1187 }
1188 }
1189 return Result;
1190}
1191
1193parseStructuralHashPrinterPassOptions(StringRef Params) {
1194 if (Params.empty())
1196 if (Params == "detailed")
1198 if (Params == "call-target-ignored")
1200 return make_error<StringError>(
1201 formatv("invalid structural hash printer parameter '{0}' ", Params).str(),
1203}
1204
1205Expected<bool> parseWinEHPrepareOptions(StringRef Params) {
1206 return PassBuilder::parseSinglePassOption(Params, "demote-catchswitch-only",
1207 "WinEHPreparePass");
1208}
1209
1210Expected<GlobalMergeOptions> parseGlobalMergeOptions(StringRef Params) {
1212 while (!Params.empty()) {
1213 StringRef ParamName;
1214 std::tie(ParamName, Params) = Params.split(';');
1215
1216 bool Enable = !ParamName.consume_front("no-");
1217 if (ParamName == "group-by-use")
1218 Result.GroupByUse = Enable;
1219 else if (ParamName == "ignore-single-use")
1220 Result.IgnoreSingleUse = Enable;
1221 else if (ParamName == "merge-const")
1222 Result.MergeConst = Enable;
1223 else if (ParamName == "merge-external")
1224 Result.MergeExternal = Enable;
1225 else if (ParamName.consume_front("max-offset=")) {
1226 if (ParamName.getAsInteger(0, Result.MaxOffset))
1227 return make_error<StringError>(
1228 formatv("invalid GlobalMergePass parameter '{0}' ", ParamName)
1229 .str(),
1231 }
1232 }
1233 return Result;
1234}
1235
1236Expected<SmallVector<std::string, 0>> parseInternalizeGVs(StringRef Params) {
1237 SmallVector<std::string, 1> PreservedGVs;
1238 while (!Params.empty()) {
1239 StringRef ParamName;
1240 std::tie(ParamName, Params) = Params.split(';');
1241
1242 if (ParamName.consume_front("preserve-gv=")) {
1243 PreservedGVs.push_back(ParamName.str());
1244 } else {
1245 return make_error<StringError>(
1246 formatv("invalid Internalize pass parameter '{0}' ", ParamName).str(),
1248 }
1249 }
1250
1251 return Expected<SmallVector<std::string, 0>>(std::move(PreservedGVs));
1252}
1253
1255parseRegAllocFastPassOptions(PassBuilder &PB, StringRef Params) {
1257 while (!Params.empty()) {
1258 StringRef ParamName;
1259 std::tie(ParamName, Params) = Params.split(';');
1260
1261 if (ParamName.consume_front("filter=")) {
1262 std::optional<RegAllocFilterFunc> Filter =
1263 PB.parseRegAllocFilter(ParamName);
1264 if (!Filter) {
1265 return make_error<StringError>(
1266 formatv("invalid regallocfast register filter '{0}' ", ParamName)
1267 .str(),
1269 }
1270 Opts.Filter = *Filter;
1271 Opts.FilterName = ParamName;
1272 continue;
1273 }
1274
1275 if (ParamName == "no-clear-vregs") {
1276 Opts.ClearVRegs = false;
1277 continue;
1278 }
1279
1280 return make_error<StringError>(
1281 formatv("invalid regallocfast pass parameter '{0}' ", ParamName).str(),
1283 }
1284 return Opts;
1285}
1286
1288parseBoundsCheckingOptions(StringRef Params) {
1290 while (!Params.empty()) {
1291 StringRef ParamName;
1292 std::tie(ParamName, Params) = Params.split(';');
1293 if (ParamName == "trap") {
1294 Options.Rt = std::nullopt;
1295 } else if (ParamName == "rt") {
1296 Options.Rt = {
1297 /*MinRuntime=*/false,
1298 /*MayReturn=*/true,
1299 };
1300 } else if (ParamName == "rt-abort") {
1301 Options.Rt = {
1302 /*MinRuntime=*/false,
1303 /*MayReturn=*/false,
1304 };
1305 } else if (ParamName == "min-rt") {
1306 Options.Rt = {
1307 /*MinRuntime=*/true,
1308 /*MayReturn=*/true,
1309 };
1310 } else if (ParamName == "min-rt-abort") {
1311 Options.Rt = {
1312 /*MinRuntime=*/true,
1313 /*MayReturn=*/false,
1314 };
1315 } else if (ParamName == "merge") {
1316 Options.Merge = true;
1317 } else {
1318 StringRef ParamEQ;
1319 StringRef Val;
1320 std::tie(ParamEQ, Val) = ParamName.split('=');
1321 int8_t Id = 0;
1322 if (ParamEQ == "guard" && !Val.getAsInteger(0, Id)) {
1323 Options.GuardKind = Id;
1324 } else {
1325 return make_error<StringError>(
1326 formatv("invalid BoundsChecking pass parameter '{0}' ", ParamName)
1327 .str(),
1329 }
1330 }
1331 }
1332 return Options;
1333}
1334
1335} // namespace
1336
1337/// Tests whether a pass name starts with a valid prefix for a default pipeline
1338/// alias.
1340 return Name.starts_with("default") || Name.starts_with("thinlto") ||
1341 Name.starts_with("lto");
1342}
1343
1344/// Tests whether registered callbacks will accept a given pass name.
1345///
1346/// When parsing a pipeline text, the type of the outermost pipeline may be
1347/// omitted, in which case the type is automatically determined from the first
1348/// pass name in the text. This may be a name that is handled through one of the
1349/// callbacks. We check this through the oridinary parsing callbacks by setting
1350/// up a dummy PassManager in order to not force the client to also handle this
1351/// type of query.
1352template <typename PassManagerT, typename CallbacksT>
1353static bool callbacksAcceptPassName(StringRef Name, CallbacksT &Callbacks) {
1354 if (!Callbacks.empty()) {
1355 PassManagerT DummyPM;
1356 for (auto &CB : Callbacks)
1357 if (CB(Name, DummyPM, {}))
1358 return true;
1359 }
1360 return false;
1361}
1362
1363template <typename CallbacksT>
1364static bool isModulePassName(StringRef Name, CallbacksT &Callbacks) {
1365 // Manually handle aliases for pre-configured pipeline fragments.
1368
1369 StringRef NameNoBracket = Name.take_until([](char C) { return C == '<'; });
1370
1371 // Explicitly handle pass manager names.
1372 if (Name == "module")
1373 return true;
1374 if (Name == "cgscc")
1375 return true;
1376 if (NameNoBracket == "function")
1377 return true;
1378 if (Name == "coro-cond")
1379 return true;
1380
1381#define MODULE_PASS(NAME, CREATE_PASS) \
1382 if (Name == NAME) \
1383 return true;
1384#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1385 if (PassBuilder::checkParametrizedPassName(Name, NAME)) \
1386 return true;
1387#define MODULE_ANALYSIS(NAME, CREATE_PASS) \
1388 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \
1389 return true;
1390#include "PassRegistry.def"
1391
1392 return callbacksAcceptPassName<ModulePassManager>(Name, Callbacks);
1393}
1394
1395template <typename CallbacksT>
1396static bool isCGSCCPassName(StringRef Name, CallbacksT &Callbacks) {
1397 // Explicitly handle pass manager names.
1398 StringRef NameNoBracket = Name.take_until([](char C) { return C == '<'; });
1399 if (Name == "cgscc")
1400 return true;
1401 if (NameNoBracket == "function")
1402 return true;
1403
1404 // Explicitly handle custom-parsed pass names.
1406 return true;
1407
1408#define CGSCC_PASS(NAME, CREATE_PASS) \
1409 if (Name == NAME) \
1410 return true;
1411#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1412 if (PassBuilder::checkParametrizedPassName(Name, NAME)) \
1413 return true;
1414#define CGSCC_ANALYSIS(NAME, CREATE_PASS) \
1415 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \
1416 return true;
1417#include "PassRegistry.def"
1418
1419 return callbacksAcceptPassName<CGSCCPassManager>(Name, Callbacks);
1420}
1421
1422template <typename CallbacksT>
1423static bool isFunctionPassName(StringRef Name, CallbacksT &Callbacks) {
1424 // Explicitly handle pass manager names.
1425 StringRef NameNoBracket = Name.take_until([](char C) { return C == '<'; });
1426 if (NameNoBracket == "function")
1427 return true;
1428 if (Name == "loop" || Name == "loop-mssa" || Name == "machine-function")
1429 return true;
1430
1431#define FUNCTION_PASS(NAME, CREATE_PASS) \
1432 if (Name == NAME) \
1433 return true;
1434#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1435 if (PassBuilder::checkParametrizedPassName(Name, NAME)) \
1436 return true;
1437#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
1438 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \
1439 return true;
1440#include "PassRegistry.def"
1441
1442 return callbacksAcceptPassName<FunctionPassManager>(Name, Callbacks);
1443}
1444
1445template <typename CallbacksT>
1446static bool isMachineFunctionPassName(StringRef Name, CallbacksT &Callbacks) {
1447 // Explicitly handle pass manager names.
1448 if (Name == "machine-function")
1449 return true;
1450
1451#define MACHINE_FUNCTION_PASS(NAME, CREATE_PASS) \
1452 if (Name == NAME) \
1453 return true;
1454#define MACHINE_FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, \
1455 PARAMS) \
1456 if (PassBuilder::checkParametrizedPassName(Name, NAME)) \
1457 return true;
1458
1459#define MACHINE_FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
1460 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \
1461 return true;
1462
1463#include "llvm/Passes/MachinePassRegistry.def"
1464
1465 return callbacksAcceptPassName<MachineFunctionPassManager>(Name, Callbacks);
1466}
1467
1468template <typename CallbacksT>
1469static bool isLoopNestPassName(StringRef Name, CallbacksT &Callbacks,
1470 bool &UseMemorySSA) {
1471 UseMemorySSA = false;
1472
1474 UseMemorySSA = true;
1475 return true;
1476 }
1477
1478#define LOOPNEST_PASS(NAME, CREATE_PASS) \
1479 if (Name == NAME) \
1480 return true;
1481#include "PassRegistry.def"
1482
1483 return callbacksAcceptPassName<LoopPassManager>(Name, Callbacks);
1484}
1485
1486template <typename CallbacksT>
1487static bool isLoopPassName(StringRef Name, CallbacksT &Callbacks,
1488 bool &UseMemorySSA) {
1489 UseMemorySSA = false;
1490
1492 UseMemorySSA = true;
1493 return true;
1494 }
1495
1496#define LOOP_PASS(NAME, CREATE_PASS) \
1497 if (Name == NAME) \
1498 return true;
1499#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1500 if (PassBuilder::checkParametrizedPassName(Name, NAME)) \
1501 return true;
1502#define LOOP_ANALYSIS(NAME, CREATE_PASS) \
1503 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \
1504 return true;
1505#include "PassRegistry.def"
1506
1507 return callbacksAcceptPassName<LoopPassManager>(Name, Callbacks);
1508}
1509
1510std::optional<std::vector<PassBuilder::PipelineElement>>
1511PassBuilder::parsePipelineText(StringRef Text) {
1512 std::vector<PipelineElement> ResultPipeline;
1513
1514 SmallVector<std::vector<PipelineElement> *, 4> PipelineStack = {
1515 &ResultPipeline};
1516 for (;;) {
1517 std::vector<PipelineElement> &Pipeline = *PipelineStack.back();
1518 size_t Pos = Text.find_first_of(",()");
1519 Pipeline.push_back({Text.substr(0, Pos), {}});
1520
1521 // If we have a single terminating name, we're done.
1522 if (Pos == Text.npos)
1523 break;
1524
1525 char Sep = Text[Pos];
1526 Text = Text.substr(Pos + 1);
1527 if (Sep == ',')
1528 // Just a name ending in a comma, continue.
1529 continue;
1530
1531 if (Sep == '(') {
1532 // Push the inner pipeline onto the stack to continue processing.
1533 PipelineStack.push_back(&Pipeline.back().InnerPipeline);
1534 continue;
1535 }
1536
1537 assert(Sep == ')' && "Bogus separator!");
1538 // When handling the close parenthesis, we greedily consume them to avoid
1539 // empty strings in the pipeline.
1540 do {
1541 // If we try to pop the outer pipeline we have unbalanced parentheses.
1542 if (PipelineStack.size() == 1)
1543 return std::nullopt;
1544
1545 PipelineStack.pop_back();
1546 } while (Text.consume_front(")"));
1547
1548 // Check if we've finished parsing.
1549 if (Text.empty())
1550 break;
1551
1552 // Otherwise, the end of an inner pipeline always has to be followed by
1553 // a comma, and then we can continue.
1554 if (!Text.consume_front(","))
1555 return std::nullopt;
1556 }
1557
1558 if (PipelineStack.size() > 1)
1559 // Unbalanced paretheses.
1560 return std::nullopt;
1561
1562 assert(PipelineStack.back() == &ResultPipeline &&
1563 "Wrong pipeline at the bottom of the stack!");
1564 return {std::move(ResultPipeline)};
1565}
1566
1567Error PassBuilder::parseModulePass(ModulePassManager &MPM,
1568 const PipelineElement &E) {
1569 auto &Name = E.Name;
1570 auto &InnerPipeline = E.InnerPipeline;
1571
1572 // First handle complex passes like the pass managers which carry pipelines.
1573 if (!InnerPipeline.empty()) {
1574 if (Name == "module") {
1575 ModulePassManager NestedMPM;
1576 if (auto Err = parseModulePassPipeline(NestedMPM, InnerPipeline))
1577 return Err;
1578 MPM.addPass(std::move(NestedMPM));
1579 return Error::success();
1580 }
1581 if (Name == "coro-cond") {
1582 ModulePassManager NestedMPM;
1583 if (auto Err = parseModulePassPipeline(NestedMPM, InnerPipeline))
1584 return Err;
1585 MPM.addPass(CoroConditionalWrapper(std::move(NestedMPM)));
1586 return Error::success();
1587 }
1588 if (Name == "cgscc") {
1589 CGSCCPassManager CGPM;
1590 if (auto Err = parseCGSCCPassPipeline(CGPM, InnerPipeline))
1591 return Err;
1593 return Error::success();
1594 }
1595 if (auto Params = parseFunctionPipelineName(Name)) {
1596 if (Params->second)
1597 return make_error<StringError>(
1598 "cannot have a no-rerun module to function adaptor",
1601 if (auto Err = parseFunctionPassPipeline(FPM, InnerPipeline))
1602 return Err;
1603 MPM.addPass(
1604 createModuleToFunctionPassAdaptor(std::move(FPM), Params->first));
1605 return Error::success();
1606 }
1607
1608 for (auto &C : ModulePipelineParsingCallbacks)
1609 if (C(Name, MPM, InnerPipeline))
1610 return Error::success();
1611
1612 // Normal passes can't have pipelines.
1613 return make_error<StringError>(
1614 formatv("invalid use of '{0}' pass as module pipeline", Name).str(),
1616 ;
1617 }
1618
1619 // Manually handle aliases for pre-configured pipeline fragments.
1622 if (!DefaultAliasRegex.match(Name, &Matches))
1623 return make_error<StringError>(
1624 formatv("unknown default pipeline alias '{0}'", Name).str(),
1626
1627 assert(Matches.size() == 3 && "Must capture two matched strings!");
1628
1629 OptimizationLevel L = *parseOptLevel(Matches[2]);
1630
1631 // This is consistent with old pass manager invoked via opt, but
1632 // inconsistent with clang. Clang doesn't enable loop vectorization
1633 // but does enable slp vectorization at Oz.
1634 PTO.LoopVectorization =
1635 L.getSpeedupLevel() > 1 && L != OptimizationLevel::Oz;
1636 PTO.SLPVectorization =
1637 L.getSpeedupLevel() > 1 && L != OptimizationLevel::Oz;
1638
1639 if (Matches[1] == "default") {
1641 } else if (Matches[1] == "thinlto-pre-link") {
1643 } else if (Matches[1] == "thinlto") {
1644 MPM.addPass(buildThinLTODefaultPipeline(L, nullptr));
1645 } else if (Matches[1] == "lto-pre-link") {
1646 if (PTO.UnifiedLTO)
1647 // When UnifiedLTO is enabled, use the ThinLTO pre-link pipeline. This
1648 // avoids compile-time performance regressions and keeps the pre-link
1649 // LTO pipeline "unified" for both LTO modes.
1651 else
1653 } else {
1654 assert(Matches[1] == "lto" && "Not one of the matched options!");
1655 MPM.addPass(buildLTODefaultPipeline(L, nullptr));
1656 }
1657 return Error::success();
1658 }
1659
1660 // Finally expand the basic registered passes from the .inc file.
1661#define MODULE_PASS(NAME, CREATE_PASS) \
1662 if (Name == NAME) { \
1663 MPM.addPass(CREATE_PASS); \
1664 return Error::success(); \
1665 }
1666#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1667 if (checkParametrizedPassName(Name, NAME)) { \
1668 auto Params = parsePassParameters(PARSER, Name, NAME); \
1669 if (!Params) \
1670 return Params.takeError(); \
1671 MPM.addPass(CREATE_PASS(Params.get())); \
1672 return Error::success(); \
1673 }
1674#define MODULE_ANALYSIS(NAME, CREATE_PASS) \
1675 if (Name == "require<" NAME ">") { \
1676 MPM.addPass( \
1677 RequireAnalysisPass< \
1678 std::remove_reference_t<decltype(CREATE_PASS)>, Module>()); \
1679 return Error::success(); \
1680 } \
1681 if (Name == "invalidate<" NAME ">") { \
1682 MPM.addPass(InvalidateAnalysisPass< \
1683 std::remove_reference_t<decltype(CREATE_PASS)>>()); \
1684 return Error::success(); \
1685 }
1686#define CGSCC_PASS(NAME, CREATE_PASS) \
1687 if (Name == NAME) { \
1688 MPM.addPass(createModuleToPostOrderCGSCCPassAdaptor(CREATE_PASS)); \
1689 return Error::success(); \
1690 }
1691#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1692 if (checkParametrizedPassName(Name, NAME)) { \
1693 auto Params = parsePassParameters(PARSER, Name, NAME); \
1694 if (!Params) \
1695 return Params.takeError(); \
1696 MPM.addPass( \
1697 createModuleToPostOrderCGSCCPassAdaptor(CREATE_PASS(Params.get()))); \
1698 return Error::success(); \
1699 }
1700#define FUNCTION_PASS(NAME, CREATE_PASS) \
1701 if (Name == NAME) { \
1702 MPM.addPass(createModuleToFunctionPassAdaptor(CREATE_PASS)); \
1703 return Error::success(); \
1704 }
1705#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1706 if (checkParametrizedPassName(Name, NAME)) { \
1707 auto Params = parsePassParameters(PARSER, Name, NAME); \
1708 if (!Params) \
1709 return Params.takeError(); \
1710 MPM.addPass(createModuleToFunctionPassAdaptor(CREATE_PASS(Params.get()))); \
1711 return Error::success(); \
1712 }
1713#define LOOPNEST_PASS(NAME, CREATE_PASS) \
1714 if (Name == NAME) { \
1715 MPM.addPass(createModuleToFunctionPassAdaptor( \
1716 createFunctionToLoopPassAdaptor(CREATE_PASS, false, false))); \
1717 return Error::success(); \
1718 }
1719#define LOOP_PASS(NAME, CREATE_PASS) \
1720 if (Name == NAME) { \
1721 MPM.addPass(createModuleToFunctionPassAdaptor( \
1722 createFunctionToLoopPassAdaptor(CREATE_PASS, false, false))); \
1723 return Error::success(); \
1724 }
1725#define LOOP_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 MPM.addPass( \
1731 createModuleToFunctionPassAdaptor(createFunctionToLoopPassAdaptor( \
1732 CREATE_PASS(Params.get()), false, false))); \
1733 return Error::success(); \
1734 }
1735#include "PassRegistry.def"
1736
1737 for (auto &C : ModulePipelineParsingCallbacks)
1738 if (C(Name, MPM, InnerPipeline))
1739 return Error::success();
1740 return make_error<StringError>(
1741 formatv("unknown module pass '{0}'", Name).str(),
1743}
1744
1745Error PassBuilder::parseCGSCCPass(CGSCCPassManager &CGPM,
1746 const PipelineElement &E) {
1747 auto &Name = E.Name;
1748 auto &InnerPipeline = E.InnerPipeline;
1749
1750 // First handle complex passes like the pass managers which carry pipelines.
1751 if (!InnerPipeline.empty()) {
1752 if (Name == "cgscc") {
1753 CGSCCPassManager NestedCGPM;
1754 if (auto Err = parseCGSCCPassPipeline(NestedCGPM, InnerPipeline))
1755 return Err;
1756 // Add the nested pass manager with the appropriate adaptor.
1757 CGPM.addPass(std::move(NestedCGPM));
1758 return Error::success();
1759 }
1760 if (auto Params = parseFunctionPipelineName(Name)) {
1762 if (auto Err = parseFunctionPassPipeline(FPM, InnerPipeline))
1763 return Err;
1764 // Add the nested pass manager with the appropriate adaptor.
1766 std::move(FPM), Params->first, Params->second));
1767 return Error::success();
1768 }
1769 if (auto MaxRepetitions = parseDevirtPassName(Name)) {
1770 CGSCCPassManager NestedCGPM;
1771 if (auto Err = parseCGSCCPassPipeline(NestedCGPM, InnerPipeline))
1772 return Err;
1773 CGPM.addPass(
1774 createDevirtSCCRepeatedPass(std::move(NestedCGPM), *MaxRepetitions));
1775 return Error::success();
1776 }
1777
1778 for (auto &C : CGSCCPipelineParsingCallbacks)
1779 if (C(Name, CGPM, InnerPipeline))
1780 return Error::success();
1781
1782 // Normal passes can't have pipelines.
1783 return make_error<StringError>(
1784 formatv("invalid use of '{0}' pass as cgscc pipeline", Name).str(),
1786 }
1787
1788// Now expand the basic registered passes from the .inc file.
1789#define CGSCC_PASS(NAME, CREATE_PASS) \
1790 if (Name == NAME) { \
1791 CGPM.addPass(CREATE_PASS); \
1792 return Error::success(); \
1793 }
1794#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1795 if (checkParametrizedPassName(Name, NAME)) { \
1796 auto Params = parsePassParameters(PARSER, Name, NAME); \
1797 if (!Params) \
1798 return Params.takeError(); \
1799 CGPM.addPass(CREATE_PASS(Params.get())); \
1800 return Error::success(); \
1801 }
1802#define CGSCC_ANALYSIS(NAME, CREATE_PASS) \
1803 if (Name == "require<" NAME ">") { \
1804 CGPM.addPass(RequireAnalysisPass< \
1805 std::remove_reference_t<decltype(CREATE_PASS)>, \
1806 LazyCallGraph::SCC, CGSCCAnalysisManager, LazyCallGraph &, \
1807 CGSCCUpdateResult &>()); \
1808 return Error::success(); \
1809 } \
1810 if (Name == "invalidate<" NAME ">") { \
1811 CGPM.addPass(InvalidateAnalysisPass< \
1812 std::remove_reference_t<decltype(CREATE_PASS)>>()); \
1813 return Error::success(); \
1814 }
1815#define FUNCTION_PASS(NAME, CREATE_PASS) \
1816 if (Name == NAME) { \
1817 CGPM.addPass(createCGSCCToFunctionPassAdaptor(CREATE_PASS)); \
1818 return Error::success(); \
1819 }
1820#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1821 if (checkParametrizedPassName(Name, NAME)) { \
1822 auto Params = parsePassParameters(PARSER, Name, NAME); \
1823 if (!Params) \
1824 return Params.takeError(); \
1825 CGPM.addPass(createCGSCCToFunctionPassAdaptor(CREATE_PASS(Params.get()))); \
1826 return Error::success(); \
1827 }
1828#define LOOPNEST_PASS(NAME, CREATE_PASS) \
1829 if (Name == NAME) { \
1830 CGPM.addPass(createCGSCCToFunctionPassAdaptor( \
1831 createFunctionToLoopPassAdaptor(CREATE_PASS, false, false))); \
1832 return Error::success(); \
1833 }
1834#define LOOP_PASS(NAME, CREATE_PASS) \
1835 if (Name == NAME) { \
1836 CGPM.addPass(createCGSCCToFunctionPassAdaptor( \
1837 createFunctionToLoopPassAdaptor(CREATE_PASS, false, false))); \
1838 return Error::success(); \
1839 }
1840#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1841 if (checkParametrizedPassName(Name, NAME)) { \
1842 auto Params = parsePassParameters(PARSER, Name, NAME); \
1843 if (!Params) \
1844 return Params.takeError(); \
1845 CGPM.addPass( \
1846 createCGSCCToFunctionPassAdaptor(createFunctionToLoopPassAdaptor( \
1847 CREATE_PASS(Params.get()), false, false))); \
1848 return Error::success(); \
1849 }
1850#include "PassRegistry.def"
1851
1852 for (auto &C : CGSCCPipelineParsingCallbacks)
1853 if (C(Name, CGPM, InnerPipeline))
1854 return Error::success();
1855 return make_error<StringError>(
1856 formatv("unknown cgscc pass '{0}'", Name).str(),
1858}
1859
1860Error PassBuilder::parseFunctionPass(FunctionPassManager &FPM,
1861 const PipelineElement &E) {
1862 auto &Name = E.Name;
1863 auto &InnerPipeline = E.InnerPipeline;
1864
1865 // First handle complex passes like the pass managers which carry pipelines.
1866 if (!InnerPipeline.empty()) {
1867 if (Name == "function") {
1868 FunctionPassManager NestedFPM;
1869 if (auto Err = parseFunctionPassPipeline(NestedFPM, InnerPipeline))
1870 return Err;
1871 // Add the nested pass manager with the appropriate adaptor.
1872 FPM.addPass(std::move(NestedFPM));
1873 return Error::success();
1874 }
1875 if (Name == "loop" || Name == "loop-mssa") {
1876 LoopPassManager LPM;
1877 if (auto Err = parseLoopPassPipeline(LPM, InnerPipeline))
1878 return Err;
1879 // Add the nested pass manager with the appropriate adaptor.
1880 bool UseMemorySSA = (Name == "loop-mssa");
1881 bool UseBFI = llvm::any_of(InnerPipeline, [](auto Pipeline) {
1882 return Pipeline.Name.contains("simple-loop-unswitch");
1883 });
1884 bool UseBPI = llvm::any_of(InnerPipeline, [](auto Pipeline) {
1885 return Pipeline.Name == "loop-predication";
1886 });
1887 FPM.addPass(createFunctionToLoopPassAdaptor(std::move(LPM), UseMemorySSA,
1888 UseBFI, UseBPI));
1889 return Error::success();
1890 }
1891 if (Name == "machine-function") {
1893 if (auto Err = parseMachinePassPipeline(MFPM, InnerPipeline))
1894 return Err;
1896 return Error::success();
1897 }
1898
1899 for (auto &C : FunctionPipelineParsingCallbacks)
1900 if (C(Name, FPM, InnerPipeline))
1901 return Error::success();
1902
1903 // Normal passes can't have pipelines.
1904 return make_error<StringError>(
1905 formatv("invalid use of '{0}' pass as function pipeline", Name).str(),
1907 }
1908
1909// Now expand the basic registered passes from the .inc file.
1910#define FUNCTION_PASS(NAME, CREATE_PASS) \
1911 if (Name == NAME) { \
1912 FPM.addPass(CREATE_PASS); \
1913 return Error::success(); \
1914 }
1915#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1916 if (checkParametrizedPassName(Name, NAME)) { \
1917 auto Params = parsePassParameters(PARSER, Name, NAME); \
1918 if (!Params) \
1919 return Params.takeError(); \
1920 FPM.addPass(CREATE_PASS(Params.get())); \
1921 return Error::success(); \
1922 }
1923#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
1924 if (Name == "require<" NAME ">") { \
1925 FPM.addPass( \
1926 RequireAnalysisPass< \
1927 std::remove_reference_t<decltype(CREATE_PASS)>, Function>()); \
1928 return Error::success(); \
1929 } \
1930 if (Name == "invalidate<" NAME ">") { \
1931 FPM.addPass(InvalidateAnalysisPass< \
1932 std::remove_reference_t<decltype(CREATE_PASS)>>()); \
1933 return Error::success(); \
1934 }
1935// FIXME: UseMemorySSA is set to false. Maybe we could do things like:
1936// bool UseMemorySSA = !("canon-freeze" || "loop-predication" ||
1937// "guard-widening");
1938// The risk is that it may become obsolete if we're not careful.
1939#define LOOPNEST_PASS(NAME, CREATE_PASS) \
1940 if (Name == NAME) { \
1941 FPM.addPass(createFunctionToLoopPassAdaptor(CREATE_PASS, false, false)); \
1942 return Error::success(); \
1943 }
1944#define LOOP_PASS(NAME, CREATE_PASS) \
1945 if (Name == NAME) { \
1946 FPM.addPass(createFunctionToLoopPassAdaptor(CREATE_PASS, false, false)); \
1947 return Error::success(); \
1948 }
1949#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1950 if (checkParametrizedPassName(Name, NAME)) { \
1951 auto Params = parsePassParameters(PARSER, Name, NAME); \
1952 if (!Params) \
1953 return Params.takeError(); \
1954 FPM.addPass(createFunctionToLoopPassAdaptor(CREATE_PASS(Params.get()), \
1955 false, false)); \
1956 return Error::success(); \
1957 }
1958#include "PassRegistry.def"
1959
1960 for (auto &C : FunctionPipelineParsingCallbacks)
1961 if (C(Name, FPM, InnerPipeline))
1962 return Error::success();
1963 return make_error<StringError>(
1964 formatv("unknown function pass '{0}'", Name).str(),
1966}
1967
1968Error PassBuilder::parseLoopPass(LoopPassManager &LPM,
1969 const PipelineElement &E) {
1970 StringRef Name = E.Name;
1971 auto &InnerPipeline = E.InnerPipeline;
1972
1973 // First handle complex passes like the pass managers which carry pipelines.
1974 if (!InnerPipeline.empty()) {
1975 if (Name == "loop") {
1976 LoopPassManager NestedLPM;
1977 if (auto Err = parseLoopPassPipeline(NestedLPM, InnerPipeline))
1978 return Err;
1979 // Add the nested pass manager with the appropriate adaptor.
1980 LPM.addPass(std::move(NestedLPM));
1981 return Error::success();
1982 }
1983
1984 for (auto &C : LoopPipelineParsingCallbacks)
1985 if (C(Name, LPM, InnerPipeline))
1986 return Error::success();
1987
1988 // Normal passes can't have pipelines.
1989 return make_error<StringError>(
1990 formatv("invalid use of '{0}' pass as loop pipeline", Name).str(),
1992 }
1993
1994// Now expand the basic registered passes from the .inc file.
1995#define LOOPNEST_PASS(NAME, CREATE_PASS) \
1996 if (Name == NAME) { \
1997 LPM.addPass(CREATE_PASS); \
1998 return Error::success(); \
1999 }
2000#define LOOP_PASS(NAME, CREATE_PASS) \
2001 if (Name == NAME) { \
2002 LPM.addPass(CREATE_PASS); \
2003 return Error::success(); \
2004 }
2005#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2006 if (checkParametrizedPassName(Name, NAME)) { \
2007 auto Params = parsePassParameters(PARSER, Name, NAME); \
2008 if (!Params) \
2009 return Params.takeError(); \
2010 LPM.addPass(CREATE_PASS(Params.get())); \
2011 return Error::success(); \
2012 }
2013#define LOOP_ANALYSIS(NAME, CREATE_PASS) \
2014 if (Name == "require<" NAME ">") { \
2015 LPM.addPass(RequireAnalysisPass< \
2016 std::remove_reference_t<decltype(CREATE_PASS)>, Loop, \
2017 LoopAnalysisManager, LoopStandardAnalysisResults &, \
2018 LPMUpdater &>()); \
2019 return Error::success(); \
2020 } \
2021 if (Name == "invalidate<" NAME ">") { \
2022 LPM.addPass(InvalidateAnalysisPass< \
2023 std::remove_reference_t<decltype(CREATE_PASS)>>()); \
2024 return Error::success(); \
2025 }
2026#include "PassRegistry.def"
2027
2028 for (auto &C : LoopPipelineParsingCallbacks)
2029 if (C(Name, LPM, InnerPipeline))
2030 return Error::success();
2031 return make_error<StringError>(formatv("unknown loop pass '{0}'", Name).str(),
2033}
2034
2035Error PassBuilder::parseMachinePass(MachineFunctionPassManager &MFPM,
2036 const PipelineElement &E) {
2037 StringRef Name = E.Name;
2038 if (!E.InnerPipeline.empty())
2039 return make_error<StringError>("invalid pipeline",
2041
2042#define MACHINE_MODULE_PASS(NAME, CREATE_PASS) \
2043 if (Name == NAME) { \
2044 MFPM.addPass(CREATE_PASS); \
2045 return Error::success(); \
2046 }
2047#define MACHINE_FUNCTION_PASS(NAME, CREATE_PASS) \
2048 if (Name == NAME) { \
2049 MFPM.addPass(CREATE_PASS); \
2050 return Error::success(); \
2051 }
2052#define MACHINE_FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, \
2053 PARAMS) \
2054 if (checkParametrizedPassName(Name, NAME)) { \
2055 auto Params = parsePassParameters(PARSER, Name, NAME); \
2056 if (!Params) \
2057 return Params.takeError(); \
2058 MFPM.addPass(CREATE_PASS(Params.get())); \
2059 return Error::success(); \
2060 }
2061#define MACHINE_FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
2062 if (Name == "require<" NAME ">") { \
2063 MFPM.addPass( \
2064 RequireAnalysisPass<std::remove_reference_t<decltype(CREATE_PASS)>, \
2065 MachineFunction>()); \
2066 return Error::success(); \
2067 } \
2068 if (Name == "invalidate<" NAME ">") { \
2069 MFPM.addPass(InvalidateAnalysisPass< \
2070 std::remove_reference_t<decltype(CREATE_PASS)>>()); \
2071 return Error::success(); \
2072 }
2073#include "llvm/Passes/MachinePassRegistry.def"
2074
2075 for (auto &C : MachineFunctionPipelineParsingCallbacks)
2076 if (C(Name, MFPM, E.InnerPipeline))
2077 return Error::success();
2078 return make_error<StringError>(
2079 formatv("unknown machine pass '{0}'", Name).str(),
2081}
2082
2083bool PassBuilder::parseAAPassName(AAManager &AA, StringRef Name) {
2084#define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS) \
2085 if (Name == NAME) { \
2086 AA.registerModuleAnalysis< \
2087 std::remove_reference_t<decltype(CREATE_PASS)>>(); \
2088 return true; \
2089 }
2090#define FUNCTION_ALIAS_ANALYSIS(NAME, CREATE_PASS) \
2091 if (Name == NAME) { \
2092 AA.registerFunctionAnalysis< \
2093 std::remove_reference_t<decltype(CREATE_PASS)>>(); \
2094 return true; \
2095 }
2096#include "PassRegistry.def"
2097
2098 for (auto &C : AAParsingCallbacks)
2099 if (C(Name, AA))
2100 return true;
2101 return false;
2102}
2103
2104Error PassBuilder::parseMachinePassPipeline(
2106 for (const auto &Element : Pipeline) {
2107 if (auto Err = parseMachinePass(MFPM, Element))
2108 return Err;
2109 }
2110 return Error::success();
2111}
2112
2113Error PassBuilder::parseLoopPassPipeline(LoopPassManager &LPM,
2114 ArrayRef<PipelineElement> Pipeline) {
2115 for (const auto &Element : Pipeline) {
2116 if (auto Err = parseLoopPass(LPM, Element))
2117 return Err;
2118 }
2119 return Error::success();
2120}
2121
2122Error PassBuilder::parseFunctionPassPipeline(
2124 for (const auto &Element : Pipeline) {
2125 if (auto Err = parseFunctionPass(FPM, Element))
2126 return Err;
2127 }
2128 return Error::success();
2129}
2130
2131Error PassBuilder::parseCGSCCPassPipeline(CGSCCPassManager &CGPM,
2132 ArrayRef<PipelineElement> Pipeline) {
2133 for (const auto &Element : Pipeline) {
2134 if (auto Err = parseCGSCCPass(CGPM, Element))
2135 return Err;
2136 }
2137 return Error::success();
2138}
2139
2152 if (MFAM) {
2154 [&] { return MachineFunctionAnalysisManagerModuleProxy(*MFAM); });
2156 [&] { return MachineFunctionAnalysisManagerFunctionProxy(*MFAM); });
2157 MFAM->registerPass(
2159 MFAM->registerPass(
2161 }
2162}
2163
2164Error PassBuilder::parseModulePassPipeline(ModulePassManager &MPM,
2165 ArrayRef<PipelineElement> Pipeline) {
2166 for (const auto &Element : Pipeline) {
2167 if (auto Err = parseModulePass(MPM, Element))
2168 return Err;
2169 }
2170 return Error::success();
2171}
2172
2173// Primary pass pipeline description parsing routine for a \c ModulePassManager
2174// FIXME: Should this routine accept a TargetMachine or require the caller to
2175// pre-populate the analysis managers with target-specific stuff?
2177 StringRef PipelineText) {
2178 auto Pipeline = parsePipelineText(PipelineText);
2179 if (!Pipeline || Pipeline->empty())
2180 return make_error<StringError>(
2181 formatv("invalid pipeline '{0}'", PipelineText).str(),
2183
2184 // If the first name isn't at the module layer, wrap the pipeline up
2185 // automatically.
2186 StringRef FirstName = Pipeline->front().Name;
2187
2188 if (!isModulePassName(FirstName, ModulePipelineParsingCallbacks)) {
2189 bool UseMemorySSA;
2190 if (isCGSCCPassName(FirstName, CGSCCPipelineParsingCallbacks)) {
2191 Pipeline = {{"cgscc", std::move(*Pipeline)}};
2192 } else if (isFunctionPassName(FirstName,
2193 FunctionPipelineParsingCallbacks)) {
2194 Pipeline = {{"function", std::move(*Pipeline)}};
2195 } else if (isLoopNestPassName(FirstName, LoopPipelineParsingCallbacks,
2196 UseMemorySSA)) {
2197 Pipeline = {{"function", {{UseMemorySSA ? "loop-mssa" : "loop",
2198 std::move(*Pipeline)}}}};
2199 } else if (isLoopPassName(FirstName, LoopPipelineParsingCallbacks,
2200 UseMemorySSA)) {
2201 Pipeline = {{"function", {{UseMemorySSA ? "loop-mssa" : "loop",
2202 std::move(*Pipeline)}}}};
2203 } else if (isMachineFunctionPassName(
2204 FirstName, MachineFunctionPipelineParsingCallbacks)) {
2205 Pipeline = {{"function", {{"machine-function", std::move(*Pipeline)}}}};
2206 } else {
2207 for (auto &C : TopLevelPipelineParsingCallbacks)
2208 if (C(MPM, *Pipeline))
2209 return Error::success();
2210
2211 // Unknown pass or pipeline name!
2212 auto &InnerPipeline = Pipeline->front().InnerPipeline;
2213 return make_error<StringError>(
2214 formatv("unknown {0} name '{1}'",
2215 (InnerPipeline.empty() ? "pass" : "pipeline"), FirstName)
2216 .str(),
2218 }
2219 }
2220
2221 if (auto Err = parseModulePassPipeline(MPM, *Pipeline))
2222 return Err;
2223 return Error::success();
2224}
2225
2226// Primary pass pipeline description parsing routine for a \c CGSCCPassManager
2228 StringRef PipelineText) {
2229 auto Pipeline = parsePipelineText(PipelineText);
2230 if (!Pipeline || Pipeline->empty())
2231 return make_error<StringError>(
2232 formatv("invalid pipeline '{0}'", PipelineText).str(),
2234
2235 StringRef FirstName = Pipeline->front().Name;
2236 if (!isCGSCCPassName(FirstName, CGSCCPipelineParsingCallbacks))
2237 return make_error<StringError>(
2238 formatv("unknown cgscc pass '{0}' in pipeline '{1}'", FirstName,
2239 PipelineText)
2240 .str(),
2242
2243 if (auto Err = parseCGSCCPassPipeline(CGPM, *Pipeline))
2244 return Err;
2245 return Error::success();
2246}
2247
2248// Primary pass pipeline description parsing routine for a \c
2249// FunctionPassManager
2251 StringRef PipelineText) {
2252 auto Pipeline = parsePipelineText(PipelineText);
2253 if (!Pipeline || Pipeline->empty())
2254 return make_error<StringError>(
2255 formatv("invalid pipeline '{0}'", PipelineText).str(),
2257
2258 StringRef FirstName = Pipeline->front().Name;
2259 if (!isFunctionPassName(FirstName, FunctionPipelineParsingCallbacks))
2260 return make_error<StringError>(
2261 formatv("unknown function pass '{0}' in pipeline '{1}'", FirstName,
2262 PipelineText)
2263 .str(),
2265
2266 if (auto Err = parseFunctionPassPipeline(FPM, *Pipeline))
2267 return Err;
2268 return Error::success();
2269}
2270
2271// Primary pass pipeline description parsing routine for a \c LoopPassManager
2273 StringRef PipelineText) {
2274 auto Pipeline = parsePipelineText(PipelineText);
2275 if (!Pipeline || Pipeline->empty())
2276 return make_error<StringError>(
2277 formatv("invalid pipeline '{0}'", PipelineText).str(),
2279
2280 if (auto Err = parseLoopPassPipeline(CGPM, *Pipeline))
2281 return Err;
2282
2283 return Error::success();
2284}
2285
2287 StringRef PipelineText) {
2288 auto Pipeline = parsePipelineText(PipelineText);
2289 if (!Pipeline || Pipeline->empty())
2290 return make_error<StringError>(
2291 formatv("invalid machine pass pipeline '{0}'", PipelineText).str(),
2293
2294 if (auto Err = parseMachinePassPipeline(MFPM, *Pipeline))
2295 return Err;
2296
2297 return Error::success();
2298}
2299
2301 // If the pipeline just consists of the word 'default' just replace the AA
2302 // manager with our default one.
2303 if (PipelineText == "default") {
2305 return Error::success();
2306 }
2307
2308 while (!PipelineText.empty()) {
2310 std::tie(Name, PipelineText) = PipelineText.split(',');
2311 if (!parseAAPassName(AA, Name))
2312 return make_error<StringError>(
2313 formatv("unknown alias analysis name '{0}'", Name).str(),
2315 }
2316
2317 return Error::success();
2318}
2319
2320std::optional<RegAllocFilterFunc>
2322 if (FilterName == "all")
2323 return nullptr;
2324 for (auto &C : RegClassFilterParsingCallbacks)
2325 if (auto F = C(FilterName))
2326 return F;
2327 return std::nullopt;
2328}
2329
2331 OS << " " << PassName << "\n";
2332}
2334 raw_ostream &OS) {
2335 OS << " " << PassName << "<" << Params << ">\n";
2336}
2337
2339 // TODO: print pass descriptions when they are available
2340
2341 OS << "Module passes:\n";
2342#define MODULE_PASS(NAME, CREATE_PASS) printPassName(NAME, OS);
2343#include "PassRegistry.def"
2344
2345 OS << "Module passes with params:\n";
2346#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2347 printPassName(NAME, PARAMS, OS);
2348#include "PassRegistry.def"
2349
2350 OS << "Module analyses:\n";
2351#define MODULE_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
2352#include "PassRegistry.def"
2353
2354 OS << "Module alias analyses:\n";
2355#define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
2356#include "PassRegistry.def"
2357
2358 OS << "CGSCC passes:\n";
2359#define CGSCC_PASS(NAME, CREATE_PASS) printPassName(NAME, OS);
2360#include "PassRegistry.def"
2361
2362 OS << "CGSCC passes with params:\n";
2363#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2364 printPassName(NAME, PARAMS, OS);
2365#include "PassRegistry.def"
2366
2367 OS << "CGSCC analyses:\n";
2368#define CGSCC_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
2369#include "PassRegistry.def"
2370
2371 OS << "Function passes:\n";
2372#define FUNCTION_PASS(NAME, CREATE_PASS) printPassName(NAME, OS);
2373#include "PassRegistry.def"
2374
2375 OS << "Function passes with params:\n";
2376#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2377 printPassName(NAME, PARAMS, OS);
2378#include "PassRegistry.def"
2379
2380 OS << "Function analyses:\n";
2381#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
2382#include "PassRegistry.def"
2383
2384 OS << "Function alias analyses:\n";
2385#define FUNCTION_ALIAS_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
2386#include "PassRegistry.def"
2387
2388 OS << "LoopNest passes:\n";
2389#define LOOPNEST_PASS(NAME, CREATE_PASS) printPassName(NAME, OS);
2390#include "PassRegistry.def"
2391
2392 OS << "Loop passes:\n";
2393#define LOOP_PASS(NAME, CREATE_PASS) printPassName(NAME, OS);
2394#include "PassRegistry.def"
2395
2396 OS << "Loop passes with params:\n";
2397#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2398 printPassName(NAME, PARAMS, OS);
2399#include "PassRegistry.def"
2400
2401 OS << "Loop analyses:\n";
2402#define LOOP_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
2403#include "PassRegistry.def"
2404
2405 OS << "Machine module passes (WIP):\n";
2406#define MACHINE_MODULE_PASS(NAME, CREATE_PASS) printPassName(NAME, OS);
2407#include "llvm/Passes/MachinePassRegistry.def"
2408
2409 OS << "Machine function passes (WIP):\n";
2410#define MACHINE_FUNCTION_PASS(NAME, CREATE_PASS) printPassName(NAME, OS);
2411#include "llvm/Passes/MachinePassRegistry.def"
2412
2413 OS << "Machine function analyses (WIP):\n";
2414#define MACHINE_FUNCTION_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
2415#include "llvm/Passes/MachinePassRegistry.def"
2416}
2417
2419 const std::function<bool(ModulePassManager &, ArrayRef<PipelineElement>)>
2420 &C) {
2421 TopLevelPipelineParsingCallbacks.push_back(C);
2422}
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:239
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:650
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
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:77
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