debugging

src/include/Mem2Reg.h

@@ -0,0 +1,58 @@
+#pragma once
+
+#include <list>
+#include <memory>
+#include <stack>
+#include <unordered_map>
+#include <unordered_set>
+#include "IR.h"
+#include "IRBuilder.h"
+#include "SysYIRAnalyser.h"
+
+namespace sysy {
+/**
+ * 实现静态单变量赋值核心类 mem2reg
+ */
+class Mem2Reg {
+private:
+  Module *pModule;
+  IRBuilder *pBuilder;
+  ActiveVarAnalysis *activeVarAnalysis;  // 活跃变量分析
+  ControlFlowAnalysis *controlFlowAnalysis;  // 控制流分析
+  DataFlowAnalysisUtils dataFlowAnalysisUtils;
+
+public:
+  Mem2Reg(Module *pMoudle, IRBuilder *pBuilder) : 
+    pModule(pMoudle), pBuilder(pBuilder), activeVarAnalysis(nullptr), controlFlowAnalysis(nullptr), dataFlowAnalysisUtils()
+   {}  // 初始化函数
+
+  void mem2regPipeline();  ///< mem2reg
+
+private:
+
+  // phi节点的插入需要计算IDF
+  std::unordered_set<BasicBlock *> computeIterDf(const std::unordered_set<BasicBlock *> &blocks);  ///< 计算定义块集合的迭代支配边界
+
+  auto computeValue2Blocks() -> void;  ///< 计算value2block的映射(不包括数组和global)
+
+  auto preOptimize1() -> void;  ///< llvm memtoreg预优化1: 删除不含load的alloc和store
+  auto preOptimize2() -> void;  ///< llvm memtoreg预优化2: 针对某个变量的Defblocks只有一个块的情况
+  auto preOptimize3() -> void;  ///< llvm memtoreg预优化3: 针对某个变量的所有读写都在同一个块中的情况
+
+  auto insertPhi() -> void;  ///< 为所有变量的迭代支配边界插入phi结点
+
+  auto rename(BasicBlock *block, std::unordered_map<Value *, int> &count,
+              std::unordered_map<Value *, std::stack<Instruction *>> &stacks) -> void;  ///< 单个块的重命名
+  auto renameAll() -> void;                                                             ///< 重命名所有块
+
+  // private helper function.
+private:
+  auto getPredIndex(BasicBlock *n, BasicBlock *s) -> int;  ///< 获取前驱索引
+  auto cascade(Instruction *instr, bool &changed, Function *func, BasicBlock *block,
+               std::list<std::unique_ptr<Instruction>> &instrs) -> void;  ///< 消除级联关系
+  auto isGlobal(Value *val) -> bool;                                      ///< 判断是否是全局变量
+  auto isArr(Value *val) -> bool;                                         ///< 判断是否是数组
+  auto usedelete(Instruction *instr) -> void;                             ///< 删除指令相关的value-use-user关系
+
+};
+}  // namespace sysy

src/include/SysYIRAnalyser.h

@@ -55,7 +55,6 @@ public:
     dominant_frontiers = df; 
   }
   
-  
   // TODO：循环分析操作方法
   
   // 清空所有分析信息
@@ -113,34 +112,86 @@ public:
   void removeCallee(Function* callee) { callees.erase(callee); }
   void clearCallees() { callees.clear(); }
   
-  // 循环分析操作
-  Loop* getLoopOfBasicBlock(BasicBlock* bb) { 
-    auto it = basicblock2Loop.find(bb);
-    return it != basicblock2Loop.end() ? it->second : nullptr; 
-  }
-  
-  void addBBToLoop(BasicBlock* bb, Loop* loop) { basicblock2Loop[bb] = loop; }
-  
-  unsigned getLoopDepthByBlock(BasicBlock* bb) {
-    Loop* loop = getLoopOfBasicBlock(bb);
-    return loop ? loop->getLoopDepth() : 0;
-  }
   
   // 值-块映射操作
-  void addValue2AllocBlocks(Value* value, BasicBlock* block) { value2AllocBlocks[value] = block; }
-  
   BasicBlock* getAllocBlockByValue(Value* value) { 
       auto it = value2AllocBlocks.find(value);
       return it != value2AllocBlocks.end() ? it->second : nullptr;
   }
-  
+  std::unordered_set<BasicBlock *> getDefBlocksByValue(Value *value) {
+    std::unordered_set<BasicBlock *> blocks;
+    if (value2DefBlocks.count(value) > 0) {
+      for (const auto &pair : value2DefBlocks[value]) {
+        blocks.insert(pair.first);
+      }
+    }
+    return blocks;
+  }
+  std::unordered_set<BasicBlock *> getUseBlocksByValue(Value *value) {
+    std::unordered_set<BasicBlock *> blocks;
+    if (value2UseBlocks.count(value) > 0) {
+      for (const auto &pair : value2UseBlocks[value]) {
+        blocks.insert(pair.first);
+      }
+    }
+    return blocks;
+  }
+
   // 值定义/使用操作
