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 -... _______________________________________________ llvm-branch-commits mailing list llvm-branch-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-branch-commits