[llvm] [CodeGen] Add MachinePassModel to support MachineFunctionProperties (PR #79587)

[via llvm-commits]

https://github.com/paperchalice updated https://github.com/llvm/llvm-project/pull/79587

>From eee4971a370e83b7570ac7b09295cc85d3520f93 Mon Sep 17 00:00:00 2001
From: PaperChalice <liujunchang97 at outlook.com>
Date: Fri, 26 Jan 2024 19:41:41 +0800
Subject: [PATCH] [CodeGen] Add MachinePassModel to support
 MachineFunctionProperties

Specialize PassConcept and PassModel to support MachineFunctionProperties.
The verification work will be done in Instrumentation.
---
 .../include/llvm/CodeGen/MachinePassManager.h |  26 ++--
 .../llvm/CodeGen/MachinePassManagerInternal.h | 118 ++++++++++++++++++
 2 files changed, 131 insertions(+), 13 deletions(-)
 create mode 100644 llvm/include/llvm/CodeGen/MachinePassManagerInternal.h

diff --git a/llvm/include/llvm/CodeGen/MachinePassManager.h b/llvm/include/llvm/CodeGen/MachinePassManager.h
index 662b7e8689717dc..6c7349dab77405d 100644
--- a/llvm/include/llvm/CodeGen/MachinePassManager.h
+++ b/llvm/include/llvm/CodeGen/MachinePassManager.h
@@ -25,15 +25,13 @@
 
 #include "llvm/ADT/FunctionExtras.h"
 #include "llvm/ADT/SmallVector.h"
+#include "llvm/CodeGen/MachinePassManagerInternal.h"
 #include "llvm/IR/PassManager.h"
 #include "llvm/Support/Error.h"
 
 #include <map>
 
 namespace llvm {
-class Module;
-class Function;
-class MachineFunction;
 
 extern template class AnalysisManager<MachineFunction>;
 
@@ -43,7 +41,15 @@ extern template class AnalysisManager<MachineFunction>;
 /// automatically mixes in \c PassInfoMixin.
 template <typename DerivedT>
 struct MachinePassInfoMixin : public PassInfoMixin<DerivedT> {
-  // TODO: Add MachineFunctionProperties support.
+  static MachineFunctionProperties getRequiredProperties() {
+    return MachineFunctionProperties();
+  }
+  static MachineFunctionProperties getSetProperties() {
+    return MachineFunctionProperties();
+  }
+  static MachineFunctionProperties getClearedProperties() {
+    return MachineFunctionProperties();
+  }
 };
 
 /// An AnalysisManager<MachineFunction> that also exposes IR analysis results.
@@ -183,9 +189,7 @@ class MachineFunctionPassManager
   template <typename PassT>
   std::enable_if_t<is_detected<has_init_t, PassT>::value>
   addDoInitialization(PassConceptT *Pass) {
-    using PassModelT =
-        detail::PassModel<MachineFunction, PassT, PreservedAnalyses,
-                          MachineFunctionAnalysisManager>;
+    using PassModelT = detail::MachinePassModel<PassT>;
     auto *P = static_cast<PassModelT *>(Pass);
     InitializationFuncs.emplace_back(
         [=](Module &M, MachineFunctionAnalysisManager &MFAM) {
@@ -205,9 +209,7 @@ class MachineFunctionPassManager
   template <typename PassT>
   std::enable_if_t<is_detected<has_fini_t, PassT>::value>
   addDoFinalization(PassConceptT *Pass) {
-    using PassModelT =
-        detail::PassModel<MachineFunction, PassT, PreservedAnalyses,
-                          MachineFunctionAnalysisManager>;
+    using PassModelT = detail::MachinePassModel<PassT>;
     auto *P = static_cast<PassModelT *>(Pass);
     FinalizationFuncs.emplace_back(
         [=](Module &M, MachineFunctionAnalysisManager &MFAM) {
@@ -236,9 +238,7 @@ class MachineFunctionPassManager
                   "machine module pass needs to define machine function pass "
                   "api. sorry.");
 
-    using PassModelT =
-        detail::PassModel<MachineFunction, PassT, PreservedAnalyses,
-                          MachineFunctionAnalysisManager>;
+    using PassModelT = detail::MachinePassModel<PassT>;
     auto *P = static_cast<PassModelT *>(Pass);
     MachineModulePasses.emplace(
         Passes.size() - 1,
diff --git a/llvm/include/llvm/CodeGen/MachinePassManagerInternal.h b/llvm/include/llvm/CodeGen/MachinePassManagerInternal.h
new file mode 100644
index 000000000000000..9ea8f3ebfc9c95f
--- /dev/null
+++ b/llvm/include/llvm/CodeGen/MachinePassManagerInternal.h
@@ -0,0 +1,118 @@
+//===- MachinePassManagerInternal.h --------------------------- -*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+/// \file
+///
+/// This header provides internal APIs and implementation details used by the
+/// pass management interfaces exposed in MachinePassManager.h. Most of them are
+/// copied from PassManagerInternal.h.
+/// See also PassManagerInternal.h.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CODEGEN_MACHINEPASSMANAGERINTERNAL_H
+#define LLVM_CODEGEN_MACHINEPASSMANAGERINTERNAL_H
+
+#include "llvm/CodeGen/MachineFunction.h"
+#include "llvm/IR/PassManager.h"
+
+namespace llvm {
+
+class MachineFunctionAnalysisManager;
+
+using MachinePassConcept =
+    detail::PassConcept<MachineFunction, MachineFunctionAnalysisManager>;
+
+namespace detail {
+
+/// Template for the abstract base class used to dispatch
+/// polymorphically over pass objects. See also \c PassConcept.
+template <>
+struct PassConcept<MachineFunction, MachineFunctionAnalysisManager> {
+  /// Generic PassConcept interface.
+  virtual ~PassConcept() = default;
+  PassConcept(MachineFunctionProperties RequiredProperties,
+              MachineFunctionProperties SetProperties,
+              MachineFunctionProperties ClearedProperties)
+      : RequiredProperties(RequiredProperties), SetProperties(SetProperties),
+        ClearedProperties(ClearedProperties) {}
+  virtual PreservedAnalyses run(MachineFunction &MF,
+                                MachineFunctionAnalysisManager &MFAM) = 0;
+
+  virtual void
+  printPipeline(raw_ostream &OS,
+                function_ref<StringRef(StringRef)> MapClassName2PassName) = 0;
+  virtual StringRef name() const = 0;
+  virtual bool isRequired() const = 0;
+
+  /// MachineFunction Properties.
+  MachineFunctionProperties RequiredProperties;
+  MachineFunctionProperties SetProperties;
+  MachineFunctionProperties ClearedProperties;
+};
+
+template <typename PassT>
+struct PassModel<MachineFunction, PassT, PreservedAnalyses,
+                 MachineFunctionAnalysisManager> : public MachinePassConcept {
+  // Generic interface
+  explicit PassModel(PassT Pass)
+      : MachinePassConcept(PassT::getRequiredProperties(),
+                           PassT::getSetProperties(),
+                           PassT::getClearedProperties()),
+        Pass(std::move(Pass)) {}
+
+  friend void swap(PassModel &LHS, PassModel &RHS) {
+    using std::swap;
+    swap(LHS.Pass, RHS.Pass);
+  }
+
+  PassModel &operator=(PassModel RHS) {
+    swap(*this, RHS);
+    return *this;
+  }
+
+  PreservedAnalyses run(MachineFunction &MF,
+                        MachineFunctionAnalysisManager &MFAM) override {
+    return Pass.run(MF, MFAM);
+  }
+
+  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>(); }
+
+  PassT Pass;
+};
+
+template <typename PassT>
+using MachinePassModel = PassModel<MachineFunction, PassT, PreservedAnalyses,
+                                   MachineFunctionAnalysisManager>;
+
+} // namespace detail
+
+} // namespace llvm
+
+#endif // LLVM_CODEGEN_MACHINEPASSMANAGERINTERNAL_H