[llvm-branch-commits] [llvm] d0c1718 - Revert "Reland "[PassManager] Support MachineFunctionProperties (#83668)" (#8…"
via llvm-branch-commits
llvm-branch-commits at lists.llvm.org
Fri Mar 29 19:19:13 PDT 2024
Author: paperchalice
Date: 2024-03-30T10:19:10+08:00
New Revision: d0c1718dfbdcaf1ae7629feba3b59a09f550ff5f
URL: https://github.com/llvm/llvm-project/commit/d0c1718dfbdcaf1ae7629feba3b59a09f550ff5f
DIFF: https://github.com/llvm/llvm-project/commit/d0c1718dfbdcaf1ae7629feba3b59a09f550ff5f.diff
LOG: Revert "Reland "[PassManager] Support MachineFunctionProperties (#83668)" (#8…"
This reverts commit 4f7132952222cd9b2709e98109d6ce0ef333940c.
Added:
Modified:
llvm/include/llvm/CodeGen/MachinePassManager.h
llvm/include/llvm/Passes/MachinePassRegistry.def
llvm/lib/Passes/PassBuilder.cpp
Removed:
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 085a78f919172d..3faffe5c4cab29 100644
--- a/llvm/include/llvm/CodeGen/MachinePassManager.h
+++ b/llvm/include/llvm/CodeGen/MachinePassManager.h
@@ -16,6 +16,8 @@
// their respective analysis managers such as ModuleAnalysisManager and
// FunctionAnalysisManager.
//
+// TODO: Add MachineFunctionProperties support.
+//
//===----------------------------------------------------------------------===//
#ifndef LLVM_CODEGEN_MACHINEPASSMANAGER_H
@@ -42,67 +44,23 @@ using MachineFunctionAnalysisManager = AnalysisManager<MachineFunction>;
/// automatically mixes in \c PassInfoMixin.
template <typename DerivedT>
struct MachinePassInfoMixin : public PassInfoMixin<DerivedT> {
-protected:
- class PropertyChanger {
- MachineFunction &MF;
-
- 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>
- 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());
- }
- };
-
-public:
- PreservedAnalyses runImpl(MachineFunction &MF,
- MachineFunctionAnalysisManager &MFAM) {
- PropertyChanger PC(MF);
- return static_cast<DerivedT *>(this)->run(MF, MFAM);
- }
+ // 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
- : PassModel<MachineFunction, PassT, MachineFunctionAnalysisManager> {
- explicit MachinePassModel(PassT &&Pass)
- : PassModel<MachineFunction, PassT, MachineFunctionAnalysisManager>(
- std::move(Pass)) {}
+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;
@@ -117,8 +75,89 @@ struct MachinePassModel
MachinePassModel &operator=(const MachinePassModel &) = delete;
PreservedAnalyses run(MachineFunction &IR,
MachineFunctionAnalysisManager &AM) override {
- return this->Pass.runImpl(IR, AM);
+ return Pass.run(IR, AM);
+ }
+
+ 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_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_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>();
+ }
+
+ PassT Pass;
};
} // namespace detail
@@ -212,12 +251,11 @@ class FunctionAnalysisManagerMachineFunctionProxy
class ModuleToMachineFunctionPassAdaptor
: public PassInfoMixin<ModuleToMachineFunctionPassAdaptor> {
-public:
- using PassConceptT =
- detail::PassConcept<MachineFunction, MachineFunctionAnalysisManager>;
+ using MachinePassConcept = detail::MachinePassConcept;
+public:
explicit ModuleToMachineFunctionPassAdaptor(
- std::unique_ptr<PassConceptT> Pass)
+ std::unique_ptr<MachinePassConcept> Pass)
: Pass(std::move(Pass)) {}
/// Runs the function pass across every function in the module.
@@ -228,39 +266,20 @@ class ModuleToMachineFunctionPassAdaptor
static bool isRequired() { return true; }
private:
- std::unique_ptr<PassConceptT> Pass;
+ std::unique_ptr<MachinePassConcept> Pass;
};
template <typename MachineFunctionPassT>
ModuleToMachineFunctionPassAdaptor
createModuleToMachineFunctionPassAdaptor(MachineFunctionPassT &&Pass) {
- using PassModelT = detail::PassModel<MachineFunction, MachineFunctionPassT,
- MachineFunctionAnalysisManager>;
+ using PassModelT = detail::MachinePassModel<MachineFunctionPassT>;
// Do not use make_unique, it causes too many template instantiations,
// causing terrible compile times.
return ModuleToMachineFunctionPassAdaptor(
- std::unique_ptr<ModuleToMachineFunctionPassAdaptor::PassConceptT>(
+ std::unique_ptr<detail::MachinePassConcept>(
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 MachinePassModelT = detail::MachinePassModel<PassT>;
- // 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 MachinePassModelT(std::forward<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 2f77ae655d9b22..016602730e0e97 100644
--- a/llvm/include/llvm/Passes/MachinePassRegistry.def
+++ b/llvm/include/llvm/Passes/MachinePassRegistry.def
@@ -127,8 +127,6 @@ 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 57975e34d4265b..f60f4eb3f0ef8c 100644
--- a/llvm/lib/Passes/PassBuilder.cpp
+++ b/llvm/lib/Passes/PassBuilder.cpp
@@ -365,33 +365,6 @@ class TriggerVerifierErrorPass
static StringRef name() { return "TriggerVerifierErrorPass"; }
};
-// A pass requires all MachineFunctionProperties.
-// DO NOT USE THIS EXCEPT FOR TESTING!
-class RequireAllMachineFunctionPropertiesPass
- : public MachinePassInfoMixin<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
deleted file mode 100644
index a9eb88ec698841..00000000000000
--- a/llvm/test/tools/llc/new-pm/machine-function-properties.mir
+++ /dev/null
@@ -1,12 +0,0 @@
-# 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
-...
More information about the llvm-branch-commits
mailing list