[midend]优化中端框架，移除无用旧代码，ignore格式文件

src/include/DeadCodeElimination.h

@@ -1,36 +0,0 @@
-#pragma once
-
-#include "IR.h"
-#include "SysYIRAnalyser.h"
-#include "SysYIRPrinter.h"
-#include "SysYIROptUtils.h"
-
-namespace sysy {
-
-class DeadCodeElimination {
- private:
-  Module *pModule;
-  ControlFlowAnalysis *pCFA;  // 控制流分析指针
-  ActiveVarAnalysis *pAVA;  // 活跃变量分析指针
-  DataFlowAnalysisUtils dataFlowAnalysisUtils;  // 数据流分析工具类
-
- public:
-  explicit DeadCodeElimination(Module *pMoudle, 
-                               ControlFlowAnalysis *pCFA = nullptr,
-                               ActiveVarAnalysis *pAVA = nullptr)
-      : pModule(pMoudle), pCFA(pCFA), pAVA(pAVA), dataFlowAnalysisUtils() {}  // 构造函数
-
-  // TODO：根据参数传入的passes来运行不同的死代码删除流程
-  // void runDCEPipeline(const std::vector<std::string>& passes = {
-  //       "dead-store", "redundant-load-store", "dead-load", "dead-alloca", "dead-global"
-  // });
-  void runDCEPipeline();  // 运行死代码删除
-
-  void eliminateDeadStores(Function* func, bool& changed);    // 消除无用存储
-  void eliminateDeadLoads(Function* func, bool& changed);     // 消除无用加载
-  void eliminateDeadAllocas(Function* func, bool& changed);   // 消除无用内存分配
-  void eliminateDeadGlobals(bool& changed);   // 消除无用全局变量
-  void eliminateDeadIndirectiveAllocas(Function* func, bool& changed);  // 消除无用间接内存分配(phi节点)
-  void eliminateDeadRedundantLoadStore(Function* func, bool& changed);  // 消除冗余加载和存储
-};
-}  // namespace sysy

src/include/Dom.h

@@ -41,7 +41,7 @@ public:
     // 实现 getPassID
     void* getPassID() const override { return &ID; }
 
-    bool runOnFunction(Function* F) override;
+    bool runOnFunction(Function* F, AnalysisManager &AM) override;
 
     std::unique_ptr<AnalysisResultBase> getResult() override;
 

src/include/Liveness.h