+  void addValue2AllocBlocks(Value* value, BasicBlock* block) { value2AllocBlocks[value] = block; }
   void addValue2DefBlocks(Value* value, BasicBlock* block) { ++value2DefBlocks[value][block]; }
   void addValue2UseBlocks(Value* value, BasicBlock* block) { ++value2UseBlocks[value][block]; }
   
+
+  // 获取值定义/使用信息
+  std::unordered_map<Value *, BasicBlock *>& getValue2AllocBlocks() {
+    return value2AllocBlocks;
+  }
+  std::unordered_map<Value *, std::unordered_map<BasicBlock *, int>>& getValue2DefBlocks() {
+    return value2DefBlocks;
+  } 
+  std::unordered_map<Value *, std::unordered_map<BasicBlock *, int>>& getValue2UseBlocks() {
+    return value2UseBlocks;
+  }
+  std::unordered_set<Value *> getValuesOfDefBlock() {
+    std::unordered_set<Value *> values;
+    for (const auto &pair : value2DefBlocks) {
+      values.insert(pair.first);
+    }
+    return values;
+  }
+
+  // 删除信息操作
+  void removeValue2AllocBlock(Value *value) { value2AllocBlocks.erase(value); }
+  bool removeValue2DefBlock(Value *value, BasicBlock *block) {
+    bool changed = false;
+    if (--value2DefBlocks[value][block] == 0) {
+      value2DefBlocks[value].erase(block);
+      if (value2DefBlocks[value].empty()) {
+        value2DefBlocks.erase(value);
+        changed = true;
+      }
+    }
+    return changed;
+  }
+  bool removeValue2UseBlock(Value *value, BasicBlock *block) {
+    bool changed = false;
+    if (--value2UseBlocks[value][block] == 0) {
+      value2UseBlocks[value].erase(block);
+      if (value2UseBlocks[value].empty()) {
+        value2UseBlocks.erase(value);
+        changed = true;
+      }
+    }
+    return changed;
+  }
+
   // 间接分配操作
   void addIndirectAlloca(AllocaInst* alloca) { indirectAllocas.emplace_back(alloca); }
-  
+  std::list<std::unique_ptr<AllocaInst>>& getIndirectAllocas() { return indirectAllocas; }
+
+  // TODO：循环分析操作
+
   // 清空所有分析信息
   void clear() {
     attribute = PlaceHolder;
@@ -256,12 +307,28 @@ public:
 class ControlFlowAnalysis {
 private:
   Module *pModule;  ///< 模块
-  std::unordered_map<BasicBlock*, BlockAnalysisInfo*> blockAnalysisInfo;  // 基本块分析信息
+  std::unordered_map<BasicBlock*, BlockAnalysisInfo*> blockAnalysisInfo;  // 基本块分析信息表
   std::unordered_map<Function*, FunctionAnalysisInfo*> functionAnalysisInfo;  // 函数分析信息
 
 public:
   explicit ControlFlowAnalysis(Module *pMoudle) : pModule(pMoudle) {} 
 
+  // 获取基本块分析信息
+  BlockAnalysisInfo* getBlockAnalysisInfo(BasicBlock *block) {
+    auto it = blockAnalysisInfo.find(block);
+    if (it != blockAnalysisInfo.end()) {
+      return it->second;
+    }
+    return nullptr;  // 如果未找到，返回nullptr
+  }
+  FunctionAnalysisInfo* getFunctionAnalysisInfo(Function *func) {
+    auto it = functionAnalysisInfo.find(func);
+    if (it != functionAnalysisInfo.end()) {
+      return it->second;
+    }
+    return nullptr;  // 如果未找到，返回nullptr
+  }
+
   void init();  // 初始化分析器
   void computeDomNode();  // 计算必经结点
   void computeDomTree();  // 构造支配树
@@ -310,14 +377,9 @@ private:
 
 public:
   DataFlowAnalysisUtils() = default;
-  
-  // 统一构造
-  DataFlowAnalysisUtils(
-    std::vector<DataFlowAnalysis *> forwardList = {},
-    std::vector<DataFlowAnalysis *> backwardList = {})
-    : forwardAnalysisList(std::move(forwardList)),
-      backwardAnalysisList(std::move(backwardList)) {}
-  
+  ~DataFlowAnalysisUtils() {
+    clear();  // 析构时清理所有分析器
+  }
   // 统一添加接口
   void addAnalyzers(
     std::vector<DataFlowAnalysis *> forwardList,
@@ -392,10 +454,10 @@ class ActiveVarAnalysis : public DataFlowAnalysis {
   }
 };
 
-// 分析管理器
-class AnalysisManager {
+// 分析管理器 后续实现
+// class AnalysisManager {
 
-};
+// };