[llvm] [PassManager] Support MachineFunctionProperties (PR #83668)
via llvm-commits
llvm-commits at lists.llvm.org
Fri Mar 22 19:31:37 PDT 2024
https://github.com/paperchalice updated https://github.com/llvm/llvm-project/pull/83668
>From 2c061d8ee3db3b9c8f45f65b2026bdbcd9e6daf3 Mon Sep 17 00:00:00 2001
From: PaperChalice <liujunchang97 at outlook.com>
Date: Thu, 7 Mar 2024 09:07:03 +0800
Subject: [PATCH 1/3] [PassManager] Support MachineFunctionProperties
---
llvm/include/llvm/IR/PassManager.h | 13 +++++++++----
llvm/include/llvm/IR/PassManagerInternal.h | 3 +++
llvm/lib/CodeGen/MachinePassManager.cpp | 16 ++++++++++++++++
3 files changed, 28 insertions(+), 4 deletions(-)
diff --git a/llvm/include/llvm/IR/PassManager.h b/llvm/include/llvm/IR/PassManager.h
index ec8b809d40bfbc..d4ecc2436d465b 100644
--- a/llvm/include/llvm/IR/PassManager.h
+++ b/llvm/include/llvm/IR/PassManager.h
@@ -64,6 +64,8 @@ extern llvm::cl::opt<bool> UseNewDbgInfoFormat;
namespace llvm {
+class MachineFunction;
+
// RemoveDIs: Provide facilities for converting debug-info from one form to
// another, which are no-ops for everything but modules.
template <class IRUnitT> inline bool shouldConvertDbgInfo(IRUnitT &IR) {
@@ -271,8 +273,10 @@ class PassManager : public PassInfoMixin<
LLVM_ATTRIBUTE_MINSIZE
std::enable_if_t<!std::is_same<PassT, PassManager>::value>
addPass(PassT &&Pass) {
- using PassModelT =
- detail::PassModel<IRUnitT, PassT, AnalysisManagerT, ExtraArgTs...>;
+ using PassModelT = std::conditional_t<
+ std::is_same_v<IRUnitT, MachineFunction>,
+ detail::MachinePassModel<PassT>,
+ detail::PassModel<IRUnitT, PassT, AnalysisManagerT, ExtraArgTs...>>;
// Do not use make_unique or emplace_back, they cause too many template
// instantiations, causing terrible compile times.
Passes.push_back(std::unique_ptr<PassConceptT>(
@@ -298,8 +302,9 @@ class PassManager : public PassInfoMixin<
static bool isRequired() { return true; }
protected:
- using PassConceptT =
- detail::PassConcept<IRUnitT, AnalysisManagerT, ExtraArgTs...>;
+ using PassConceptT = std::conditional_t<
+ std::is_same_v<IRUnitT, MachineFunction>, detail::MachinePassConcept,
+ detail::PassConcept<IRUnitT, AnalysisManagerT, ExtraArgTs...>>;
std::vector<std::unique_ptr<PassConceptT>> Passes;
};
diff --git a/llvm/include/llvm/IR/PassManagerInternal.h b/llvm/include/llvm/IR/PassManagerInternal.h
index 4ada6ee5dd6831..06b941fe947fdb 100644
--- a/llvm/include/llvm/IR/PassManagerInternal.h
+++ b/llvm/include/llvm/IR/PassManagerInternal.h
@@ -328,6 +328,9 @@ struct AnalysisPassModel
PassT Pass;
};
+struct MachinePassConcept;
+template <typename PassT> struct MachinePassModel;
+
} // end namespace detail
} // end namespace llvm
diff --git a/llvm/lib/CodeGen/MachinePassManager.cpp b/llvm/lib/CodeGen/MachinePassManager.cpp
index 2763193b2c306b..84553477226184 100644
--- a/llvm/lib/CodeGen/MachinePassManager.cpp
+++ b/llvm/lib/CodeGen/MachinePassManager.cpp
@@ -121,11 +121,27 @@ PassManager<MachineFunction>::run(MachineFunction &MF,
for (auto &Pass : Passes) {
if (!PI.runBeforePass<MachineFunction>(*Pass, MF))
continue;
+ auto &MFProps = MF.getProperties();
+#ifndef NDEBUG
+ auto RequiredProperties = Pass->getRequiredProperties();
+ if (!MFProps.verifyRequiredProperties(RequiredProperties)) {
+ errs() << "MachineFunctionProperties required by " << Pass->name()
+ << " pass are not met by function " << F.getName() << ".\n"
+ << "Required properties: ";
+ RequiredProperties.print(errs());
+ errs() << "\nCurrent properties: ";
+ MFProps.print(errs());
+ errs() << '\n';
+ report_fatal_error("MachineFunctionProperties check failed");
+ }
+#endif
PreservedAnalyses PassPA = Pass->run(MF, MFAM);
if (MMI.getMachineFunction(F)) {
MFAM.invalidate(MF, PassPA);
PI.runAfterPass(*Pass, MF, PassPA);
+ MFProps.set(Pass->getSetProperties());
+ MFProps.reset(Pass->getClearedProperties());
} else {
MFAM.clear(MF, F.getName());
PI.runAfterPassInvalidated<MachineFunction>(*Pass, PassPA);
>From fff433862e9fa2e2d49b5408358d68b902e13783 Mon Sep 17 00:00:00 2001
From: PaperChalice <liujunchang97 at outlook.com>
Date: Fri, 8 Mar 2024 09:02:35 +0800
Subject: [PATCH 2/3] Add a simple test
---
.../include/llvm/CodeGen/MachinePassManager.h | 77 ++++++++++++++-----
.../llvm/Passes/MachinePassRegistry.def | 2 +
llvm/lib/Passes/PassBuilder.cpp | 27 +++++++
.../new-pm/machine-function-properties.mir | 12 +++
4 files changed, 99 insertions(+), 19 deletions(-)
create mode 100644 llvm/test/tools/llc/new-pm/machine-function-properties.mir
diff --git a/llvm/include/llvm/CodeGen/MachinePassManager.h b/llvm/include/llvm/CodeGen/MachinePassManager.h
index 3faffe5c4cab29..27e1fea1a7c88e 100644
--- a/llvm/include/llvm/CodeGen/MachinePassManager.h
+++ b/llvm/include/llvm/CodeGen/MachinePassManager.h
@@ -138,26 +138,44 @@ template <typename PassT> struct MachinePassModel : MachinePassConcept {
return getSetPropertiesImpl<PassT>();
}
- template <typename T>
- using has_get_cleared_properties_t =
- decltype(std::declval<T &>().getClearedProperties());
- template <typename T>
- static std::enable_if_t<is_detected<has_get_cleared_properties_t, T>::value,
- MachineFunctionProperties>
- getClearedPropertiesImpl() {
- return PassT::getClearedProperties();
- }
- template <typename T>
- static std::enable_if_t<!is_detected<has_get_cleared_properties_t, T>::value,
- MachineFunctionProperties>
- getClearedPropertiesImpl() {
- return MachineFunctionProperties();
- }
- MachineFunctionProperties getClearedProperties() const override {
- return getClearedPropertiesImpl<PassT>();
- }
+ template <typename T>
+ using has_get_cleared_properties_t =
+ decltype(std::declval<T &>().getClearedProperties());
+
+ public:
+ PropertyChanger(MachineFunction &MF) : MF(MF) {
+#ifndef NDEBUG
+ if constexpr (is_detected<has_get_required_properties_t,
+ DerivedT>::value) {
+ auto &MFProps = MF.getProperties();
+ auto RequiredProperties = DerivedT::getRequiredProperties();
+ if (!MFProps.verifyRequiredProperties(RequiredProperties)) {
+ errs() << "MachineFunctionProperties required by " << DerivedT::name()
+ << " pass are not met by function " << MF.getName() << ".\n"
+ << "Required properties: ";
+ RequiredProperties.print(errs());
+ errs() << "\nCurrent properties: ";
+ MFProps.print(errs());
+ errs() << '\n';
+ report_fatal_error("MachineFunctionProperties check failed");
+ }
+#endif
+ }
+ }
+
+ ~PropertyChanger() {
+ if constexpr (is_detected<has_get_set_properties_t, DerivedT>::value)
+ MF.getProperties().set(DerivedT::getSetProperties());
+ if constexpr (is_detected<has_get_cleared_properties_t, DerivedT>::value)
+ MF.getProperties().reset(DerivedT::getClearedProperties());
+ }
+ };
- PassT Pass;
+ PreservedAnalyses run(MachineFunction &MF,
+ MachineFunctionAnalysisManager &MFAM) {
+ PropertyChanger PC(MF);
+ return static_cast<DerivedT *>(this)->run(MF, MFAM);
+ }
};
} // namespace detail
@@ -280,6 +298,27 @@ createModuleToMachineFunctionPassAdaptor(MachineFunctionPassT &&Pass) {
new PassModelT(std::forward<MachineFunctionPassT>(Pass))));
}
+template <>
+template <typename PassT>
+std::enable_if_t<!std::is_same<PassT, PassManager<MachineFunction>>::value>
+PassManager<MachineFunction>::addPass(PassT &&Pass) {
+ using PassModelT =
+ detail::PassModel<MachineFunction, PassT, MachineFunctionAnalysisManager>;
+ using MachineFunctionPassModelT =
+ detail::PassModel<MachineFunction, MachinePassInfoMixin<PassT>,
+ MachineFunctionAnalysisManager>;
+ // Do not use make_unique or emplace_back, they cause too many template
+ // instantiations, causing terrible compile times.
+ if constexpr (std::is_base_of_v<MachinePassInfoMixin<PassT>, PassT>) {
+ Passes.push_back(
+ std::unique_ptr<PassConceptT>(new MachineFunctionPassModelT(
+ std::forward<MachinePassInfoMixin<PassT>>(Pass))));
+ } else {
+ Passes.push_back(std::unique_ptr<PassConceptT>(
+ new PassModelT(std::forward<PassT>(Pass))));
+ }
+}
+
template <>
PreservedAnalyses
PassManager<MachineFunction>::run(MachineFunction &,
diff --git a/llvm/include/llvm/Passes/MachinePassRegistry.def b/llvm/include/llvm/Passes/MachinePassRegistry.def
index 016602730e0e97..2f77ae655d9b22 100644
--- a/llvm/include/llvm/Passes/MachinePassRegistry.def
+++ b/llvm/include/llvm/Passes/MachinePassRegistry.def
@@ -127,6 +127,8 @@ MACHINE_FUNCTION_PASS("dead-mi-elimination", DeadMachineInstructionElimPass())
// MACHINE_FUNCTION_PASS("free-machine-function", FreeMachineFunctionPass())
MACHINE_FUNCTION_PASS("no-op-machine-function", NoOpMachineFunctionPass())
MACHINE_FUNCTION_PASS("print", PrintMIRPass())
+MACHINE_FUNCTION_PASS("require-all-machine-function-properties",
+ RequireAllMachineFunctionPropertiesPass())
#undef MACHINE_FUNCTION_PASS
// After a pass is converted to new pass manager, its entry should be moved from
diff --git a/llvm/lib/Passes/PassBuilder.cpp b/llvm/lib/Passes/PassBuilder.cpp
index f60f4eb3f0ef8c..8c8fcf5ecdb027 100644
--- a/llvm/lib/Passes/PassBuilder.cpp
+++ b/llvm/lib/Passes/PassBuilder.cpp
@@ -365,6 +365,33 @@ class TriggerVerifierErrorPass
static StringRef name() { return "TriggerVerifierErrorPass"; }
};
+// A pass requires all MachineFunctionProperties.
+// DO NOT USE THIS EXCEPT FOR TESTING!
+class RequireAllMachineFunctionPropertiesPass
+ : public PassInfoMixin<RequireAllMachineFunctionPropertiesPass> {
+public:
+ PreservedAnalyses run(MachineFunction &, MachineFunctionAnalysisManager &) {
+ return PreservedAnalyses::none();
+ }
+
+ static MachineFunctionProperties getRequiredProperties() {
+ MachineFunctionProperties MFProps;
+ MFProps.set(MachineFunctionProperties::Property::FailedISel);
+ MFProps.set(MachineFunctionProperties::Property::FailsVerification);
+ MFProps.set(MachineFunctionProperties::Property::IsSSA);
+ MFProps.set(MachineFunctionProperties::Property::Legalized);
+ MFProps.set(MachineFunctionProperties::Property::NoPHIs);
+ MFProps.set(MachineFunctionProperties::Property::NoVRegs);
+ MFProps.set(MachineFunctionProperties::Property::RegBankSelected);
+ MFProps.set(MachineFunctionProperties::Property::Selected);
+ MFProps.set(MachineFunctionProperties::Property::TiedOpsRewritten);
+ MFProps.set(MachineFunctionProperties::Property::TracksDebugUserValues);
+ MFProps.set(MachineFunctionProperties::Property::TracksLiveness);
+ return MFProps;
+ }
+ static StringRef name() { return "RequireAllMachineFunctionPropertiesPass"; }
+};
+
} // namespace
PassBuilder::PassBuilder(TargetMachine *TM, PipelineTuningOptions PTO,
diff --git a/llvm/test/tools/llc/new-pm/machine-function-properties.mir b/llvm/test/tools/llc/new-pm/machine-function-properties.mir
new file mode 100644
index 00000000000000..a9eb88ec698841
--- /dev/null
+++ b/llvm/test/tools/llc/new-pm/machine-function-properties.mir
@@ -0,0 +1,12 @@
+# REQUIRES: asserts
+# RUN: not --crash llc -mtriple=x86_64-pc-linux-gnu -passes=require-all-machine-function-properties -filetype=null %s 2>&1 | FileCheck %s
+
+# CHECK: MachineFunctionProperties required by RequireAllMachineFunctionPropertiesPass pass are not met by function f.
+
+---
+name: f
+selected: false
+body: |
+ bb.0:
+ RET 0
+...
>From beae3d0cbbe185b76314f6afd317e21afa26830f Mon Sep 17 00:00:00 2001
From: PaperChalice <liujunchang97 at outlook.com>
Date: Thu, 14 Mar 2024 19:49:12 +0800
Subject: [PATCH 3/3] another method
---
.../include/llvm/CodeGen/MachinePassManager.h | 155 ++++++------------
llvm/include/llvm/IR/PassManager.h | 13 +-
llvm/include/llvm/IR/PassManagerInternal.h | 3 -
llvm/lib/CodeGen/MachinePassManager.cpp | 16 --
llvm/lib/Passes/PassBuilder.cpp | 5 +-
5 files changed, 59 insertions(+), 133 deletions(-)
diff --git a/llvm/include/llvm/CodeGen/MachinePassManager.h b/llvm/include/llvm/CodeGen/MachinePassManager.h
index 27e1fea1a7c88e..99310f5478ed2f 100644
--- a/llvm/include/llvm/CodeGen/MachinePassManager.h
+++ b/llvm/include/llvm/CodeGen/MachinePassManager.h
@@ -44,99 +44,16 @@ using MachineFunctionAnalysisManager = AnalysisManager<MachineFunction>;
/// automatically mixes in \c PassInfoMixin.
template <typename DerivedT>
struct MachinePassInfoMixin : public PassInfoMixin<DerivedT> {
- // TODO: Add MachineFunctionProperties support.
-};
-
-namespace detail {
-struct MachinePassConcept
- : PassConcept<MachineFunction, MachineFunctionAnalysisManager> {
- virtual MachineFunctionProperties getRequiredProperties() const = 0;
- virtual MachineFunctionProperties getSetProperties() const = 0;
- virtual MachineFunctionProperties getClearedProperties() const = 0;
-};
-
-template <typename PassT> struct MachinePassModel : MachinePassConcept {
- explicit MachinePassModel(PassT &&Pass) : Pass(std::move(Pass)) {}
- // We have to explicitly define all the special member functions because MSVC
- // refuses to generate them.
- MachinePassModel(const MachinePassModel &Arg) : Pass(Arg.Pass) {}
- MachinePassModel(MachinePassModel &&Arg) : Pass(std::move(Arg.Pass)) {}
-
- friend void swap(MachinePassModel &LHS, MachinePassModel &RHS) {
- using std::swap;
- swap(LHS.Pass, RHS.Pass);
- }
-
- MachinePassModel &operator=(MachinePassModel RHS) {
- swap(*this, RHS);
- return *this;
- }
-
- MachinePassModel &operator=(const MachinePassModel &) = delete;
- PreservedAnalyses run(MachineFunction &IR,
- MachineFunctionAnalysisManager &AM) override {
- return Pass.run(IR, AM);
- }
+ class PropertyChanger {
+ MachineFunction &MF;
- void printPipeline(
- raw_ostream &OS,
- function_ref<StringRef(StringRef)> MapClassName2PassName) override {
- Pass.printPipeline(OS, MapClassName2PassName);
- }
-
- StringRef name() const override { return PassT::name(); }
-
- template <typename T>
- using has_required_t = decltype(std::declval<T &>().isRequired());
- template <typename T>
- static std::enable_if_t<is_detected<has_required_t, T>::value, bool>
- passIsRequiredImpl() {
- return T::isRequired();
- }
- template <typename T>
- static std::enable_if_t<!is_detected<has_required_t, T>::value, bool>
- passIsRequiredImpl() {
- return false;
- }
- bool isRequired() const override { return passIsRequiredImpl<PassT>(); }
-
- template <typename T>
- using has_get_required_properties_t =
- decltype(std::declval<T &>().getRequiredProperties());
- template <typename T>
- static std::enable_if_t<is_detected<has_get_required_properties_t, T>::value,
- MachineFunctionProperties>
- getRequiredPropertiesImpl() {
- return PassT::getRequiredProperties();
- }
- template <typename T>
- static std::enable_if_t<!is_detected<has_get_required_properties_t, T>::value,
- MachineFunctionProperties>
- getRequiredPropertiesImpl() {
- return MachineFunctionProperties();
- }
- MachineFunctionProperties getRequiredProperties() const override {
- return getRequiredPropertiesImpl<PassT>();
- }
+ template <typename T>
+ using has_get_required_properties_t =
+ decltype(std::declval<T &>().getRequiredProperties());
- template <typename T>
- using has_get_set_properties_t =
- decltype(std::declval<T &>().getSetProperties());
- template <typename T>
- static std::enable_if_t<is_detected<has_get_set_properties_t, T>::value,
- MachineFunctionProperties>
- getSetPropertiesImpl() {
- return PassT::getSetProperties();
- }
- template <typename T>
- static std::enable_if_t<!is_detected<has_get_set_properties_t, T>::value,
- MachineFunctionProperties>
- getSetPropertiesImpl() {
- return MachineFunctionProperties();
- }
- MachineFunctionProperties getSetProperties() const override {
- return getSetPropertiesImpl<PassT>();
- }
+ template <typename T>
+ using has_get_set_properties_t =
+ decltype(std::declval<T &>().getSetProperties());
template <typename T>
using has_get_cleared_properties_t =
@@ -177,6 +94,40 @@ template <typename PassT> struct MachinePassModel : MachinePassConcept {
return static_cast<DerivedT *>(this)->run(MF, MFAM);
}
};
+
+namespace detail {
+
+template <typename PassT>
+struct MachinePassModel
+ : PassModel<MachineFunction, PassT, MachineFunctionAnalysisManager> {
+ explicit MachinePassModel(PassT &&Pass)
+ : PassModel<MachineFunction, PassT, MachineFunctionAnalysisManager>(
+ std::move(Pass)) {}
+ // We have to explicitly define all the special member functions because MSVC
+ // refuses to generate them.
+ MachinePassModel(const MachinePassModel &Arg)
+ : PassModel<MachineFunction, PassT, MachineFunctionAnalysisManager>(
+ Arg.Pass) {}
+ MachinePassModel(MachinePassModel &&Arg)
+ : PassModel<MachineFunction, PassT, MachineFunctionAnalysisManager>(
+ std::move(Arg.Pass)) {}
+
+ friend void swap(MachinePassModel &LHS, MachinePassModel &RHS) {
+ using std::swap;
+ swap(LHS.Pass, RHS.Pass);
+ }
+
+ MachinePassModel &operator=(MachinePassModel RHS) {
+ swap(*this, RHS);
+ return *this;
+ }
+
+ MachinePassModel &operator=(const MachinePassModel &) = delete;
+ PreservedAnalyses run(MachineFunction &IR,
+ MachineFunctionAnalysisManager &AM) override {
+ return this->Pass.MachinePassInfoMixin<PassT>::run(IR, AM);
+ }
+};
} // namespace detail
using MachineFunctionAnalysisManagerModuleProxy =
@@ -269,11 +220,12 @@ class FunctionAnalysisManagerMachineFunctionProxy
class ModuleToMachineFunctionPassAdaptor
: public PassInfoMixin<ModuleToMachineFunctionPassAdaptor> {
- using MachinePassConcept = detail::MachinePassConcept;
-
public:
+ using PassConceptT =
+ detail::PassConcept<MachineFunction, MachineFunctionAnalysisManager>;
+
explicit ModuleToMachineFunctionPassAdaptor(
- std::unique_ptr<MachinePassConcept> Pass)
+ std::unique_ptr<PassConceptT> Pass)
: Pass(std::move(Pass)) {}
/// Runs the function pass across every function in the module.
@@ -284,17 +236,18 @@ class ModuleToMachineFunctionPassAdaptor
static bool isRequired() { return true; }
private:
- std::unique_ptr<MachinePassConcept> Pass;
+ std::unique_ptr<PassConceptT> Pass;
};
template <typename MachineFunctionPassT>
ModuleToMachineFunctionPassAdaptor
createModuleToMachineFunctionPassAdaptor(MachineFunctionPassT &&Pass) {
- using PassModelT = detail::MachinePassModel<MachineFunctionPassT>;
+ using PassModelT = detail::PassModel<MachineFunction, MachineFunctionPassT,
+ MachineFunctionAnalysisManager>;
// Do not use make_unique, it causes too many template instantiations,
// causing terrible compile times.
return ModuleToMachineFunctionPassAdaptor(
- std::unique_ptr<detail::MachinePassConcept>(
+ std::unique_ptr<ModuleToMachineFunctionPassAdaptor::PassConceptT>(
new PassModelT(std::forward<MachineFunctionPassT>(Pass))));
}
@@ -304,15 +257,11 @@ std::enable_if_t<!std::is_same<PassT, PassManager<MachineFunction>>::value>
PassManager<MachineFunction>::addPass(PassT &&Pass) {
using PassModelT =
detail::PassModel<MachineFunction, PassT, MachineFunctionAnalysisManager>;
- using MachineFunctionPassModelT =
- detail::PassModel<MachineFunction, MachinePassInfoMixin<PassT>,
- MachineFunctionAnalysisManager>;
// Do not use make_unique or emplace_back, they cause too many template
// instantiations, causing terrible compile times.
if constexpr (std::is_base_of_v<MachinePassInfoMixin<PassT>, PassT>) {
- Passes.push_back(
- std::unique_ptr<PassConceptT>(new MachineFunctionPassModelT(
- std::forward<MachinePassInfoMixin<PassT>>(Pass))));
+ Passes.push_back(std::unique_ptr<PassConceptT>(
+ new detail::MachinePassModel<PassT>(std::forward<PassT>(Pass))));
} else {
Passes.push_back(std::unique_ptr<PassConceptT>(
new PassModelT(std::forward<PassT>(Pass))));
diff --git a/llvm/include/llvm/IR/PassManager.h b/llvm/include/llvm/IR/PassManager.h
index d4ecc2436d465b..ec8b809d40bfbc 100644
--- a/llvm/include/llvm/IR/PassManager.h
+++ b/llvm/include/llvm/IR/PassManager.h
@@ -64,8 +64,6 @@ extern llvm::cl::opt<bool> UseNewDbgInfoFormat;
namespace llvm {
-class MachineFunction;
-
// RemoveDIs: Provide facilities for converting debug-info from one form to
// another, which are no-ops for everything but modules.
template <class IRUnitT> inline bool shouldConvertDbgInfo(IRUnitT &IR) {
@@ -273,10 +271,8 @@ class PassManager : public PassInfoMixin<
LLVM_ATTRIBUTE_MINSIZE
std::enable_if_t<!std::is_same<PassT, PassManager>::value>
addPass(PassT &&Pass) {
- using PassModelT = std::conditional_t<
- std::is_same_v<IRUnitT, MachineFunction>,
- detail::MachinePassModel<PassT>,
- detail::PassModel<IRUnitT, PassT, AnalysisManagerT, ExtraArgTs...>>;
+ using PassModelT =
+ detail::PassModel<IRUnitT, PassT, AnalysisManagerT, ExtraArgTs...>;
// Do not use make_unique or emplace_back, they cause too many template
// instantiations, causing terrible compile times.
Passes.push_back(std::unique_ptr<PassConceptT>(
@@ -302,9 +298,8 @@ class PassManager : public PassInfoMixin<
static bool isRequired() { return true; }
protected:
- using PassConceptT = std::conditional_t<
- std::is_same_v<IRUnitT, MachineFunction>, detail::MachinePassConcept,
- detail::PassConcept<IRUnitT, AnalysisManagerT, ExtraArgTs...>>;
+ using PassConceptT =
+ detail::PassConcept<IRUnitT, AnalysisManagerT, ExtraArgTs...>;
std::vector<std::unique_ptr<PassConceptT>> Passes;
};
diff --git a/llvm/include/llvm/IR/PassManagerInternal.h b/llvm/include/llvm/IR/PassManagerInternal.h
index 06b941fe947fdb..4ada6ee5dd6831 100644
--- a/llvm/include/llvm/IR/PassManagerInternal.h
+++ b/llvm/include/llvm/IR/PassManagerInternal.h
@@ -328,9 +328,6 @@ struct AnalysisPassModel
PassT Pass;
};
-struct MachinePassConcept;
-template <typename PassT> struct MachinePassModel;
-
} // end namespace detail
} // end namespace llvm
diff --git a/llvm/lib/CodeGen/MachinePassManager.cpp b/llvm/lib/CodeGen/MachinePassManager.cpp
index 84553477226184..2763193b2c306b 100644
--- a/llvm/lib/CodeGen/MachinePassManager.cpp
+++ b/llvm/lib/CodeGen/MachinePassManager.cpp
@@ -121,27 +121,11 @@ PassManager<MachineFunction>::run(MachineFunction &MF,
for (auto &Pass : Passes) {
if (!PI.runBeforePass<MachineFunction>(*Pass, MF))
continue;
- auto &MFProps = MF.getProperties();
-#ifndef NDEBUG
- auto RequiredProperties = Pass->getRequiredProperties();
- if (!MFProps.verifyRequiredProperties(RequiredProperties)) {
- errs() << "MachineFunctionProperties required by " << Pass->name()
- << " pass are not met by function " << F.getName() << ".\n"
- << "Required properties: ";
- RequiredProperties.print(errs());
- errs() << "\nCurrent properties: ";
- MFProps.print(errs());
- errs() << '\n';
- report_fatal_error("MachineFunctionProperties check failed");
- }
-#endif
PreservedAnalyses PassPA = Pass->run(MF, MFAM);
if (MMI.getMachineFunction(F)) {
MFAM.invalidate(MF, PassPA);
PI.runAfterPass(*Pass, MF, PassPA);
- MFProps.set(Pass->getSetProperties());
- MFProps.reset(Pass->getClearedProperties());
} else {
MFAM.clear(MF, F.getName());
PI.runAfterPassInvalidated<MachineFunction>(*Pass, PassPA);
diff --git a/llvm/lib/Passes/PassBuilder.cpp b/llvm/lib/Passes/PassBuilder.cpp
index 8c8fcf5ecdb027..05b0931505328d 100644
--- a/llvm/lib/Passes/PassBuilder.cpp
+++ b/llvm/lib/Passes/PassBuilder.cpp
@@ -368,9 +368,10 @@ class TriggerVerifierErrorPass
// A pass requires all MachineFunctionProperties.
// DO NOT USE THIS EXCEPT FOR TESTING!
class RequireAllMachineFunctionPropertiesPass
- : public PassInfoMixin<RequireAllMachineFunctionPropertiesPass> {
+ : public MachinePassInfoMixin<RequireAllMachineFunctionPropertiesPass> {
public:
- PreservedAnalyses run(MachineFunction &, MachineFunctionAnalysisManager &) {
+ PreservedAnalyses run(MachineFunction &MF, MachineFunctionAnalysisManager &) {
+ PropertyChanger PC(MF);
return PreservedAnalyses::none();
}
More information about the llvm-commits
mailing list