@@ -20,7 +20,8 @@ class Instruction;
 class LivenessAnalysisResult : public AnalysisResultBase {
 public:
   LivenessAnalysisResult(Function *F); // 构造函数，需要一个函数来关联结果
-
+  LivenessAnalysisResult::LivenessAnalysisResult(Function *F) : AssociatedFunction(F) {}
+  
   // 获取给定基本块的 LiveIn 集合
   const std::set<Value *> *getLiveIn(BasicBlock *BB) const;
 
@@ -52,7 +53,7 @@ public:
   static char ID; // LLVM 风格的唯一 ID
 
   LivenessAnalysisPass() : AnalysisPass("LivenessAnalysis", Pass::Granularity::Function) {}
-
+    
   // 实现 getPassID
   void *getPassID() const override { return &ID; }
 

src/include/Mem2Reg.h

@@ -1,79 +0,0 @@
-// 假设 Mem2Reg.h 看起来像这样 (你需要根据实际情况调整)
-#ifndef SYSY_MEM2REG_H
-#define SYSY_MEM2REG_H
-
-#include <vector>
-#include <unordered_map>
-#include <unordered_set>
-#include <stack>
-#include <queue> // For computeIteratedDomFrontiers
-
-// Include your IR and analysis headers
-#include "IR.h"
-#include "IRBuilder.h"
-#include "SysYIRAnalyser.h"
-#include "SysYIROptUtils.h"
-
-namespace sysy {
-
-class Mem2Reg {
-private:
-  Module* pModule;
-  IRBuilder* pBuilder;
-  ControlFlowAnalysis* controlFlowAnalysis;
-  ActiveVarAnalysis* activeVarAnalysis;
-  DataFlowAnalysisUtils dataFlowAnalysisUtils; // If this is part of Mem2Reg or an external helper
-
-public:
-  Mem2Reg(Module* module, IRBuilder* builder, ControlFlowAnalysis* cfa, ActiveVarAnalysis* ava)
-    : pModule(module), pBuilder(builder), controlFlowAnalysis(cfa), activeVarAnalysis(ava) {}
-    // Constructor initializes members
-  void run();
-
-  // --- 新增的私有成员变量和方法，用于SSA转换上下文 ---
-  // 这是核心，用于存储 SSA 转换过程中的状态
-  std::vector<AllocaInst*> currentFunctionAllocas; // 当前函数中所有可提升的 alloca
-  // alloca -> set of BasicBlocks where it's defined (stored into)
-  std::unordered_map<AllocaInst*, std::unordered_set<BasicBlock*>> allocaDefsBlock; 
-  // alloca -> set of BasicBlocks where it's used (loaded from)
-  std::unordered_map<AllocaInst*, std::unordered_set<BasicBlock*>> allocaUsesBlock; 
-
-  // BasicBlock -> Map of (PhiInst, Original AllocaInst)
-  // 用于在 rename 阶段通过 phi 指令找到它代表的原始 alloca
-  std::unordered_map<BasicBlock*, std::unordered_map<PhiInst*, AllocaInst*>> phiMap;
-  std::vector<PhiInst*> allPhiInstructions; // 收集所有创建的 Phi 指令以便后续简化和清理
-
-  // --- 核心 SSA 转换辅助函数 ---
-  // 计算给定定义块集合的迭代支配边界
-  std::unordered_set<BasicBlock*> computeIteratedDomFrontiers(const std::unordered_set<BasicBlock*>& blocks);
-
-  // 分析一个 alloca 的所有 uses，填充 allocaDefsBlock 和 allocaUsesBlock
-  void allocaAnalysis(AllocaInst* alloca);
-
-  // 判断一个 alloca 是否可以被提升为寄存器 (无地址逃逸，标量类型)
-  bool is_promoted(AllocaInst* alloca);
-
-  // 在迭代支配边界处插入 Phi 指令
-  void insertPhiNodes(Function* func);
-
-  // 递归地重命名基本块中的变量并填充 Phi 指令
-  // 这里的 `count` 和 `stacks` 是临时的，用于 DFS 过程中传递状态
-  void renameBlock(BasicBlock* block, 
-                      std::unordered_map<AllocaInst*, Value*>& currentIncomings,
-                      std::unordered_set<BasicBlock*>& visitedBlocks); // 修改为传递 map 和 set
-
-  // 简化冗余的 Phi 指令 (当所有输入都相同时)
-  void simplifyphi(PhiInst* phi);
-
-  // 获取前驱块在后继块前驱列表中的索引，用于 Phi 指令入边
-  int getPredIndex(BasicBlock* pred, BasicBlock* succ);
-
-  // --- Mem2Reg 的主要工作流函数 ---
-  // 对单个函数执行内存到寄存器的提升
-  bool promoteMemoryToRegisters(Function* func);
-
-};
-
-} // namespace sysy
-
-#endif // SYSY_MEM2REG_H

src/include/Pass.h

@@ -111,6 +111,9 @@ private:
 // AnalysisManager: 负责管理和提供分析结果
 // ======================================================================
 class AnalysisManager {
+private:
+  std::map<std::pair<Function *, void *>, std::unique_ptr<AnalysisResultBase>> cachedResults;
+  // cachedResults 存储分析结果，键是 (Function*, AnalysisPass ID)
 public:
   AnalysisManager() = default;
   ~AnalysisManager() = default;
@@ -172,97 +175,38 @@ public:
       cachedResults = std::move(newCachedResults);
     }
   }
