[midend]更新遍静态ID定义方法，

注册遍模板函数重构（针对遍的不同构造方法），修复phi指令更新引起的旧代码错误，将CFG优化适配到现有终端框架中，独立CFG优化方法使得其他优化遍能独立调用， usedelete方法回调取消删除功能。 IRGenerator代码风格修改。
2025-07-23 17:19:11 +08:00
parent 3df3d7a097
commit 87d38be255
12 changed files with 509 additions and 298 deletions
--- a/src/include/Dom.h
+++ b/src/include/Dom.h
@@ -34,7 +34,7 @@ private:
 class DominatorTreeAnalysisPass : public AnalysisPass {
 public:
    // 唯一的 Pass ID
-    static char ID; // LLVM 风格的唯一 ID
+    static void *ID;

    DominatorTreeAnalysisPass() : AnalysisPass("DominatorTreeAnalysis", Pass::Granularity::Function) {}

--- a/src/include/Liveness.h
+++ b/src/include/Liveness.h
@@ -49,7 +49,7 @@ private:
 class LivenessAnalysisPass : public AnalysisPass {
 public:
  // 唯一的 Pass ID
-  static char ID; // LLVM 风格的唯一 ID
+  static void *ID; // LLVM 风格的唯一 ID

  LivenessAnalysisPass() : AnalysisPass("LivenessAnalysis", Pass::Granularity::Function) {}
    
--- a/src/include/Pass.h
+++ b/src/include/Pass.h
@@ -7,7 +7,9 @@
 #include <string>
 #include <typeindex> // For std::type_index (although void* ID is more common in LLVM)
 #include <vector>
+#include <type_traits>
 #include "IR.h"
+#include "IRBuilder.h"

 namespace sysy {

@@ -117,64 +119,142 @@ private:
 // ======================================================================
 class AnalysisManager {
 private:
-  std::map<std::pair<Function *, void *>, std::unique_ptr<AnalysisResultBase>> cachedResults;
-  // cachedResults 存储分析结果，键是 (Function*, AnalysisPass ID)
+  Module *pModuleRef; // 指向被分析的Module
+
+  // 缓存不同粒度的分析结果
+  std::map<void *, std::unique_ptr<AnalysisResultBase>> moduleCachedResults;
+  std::map<std::pair<Function *, void *>, std::unique_ptr<AnalysisResultBase>> functionCachedResults;
+  std::map<std::pair<BasicBlock *, void *>, std::unique_ptr<AnalysisResultBase>> basicBlockCachedResults;
+
+
 public:
-  AnalysisManager() = default;
+  // 构造函数接收 Module 指针
+  AnalysisManager(Module *M) : pModuleRef(M) {}
+  AnalysisManager() = delete; // 禁止无参构造
+
  ~AnalysisManager() = default;

-  // 获取分析结果
+  // 获取分析结果的通用模板函数
  // T 是 AnalysisResult 的具体类型，E 是 AnalysisPass 的具体类型
-  // PassManager 应该在运行 Pass 之前调用 registerAnalysisPass
-  template <typename T, typename E> T *getAnalysisResult(Function *F) { // 针对函数级别的分析，需要传入 Function*
-    void *analysisID = E::ID;                                           // 获取分析遍的唯一 ID
+  // F 和 BB 参数用于提供上下文，根据分析遍的粒度来使用
+  template <typename T, typename E> T *getAnalysisResult(Function *F = nullptr, BasicBlock *BB = nullptr) {
+    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
+      std::cerr << "Error: Analysis pass with ID " << analysisID << " not registered.\n";
      return nullptr;
    }
-
    AnalysisPass *analysisPass = static_cast<AnalysisPass *>(basePass.get());

-    // 确保分析遍的粒度与请求的上下文匹配
-    if (analysisPass->getGranularity() == Pass::Granularity::Function) {
-      analysisPass->runOnFunction(F, *this); // 运行分析遍
-      // 获取结果并缓存
-      std::unique_ptr<AnalysisResultBase> result = analysisPass->getResult();
-      T *specificResult = static_cast<T *>(result.get());
-      cachedResults[{F, analysisID}] = std::move(result); // 缓存结果
-      return specificResult;
+    // 根据分析遍的粒度处理
+    switch (analysisPass->getGranularity()) {
+      case Pass::Granularity::Module: {
+        // 检查是否已存在有效结果
+        auto it = moduleCachedResults.find(analysisID);
+        if (it != moduleCachedResults.end()) {
+          return static_cast<T *>(it->second.get()); // 返回缓存结果
+        }
+        // 运行模块级分析遍
+        if (!pModuleRef) {
+          std::cerr << "Error: Module reference not set for AnalysisManager to run Module Pass.\n";
+          return nullptr;
+        }
+        analysisPass->runOnModule(pModuleRef, *this);
+        // 获取结果并缓存
+        std::unique_ptr<AnalysisResultBase> result = analysisPass->getResult();
+        T *specificResult = static_cast<T *>(result.get());
+        moduleCachedResults[analysisID] = std::move(result); // 缓存结果
+        return specificResult;
+      }
+      case Pass::Granularity::Function: {
+        // 检查请求的上下文是否正确
+        if (!F) {
+          std::cerr << "Error: Function context required for Function-level Analysis Pass.\n";
+          return nullptr;
+        }
+        // 检查是否已存在有效结果
+        auto it = functionCachedResults.find({F, analysisID});
+        if (it != functionCachedResults.end()) {
+          return static_cast<T *>(it->second.get()); // 返回缓存结果
+        }
+        // 运行函数级分析遍
+        analysisPass->runOnFunction(F, *this);
+        // 获取结果并缓存
+        std::unique_ptr<AnalysisResultBase> result = analysisPass->getResult();
+        T *specificResult = static_cast<T *>(result.get());
+        functionCachedResults[{F, analysisID}] = std::move(result); // 缓存结果
+        return specificResult;
+      }
+      case Pass::Granularity::BasicBlock: {
+        // 检查请求的上下文是否正确
+        if (!BB) {
+          std::cerr << "Error: BasicBlock context required for BasicBlock-level Analysis Pass.\n";
+          return nullptr;
+        }
+        // 检查是否已存在有效结果
+        auto it = basicBlockCachedResults.find({BB, analysisID});
+        if (it != basicBlockCachedResults.end()) {
+          return static_cast<T *>(it->second.get()); // 返回缓存结果
+        }
+        // 运行基本块级分析遍
+        analysisPass->runOnBasicBlock(BB, *this);
+        // 获取结果并缓存
+        std::unique_ptr<AnalysisResultBase> result = analysisPass->getResult();
+        T *specificResult = static_cast<T *>(result.get());
+        basicBlockCachedResults[{BB, analysisID}] = std::move(result); // 缓存结果
+        return specificResult;
+      }
    }
-    // TODO: 处理 Module 或 BasicBlock 粒度的分析
-
-    return nullptr;
+    return nullptr; // 不会到达这里
  }

-  // 使所有或特定分析结果失效 (当 IR 被修改时调用)
-  void invalidateAllAnalyses() { cachedResults.clear(); }
+  // 使所有分析结果失效 (当 IR 被修改时调用)
+  void invalidateAllAnalyses() {
+    moduleCachedResults.clear();
+    functionCachedResults.clear();
+    basicBlockCachedResults.clear();
+  }

  // 使特定分析结果失效
-  void invalidateAnalysis(void *analysisID, Function *F = nullptr) {
-    if (F) {
-      // 使特定函数的特定分析结果失效
-      cachedResults.erase({F, analysisID});
+  // void *analysisID: 要失效的分析的ID
+  // Function *F: 如果是函数级分析，指定函数；如果是模块级或基本块级，则为nullptr (取决于调用方式)
+  // BasicBlock *BB: 如果是基本块级分析，指定基本块；否则为nullptr
+  void invalidateAnalysis(void *analysisID, Function *F = nullptr, BasicBlock *BB = nullptr) {
+    if (BB) {
+      // 使特定基本块的特定分析结果失效
+      basicBlockCachedResults.erase({BB, analysisID});
+    } else if (F) {
+      // 使特定函数的特定分析结果失效 (也可能包含聚合的BasicBlock结果)
+      functionCachedResults.erase({F, analysisID});
+      // 遍历所有属于F的基本块，使其BasicBlockCache失效 (如果该分析是BasicBlock粒度的)
+      // 这需要遍历F的所有基本块，效率较低，更推荐在BasicBlockPass的invalidateAnalysisUsage中精确指定
+      // 或者在Function级别的invalidate时，清空该Function的所有BasicBlock分析
+      // 这里的实现简单地清空该Function下所有该ID的BasicBlock缓存
+      for (auto it = basicBlockCachedResults.begin(); it != basicBlockCachedResults.end(); ) {
+          // 假设BasicBlock::getParent()方法存在，可以获取所属Function
+          if (it->first.second == analysisID /* && it->first.first->getParent() == F */) { // 需要BasicBlock能获取其父函数
+              it = basicBlockCachedResults.erase(it);
+          } else {
+              ++it;
+          }
+      }
+
    } else {
-      // 使所有函数的特定分析结果失效
-      // 遍历并删除匹配的元素，避免拷贝 unique_ptr
-      for (auto it = cachedResults.begin(); it != cachedResults.end(); ) {
+      // 使所有函数的特定分析结果失效 (Module级和所有Function/BasicBlock级)
+      moduleCachedResults.erase(analysisID);
+      for (auto it = functionCachedResults.begin(); it != functionCachedResults.end(); ) {
        if (it->first.second == analysisID) {
-          it = cachedResults.erase(it); // erase 返回下一个元素的迭代器
+          it = functionCachedResults.erase(it);
+        } else {
+          ++it;
+        }
+      }
+      for (auto it = basicBlockCachedResults.begin(); it != basicBlockCachedResults.end(); ) {
+        if (it->first.second == analysisID) {
+          it = basicBlockCachedResults.erase(it);
        } else {
          ++it;
        }
@@ -191,26 +271,26 @@ private:
  std::vector<std::unique_ptr<Pass>> passes;
  AnalysisManager analysisManager;
  Module *pmodule;
+  IRBuilder *pBuilder;

 public:
  PassManager() = default;
  ~PassManager() = default;

-  PassManager(Module *module) : pmodule(module) , analysisManager() {}
+  PassManager(Module *module, IRBuilder *builder) : pmodule(module) ,pBuilder(builder), analysisManager(module) {}
  
  // 运行所有注册的遍
  bool run();
  
  // 运行优化管道主要负责注册和运行优化遍
  // 这里可以根据 optLevel 和 DEBUG 控制不同的优化遍
-  void runOptimizationPipeline(Module* moduleIR, int optLevel);
+  void runOptimizationPipeline(Module* moduleIR, IRBuilder* builder, int optLevel);

  // 添加遍：现在接受 Pass 的 ID，而不是直接的 unique_ptr
  void addPass(void *passID);

  AnalysisManager &getAnalysisManager() { return analysisManager; }

-
 };

 // ======================================================================
@@ -218,15 +298,18 @@ public:
 // ======================================================================

 // 用于分析遍的注册
-template <typename AnalysisPassType> void registerAnalysisPass() {
-  PassRegistry::getPassRegistry().registerPass(&AnalysisPassType::ID,
-                                               []() { return std::make_unique<AnalysisPassType>(); });
-}
+template <typename AnalysisPassType> void registerAnalysisPass();

-// 用于优化遍的注册
-template <typename OptimizationPassType> void registerOptimizationPass() {
-  PassRegistry::getPassRegistry().registerPass(&OptimizationPassType::ID,
-                                               []() { return std::make_unique<OptimizationPassType>(); });
-}
+// (1) 针对需要 IRBuilder 参数的优化遍的重载
+// 这个模板只在 OptimizationPassType 可以通过 IRBuilder* 构造时才有效
+template <typename OptimizationPassType, typename std::enable_if<
+    std::is_constructible<OptimizationPassType, IRBuilder*>::value, int>::type = 0>
+void registerOptimizationPass(IRBuilder* builder);
+
+// (2) 针对不需要 IRBuilder 参数的所有其他优化遍的重载
+// 这个模板只在 OptimizationPassType 不能通过 IRBuilder* 构造时才有效
+template <typename OptimizationPassType, typename std::enable_if<
+    !std::is_constructible<OptimizationPassType, IRBuilder*>::value, int>::type = 0>
+void registerOptimizationPass();

 } // namespace sysy
--- a/src/include/SysYIRCFGOpt.h
+++ b/src/include/SysYIRCFGOpt.h
@@ -2,6 +2,7 @@

 #include "IR.h"
 #include "IRBuilder.h"
+#include "Pass.h"

 namespace sysy {

@@ -17,44 +18,79 @@ namespace sysy {
 // - 合并连续的跳转指令（Jump Threading）在合并不可达块中似乎已经实现了
 // - 基本块重排序（Block Reordering），提升局部性

-class SysYCFGOpt {
- private:
-  Module *pModule;
-  IRBuilder *pBuilder;
-
- public:
-  SysYCFGOpt(Module *pMoudle, IRBuilder *pBuilder) : pModule(pMoudle), pBuilder(pBuilder) {}
-
-  void SysYOptimizateAfterIR(){
-    
-    auto &functions = pModule->getFunctions();
-    for (auto &function : functions) {
-      bool changed = false;
-      while(changed){
-        changed = false;
-        changed |= SysYCondBr2Br(function.second.get(), pBuilder);
-        // 删除br后面的无用指令
-        changed |= SysYDelInstAfterBr(function.second.get());
-        // 合并空基本块
-        changed |= SysYBlockMerge(function.second.get());
-        // 删除无前驱块
-        changed |= SysYDelNoPreBLock(function.second.get());
-        // 删除空块
-        changed |= SysYDelEmptyBlock(function.second.get(), pBuilder);
-        // 添加return指令
-        changed |= SysYAddReturn(function.second.get(), pBuilder);
-      }
-    }
-  }
-
+// 辅助工具类，包含实际的CFG优化逻辑
+// 这些方法可以被独立的Pass调用
+class SysYCFGOptUtils {
 public:
  static bool SysYDelInstAfterBr(Function *func); // 删除br后面的指令
  static bool SysYDelEmptyBlock(Function *func, IRBuilder* pBuilder); // 空块删除
  static bool SysYDelNoPreBLock(Function *func); // 删除无前驱块（不可达块）
-  static bool SysYBlockMerge(Function *func);    // 合并基本块(主要针对嵌套if while的exit块，
-                            // 也可以修改IR生成实现回填机制
-  static bool SysYAddReturn(Function *func, IRBuilder* pBuilder);     // 添加return指令(主要针对Void函数)
-  static bool SysYCondBr2Br(Function *func, IRBuilder* pBuilder);  // 条件分支(已知cond的值)转换为无条件分支
+  static bool SysYBlockMerge(Function *func);    // 合并基本块
+  static bool SysYAddReturn(Function *func, IRBuilder* pBuilder);     // 添加return指令
+  static bool SysYCondBr2Br(Function *func, IRBuilder* pBuilder);  // 条件分支转换为无条件分支
 };

-}  // namespace sysy
+// ======================================================================
+// 独立的CFG优化遍
+// ======================================================================
+
+class SysYDelInstAfterBrPass : public OptimizationPass {
+public:
+  static void *ID; // 唯一ID
+  SysYDelInstAfterBrPass() : OptimizationPass("SysYDelInstAfterBrPass", Granularity::Function) {}
+  bool runOnFunction(Function *F, AnalysisManager& AM) override;
+  void getAnalysisUsage(std::set<void *> &analysisDependencies, std::set<void *> &analysisInvalidations) const override {
+    // 这个优化可能改变CFG结构，使一些CFG相关的分析失效
+    // 可以在这里指定哪些分析会失效，例如支配树、活跃变量等
+    // analysisInvalidations.insert(DominatorTreeAnalysisPass::ID); // 示例
+  }
+  void *getPassID() const override { return &ID; }
+};
+
+class SysYDelEmptyBlockPass : public OptimizationPass {
+private:
+  IRBuilder *pBuilder;
+public:
+  static void *ID;
+  SysYDelEmptyBlockPass(IRBuilder *builder) : OptimizationPass("SysYDelEmptyBlockPass", Granularity::Function), pBuilder(builder) {}
+  bool runOnFunction(Function *F, AnalysisManager& AM) override;
+  void *getPassID() const override { return &ID; }
+};
+
+class SysYDelNoPreBLockPass : public OptimizationPass {
+public:
+  static void *ID;
+  SysYDelNoPreBLockPass() : OptimizationPass("SysYDelNoPreBLockPass", Granularity::Function) {}
+  bool runOnFunction(Function *F, AnalysisManager& AM) override;
+  void *getPassID() const override { return &ID; }
+};
+
+class SysYBlockMergePass : public OptimizationPass {
+public:
+  static void *ID;
+  SysYBlockMergePass() : OptimizationPass("SysYBlockMergePass", Granularity::Function) {}
+  bool runOnFunction(Function *F, AnalysisManager& AM) override;
+  void *getPassID() const override { return &ID; }
+};
+
+class SysYAddReturnPass : public OptimizationPass {
+private:
+  IRBuilder *pBuilder;
+public:
+  static void *ID;
+  SysYAddReturnPass(IRBuilder *builder) : OptimizationPass("SysYAddReturnPass", Granularity::Function), pBuilder(builder) {}
+  bool runOnFunction(Function *F, AnalysisManager& AM) override;
+  void *getPassID() const override { return &ID; }
+};
+
+class SysYCondBr2BrPass : public OptimizationPass {
+private:
+  IRBuilder *pBuilder;
+public:
+  static void *ID;
+  SysYCondBr2BrPass(IRBuilder *builder) : OptimizationPass("SysYCondBr2BrPass", Granularity::Function), pBuilder(builder) {}
+  bool runOnFunction(Function *F, AnalysisManager& AM) override;
+  void *getPassID() const override { return &ID; }
+};
+
+}  // namespace sysy
--- a/src/include/SysYIROptUtils.h
+++ b/src/include/SysYIROptUtils.h
@@ -10,15 +10,12 @@ namespace sysy {
 class SysYIROptUtils{

 public:
-  // 删除use关系
-  // 根据指令的使用情况删除其所有的use关系
-  // 找到指令的所有使用者，并从它们的使用列表中删除该指令
+  // 仅仅删除use关系
  static void usedelete(Instruction *instr) {
    for (auto &use : instr->getOperands()) {
      Value* val = use->getValue();
      val->removeUse(use);
    }
-    instr->getParent()->removeInst(instr); // 从基本块中删除指令
  }

  // 判断是否是全局变量