[midend]重构中端，建立遍管理器，注册器等，初步构建支配树分析遍，增加基本块方法

2025-07-21 15:19:38 +08:00
parent 88604c1f94
commit 550f4017be
5 changed files with 538 additions and 1 deletions
--- a/src/include/Pass.h
+++ b/src/include/Pass.h
@@ -0,0 +1,284 @@
+#pragma once
+
+#include <functional> // For std::function
+#include <map>
+#include <memory>
+#include <set>
+#include <string>
+#include <typeindex> // For std::type_index (although void* ID is more common in LLVM)
+#include <vector>
+
+namespace sysy {
+
+// 抽象基类：分析结果
+class AnalysisResultBase {
+public:
+  virtual ~AnalysisResultBase() = default;
+};
+
+// 抽象基类：Pass
+class Pass {
+public:
+  enum class Granularity { Module, Function, BasicBlock };
+
+  enum class PassKind { Analysis, Optimization };
+
+  Pass(const std::string &name, Granularity g, PassKind k) : Name(name), G(g), K(k) {}
+  virtual ~Pass() = default;
+
+  const std::string &getName() const { return Name; }
+  Granularity getGranularity() const { return G; }
+  PassKind getPassKind() const { return K; }
+
+  virtual bool runOnModule(Module *M, AnalysisManager& AM) { return false; }
+  virtual bool runOnFunction(Function *F, AnalysisManager& AM) { return false; }
+  virtual bool runOnBasicBlock(BasicBlock *BB, AnalysisManager& AM) { return false; }
+
+  // 所有 Pass 都必须提供一个唯一的 ID
+  // 这通常是一个静态成员，并在 Pass 类外部定义
+  virtual void *getPassID() const = 0;
+
+protected:
+  std::string Name;
+  Granularity G;
+  PassKind K;
+};
+
+// 抽象基类：分析遍
+class AnalysisPass : public Pass {
+public:
+  AnalysisPass(const std::string &name, Granularity g) : Pass(name, g, PassKind::Analysis) {}
+
+  virtual std::unique_ptr<AnalysisResultBase> getResult() = 0;
+};
+
+// 抽象基类：优化遍
+class OptimizationPass : public Pass {
+public:
+  OptimizationPass(const std::string &name, Granularity g) : Pass(name, g, PassKind::Optimization) {}
+
+  virtual void getAnalysisUsage(std::set<void *> &analysisDependencies, std::set<void *> &analysisInvalidations) const {
+    // 默认不依赖也不修改任何分析
+  }
+};
+
+// ======================================================================
+// PassRegistry: 全局 Pass 注册表 (单例)
+// ======================================================================
+class PassRegistry {
+public:
+  // Pass 工厂函数类型：返回 Pass 的唯一指针
+  using PassFactory = std::function<std::unique_ptr<Pass>()>;
+
+  // 获取 PassRegistry 实例 (单例模式)
+  static PassRegistry &getPassRegistry() {
+    static PassRegistry instance;
+    return instance;
+  }
+
+  // 注册一个 Pass
+  // passID 是 Pass 类的唯一静态 ID (例如 MyPass::ID 的地址)
+  // factory 是一个 lambda 或函数指针，用于创建该 Pass 的实例
+  void registerPass(void *passID, PassFactory factory) {
+    if (factories.count(passID)) {
+      // Error: Pass with this ID already registered
+      // You might want to throw an exception or log an error
+      return;
+    }
+    factories[passID] = std::move(factory);
+  }
+
+  // 通过 Pass ID 创建一个 Pass 实例
+  std::unique_ptr<Pass> createPass(void *passID) {
+    auto it = factories.find(passID);
+    if (it == factories.end()) {
+      // Error: Pass with this ID not registered
+      return nullptr;
+    }
+    return it->second(); // 调用工厂函数创建实例
+  }
+
+private:
+  PassRegistry() = default; // 私有构造函数，实现单例
+  ~PassRegistry() = default;
+  PassRegistry(const PassRegistry &) = delete;            // 禁用拷贝构造
+  PassRegistry &operator=(const PassRegistry &) = delete; // 禁用赋值操作
+
+  std::map<void *, PassFactory> factories;
+};
+
+// ======================================================================
+// AnalysisManager: 负责管理和提供分析结果
+// ======================================================================
+class AnalysisManager {
+public:
+  AnalysisManager() = default;
+  ~AnalysisManager() = default;
+
+  // 获取分析结果
+  // T 是 AnalysisResult 的具体类型，E 是 AnalysisPass 的具体类型
+  // PassManager 应该在运行 Pass 之前调用 registerAnalysisPass
+  template <typename T, typename E> T *getAnalysisResult(Function *F) { // 针对函数级别的分析，需要传入 Function*
+    void *analysisID = E::ID;                                           // 获取分析遍的唯一 ID
+
+    // 检查是否已存在有效结果
+    auto it = cachedResults.find({F, analysisID});
+    if (it != cachedResults.end()) {
+      return static_cast<T *>(it->second.get()); // 返回缓存结果
+    }
+
+    // 如果没有缓存结果，通过 PassRegistry 创建分析遍并运行它
+    // 注意：这里需要 PassRegistry 实例。如果 AnalysisManager 独立于 PassManager，
+    // 则需要传入 PassRegistry 引用或指针。
+    // 为了简化，假设 AnalysisManager 能够访问到 PassRegistry
+    std::unique_ptr<Pass> basePass = PassRegistry::getPassRegistry().createPass(analysisID);
+    if (!basePass) {
+      // Error: Analysis pass not registered
+      return nullptr;
+    }
+
+    AnalysisPass *analysisPass = static_cast<AnalysisPass *>(basePass.get());
+
+    // 确保分析遍的粒度与请求的上下文匹配
+    if (analysisPass->getGranularity() == Pass::Granularity::Function) {
+      analysisPass->runOnFunction(F); // 运行分析遍
+      // 获取结果并缓存
+      std::unique_ptr<AnalysisResultBase> result = analysisPass->getResult();
+      T *specificResult = static_cast<T *>(result.get());
+      cachedResults[{F, analysisID}] = std::move(result); // 缓存结果
+      return specificResult;
+    }
+    // TODO: 处理 Module 或 BasicBlock 粒度的分析
+
+    return nullptr;
+  }
+
+  // 使所有或特定分析结果失效 (当 IR 被修改时调用)
+  void invalidateAllAnalyses() { cachedResults.clear(); }
+
+  // 使特定分析结果失效
+  void invalidateAnalysis(void *analysisID, Function *F = nullptr) {
+    if (F) {
+      // 使特定函数的特定分析结果失效
+      cachedResults.erase({F, analysisID});
+    } else {
+      // 使所有函数的特定分析结果失效
+      std::map<std::pair<Function *, void *>, std::unique_ptr<AnalysisResultBase>> newCachedResults;
+      for (auto &pair : cachedResults) {
+        if (pair.first.second != analysisID) {
+          newCachedResults.insert(std::move(pair));
+        }
+      }
+      cachedResults = std::move(newCachedResults);
+    }
+  }
+
+private:
+  std::map<std::pair<Function *, void *>, std::unique_ptr<AnalysisResultBase>> cachedResults;
+};
+
+// ======================================================================
+// PassManager：遍管理器
+// ======================================================================
+class PassManager {
+  
+  Module *pmodule;
+  AnalysisManager &AM; // 引用 AnalysisManager，用于获取分析结果
+
+public:
+  PassManager() = default;
+  ~PassManager() = default;
+
+  // 添加遍：现在接受 Pass 的 ID，而不是直接的 unique_ptr
+  void addPass(void *passID) {
+    PassRegistry &registry = PassRegistry::getPassRegistry();
+    std::unique_ptr<Pass> P = registry.createPass(passID);
+    if (!P) {
+      // Error: Pass not found or failed to create
+      return;
+    }
+
+    passes.push_back(std::move(P));
+  }
+
+  // 运行所有注册的遍
+  bool run(Module *M) {
+    bool changed = false;
+    for (const auto &p : passes) {
+      bool passChanged = false; // 记录当前遍是否修改了 IR
+
+      // 处理优化遍的分析依赖和失效
+      if (p->getPassKind() == Pass::PassKind::Optimization) {
+        OptimizationPass *optPass = static_cast<OptimizationPass *>(p.get());
+        std::set<void *> analysisDependencies;
+        std::set<void *> analysisInvalidations;
+        optPass->getAnalysisUsage(analysisDependencies, analysisInvalidations);
+
+        // PassManager 不显式运行分析依赖。
+        // 而是优化遍在 runOnFunction 内部通过 AnalysisManager.getAnalysisResult 按需请求。
+      }
+
+      if (p->getGranularity() == Pass::Granularity::Module) {
+        passChanged = p->runOnModule(M, AM);
+      } else if (p->getGranularity() == Pass::Granularity::Function) {
+        for (auto &funcPair : M->getFunctions()) {
+          Function *F = funcPair.second.get();
+          passChanged = p->runOnFunction(F, AM) || passChanged;
+
+          if (passChanged && p->getPassKind() == Pass::PassKind::Optimization) {
+            OptimizationPass *optPass = static_cast<OptimizationPass *>(p.get());
+            std::set<void *> analysisDependencies;
+            std::set<void *> analysisInvalidations;
+            optPass->getAnalysisUsage(analysisDependencies, analysisInvalidations);
+            for (void *invalidationID : analysisInvalidations) {
+              analysisManager.invalidateAnalysis(invalidationID, F);
+            }
+          }
+        }
+      } else if (p->getGranularity() == Pass::Granularity::BasicBlock) {
+        for (auto &funcPair : M->getFunctions()) {
+          Function *F = funcPair.second.get();
+          for (auto &bbPtr : funcPair.second->getBasicBlocks()) {
+            passChanged = p->runOnBasicBlock(bbPtr.get(), AM) || passChanged;
+
+            if (passChanged && p->getPassKind() == Pass::PassKind::Optimization) {
+              OptimizationPass *optPass = static_cast<OptimizationPass *>(p.get());
+              std::set<void *> analysisDependencies;
+              std::set<void *> analysisInvalidations;
+              optPass->getAnalysisUsage(analysisDependencies, analysisInvalidations);
+              for (void *invalidationID : analysisInvalidations) {
+                analysisManager.invalidateAnalysis(invalidationID, F);
+              }
+            }
+          }
+        }
+      }
+      changed = changed || passChanged;
+    }
+    return changed;
+  }
+
+  AnalysisManager &getAnalysisManager() { return analysisManager; }
+
+private:
+  std::vector<std::unique_ptr<Pass>> passes;
+  AnalysisManager analysisManager;
+};
+
+// ======================================================================
+// 辅助宏或函数，用于简化 Pass 的注册
+// ======================================================================
+
+// 用于分析遍的注册
+template <typename AnalysisPassType> void registerAnalysisPass() {
+  PassRegistry::getPassRegistry().registerPass(&AnalysisPassType::ID,
+                                               []() { return std::make_unique<AnalysisPassType>(); });
+}
+
+// 用于优化遍的注册
+template <typename OptimizationPassType> void registerOptimizationPass() {
+  PassRegistry::getPassRegistry().registerPass(&OptimizationPassType::ID,
+                                               []() { return std::make_unique<OptimizationPassType>(); });
+}
+
+} // namespace sysy