-
-private:
-  std::map<std::pair<Function *, void *>, std::unique_ptr<AnalysisResultBase>> cachedResults;
 };
 
 // ======================================================================
 // PassManager：遍管理器
 // ======================================================================
 class PassManager {
-  
+private:
+  std::vector<std::unique_ptr<Pass>> passes;
+  AnalysisManager analysisManager;
   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));
+  PassManager(Module *module) : pmodule(module) {
+    analysisManager = AnalysisManager(); // 初始化分析管理器
   }
-
+  
   // 运行所有注册的遍
-  bool run(Module *M) {
-    bool changed = false;
-    for (const auto &p : passes) {
-      bool passChanged = false; // 记录当前遍是否修改了 IR
+  bool run();
+  
+  // 运行优化管道主要负责注册和运行优化遍
+  // 这里可以根据 optLevel 和 DEBUG 控制不同的优化遍
+  void runOptimizationPipeline(Module* moduleIR, int optLevel);
 
-      // 处理优化遍的分析依赖和失效
-      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;
-  }
+  // 添加遍：现在接受 Pass 的 ID，而不是直接的 unique_ptr
+  void addPass(void *passID);
 
   AnalysisManager &getAnalysisManager() { return analysisManager; }
 
-private:
-  std::vector<std::unique_ptr<Pass>> passes;
-  AnalysisManager analysisManager;
+
 };
 
 // ======================================================================

src/include/Reg2Mem.h

@@ -1,22 +0,0 @@
-#pragma once
-
-#include "IR.h"
-#include "IRBuilder.h"
-#include "SysYIROptUtils.h"
-
-namespace sysy {
-/**
- * Reg2Mem(后端未做phi指令翻译)
- */
-class Reg2Mem {
-private:
-  Module *pModule;
-  IRBuilder *pBuilder;
-
-public:
-  Reg2Mem(Module *pMoudle, IRBuilder *pBuilder) : pModule(pMoudle), pBuilder(pBuilder) {}
-
-  void DeletePhiInst();
-};
-
-} // namespace sysy

src/include/SysYIRPass.h

@@ -1,59 +0,0 @@
-#pragma once
-
-#include "IR.h"
-
-namespace sysy {
-
-// 前置声明
-class FunctionPass;
-class ModulePass;
-class AnalysisPass;
-class PassManager;
-
-// 抽象基类 Pass
-class Pass {
-public:
-    enum PassKind {
-        PK_Function,
-        PK_Module,
-        PK_Analysis
-    };
-
-    Pass(PassKind kind, const std::string& name) : Kind(kind), Name(name) {}
-    virtual ~Pass() = default;
-
-    PassKind getPassKind() const { return Kind; }
-    const std::string& getPassName() const { return Name; }
-
-    // 每个Pass需要实现此方法来执行其逻辑
-    // 具体的run方法将根据Pass类型在FunctionPass和ModulePass中定义
-protected:
-    PassKind Kind;
-    std::string Name;
-};
-
-// 针对函数的优化遍
-class FunctionPass : public Pass {
-public:
-    FunctionPass(const std::string& name) : Pass(PK_Function, name) {}
-    // 真正的优化逻辑将在此方法中实现
-    virtual bool runOnFunction(Function& F) = 0;
-};
-
-// 针对模块的优化遍
-class ModulePass : public Pass {
-public:
-    ModulePass(const std::string& name) : Pass(PK_Module, name) {}
-    // 真正的优化逻辑将在此方法中实现
-    virtual bool runOnModule(Module& M) = 0;
-};
-
-// 分析遍
-class AnalysisPass : public Pass {
-public:
-    AnalysisPass(const std::string& name) : Pass(PK_Analysis, name) {}
-    // 分析遍通常需要一个模块或函数作为输入，并计算出分析结果
-    // 具体分析结果的存储和访问方式需要设计
-};
-
-} // namespace sysy