[midend]将alloca声明统一到entry块，增加mem2reg的机会，TODO：不是很明白为什么开了优化过不了一些样例正在排查原因

src/backend/RISCv64/RISCv64Backend.cpp

@@ -12,6 +12,39 @@ std::string RISCv64CodeGen::code_gen() {
     return module_gen();
 }
 
+unsigned RISCv64CodeGen::getTypeSizeInBytes(Type* type) {
+    if (!type) {
+        assert(false && "Cannot get size of a null type.");
+        return 0;
+    }
+
+    switch (type->getKind()) {
+        // 对于SysY语言，基本类型int和float都占用4字节
+        case Type::kInt:
+        case Type::kFloat:
+            return 4;
+
+        // 指针类型在RISC-V 64位架构下占用8字节
+        // 虽然SysY没有'int*'语法，但数组变量在IR层面本身就是指针类型
+        case Type::kPointer:
+            return 8;
+
+        // 数组类型的总大小 = 元素数量 * 单个元素的大小
+        case Type::kArray: {
+            auto arrayType = type->as<ArrayType>();
+            // 递归调用以计算元素大小
+            return arrayType->getNumElements() * getTypeSizeInBytes(arrayType->getElementType());
+        }
+
+        // 其他类型，如Void, Label等不占用栈空间，或者不应该出现在这里
+        default:
+            // 如果遇到未处理的类型，触发断言，方便调试
+            // assert(false && "Unsupported type for size calculation.");
+            return 0; // 对于像Label或Void这样的类型，返回0是合理的
+    }
+}
+
+
 void printInitializer(std::stringstream& ss, const ValueCounter& init_values) {
     for (size_t i = 0; i < init_values.getValues().size(); ++i) {
         auto val = init_values.getValues()[i];
@@ -39,18 +72,36 @@ std::string RISCv64CodeGen::module_gen() {
 
     for (const auto& global_ptr : module->getGlobals()) {
         GlobalValue* global = global_ptr.get();
+        
+        // [核心修改] 使用更健壮的逻辑来判断是否为大型零初始化数组
+        bool is_all_zeros = true;
         const auto& init_values = global->getInitValues();
         
-        // 判断是否为大型零初始化数组，以便放入.bss段
-        bool is_large_zero_array = false;
-        if (init_values.getValues().size() == 1) {
-            if (auto const_val = dynamic_cast<ConstantValue*>(init_values.getValues()[0])) {
-                if (const_val->isInt() && const_val->getInt() == 0 && init_values.getNumbers()[0] > 16) {
-                    is_large_zero_array = true;
+        // 检查初始化值是否全部为0
+        if (init_values.getValues().empty()) {
+            // 如果 ValueCounter 为空，GlobalValue 的构造函数会确保它是零初始化的
+            is_all_zeros = true;
+        } else {
+            for (auto val : init_values.getValues()) {
+                if (auto const_val = dynamic_cast<ConstantValue*>(val)) {
+                    if (!const_val->isZero()) {
+                        is_all_zeros = false;
+                        break;
+                    }
+                } else {
+                    // 如果初始值包含非常量（例如，另一个全局变量的地址），则不认为是纯零初始化
+                    is_all_zeros = false;
+                    break;
                 }
             }
         }
 
+        // 使用 getTypeSizeInBytes 检查总大小是否超过阈值 (16个整数 = 64字节)
+        Type* allocated_type = global->getType()->as<PointerType>()->getBaseType();
+        unsigned total_size = getTypeSizeInBytes(allocated_type);
+        
+        bool is_large_zero_array = is_all_zeros && (total_size > 64);
+
         if (is_large_zero_array) {
             bss_globals.push_back(global);
         } else {
@@ -58,12 +109,12 @@ std::string RISCv64CodeGen::module_gen() {
         }
     }
 
-    // --- 步骤2：生成 .bss 段的代码 (这部分不变) ---
+    // --- 步骤2：生成 .bss 段的代码 ---
     if (!bss_globals.empty()) {
         ss << ".bss\n";
         for (GlobalValue* global : bss_globals) {
-            unsigned count = global->getInitValues().getNumbers()[0];
-            unsigned total_size = count * 4; // 假设元素都是4字节
+            Type* allocated_type = global->getType()->as<PointerType>()->getBaseType();
+            unsigned total_size = getTypeSizeInBytes(allocated_type);
 
             ss << "    .align 3\n";
             ss << ".globl " << global->getName() << "\n";
@@ -74,33 +125,45 @@ std::string RISCv64CodeGen::module_gen() {
         }
     }
     
-    // --- [修改] 步骤3：生成 .data 段的代码 ---
-    // 我们需要检查 data_globals 和 常量列表是否都为空
+    // --- 步骤3：生成 .data 段的代码 ---
     if (!data_globals.empty() || !module->getConsts().empty()) {
         ss << ".data\n";
 
-        // a. 先处理普通的全局变量 (GlobalValue)
+        // a. 处理普通的全局变量 (GlobalValue)
         for (GlobalValue* global : data_globals) {
+            Type* allocated_type = global->getType()->as<PointerType>()->getBaseType();
+            unsigned total_size = getTypeSizeInBytes(allocated_type);
+            
+            ss << "    .align 3\n";
             ss << ".globl " << global->getName() << "\n";
+            ss << ".type " << global->getName() << ", @object\n";
+            ss << ".size " << global->getName() << ", " << total_size << "\n";
             ss << global->getName() << ":\n";
             printInitializer(ss, global->getInitValues());
         }
 
-        // b. [新增] 再处理全局常量 (ConstantVariable)
+        // b. 处理全局常量 (ConstantVariable)
         for (const auto& const_ptr : module->getConsts()) {
             ConstantVariable* cnst = const_ptr.get();
+            Type* allocated_type = cnst->getType()->as<PointerType>()->getBaseType();
+            unsigned total_size = getTypeSizeInBytes(allocated_type);
+
+            ss << "    .align 3\n";
             ss << ".globl " << cnst->getName() << "\n";
+            ss << ".type " << cnst->getName() << ", @object\n";
+            ss << ".size " << cnst->getName() << ", " << total_size << "\n";
             ss << cnst->getName() << ":\n";
             printInitializer(ss, cnst->getInitValues());
         }
     }
 
-    // --- 处理函数 (.text段) 的逻辑保持不变 ---
+    // --- 步骤4：处理函数 (.text段) 的逻辑 ---
     if (!module->getFunctions().empty()) {
         ss << ".text\n";
         for (const auto& func_pair : module->getFunctions()) {
-            if (func_pair.second.get()) {
+            if (func_pair.second.get() && !func_pair.second->getBasicBlocks().empty()) {
                 ss << function_gen(func_pair.second.get());
+                if (DEBUG) std::cerr << "Function: " << func_pair.first << " generated.\n";
             }
         }
     }

src/include/backend/RISCv64/RISCv64Backend.h

@@ -22,6 +22,10 @@ private:
     // 函数级代码生成 (实现新的流水线)
     std::string function_gen(Function* func);
 
+    
+    // 私有辅助函数，用于根据类型计算其占用的字节数。
+    unsigned getTypeSizeInBytes(Type* type);
+    
     Module* module;
 };
 

src/include/midend/IR.h

@@ -576,7 +576,9 @@ public:
     if (iter != predecessors.end()) {
       predecessors.erase(iter);
     } else {
-      assert(false);
+      // 如果没有找到前驱块，可能是因为它已经被移除或不存在
+      // 这可能是一个错误情况，或者是因为在CFG优化过程中已经处理
+      // assert(false && "Predecessor block not found in BasicBlock");
     }
   }
   void removeSuccessor(BasicBlock *block) {
@@ -584,7 +586,9 @@ public:
     if (iter != successors.end()) {
       successors.erase(iter);
     } else {
-      assert(false);
+      // 如果没有找到后继块，可能是因为它已经被移除或不存在
+      // 这可能是一个错误情况，或者是因为在CFG优化过程中已经处理
+      // assert(false && "Successor block not found in BasicBlock");
     }
   }
   void replacePredecessor(BasicBlock *oldBlock, BasicBlock *newBlock) {
@@ -916,10 +920,23 @@ class PhiInst : public Instruction {
   Value* getIncomingValue(unsigned k) const {return getOperand(2 * k);}  ///< 获取位置为k的值
   BasicBlock* getIncomingBlock(unsigned k) const {return dynamic_cast<BasicBlock*>(getOperand(2 * k + 1));}
 
+  Value* getIncomingValue(BasicBlock* blk) const {
+    return getvalfromBlk(blk);
+  }  ///< 获取指定基本块的传入值
+
+  BasicBlock* getIncomingBlock(Value* val) const {
+    return getBlkfromVal(val);
+  }  ///< 获取指定值的传入基本块
+
+  void replaceIncoming(BasicBlock *oldBlock, BasicBlock *newBlock, Value *newValue){
+    delBlk(oldBlock);
+    addIncoming(newValue, newBlock);
+  }
+
   auto& getincomings() const {return blk2val;}  ///< 获取所有的基本块和对应的值
 
-  Value* getvalfromBlk(BasicBlock* blk);
-  BasicBlock* getBlkfromVal(Value* val);
+  Value* getvalfromBlk(BasicBlock* blk) const ;
+  BasicBlock* getBlkfromVal(Value* val) const ;
 
   unsigned getNumIncomingValues() const { return vsize; }  ///< 获取传入值的数量
   void addIncoming(Value *value, BasicBlock *block) {
@@ -930,6 +947,10 @@ class PhiInst : public Instruction {
     vsize++;
   }  ///< 添加传入值和对应的基本块
 
+  void removeIncoming(BasicBlock *block){
+    delBlk(block);
+  }
+
   void delValue(Value* val);
   void delBlk(BasicBlock* blk);
 

src/include/midend/Pass/Analysis/Dom.h

@@ -6,30 +6,82 @@
 #include <set>
 #include <vector>
 #include <algorithm>
+#include <functional>
 
 namespace sysy {
 
-// 支配树分析结果类 (保持不变)
+// 支配树分析结果类
 class DominatorTree : public AnalysisResultBase {
 public:
     DominatorTree(Function* F);
+    // 获取指定基本块的所有支配者
     const std::set<BasicBlock*>* getDominators(BasicBlock* BB) const;
-    BasicBlock* getImmediateDominator(BasicBlock* BB) const;
-    const std::set<BasicBlock*>* getDominanceFrontier(BasicBlock* BB) const;
+    // 获取指定基本块的即时支配者 (Immediate Dominator)
+    BasicBlock* getImmediateDominator(BasicBlock* BB) const;  
+    // 获取指定基本块的支配边界 (Dominance Frontier)
+    const std::set<BasicBlock*>* getDominanceFrontier(BasicBlock* BB) const;   
+    // 获取指定基本块在支配树中的子节点
     const std::set<BasicBlock*>* getDominatorTreeChildren(BasicBlock* BB) const;
+    // 额外的 Getter：获取所有支配者、即时支配者和支配边界的完整映射（可选，主要用于调试或特定场景）
     const std::map<BasicBlock*, std::set<BasicBlock*>>& getDominatorsMap() const { return Dominators; }
     const std::map<BasicBlock*, BasicBlock*>& getIDomsMap() const { return IDoms; }
     const std::map<BasicBlock*, std::set<BasicBlock*>>& getDominanceFrontiersMap() const { return DominanceFrontiers; }
+
+    // 计算所有基本块的支配者集合
     void computeDominators(Function* F);
-    void computeIDoms(Function* F);
+    // 计算所有基本块的即时支配者（内部使用 Lengauer-Tarjan 算法）
+    void computeIDoms(Function* F); 
+    // 计算所有基本块的支配边界
     void computeDominanceFrontiers(Function* F);
+    // 计算支配树的结构（即每个节点的直接子节点）
     void computeDominatorTreeChildren(Function* F);
 private:
+    // 与该支配树关联的函数
     Function* AssociatedFunction;
-    std::map<BasicBlock*, std::set<BasicBlock*>> Dominators;
-    std::map<BasicBlock*, BasicBlock*> IDoms;
-    std::map<BasicBlock*, std::set<BasicBlock*>> DominanceFrontiers;
-    std::map<BasicBlock*, std::set<BasicBlock*>> DominatorTreeChildren;
+    std::map<BasicBlock*, std::set<BasicBlock*>> Dominators;       // 每个基本块的支配者集合
+    std::map<BasicBlock*, BasicBlock*> IDoms;                      // 每个基本块的即时支配者
+    std::map<BasicBlock*, std::set<BasicBlock*>> DominanceFrontiers; // 每个基本块的支配边界
+    std::map<BasicBlock*, std::set<BasicBlock*>> DominatorTreeChildren; // 支配树中每个基本块的子节点
+
+    // ==========================================================
+    // Lengauer-Tarjan 算法内部所需的数据结构和辅助函数
+    // 这些成员是私有的，以封装 LT 算法的复杂性并避免命名空间污染
+    // ==========================================================
+
+    // DFS 遍历相关：
+    std::map<BasicBlock*, int> dfnum_map;            // 存储每个基本块的 DFS 编号
+    std::vector<BasicBlock*> vertex_vec;             // 通过 DFS 编号反向查找对应的基本块指针
+    std::map<BasicBlock*, BasicBlock*> parent_map;   // 存储 DFS 树中每个基本块的父节点
+    int df_counter;                                  // DFS 计数器，也代表 DFS 遍历的总节点数 (N)
+
+    // 半支配者 (Semi-dominator) 相关：
+    std::map<BasicBlock*, BasicBlock*> sdom_map;     // 存储每个基本块的半支配者
+    std::map<BasicBlock*, BasicBlock*> idom_map;     // 存储每个基本块的即时支配者 (IDom)
+    std::map<BasicBlock*, std::vector<BasicBlock*>> bucket_map; // 桶结构，用于存储具有相同半支配者的节点，以延迟 IDom 计算
+
+    // 并查集 (Union-Find) 相关（用于 evalAndCompress 函数）：
+    std::map<BasicBlock*, BasicBlock*> ancestor_map; // 并查集中的父节点（用于路径压缩）
+    std::map<BasicBlock*, BasicBlock*> label_map;    // 并查集中，每个集合的代表节点（或其路径上 sdom 最小的节点）
+
+    // ==========================================================
+    // 辅助计算函数 (私有)
+    // ==========================================================
+
+    // 计算基本块的逆后序遍历 (Reverse Post Order, RPO) 顺序
+    // RPO 用于优化支配者计算和 LT 算法的效率
+    std::vector<BasicBlock*> computeReversePostOrder(Function* F);
+
+    // Lengauer-Tarjan 算法特定的辅助 DFS 函数
+    // 用于初始化 dfnum_map, vertex_vec, parent_map
+    void dfs_lt_helper(BasicBlock* u);                 
+    
+    // 结合了并查集的 Find 操作和 LT 算法的 Eval 操作
+    // 用于在路径压缩时更新 label，找到路径上 sdom 最小的节点
+    BasicBlock* evalAndCompress_lt_helper(BasicBlock* i); 
+    
+    // 并查集的 Link 操作
+    // 将 v_child 挂载到 u_parent 的并查集树下
+    void link_lt_helper(BasicBlock* u_parent, BasicBlock* v_child); 
 };
 
 

src/include/midend/Pass/Optimize/Mem2Reg.h

@@ -75,11 +75,7 @@ private:
     // --------------------------------------------------------------------
 
     // 对支配树进行深度优先遍历，重命名变量并替换 load/store 指令
-    // alloca: 当前正在处理的 AllocaInst
-    // currentBB: 当前正在遍历的基本块
-    // dt: 支配树分析结果
-    // valueStack: 存储当前 AllocaInst 在当前路径上可见的 SSA 值栈
-    void renameVariables(AllocaInst* alloca, BasicBlock* currentBB);
+    void renameVariables(BasicBlock* currentBB);
 
     // --------------------------------------------------------------------
     // 阶段4: 清理

src/midend/IR.cpp

@@ -569,15 +569,15 @@ void User::replaceOperand(unsigned index, Value *value) {
  * phi相关函数
  */
 
-Value* PhiInst::getvalfromBlk(BasicBlock* blk){
-  refreshB2VMap();
+Value* PhiInst::getvalfromBlk(BasicBlock* blk) const {
+  // refreshB2VMap();
   if( blk2val.find(blk) != blk2val.end()) {
     return blk2val.at(blk);
   }
   return nullptr;
 }
 
-BasicBlock* PhiInst::getBlkfromVal(Value* val){
+BasicBlock* PhiInst::getBlkfromVal(Value* val) const {
   // 返回第一个值对应的基本块
   for(unsigned i = 0; i < vsize; i++) {
     if(getValue(i) == val) {
@@ -591,6 +591,9 @@ void PhiInst::delValue(Value* val){
   //根据value删除对应的基本块和值
   unsigned i = 0;
   BasicBlock* blk = getBlkfromVal(val);
+  if(blk == nullptr) {
+    return; // 如果val没有对应的基本块，直接返回
+  }
   for(i = 0; i < vsize; i++) {
     if(getValue(i) == val) {
       break;
@@ -606,6 +609,9 @@ void PhiInst::delBlk(BasicBlock* blk){
   //根据Blk删除对应的基本块和值
   unsigned i = 0;
   Value* val = getvalfromBlk(blk);
+  if(val == nullptr) {
+    return; // 如果blk没有对应的值，直接返回
+  }
   for(i = 0; i < vsize; i++) {
     if(getBlock(i) == blk) {
       break;
@@ -618,9 +624,12 @@ void PhiInst::delBlk(BasicBlock* blk){
 }
 
 void PhiInst::replaceBlk(BasicBlock* newBlk, unsigned k){
-  refreshB2VMap();
+  // refreshB2VMap();
   BasicBlock* oldBlk = getBlock(k);
   Value* val = blk2val.at(oldBlk);
+  if(newBlk == oldBlk || oldBlk == nullptr) {
+    return; // 如果新旧基本块相同，直接返回
+  }
   // Value* val = blk2val.at(getBlock(k));
   // 替换基本块
   setOperand(2 * k + 1, newBlk);
@@ -630,7 +639,7 @@ void PhiInst::replaceBlk(BasicBlock* newBlk, unsigned k){
 }
 
 void PhiInst::replaceold2new(BasicBlock* oldBlk, BasicBlock* newBlk){
-  refreshB2VMap();
+  // refreshB2VMap();
   Value* val = blk2val.at(oldBlk);
   // 替换基本块
   delBlk(oldBlk);

src/midend/Pass/Analysis/Dom.cpp

@@ -1,19 +1,30 @@
 #include "Dom.h"
-#include <limits> // for std::numeric_limits
+#include <algorithm> // for std::set_intersection, std::reverse
+#include <iostream>  // for debug output
+#include <limits>    // for std::numeric_limits
 #include <queue>
+#include <functional> // for std::function
+#include <map>
+#include <vector>
+#include <set>
 
 namespace sysy {
 
-// 初始化 支配树静态 ID
+// ==============================================================
+// DominatorTreeAnalysisPass 的静态ID
+// ==============================================================
 void *DominatorTreeAnalysisPass::ID = (void *)&DominatorTreeAnalysisPass::ID;
+
 // ==============================================================
 // DominatorTree 结果类的实现
 // ==============================================================
 
+// 构造函数：初始化关联函数，但不进行计算
 DominatorTree::DominatorTree(Function *F) : AssociatedFunction(F) {
-  // 构造时可以不计算，在分析遍运行里计算并填充
+  // 构造时不需要计算，在分析遍运行里计算并填充
 }
 
+// Getter 方法 (保持不变)
 const std::set<BasicBlock *> *DominatorTree::getDominators(BasicBlock *BB) const {
   auto it = Dominators.find(BB);
   if (it != Dominators.end()) {
@@ -38,164 +49,437 @@ const std::set<BasicBlock *> *DominatorTree::getDominanceFrontier(BasicBlock *BB
   return nullptr;
 }
 
-const std::set<BasicBlock*>* DominatorTree::getDominatorTreeChildren(BasicBlock* BB) const {
-    auto it = DominatorTreeChildren.find(BB);
-    if (it != DominatorTreeChildren.end()) {
-        return &(it->second);
-    }
-    return nullptr;
+const std::set<BasicBlock *> *DominatorTree::getDominatorTreeChildren(BasicBlock *BB) const {
+  auto it = DominatorTreeChildren.find(BB);
+  if (it != DominatorTreeChildren.end()) {
+    return &(it->second);
+  }
+  return nullptr;
 }
 
-void DominatorTree::computeDominators(Function *F) {
-  // 经典的迭代算法计算支配者集合
-  // TODO: 可以替换为更高效的算法，如 Lengauer-Tarjan 算法
-  BasicBlock *entryBlock = F->getEntryBlock();
+// 辅助函数：打印 BasicBlock 集合 (保持不变)
+void printBBSet(const std::string &prefix, const std::set<BasicBlock *> &s) {
+  if (!DEBUG)
+    return;
+  std::cout << prefix << "{";
+  bool first = true;
+  for (const auto &bb : s) {
+    if (!first)
+      std::cout << ", ";
+    std::cout << bb->getName();
+    first = false;
+  }
+  std::cout << "}" << std::endl;
+}
 
-  for (const auto &bb_ptr : F->getBasicBlocks()) {
-    BasicBlock *bb = bb_ptr.get();
+// 辅助函数：计算逆后序遍历 (RPO) - 保持不变
+std::vector<BasicBlock*> DominatorTree::computeReversePostOrder(Function* F) {
+    std::vector<BasicBlock*> postOrder;
+    std::set<BasicBlock*> visited;
+    
+    std::function<void(BasicBlock*)> dfs_rpo =
+        [&](BasicBlock* bb) {
+        visited.insert(bb);
+        for (BasicBlock* succ : bb->getSuccessors()) {
+            if (visited.find(succ) == visited.end()) {
+                dfs_rpo(succ);
+            }
+        }
+        postOrder.push_back(bb);
+    };
+
+    dfs_rpo(F->getEntryBlock());
+    std::reverse(postOrder.begin(), postOrder.end());
+    
+    if (DEBUG) {
+        std::cout << "--- Computed RPO: ";
+        for (BasicBlock* bb : postOrder) {
+            std::cout << bb->getName() << " ";
+        }
+        std::cout << "---" << std::endl;
+    }
+    return postOrder;
+}
+
+// computeDominators 方法 (保持不变，因为它它是独立于IDom算法的)
+void DominatorTree::computeDominators(Function *F) {
+  if (DEBUG)
+    std::cout << "--- Computing Dominators ---" << std::endl;
+
+  BasicBlock *entryBlock = F->getEntryBlock();
+  std::vector<BasicBlock*> bbs_rpo = computeReversePostOrder(F);
+
+  for (BasicBlock *bb : bbs_rpo) {
     if (bb == entryBlock) {
+      Dominators[bb].clear();
       Dominators[bb].insert(bb);
+      if (DEBUG) std::cout << "Init Dominators[" << bb->getName() << "]: {" << bb->getName() << "}" << std::endl;
     } else {
-      for (const auto &all_bb_ptr : F->getBasicBlocks()) {
-        Dominators[bb].insert(all_bb_ptr.get());
+      Dominators[bb].clear();
+      for (BasicBlock *all_bb : bbs_rpo) {
+        Dominators[bb].insert(all_bb);
+      }
+      if (DEBUG) {
+        std::cout << "Init Dominators[" << bb->getName() << "]: ";
+        printBBSet("", Dominators[bb]);
       }
     }
   }
 
   bool changed = true;
+  int iteration = 0;
   while (changed) {
     changed = false;
-    for (const auto &bb_ptr : F->getBasicBlocks()) {
-      BasicBlock *bb = bb_ptr.get();
-      if (bb == entryBlock)
-        continue;
+    iteration++;
+    if (DEBUG) std::cout << "Iteration " << iteration << std::endl;
+
+    for (BasicBlock *bb : bbs_rpo) {
+      if (bb == entryBlock) continue;
 
       std::set<BasicBlock *> newDom;
-      bool firstPred = true;
+      bool firstPredProcessed = false;
+
       for (BasicBlock *pred : bb->getPredecessors()) {
-        if (Dominators.count(pred)) {
-          if (firstPred) {
-            newDom = Dominators[pred];
-            firstPred = false;
-          } else {
-            std::set<BasicBlock *> intersection;
-            std::set_intersection(newDom.begin(), newDom.end(), Dominators[pred].begin(), Dominators[pred].end(),
-                                  std::inserter(intersection, intersection.begin()));
-            newDom = intersection;
-          }
+        if(DEBUG){
+          std::cout << "  Processing predecessor: " << pred->getName() << std::endl;
         }
+          if (!firstPredProcessed) {
+              newDom = Dominators[pred];
+              firstPredProcessed = true;
+          } else {
+              std::set<BasicBlock *> intersection;
+              std::set_intersection(newDom.begin(), newDom.end(), Dominators[pred].begin(), Dominators[pred].end(),
+                                     std::inserter(intersection, intersection.begin()));
+              newDom = intersection;
+          }
       }
       newDom.insert(bb);
 
       if (newDom != Dominators[bb]) {
+        if (DEBUG) {
+          std::cout << "  Dominators[" << bb->getName() << "] changed from ";
+          printBBSet("", Dominators[bb]);
+          std::cout << "  to ";
+          printBBSet("", newDom);
+        }
         Dominators[bb] = newDom;
         changed = true;
       }
     }
   }
+  if (DEBUG)
+    std::cout << "--- Dominators Computation Finished ---" << std::endl;
 }
 
-void DominatorTree::computeIDoms(Function *F) {
-  // 采用与之前类似的简化实现。TODO:Lengauer-Tarjan等算法。
-  BasicBlock *entryBlock = F->getEntryBlock();
-  IDoms[entryBlock] = nullptr;
+// ==============================================================
+// Lengauer-Tarjan 算法辅助数据结构和函数 (私有成员)
+// ==============================================================
 
-  for (const auto &bb_ptr : F->getBasicBlocks()) {
-    BasicBlock *bb = bb_ptr.get();
-    if (bb == entryBlock)
-      continue;
-
-    BasicBlock *currentIDom = nullptr;
-    const std::set<BasicBlock *> *domsOfBB = getDominators(bb);
-    if (!domsOfBB)
-      continue;
-
-    for (BasicBlock *D : *domsOfBB) {
-      if (D == bb)
-        continue;
-
-      bool isCandidateIDom = true;
-      for (BasicBlock *candidate : *domsOfBB) {
-        if (candidate == bb || candidate == D)
-          continue;
-        const std::set<BasicBlock *> *domsOfCandidate = getDominators(candidate);
-        if (domsOfCandidate && domsOfCandidate->count(D) == 0 && domsOfBB->count(candidate)) {
-          isCandidateIDom = false;
-          break;
-        }
-      }
-      if (isCandidateIDom) {
-        currentIDom = D;
-        break;
-      }
+// DFS 遍历，填充 dfnum_map, vertex_vec, parent_map
+// 对应用户代码的 dfs 函数
+void DominatorTree::dfs_lt_helper(BasicBlock* u) {
+    dfnum_map[u] = df_counter;
+    if (df_counter >= vertex_vec.size()) { // 动态调整大小
+        vertex_vec.resize(df_counter + 1);
+    }
+    vertex_vec[df_counter] = u;
+    if (DEBUG) std::cout << "  DFS: Visiting " << u->getName() << ", dfnum = " << df_counter << std::endl;
+    df_counter++;
+
+    for (BasicBlock* v : u->getSuccessors()) {
+        if (dfnum_map.find(v) == dfnum_map.end()) { // 如果 v 未访问过
+            parent_map[v] = u;
+            if (DEBUG) std::cout << "    DFS: Setting parent[" << v->getName() << "] = " << u->getName() << std::endl;
+            dfs_lt_helper(v);
+        }
     }
-    IDoms[bb] = currentIDom;
-  }
 }
 
+// 并查集：找到集合的代表，并进行路径压缩
+// 同时更新 label，确保 label[i] 总是指向其祖先链中 sdom_map 最小的节点
+// 对应用户代码的 find 函数，也包含了 eval 的逻辑
+BasicBlock* DominatorTree::evalAndCompress_lt_helper(BasicBlock* i) {
+    if (DEBUG) std::cout << "    Eval: Processing " << i->getName() << std::endl;
+    // 如果 i 是根 (ancestor_map[i] == nullptr)
+    if (ancestor_map.find(i) == ancestor_map.end() || ancestor_map[i] == nullptr) {
+        if (DEBUG) std::cout << "      Eval: " << i->getName() << " is root, returning itself." << std::endl;
+        return i; // 根节点自身就是路径上sdom最小的，因为它没有祖先
+    }
+    
+    // 如果 i 的祖先不是根，则递归查找并进行路径压缩
+    BasicBlock* root_ancestor = evalAndCompress_lt_helper(ancestor_map[i]);
+    
+    // 路径压缩时，根据 sdom_map 比较并更新 label_map
+    // 确保 label_map[i] 存储的是 i 到 root_ancestor 路径上 sdom_map 最小的节点
+    // 注意：这里的 ancestor_map[i] 已经被递归调用压缩过一次了，所以是root_ancestor的旧路径
+    // 应该比较的是 label_map[ancestor_map[i]] 和 label_map[i]
+    if (sdom_map.count(label_map[ancestor_map[i]]) && // 确保 label_map[ancestor_map[i]] 存在 sdom
+        sdom_map.count(label_map[i]) &&                // 确保 label_map[i] 存在 sdom
+        dfnum_map[sdom_map[label_map[ancestor_map[i]]]] < dfnum_map[sdom_map[label_map[i]]]) {
+        if (DEBUG) std::cout << "      Eval: Updating label for " << i->getName() << " from " 
+                              << label_map[i]->getName() << " to " << label_map[ancestor_map[i]]->getName() << std::endl;
+        label_map[i] = label_map[ancestor_map[i]];
+    }
+    
+    ancestor_map[i] = root_ancestor; // 执行路径压缩：将 i 直接指向其所属集合的根
+    if (DEBUG) std::cout << "      Eval: Path compression for " << i->getName() << ", new ancestor = " 
+                          << (root_ancestor ? root_ancestor->getName() : "nullptr") << std::endl;
+    
+    return label_map[i]; // <-- **将这里改为返回 label_map[i]**
+}
+
+// Link 函数：将 v 加入 u 的 DFS 树子树中 (实际上是并查集操作)
+// 对应用户代码的 fa[u] = fth[u];
+void DominatorTree::link_lt_helper(BasicBlock* u_parent, BasicBlock* v_child) {
+    ancestor_map[v_child] = u_parent; // 设置并查集父节点
+    label_map[v_child] = v_child;     // 初始化 label 为自身
+    if (DEBUG) std::cout << "  Link: " << v_child->getName() << " linked to " << u_parent->getName() << std::endl;
+}
+
+// ==============================================================
+// Lengauer-Tarjan 算法实现 computeIDoms
+// ==============================================================
+void DominatorTree::computeIDoms(Function *F) {
+    if (DEBUG) std::cout << "--- Computing Immediate Dominators (IDoms) using Lengauer-Tarjan ---" << std::endl;
+
+    BasicBlock *entryBlock = F->getEntryBlock();
+
+    // 1. 初始化所有 LT 相关的数据结构
+    dfnum_map.clear();
+    vertex_vec.clear();
+    parent_map.clear();
+    sdom_map.clear();
+    idom_map.clear();
+    bucket_map.clear();
+    ancestor_map.clear();
+    label_map.clear();
+    df_counter = 0; // DFS 计数器从 0 开始
+
+    // 预分配 vertex_vec 的大小，避免频繁resize
+    vertex_vec.resize(F->getBasicBlocks().size() + 1); 
+    // 在 DFS 遍历之前，先为所有基本块初始化 sdom 和 label
+    // 这是 Lengauer-Tarjan 算法的要求，确保所有节点在 Phase 2 开始前都在 map 中
+    for (auto &bb_ptr : F->getBasicBlocks()) {
+        BasicBlock* bb = bb_ptr.get();
+        sdom_map[bb] = bb; // sdom(bb) 初始化为 bb 自身
+        label_map[bb] = bb; // label(bb) 初始化为 bb 自身 (用于 Union-Find 的路径压缩)
+    }
+    // 确保入口块也被正确初始化（如果它不在 F->getBasicBlocks() 的正常迭代中）
+    sdom_map[entryBlock] = entryBlock;
+    label_map[entryBlock] = entryBlock;
+    // Phase 1: DFS 遍历并预处理
+    // 对应用户代码的 dfs(st)
+    dfs_lt_helper(entryBlock);
+    idom_map[entryBlock] = nullptr; // 入口块没有即时支配者
+    if (DEBUG) std::cout << "  IDom[" << entryBlock->getName() << "] = nullptr" << std::endl;
+
+    if (DEBUG) std::cout << "  Sdom[" << entryBlock->getName() << "] = " << entryBlock->getName() << std::endl;
+    
+    // 初始化并查集的祖先和 label
+    for (auto const& [bb_key, dfn_val] : dfnum_map) {
+        ancestor_map[bb_key] = nullptr; // 初始为独立集合的根
+        label_map[bb_key] = bb_key;   // 初始 label 为自身
+    }
+
+    if (DEBUG) {
+        std::cout << "  --- DFS Phase Complete ---" << std::endl;
+        std::cout << "  dfnum_map:" << std::endl;
+        for (auto const& [bb, dfn] : dfnum_map) {
+            std::cout << "    " << bb->getName() << " -> " << dfn << std::endl;
+        }
+        std::cout << "  vertex_vec (by dfnum):" << std::endl;
+        for (size_t k = 0; k < df_counter; ++k) {
+            if (vertex_vec[k]) std::cout << "    [" << k << "] -> " << vertex_vec[k]->getName() << std::endl;
+        }
+        std::cout << "  parent_map:" << std::endl;
+        for (auto const& [child, parent] : parent_map) {
+            std::cout << "    " << child->getName() << " -> " << (parent ? parent->getName() : "nullptr") << std::endl;
+        }
+        std::cout << "  ------------------------" << std::endl;
+    }
+
+
+    // Phase 2: 计算半支配者 (sdom)
+    // 对应用户代码的 for (int i = dfc; i >= 2; --i) 循环的上半部分
+    // 按照 DFS 编号递减的顺序遍历所有节点 (除了 entryBlock，它的 DFS 编号是 0)
+    if (DEBUG) std::cout << "--- Phase 2: Computing Semi-Dominators (sdom) ---" << std::endl;
+    for (int i = df_counter - 1; i >= 1; --i) { // 从 DFS 编号最大的节点开始，到 1
+        BasicBlock* w = vertex_vec[i]; // 当前处理的节点
+        if (DEBUG) std::cout << "  Processing node w: " << w->getName() << " (dfnum=" << i << ")" << std::endl;
+
+
+        // 对于 w 的每个前驱 v
+        for (BasicBlock* v : w->getPredecessors()) {
+            if (DEBUG) std::cout << "    Considering predecessor v: " << v->getName() << std::endl;
+            // 如果前驱 v 未被 DFS 访问过 (即不在 dfnum_map 中)，则跳过
+            if (dfnum_map.find(v) == dfnum_map.end()) {
+                if (DEBUG) std::cout << "      Predecessor " << v->getName() << " not in DFS tree, skipping." << std::endl;
+                continue; 
+            }
+
+            // 调用 evalAndCompress 来找到 v 在其 DFS 树祖先链上具有最小 sdom 的节点
+            BasicBlock* u_with_min_sdom_on_path = evalAndCompress_lt_helper(v);
+            if (DEBUG) std::cout << "      Eval(" << v->getName() << ") returned " 
+                                  << u_with_min_sdom_on_path->getName() << std::endl;
+            if (DEBUG && sdom_map.count(u_with_min_sdom_on_path) && sdom_map.count(w)) {
+                std::cout << "      Comparing sdom: dfnum[" << sdom_map[u_with_min_sdom_on_path]->getName() << "] (" << dfnum_map[sdom_map[u_with_min_sdom_on_path]] 
+                          << ") vs dfnum[" << sdom_map[w]->getName() << "] (" << dfnum_map[sdom_map[w]] << ")" << std::endl;
+            }
+            // 比较 sdom(u) 和 sdom(w)
+            if (sdom_map.count(u_with_min_sdom_on_path) && sdom_map.count(w) &&
+                dfnum_map[sdom_map[u_with_min_sdom_on_path]] < dfnum_map[sdom_map[w]]) {
+                if (DEBUG) std::cout << "      Updating sdom[" << w->getName() << "] from " 
+                                      << sdom_map[w]->getName() << " to " 
+                                      << sdom_map[u_with_min_sdom_on_path]->getName() << std::endl;
+                sdom_map[w] = sdom_map[u_with_min_sdom_on_path]; // 更新 sdom(w)
+                if (DEBUG) std::cout << "      Sdom update applied. New sdom[" << w->getName() << "] = " << sdom_map[w]->getName() << std::endl;
+            }
+        }
+        
+        // 将 w 加入 sdom(w) 对应的桶中
+        bucket_map[sdom_map[w]].push_back(w);
+        if (DEBUG) std::cout << "    Adding " << w->getName() << " to bucket of sdom(" << w->getName() << "): " 
+                              << sdom_map[w]->getName() << std::endl;
+
+        // 将 w 的父节点加入并查集 (link 操作)
+        if (parent_map.count(w) && parent_map[w] != nullptr) {
+            link_lt_helper(parent_map[w], w);
+        }
+        
+        // Phase 3-part 1: 处理 parent[w] 的桶中所有节点，确定部分 idom
+        if (parent_map.count(w) && parent_map[w] != nullptr) {
+            BasicBlock* p = parent_map[w]; // p 是 w 的父节点
+            if (DEBUG) std::cout << "    Processing bucket for parent " << p->getName() << std::endl;
+
+            // 注意：这里需要复制桶的内容，因为原始桶在循环中会被clear
+            std::vector<BasicBlock*> nodes_in_p_bucket_copy = bucket_map[p];
+            for (BasicBlock* y : nodes_in_p_bucket_copy) {
+                if (DEBUG) std::cout << "      Processing node y from bucket: " << y->getName() << std::endl;
+                // 找到 y 在其 DFS 树祖先链上具有最小 sdom 的节点
+                BasicBlock* u = evalAndCompress_lt_helper(y);
+                if (DEBUG) std::cout << "        Eval(" << y->getName() << ") returned " << u->getName() << std::endl;
+                
+                // 确定 idom(y)
+                // if sdom(eval(y)) == sdom(parent(w)), then idom(y) = parent(w)
+                // else idom(y) = eval(y)
+                if (sdom_map.count(u) && sdom_map.count(p) &&
+                    dfnum_map[sdom_map[u]] < dfnum_map[sdom_map[p]]) {
+                    idom_map[y] = u; // 确定的 idom
+                    if (DEBUG) std::cout << "        IDom[" << y->getName() << "] set to " << u->getName() << std::endl;
+                } else {
+                    idom_map[y] = p; // p 是 y 的 idom
+                    if (DEBUG) std::cout << "        IDom[" << y->getName() << "] set to " << p->getName() << std::endl;
+                }
+            }
+            bucket_map[p].clear(); // 清空桶，防止重复处理
+            if (DEBUG) std::cout << "    Cleared bucket for parent " << p->getName() << std::endl;
+        }
+    }
+
+    // Phase 3-part 2: 最终确定 idom (处理那些 idom != sdom 的节点)
+    if (DEBUG) std::cout << "--- Phase 3: Finalizing Immediate Dominators (idom) ---" << std::endl;
+    for (int i = 1; i < df_counter; ++i) { // 从 DFS 编号最小的节点 (除了 entryBlock) 开始
+        BasicBlock* w = vertex_vec[i];
+        if (DEBUG) std::cout << "  Finalizing node w: " << w->getName() << std::endl;
+        if (idom_map.count(w) && sdom_map.count(w) && idom_map[w] != sdom_map[w]) {
+            // idom[w] 的 idom 是其真正的 idom
+            if (DEBUG) std::cout << "    idom[" << w->getName() << "] (" << idom_map[w]->getName() 
+                                  << ") != sdom[" << w->getName() << "] (" << sdom_map[w]->getName() << ")" << std::endl;
+            if (idom_map.count(idom_map[w])) {
+                idom_map[w] = idom_map[idom_map[w]];
+                if (DEBUG) std::cout << "    Updating idom[" << w->getName() << "] to idom(idom(w)): " 
+                                      << idom_map[w]->getName() << std::endl;
+            } else {
+                 if (DEBUG) std::cout << "    Warning: idom(idom(" << w->getName() << ")) not found, leaving idom[" << w->getName() << "] as is." << std::endl;
+            }
+        }
+        if (DEBUG) {
+            std::cout << "  Final IDom[" << w->getName() << "] = " << (idom_map[w] ? idom_map[w]->getName() : "nullptr") << std::endl;
+        }
+    }
+
+    // 将计算结果从 idom_map 存储到 DominatorTree 的成员变量 IDoms 中
+    IDoms = idom_map; 
+
+    if (DEBUG) std::cout << "--- Immediate Dominators Computation Finished ---" << std::endl;
+}
+
+// ==============================================================
+// computeDominanceFrontiers 和 computeDominatorTreeChildren (保持不变)
+// ==============================================================
+
 void DominatorTree::computeDominanceFrontiers(Function *F) {
-  // 经典的支配边界计算算法
+  if (DEBUG)
+    std::cout << "--- Computing Dominance Frontiers ---" << std::endl;
+
   for (const auto &bb_ptr_X : F->getBasicBlocks()) {
     BasicBlock *X = bb_ptr_X.get();
     DominanceFrontiers[X].clear();
 
-    for (BasicBlock *Y : X->getSuccessors()) {
-      const std::set<BasicBlock *> *domsOfY = getDominators(Y);
-      if (domsOfY && domsOfY->find(X) == domsOfY->end()) {
-        DominanceFrontiers[X].insert(Y);
-      }
-    }
-
-    const std::set<BasicBlock *> *domsOfX = getDominators(X);
-    if (!domsOfX)
-      continue;
     for (const auto &bb_ptr_Z : F->getBasicBlocks()) {
       BasicBlock *Z = bb_ptr_Z.get();
-      if (Z == X)
-        continue;
       const std::set<BasicBlock *> *domsOfZ = getDominators(Z);
-      if (domsOfZ && domsOfZ->count(X) && Z != X) {
 
-        for (BasicBlock *Y : Z->getSuccessors()) {
-          const std::set<BasicBlock *> *domsOfY = getDominators(Y);
-          if (domsOfY && domsOfY->find(X) == domsOfY->end()) {
-            DominanceFrontiers[X].insert(Y);
-          }
+      if (!domsOfZ || domsOfZ->find(X) == domsOfZ->end()) { // Z 不被 X 支配
+        continue;
+      }
+
+      for (BasicBlock *Y : Z->getSuccessors()) {
+        const std::set<BasicBlock *> *domsOfY = getDominators(Y);
+        // 如果 Y == X，或者 Y 不被 X 严格支配 (即 Y 不被 X 支配)
+        if (Y == X || (domsOfY && domsOfY->find(X) == domsOfY->end())) {
+          DominanceFrontiers[X].insert(Y);
         }
       }
     }
+    if (DEBUG) {
+      std::cout << "  DF(" << X->getName() << "): ";
+      printBBSet("", DominanceFrontiers[X]);
+    }
   }
+  if (DEBUG)
+    std::cout << "--- Dominance Frontiers Computation Finished ---" << std::endl;
 }
 
 void DominatorTree::computeDominatorTreeChildren(Function *F) {
+  if (DEBUG)
+    std::cout << "--- Computing Dominator Tree Children ---" << std::endl;
+  // 首先清空，确保重新计算时是空的
+  for (auto &bb_ptr : F->getBasicBlocks()) {
+    DominatorTreeChildren[bb_ptr.get()].clear();
+  }
+
   for (auto &bb_ptr : F->getBasicBlocks()) {
     BasicBlock *B = bb_ptr.get();
-    auto it = getImmediateDominator(B);
-    if (it != nullptr) {
-      BasicBlock *A = it;
-      if (A) {
-        DominatorTreeChildren[A].insert(B);
+    BasicBlock *A = getImmediateDominator(B); // A 是 B 的即时支配者
+
+    if (A) { // 如果 B 有即时支配者 A (即 B 不是入口块)
+      DominatorTreeChildren[A].insert(B);
+      if (DEBUG) {
+        std::cout << "  " << B->getName() << " is child of " << A->getName() << std::endl;
       }
     }
   }
+  if (DEBUG)
+    std::cout << "--- Dominator Tree Children Computation Finished ---" << std::endl;
 }
 
 // ==============================================================
-// DominatorTreeAnalysisPass 的实现
+// DominatorTreeAnalysisPass 的实现 (保持不变)
 // ==============================================================
 
-
-bool DominatorTreeAnalysisPass::runOnFunction(Function* F, AnalysisManager &AM) {
+bool DominatorTreeAnalysisPass::runOnFunction(Function *F, AnalysisManager &AM) {
+  // 每次运行时清空旧数据，确保重新计算
   CurrentDominatorTree = std::make_unique<DominatorTree>(F);
+
   CurrentDominatorTree->computeDominators(F);
-  CurrentDominatorTree->computeIDoms(F);
+  CurrentDominatorTree->computeIDoms(F); // 修正后的LT算法
   CurrentDominatorTree->computeDominanceFrontiers(F);
   CurrentDominatorTree->computeDominatorTreeChildren(F);
   return false;
 }
 
 std::unique_ptr<AnalysisResultBase> DominatorTreeAnalysisPass::getResult() {
-  // 返回计算好的 DominatorTree 实例，所有权转移给 AnalysisManager
   return std::move(CurrentDominatorTree);
 }
 

src/midend/Pass/Optimize/Mem2Reg.cpp

@@ -60,7 +60,7 @@ void Mem2RegContext::run(Function *func, AnalysisManager *AM) {
   }
 
   // 从入口基本块开始，对支配树进行 DFS 遍历，进行变量重命名
-  renameVariables(nullptr, func->getEntryBlock()); // 第一个参数 alloca 在这里不使用，因为是递归入口点
+  renameVariables(func->getEntryBlock()); // 第一个参数 alloca 在这里不使用，因为是递归入口点
 
   // --------------------------------------------------------------------
   // 阶段4: 清理
@@ -209,16 +209,21 @@ void Mem2RegContext::insertPhis(AllocaInst *alloca, const std::unordered_set<Bas
 }
 
 // 对支配树进行深度优先遍历，重命名变量并替换 load/store 指令
-void Mem2RegContext::renameVariables(AllocaInst *currentAlloca, BasicBlock *currentBB) {
-  // 维护一个局部栈，用于存储当前基本块中为 Phi 和 Store 创建的 SSA 值，以便在退出时弹出
-  std::stack<Value *> localStackPushed;
+// 移除了 AllocaInst *currentAlloca 参数，因为这个函数是为整个基本块处理所有可提升的 Alloca
+void Mem2RegContext::renameVariables(BasicBlock *currentBB) {
+  // 1. 在函数开始时，记录每个 promotableAlloca 的当前栈深度。
+  // 这将用于在函数返回时精确地回溯栈状态。
+  std::map<AllocaInst *, size_t> originalStackSizes;
+  for (auto alloca : promotableAllocas) {
+    originalStackSizes[alloca] = allocaToValueStackMap[alloca].size();
+  }
 
   // --------------------------------------------------------------------
   // 处理当前基本块的指令
   // --------------------------------------------------------------------
   for (auto instIter = currentBB->getInstructions().begin(); instIter != currentBB->getInstructions().end();) {
     Instruction *inst = instIter->get();
-    bool instDeleted = false;
+      bool instDeleted = false;
 
     // 处理 Phi 指令 (如果是当前 alloca 的 Phi)
     if (auto phiInst = dynamic_cast<PhiInst *>(inst)) {
@@ -227,55 +232,69 @@ void Mem2RegContext::renameVariables(AllocaInst *currentAlloca, BasicBlock *curr
         if (allocaToPhiMap[alloca].count(currentBB) && allocaToPhiMap[alloca][currentBB] == phiInst) {
           // 为 Phi 指令的输出创建一个新的 SSA 值，并压入值栈
           allocaToValueStackMap[alloca].push(phiInst);
-          localStackPushed.push(phiInst); // 记录以便弹出
-          break;                          // 找到对应的 alloca，处理下一个指令
+          if (DEBUG) {
+            std::cout << "Mem2Reg: Pushed Phi " << (phiInst->getName().empty() ? "anonymous" : phiInst->getName()) << " for alloca " << alloca->getName()
+              << ". Stack size: " << allocaToValueStackMap[alloca].size() << std::endl;
+          }
+          break; // 找到对应的 alloca，处理下一个指令
         }
       }
     }
     // 处理 LoadInst
     else if (auto loadInst = dynamic_cast<LoadInst *>(inst)) {
-      // 检查这个 LoadInst 是否是为某个可提升的 alloca
       for (auto alloca : promotableAllocas) {
-        if (loadInst->getPointer() == alloca) { 
-          // loadInst->getPointer() 返回 AllocaInst*
-          // 将 LoadInst 的所有用途替换为当前 alloca 值栈顶部的 SSA 值
+        // 检查 LoadInst 的指针是否直接是 alloca，或者是指向 alloca 的 GEP
+        Value *ptrOperand = loadInst->getPointer();
+        if (ptrOperand == alloca || (dynamic_cast<GetElementPtrInst *>(ptrOperand) &&
+                                     dynamic_cast<GetElementPtrInst *>(ptrOperand)->getBasePointer() == alloca)) {
           assert(!allocaToValueStackMap[alloca].empty() && "Value stack empty for alloca during load replacement!");
-          if(DEBUG){
-            std::cout << "Mem2Reg: Replacing load " << loadInst->getPointer()->getName() << " with SSA value." << std::endl;
+          if (DEBUG) {
+            std::cout << "Mem2Reg: Replacing load "
+                      << (ptrOperand->getName().empty() ? "anonymous" : ptrOperand->getName()) << " with SSA value "
+                      << (allocaToValueStackMap[alloca].top()->getName().empty()
+                              ? "anonymous"
+                              : allocaToValueStackMap[alloca].top()->getName())
+                      << " for alloca " << alloca->getName() << std::endl;
+            std::cout << "Mem2Reg: allocaToValueStackMap[" << alloca->getName()
+                      << "] size: " << allocaToValueStackMap[alloca].size() << std::endl;
           }
           loadInst->replaceAllUsesWith(allocaToValueStackMap[alloca].top());
           instIter = SysYIROptUtils::usedelete(instIter);
           instDeleted = true;
-          // std::cerr << "Mem2Reg: Replaced load " << loadInst->name() << " with SSA value." << std::endl;
           break;
         }
       }
     }
     // 处理 StoreInst
     else if (auto storeInst = dynamic_cast<StoreInst *>(inst)) {
-      // 检查这个 StoreInst 是否是为某个可提升的 alloca
       for (auto alloca : promotableAllocas) {
-        if (storeInst->getPointer() == alloca) { 
-          // 假设 storeInst->getPointer() 返回 AllocaInst*
-          // 将 StoreInst 存储的值作为新的 SSA 值，压入值栈
-          if(DEBUG){
-            std::cout << "Mem2Reg: Replacing store to " << storeInst->getPointer()->getName() << " with SSA value." << std::endl;
+        // 检查 StoreInst 的指针是否直接是 alloca，或者是指向 alloca 的 GEP
+        Value *ptrOperand = storeInst->getPointer();
+        if (ptrOperand == alloca || (dynamic_cast<GetElementPtrInst *>(ptrOperand) &&
+                                     dynamic_cast<GetElementPtrInst *>(ptrOperand)->getBasePointer() == alloca)) {
+          if (DEBUG) {
+            std::cout << "Mem2Reg: Replacing store to "
+                      << (ptrOperand->getName().empty() ? "anonymous" : ptrOperand->getName()) << " with SSA value "
+                      << (storeInst->getValue()->getName().empty() ? "anonymous" : storeInst->getValue()->getName())
+                      << " for alloca " << alloca->getName() << std::endl;
+            std::cout << "Mem2Reg: allocaToValueStackMap[" << alloca->getName()
+                      << "] size before push: " << allocaToValueStackMap[alloca].size() << std::endl;
           }
           allocaToValueStackMap[alloca].push(storeInst->getValue());
-          localStackPushed.push(storeInst->getValue());          // 记录以便弹出
           instIter = SysYIROptUtils::usedelete(instIter);
           instDeleted = true;
-          // std::cerr << "Mem2Reg: Replaced store to " << storeInst->ptr()->name() << " with SSA value." << std::endl;
+          if (DEBUG) {
+            std::cout << "Mem2Reg: allocaToValueStackMap[" << alloca->getName()
+                      << "] size after push: " << allocaToValueStackMap[alloca].size() << std::endl;
+          }
           break;
         }
       }
     }
-
     if (!instDeleted) {
       ++instIter; // 如果指令没有被删除，移动到下一个
     }
   }
-
   // --------------------------------------------------------------------
   // 处理后继基本块的 Phi 指令参数
   // --------------------------------------------------------------------
@@ -290,40 +309,57 @@ void Mem2RegContext::renameVariables(AllocaInst *currentAlloca, BasicBlock *curr
         // 参数值是当前 alloca 值栈顶部的 SSA 值
         assert(!allocaToValueStackMap[alloca].empty() && "Value stack empty for alloca when setting phi operand!");
         phiInst->addIncoming(allocaToValueStackMap[alloca].top(), currentBB);
+        if (DEBUG) {
+          std::cout << "Mem2Reg: Added incoming arg to Phi "
+                    << (phiInst->getName().empty() ? "anonymous" : phiInst->getName()) << " from "
+                    << currentBB->getName() << " with value "
+                    << (allocaToValueStackMap[alloca].top()->getName().empty()
+                            ? "anonymous"
+                            : allocaToValueStackMap[alloca].top()->getName())
+                    << std::endl;
+        }
       }
     }
   }
-
   // --------------------------------------------------------------------
   // 递归访问支配树的子节点
   // --------------------------------------------------------------------
   const std::set<BasicBlock *> *dominatedBlocks = dt->getDominatorTreeChildren(currentBB);
-  if(dominatedBlocks){
+  if (dominatedBlocks) { // 检查是否存在子节点
+    if(DEBUG){
+      std::cout << "Mem2Reg: Processing dominated blocks for " << currentBB->getName() << std::endl;
+      for (auto dominatedBB : *dominatedBlocks) {
+        std::cout << "Mem2Reg: Dominated block: " << (dominatedBB ? dominatedBB->getName() : "null") << std::endl;
+      }
+    }
     for (auto dominatedBB : *dominatedBlocks) {
-      if (dominatedBB) {
-        if(DEBUG){
-          std::cout << "Mem2Reg: Recursively renaming variables in dominated block: " << dominatedBB->getName() << std::endl;
+      if (dominatedBB) { // 确保子块有效
+        if (DEBUG) {
+          std::cout << "Mem2Reg: Recursively renaming variables in dominated block: " << dominatedBB->getName()
+                    << std::endl;
         }
-        renameVariables(currentAlloca, dominatedBB);
+        renameVariables(dominatedBB); // 递归调用，不再传递 currentAlloca
       }
     }
   }
-  
 
   // --------------------------------------------------------------------
-  // 退出基本块时，弹出在此块中压入值栈的 SSA 值
+  // 退出基本块时，弹出在此块中压入值栈的 SSA 值，恢复栈到进入该块时的状态
   // --------------------------------------------------------------------
-  while (!localStackPushed.empty()) {
-    Value *val = localStackPushed.top();
-    localStackPushed.pop();
-    // 找到是哪个 alloca 对应的栈
-    for (auto alloca : promotableAllocas) {
-      if (!allocaToValueStackMap[alloca].empty() && allocaToValueStackMap[alloca].top() == val) {
-        allocaToValueStackMap[alloca].pop();
-        break;
+  for (auto alloca : promotableAllocas) {
+    while (allocaToValueStackMap[alloca].size() > originalStackSizes[alloca]) {
+      if (DEBUG) {
+        std::cout << "Mem2Reg: Popping value "
+                  << (allocaToValueStackMap[alloca].top()->getName().empty()
+                          ? "anonymous"
+                          : allocaToValueStackMap[alloca].top()->getName())
+                  << " for alloca " << alloca->getName() << ". Stack size: " << allocaToValueStackMap[alloca].size()
+                  << " -> " << (allocaToValueStackMap[alloca].size() - 1) << std::endl;
       }
+      allocaToValueStackMap[alloca].pop();
     }
   }
+
 }
 
 // 删除所有原始的 AllocaInst、LoadInst 和 StoreInst

src/midend/Pass/Optimize/SysYIRCFGOpt.cpp

@@ -1,12 +1,12 @@
 #include "SysYIRCFGOpt.h"
 #include "SysYIROptUtils.h"
 #include <cassert>
+#include <iostream>
 #include <list>
 #include <map>
 #include <memory>
-#include <string>
-#include <iostream>
 #include <queue> // 引入队列，SysYDelNoPreBLock需要
+#include <string>
 
 namespace sysy {
 
@@ -18,7 +18,6 @@ void *SysYBlockMergePass::ID = (void *)&SysYBlockMergePass::ID;
 void *SysYAddReturnPass::ID = (void *)&SysYAddReturnPass::ID;
 void *SysYCondBr2BrPass::ID = (void *)&SysYCondBr2BrPass::ID;
 
-
 // ======================================================================
 // SysYCFGOptUtils: 辅助工具类，包含实际的CFG优化逻辑
 // ======================================================================
@@ -26,40 +25,42 @@ void *SysYCondBr2BrPass::ID = (void *)&SysYCondBr2BrPass::ID;
 // 删除br后的无用指令
 bool SysYCFGOptUtils::SysYDelInstAfterBr(Function *func) {
   bool changed = false;
-  
+
   auto basicBlocks = func->getBasicBlocks();
   for (auto &basicBlock : basicBlocks) {
     bool Branch = false;
     auto &instructions = basicBlock->getInstructions();
     auto Branchiter = instructions.end();
     for (auto iter = instructions.begin(); iter != instructions.end(); ++iter) {
-      if ((*iter)->isTerminator()){
+      if ((*iter)->isTerminator()) {
         Branch = true;
         Branchiter = iter;
         break;
       }
     }
-    if (Branchiter != instructions.end()) ++Branchiter;
+    if (Branchiter != instructions.end())
+      ++Branchiter;
     while (Branchiter != instructions.end()) {
       changed = true;
       Branchiter = instructions.erase(Branchiter);
     }
-    
-    if (Branch) {  // 更新前驱后继关系
-      auto thelastinstinst = basicBlock->getInstructions().end();
-      --thelastinstinst;
+
+    if (Branch) { // 更新前驱后继关系
+      auto thelastinstinst = basicBlock->terminator();
       auto &Successors = basicBlock->getSuccessors();
       for (auto iterSucc = Successors.begin(); iterSucc != Successors.end();) {
         (*iterSucc)->removePredecessor(basicBlock.get());
         basicBlock->removeSuccessor(*iterSucc);
       }
       if (thelastinstinst->get()->isUnconditional()) {
-        BasicBlock* branchBlock = dynamic_cast<BasicBlock *>(thelastinstinst->get()->getOperand(0));
+        auto brinst = dynamic_cast<UncondBrInst *>(thelastinstinst->get());
+        BasicBlock *branchBlock = dynamic_cast<BasicBlock *>(brinst->getBlock());
         basicBlock->addSuccessor(branchBlock);
         branchBlock->addPredecessor(basicBlock.get());
       } else if (thelastinstinst->get()->isConditional()) {
-        BasicBlock* thenBlock = dynamic_cast<BasicBlock *>(thelastinstinst->get()->getOperand(1));
-        BasicBlock* elseBlock = dynamic_cast<BasicBlock *>(thelastinstinst->get()->getOperand(2));
+        auto brinst = dynamic_cast<CondBrInst *>(thelastinstinst->get());
+        BasicBlock *thenBlock = dynamic_cast<BasicBlock *>(brinst->getThenBlock());
+        BasicBlock *elseBlock = dynamic_cast<BasicBlock *>(brinst->getElseBlock());
         basicBlock->addSuccessor(thenBlock);
         basicBlock->addSuccessor(elseBlock);
         thenBlock->addPredecessor(basicBlock.get());
@@ -75,26 +76,26 @@ bool SysYCFGOptUtils::SysYDelInstAfterBr(Function *func) {
 bool SysYCFGOptUtils::SysYBlockMerge(Function *func) {
   bool changed = false;
 
-  for (auto blockiter = func->getBasicBlocks().begin();
-        blockiter != func->getBasicBlocks().end();) {
+  for (auto blockiter = func->getBasicBlocks().begin(); blockiter != func->getBasicBlocks().end();) {
     if (blockiter->get()->getNumSuccessors() == 1) {
       // 如果当前块只有一个后继块
       // 且后继块只有一个前驱块
       // 则将当前块和后继块合并
       if (((blockiter->get())->getSuccessors()[0])->getNumPredecessors() == 1) {
         // std::cout << "merge block: " << blockiter->get()->getName() << std::endl;
-        BasicBlock* block = blockiter->get();
-        BasicBlock* nextBlock = blockiter->get()->getSuccessors()[0];
+        BasicBlock *block = blockiter->get();
+        BasicBlock *nextBlock = blockiter->get()->getSuccessors()[0];
         // auto nextarguments = nextBlock->getArguments();
         // 删除br指令
         if (block->getNumInstructions() != 0) {
-          auto thelastinstinst = block->end();
-          (--thelastinstinst);
+          auto thelastinstinst = block->terminator();
           if (thelastinstinst->get()->isUnconditional()) {
             thelastinstinst = SysYIROptUtils::usedelete(thelastinstinst);
           } else if (thelastinstinst->get()->isConditional()) {
-            // 如果是条件分支，判断条件是否相同，主要优化相同布尔表达式
-            if (thelastinstinst->get()->getOperand(1)->getName() == thelastinstinst->get()->getOperand(1)->getName()) {
+            // 按道理不会走到这个分支
+            // 如果是条件分支，查看then else是否相同
+            auto brinst = dynamic_cast<CondBrInst *>(thelastinstinst->get());
+            if (brinst->getThenBlock() == brinst->getElseBlock()) {
               thelastinstinst = SysYIROptUtils::usedelete(thelastinstinst);
             }
           }
@@ -104,7 +105,7 @@ bool SysYCFGOptUtils::SysYBlockMerge(Function *func) {
         for (auto institer = nextBlock->begin(); institer != nextBlock->end();) {
           institer->get()->setParent(block);
           block->getInstructions().emplace_back(institer->release());
-          institer = nextBlock->getInstructions().erase(institer);   
+          institer = nextBlock->getInstructions().erase(institer);
         }
         // 更新前驱后继关系，类似树节点操作
         block->removeSuccessor(nextBlock);
@@ -135,318 +136,431 @@ bool SysYCFGOptUtils::SysYBlockMerge(Function *func) {
 
 // 删除无前驱块，兼容SSA后的处理
 bool SysYCFGOptUtils::SysYDelNoPreBLock(Function *func) {
-  
-  bool changed = false;
+  bool changed = false;                   // 标记是否有基本块被删除
+  std::set<BasicBlock *> reachableBlocks; // 用于存储所有可达的基本块
+  std::queue<BasicBlock *> blockQueue;    // BFS 遍历队列
 
-  for (auto &block : func->getBasicBlocks()) {
-    block->setreachableFalse();
+  BasicBlock *entryBlock = func->getEntryBlock();
+  if (entryBlock) {                     // 确保函数有入口块
+    reachableBlocks.insert(entryBlock); // 将入口块标记为可达
+    blockQueue.push(entryBlock);        // 入口块入队
   }
-  // 对函数基本块做一个拓扑排序，排查不可达基本块
-  auto entryBlock = func->getEntryBlock();
-  entryBlock->setreachableTrue();
-  std::queue<BasicBlock *> blockqueue;
-  blockqueue.push(entryBlock);
-  while (!blockqueue.empty()) {
-    auto block = blockqueue.front();
-    blockqueue.pop();
-    for (auto &succ : block->getSuccessors()) {
-      if (!succ->getreachable()) {
-        succ->setreachableTrue();
-        blockqueue.push(succ);
+  // 如果没有入口块（比如一个空函数），则没有块是可达的，所有块都将被删除。
+
+  while (!blockQueue.empty()) { // BFS 遍历：只要队列不空
+    BasicBlock *currentBlock = blockQueue.front();
+    blockQueue.pop(); // 取出当前块
+
+    for (auto &succ : currentBlock->getSuccessors()) { // 遍历当前块的所有后继
+      // 如果后继块不在 reachableBlocks 中（即尚未被访问过）
+      if (reachableBlocks.find(succ) == reachableBlocks.end()) {
+        reachableBlocks.insert(succ); // 标记为可达
+        blockQueue.push(succ);        // 入队，以便继续遍历
       }
     }
   }
 
-  // 删除不可达基本块指令
-  for (auto blockIter = func->getBasicBlocks().begin(); blockIter != func->getBasicBlocks().end(); blockIter++) {
-    if (!blockIter->get()->getreachable()) {
-      for (auto instIter = blockIter->get()->getInstructions().begin();
-          instIter != blockIter->get()->getInstructions().end();) {
-        instIter = SysYIROptUtils::usedelete(instIter);
+  std::vector<BasicBlock *> blocksToDelete; // 用于存储所有不可达的基本块
+
+  for (auto &blockPtr : func->getBasicBlocks()) {
+    BasicBlock *block = blockPtr.get();
+    // 如果当前块不在 reachableBlocks 集合中，说明它是不可达的
+    if (reachableBlocks.find(block) == reachableBlocks.end()) {
+      blocksToDelete.push_back(block); // 将其加入待删除列表
+      changed = true;                  // 只要找到一个不可达块，就说明函数发生了改变
+    }
+  }
+
+  for (BasicBlock *unreachableBlock : blocksToDelete) {
+    // 遍历不可达块中的所有指令，并删除它们
+    for (auto instIter = unreachableBlock->getInstructions().begin();
+         instIter != unreachableBlock->getInstructions().end();) {
+      instIter = SysYIROptUtils::usedelete(instIter);
+    }
+  }
+
+  for (BasicBlock *unreachableBlock : blocksToDelete) {
+    for (BasicBlock *succBlock : unreachableBlock->getSuccessors()) {
+      // 只有当后继块自身是可达的（没有被删除）时才需要处理
+      if (reachableBlocks.count(succBlock)) {
+        for (auto &phiInstPtr : succBlock->getInstructions()) {
+          // Phi 指令总是在基本块的开头。一旦遇到非 Phi 指令即可停止。
+          if (phiInstPtr->getKind() != Instruction::kPhi) {
+            break;
+          }
+          // 将这个 Phi 节点中来自不可达前驱（unreachableBlock）的输入参数删除
+          dynamic_cast<PhiInst *>(phiInstPtr.get())->delBlk(unreachableBlock);
+        }
       }
     }
   }
 
-  
   for (auto blockIter = func->getBasicBlocks().begin(); blockIter != func->getBasicBlocks().end();) {
-    if (!blockIter->get()->getreachable()) {
-      for (auto succblock : blockIter->get()->getSuccessors()) {
-        for (auto &phiinst : succblock->getInstructions()) {
-        if (phiinst->getKind() != Instruction::kPhi) {
-          break;
-        }
-          // 使用 delBlk 方法正确地删除对应于被删除基本块的传入值
-          dynamic_cast<PhiInst *>(phiinst.get())->delBlk(blockIter->get());
-        }
-      }
-      // 删除不可达基本块，注意迭代器不可达问题
+    BasicBlock *currentBlock = blockIter->get();
+    // 如果当前块不在可达块集合中，则将其从函数中移除
+    if (reachableBlocks.find(currentBlock) == reachableBlocks.end()) {
+      // func->removeBasicBlock 应该返回下一个有效的迭代器
       func->removeBasicBlock((blockIter++)->get());
-      changed = true;
     } else {
-      blockIter++;
+      blockIter++; // 如果可达，则移动到下一个块
     }
   }
-  
+
   return changed;
 }
 
-// 删除空块
-bool SysYCFGOptUtils::SysYDelEmptyBlock(Function *func, IRBuilder* pBuilder) {
+bool SysYCFGOptUtils::SysYDelEmptyBlock(Function *func, IRBuilder *pBuilder) {
   bool changed = false;
 
-  // 收集不可达基本块
-  // 这里的不可达基本块是指没有实际指令的基本块
-  // 当一个基本块没有实际指令例如只有phi指令和一个uncondbr指令时，也会被视作不可达
-  auto basicBlocks = func->getBasicBlocks();
-  std::map<sysy::BasicBlock *, BasicBlock *> EmptyBlocks;
-  // 空块儿和后继的基本块的映射
-  for (auto &basicBlock : basicBlocks) {
-    if (basicBlock->getNumInstructions() == 0) {
-      if (basicBlock->getNumSuccessors() == 1) {
-        EmptyBlocks[basicBlock.get()] = basicBlock->getSuccessors().front();
-      }
-    }
-    else{
-      // 如果只有phi指令和一个uncondbr。(phi)*(uncondbr)?
-        // 判断除了最后一个指令之外是不是只有phi指令
-      bool onlyPhi = true;
-      for (auto &inst : basicBlock->getInstructions()) {
-        if (!inst->isPhi() && !inst->isUnconditional()) {
-          onlyPhi = false;
-          break;
-        }
-      }
-      if(onlyPhi && basicBlock->getNumSuccessors() == 1) // 确保有后继且只有一个
-        EmptyBlocks[basicBlock.get()] = basicBlock->getSuccessors().front();
-    }
+  // 步骤 1: 识别并映射所有符合“空块”定义的基本块及其目标后继
+  // 使用 std::map 来存储 <空块, 空块跳转目标>
+  // 这样可以处理空块链：A -> B -> C，如果 B 是空块，A 应该跳到 C
+  std::map<BasicBlock *, BasicBlock *> emptyBlockRedirectMap;
+
+  // 为了避免在遍历 func->getBasicBlocks() 时修改它导致迭代器失效，
+  // 我们先收集所有的基本块。
+  std::vector<BasicBlock *> allBlocks;
+  for (auto &blockPtr : func->getBasicBlocks()) {
+    allBlocks.push_back(blockPtr.get());
   }
-  // 更新基本块信息，增加必要指令
-  for (auto &basicBlock : basicBlocks) {
-    // 把空块转换成只有跳转指令的不可达块 (这段逻辑在优化遍中可能需要调整，这里是原样保留)
-    // 通常，DelEmptyBlock 应该在BlockMerge之后运行，如果存在完全空块，它会尝试填充一个Br指令。
-    // 但是，它主要目的是重定向跳转。
-    if (distance(basicBlock->begin(), basicBlock->end()) == 0) {
-      if (basicBlock->getNumSuccessors() == 0) {
-        continue;
-      }
-      if (basicBlock->getNumSuccessors() > 1) {
-        // 如果一个空块有多个后继，说明CFG结构有问题或者需要特殊处理，这里简单assert
-        assert(false && "Empty block with multiple successors found during SysYDelEmptyBlock");
-      }
-      // 这里的逻辑有点问题，如果一个块是空的，且只有一个后继，应该直接跳转到后继。
-      // 如果这个块最终被删除了，那么其前驱也需要重定向。
-      // 这个循环的目的是重定向现有的跳转指令，而不是创建新的。
-      // 所以下面的逻辑才是核心。
-      // pBuilder->setPosition(basicBlock.get(), basicBlock->end());
-      // pBuilder->createUncondBrInst(basicBlock->getSuccessors()[0], {});
+
+  for (BasicBlock *block : allBlocks) {
+    // 入口块通常不应该被认为是空块并删除，除非它没有实际指令且只有一个后继，
+    // 但为了安全起见，通常会跳过入口块的删除。
+    // 如果入口块是空的，它应该被合并到它的后继，但处理起来更复杂，这里先不处理入口块为空的情况
+    if (block == func->getEntryBlock()) {
       continue;
     }
 
-    auto thelastinst = basicBlock->getInstructions().end();
-    --thelastinst;
-
-    // 根据br指令传递的后继块信息，跳过空块链
-    if (thelastinst->get()->isUnconditional()) {
-      BasicBlock* OldBrBlock = dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(0));
-      BasicBlock *thelastBlockOld = nullptr;
-      // 如果空块链表为多个块
-      while (EmptyBlocks.count(dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(0)))) {
-        thelastBlockOld = dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(0));
-        thelastinst->get()->replaceOperand(0, EmptyBlocks[thelastBlockOld]);
-      }
-
-      // 如果有重定向发生
-      if (thelastBlockOld != nullptr) {
-          basicBlock->removeSuccessor(OldBrBlock);
-          OldBrBlock->removePredecessor(basicBlock.get());
-          basicBlock->addSuccessor(dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(0)));
-          dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(0))->addPredecessor(basicBlock.get());
-          changed = true; // 标记IR被修改
-      }
-
-
-      if (thelastBlockOld != nullptr) {
-        for (auto &InstInNew : dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(0))->getInstructions()) {
-        if (InstInNew->isPhi()) {
-          // 使用 delBlk 方法删除 oldBlock 对应的传入值
-          dynamic_cast<PhiInst *>(InstInNew.get())->delBlk(thelastBlockOld);
-        } else {
+    // 检查基本块是否是空的：除了Phi指令外，只包含一个终止指令 (Terminator)
+    // 且该终止指令必须是无条件跳转。
+    // 空块必须只有一个后继才能被简化
+    if (block->getNumSuccessors() == 1) {
+      bool hasNonPhiNonTerminator = false;
+      // 遍历除了最后一个指令之外的指令
+      for (auto instIter = block->getInstructions().begin(); instIter != block->getInstructions().end();) {
+        // 如果是终止指令（例如 br, ret），且不是最后一个指令，则该块有问题
+        if ((*instIter)->isTerminator() && instIter != block->terminator()) {
+          hasNonPhiNonTerminator = true;
           break;
         }
-  }
-      }
-
-    } else if (thelastinst->get()->getKind() == Instruction::kCondBr) {
-      auto OldThenBlock = dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(1));
-      auto OldElseBlock = dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(2));
-      bool thenChanged = false;
-      bool elseChanged = false;
-
-
-      BasicBlock *thelastBlockOld = nullptr;
-      while (EmptyBlocks.count(dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(1)))) {
-        thelastBlockOld = dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(1));
-        thelastinst->get()->replaceOperand(
-            1, EmptyBlocks[dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(1))]);
-        thenChanged = true;
-      }
-
-      if (thenChanged) {
-        basicBlock->removeSuccessor(OldThenBlock);
-        OldThenBlock->removePredecessor(basicBlock.get());
-        basicBlock->addSuccessor(dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(1)));
-        dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(1))->addPredecessor(basicBlock.get());
-        changed = true; // 标记IR被修改
-      }
-      
-      // 处理 then 和 else 分支合并的情况
-      if (dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(1)) ==
-          dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(2))) {
-        auto thebrBlock = dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(1));
-        thelastinst = SysYIROptUtils::usedelete(thelastinst);
-        pBuilder->setPosition(basicBlock.get(), basicBlock->end());
-        pBuilder->createUncondBrInst(thebrBlock);
-        changed = true; // 标记IR被修改
-        continue;
-      }
-      
-      if (thelastBlockOld != nullptr) {
-        for (auto &InstInNew : dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(1))->getInstructions()) {
-          if (InstInNew->isPhi()) {
-            // 使用 delBlk 方法删除 oldBlock 对应的传入值
-            dynamic_cast<PhiInst *>(InstInNew.get())->delBlk(thelastBlockOld);
-          } else {
-            break;
+        // 如果不是 Phi 指令且不是终止指令
+        if (!(*instIter)->isPhi() && !(*instIter)->isTerminator()) {
+          hasNonPhiNonTerminator = true;
+          break;
+        }
+        ++instIter;
+        if (!hasNonPhiNonTerminator &&
+            instIter == block->getInstructions().end()) { // 如果块中只有 Phi 指令和一个 Terminator
+          // 确保最后一个指令是无条件跳转
+          auto lastInst = block->terminator()->get();
+          if (lastInst && lastInst->isUnconditional()) {
+            emptyBlockRedirectMap[block] = block->getSuccessors().front();
           }
-       }
-      }
-
-      thelastBlockOld = nullptr;
-      while (EmptyBlocks.count(dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(2)))) {
-        thelastBlockOld = dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(2));
-        thelastinst->get()->replaceOperand(
-            2, EmptyBlocks[dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(2))]);
-        elseChanged = true;
-      }
-      
-      if (elseChanged) {
-        basicBlock->removeSuccessor(OldElseBlock);
-        OldElseBlock->removePredecessor(basicBlock.get());
-        basicBlock->addSuccessor(dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(2)));
-        dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(2))->addPredecessor(basicBlock.get());
-        changed = true; // 标记IR被修改
-      }
-
-      // 处理 then 和 else 分支合并的情况
-      if (dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(1)) ==
-          dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(2))) {
-        auto thebrBlock = dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(1));
-        thelastinst = SysYIROptUtils::usedelete(thelastinst);
-        pBuilder->setPosition(basicBlock.get(), basicBlock->end());
-        pBuilder->createUncondBrInst(thebrBlock);
-        changed = true; // 标记IR被修改
-        continue;
-      }
-      
-
-      // 如果有重定向发生
-      // 需要更新后继块的前驱关系
-      if (thelastBlockOld != nullptr) {
-        for (auto &InstInNew : dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(2))->getInstructions()) {
-          if (InstInNew->isPhi()) {
-            // 使用 delBlk 方法删除 oldBlock 对应的传入值
-            dynamic_cast<PhiInst *>(InstInNew.get())->delBlk(thelastBlockOld);
-          } else {
-            break;
-          }
-        } 
-      }
-      
-    } else {
-      // 如果不是终止指令，但有后继 (例如，末尾没有显式终止指令的块)
-      // 这段逻辑可能需要更严谨的CFG检查来确保正确性
-      if (basicBlock->getNumSuccessors() == 1) {
-        // 这里的逻辑似乎是想为没有terminator的块添加一个，但通常这应该在CFG构建阶段完成。
-        // 如果这里仍然执行，确保它符合预期。
-        // pBuilder->setPosition(basicBlock.get(), basicBlock->end());
-        // pBuilder->createUncondBrInst(basicBlock->getSuccessors()[0], {});
-        // auto thelastinst = basicBlock->getInstructions().end();
-        // (--thelastinst);
-        // auto OldBrBlock = dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(0));
-        // sysy::BasicBlock *thelastBlockOld = nullptr;
-        // while (EmptyBlocks.find(dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(0))) !=
-        //         EmptyBlocks.end()) {
-        //   thelastBlockOld = dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(0));
-
-        //   thelastinst->get()->replaceOperand(
-        //       0, EmptyBlocks[dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(0))]);
-        // }
-        
-        // basicBlock->removeSuccessor(OldBrBlock);
-        // OldBrBlock->removePredecessor(basicBlock.get());
-        // basicBlock->addSuccessor(dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(0)));
-        // dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(0))->addPredecessor(basicBlock.get());
-        // changed = true; // 标记IR被修改
-        // if (thelastBlockOld != nullptr) {
-        //   int indexphi = 0;
-        //   for (auto &pred : dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(0))->getPredecessors()) {
-        //     if (pred == thelastBlockOld) {
-        //       break;
-        //     }
-        //     indexphi++;
-        //   }
-
-        //   for (auto &InstInNew : dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(0))->getInstructions()) {
-        //     if (InstInNew->isPhi()) {
-        //       dynamic_cast<PhiInst *>(InstInNew.get())->removeOperand(indexphi + 1);
-        //     } else {
-        //       break;
-        //     }
-        //   }
-        // }
+        }
       }
     }
   }
 
-  // 真正的删除空块
-  for (auto iter = func->getBasicBlocks().begin(); iter != func->getBasicBlocks().end();) {
-    
-    if (EmptyBlocks.count(iter->get())) {
-      // EntryBlock跳过
-      if (iter->get() == func->getEntryBlock()) {
-        ++iter;
-        continue;
+  // 步骤 2: 遍历 emptyBlockRedirectMap，处理空块链
+  // 确保每个空块都直接重定向到其最终的非空后继块
+  for (auto const &[emptyBlock, directSucc] : emptyBlockRedirectMap) {
+    BasicBlock *targetBlock = directSucc;
+    // 沿着空块链一直找到最终的非空块目标
+    while (emptyBlockRedirectMap.count(targetBlock)) {
+      targetBlock = emptyBlockRedirectMap[targetBlock];
+    }
+    emptyBlockRedirectMap[emptyBlock] = targetBlock; // 更新映射到最终目标
+  }
+
+  // 步骤 3: 遍历所有基本块，重定向其终止指令，绕过空块
+  // 注意：这里需要再次遍历所有块，包括可能成为新目标的块
+  for (BasicBlock *currentBlock : allBlocks) {
+    // 如果 currentBlock 本身就是个空块，它会通过其前驱的重定向被处理，这里跳过
+    if (emptyBlockRedirectMap.count(currentBlock)) {
+      continue;
+    }
+
+    // 获取当前块的最后一个指令（终止指令）
+    if (currentBlock->getInstructions().empty()) {
+      // 理论上，除了入口块和可能被合并的空块外，所有块都应该有终止指令
+      // 如果这里碰到空块，可能是逻辑错误或者需要特殊处理
+      continue;
+    }
+
+    std::function<Value *(Value *, BasicBlock *)> getUltimateSourceValue = [&](Value *val,
+                                                                               BasicBlock *currentDefBlock) -> Value * {
+      // 如果值不是指令，例如常量或函数参数，则它本身就是最终来源
+      if (auto instr = dynamic_cast<Instruction *>(val)) { // Assuming Value* has a method to check if it's an instruction
+        return val;
       }
 
-      for (auto instIter = iter->get()->getInstructions().begin();
-         instIter != iter->get()->getInstructions().end();) {
-        instIter = SysYIROptUtils::usedelete(instIter);
+      Instruction *inst = dynamic_cast<Instruction *>(val);
+      // 如果定义指令不在任何空块中，它就是最终来源
+      if (!emptyBlockRedirectMap.count(currentDefBlock)) {
+        return val;
       }
-      // 删除不可达基本块的phi指令的操作数
-      for (auto &succ : iter->get()->getSuccessors()) {
-        for (auto &instinsucc : succ->getInstructions()) {
-          if (instinsucc->isPhi()) {
-            // iter->get() 就是当前被删除的空基本块，它作为前驱连接到这里的Phi指令
-            dynamic_cast<PhiInst *>(instinsucc.get())->delBlk(iter->get());
+
+      // 如果是 Phi 指令，且它在空块中，则继续追溯其在空块链中前驱的传入值
+      if (inst->getKind() == Instruction::kPhi) {
+        PhiInst *phi = dynamic_cast<PhiInst *>(inst);
+        // 查找哪个前驱是空块链中的上一个块
+        for (size_t i = 0; i < phi->getNumOperands(); i += 2) {
+          BasicBlock *incomingBlock = dynamic_cast<BasicBlock *>(phi->getOperand(i + 1));
+          // 检查 incomingBlock 是否是当前空块的前驱，且也在空块映射中（或就是 P）
+          // 找到在空块链中导致 currentDefBlock 的那个前驱块
+          if (emptyBlockRedirectMap.count(incomingBlock) || incomingBlock == currentBlock) {
+            // 递归追溯该传入值
+            return getUltimateSourceValue(phi->getIncomingValue(incomingBlock), incomingBlock);
+          }
+        }
+      }
+      // 如果是其他指令或者无法追溯到Phi链，则认为它在空块中产生，无法安全传播，返回null或原值
+      // 在严格的空块定义下，除了Phi和Terminator，不应有其他指令产生值。
+      return val; // Fallback: If not a Phi, or unable to trace, return itself (may be dangling)
+    };
+
+    auto lastInst = currentBlock->getInstructions().back().get();
+
+    if (lastInst->isUnconditional()) { // 无条件跳转
+      UncondBrInst *brInst = dynamic_cast<UncondBrInst *>(lastInst);
+      BasicBlock *oldTarget = dynamic_cast<BasicBlock *>(brInst->getBlock()); // 原始跳转目标
+
+      if (emptyBlockRedirectMap.count(oldTarget)) {               // 如果目标是空块
+        BasicBlock *newTarget = emptyBlockRedirectMap[oldTarget]; // 获取最终目标
+
+        // 更新 CFG 关系
+        currentBlock->removeSuccessor(oldTarget);
+        oldTarget->removePredecessor(currentBlock);
+
+        brInst->replaceOperand(0, newTarget); // 更新跳转指令的操作数
+        currentBlock->addSuccessor(newTarget);
+        newTarget->addPredecessor(currentBlock);
+
+        changed = true; // 标记发生改变
+
+        for (auto &phiInstPtr : newTarget->getInstructions()) {
+          if (phiInstPtr->getKind() == Instruction::kPhi) {
+            PhiInst *phiInst = dynamic_cast<PhiInst *>(phiInstPtr.get());
+            BasicBlock *actualEmptyPredecessorOfS = nullptr;
+            for (size_t i = 0; i < phiInst->getNumOperands(); i += 2) {
+              BasicBlock *incomingBlock = dynamic_cast<BasicBlock *>(phiInst->getOperand(i + 1));
+              if (incomingBlock && emptyBlockRedirectMap.count(incomingBlock) &&
+                  emptyBlockRedirectMap[incomingBlock] == newTarget) {
+                actualEmptyPredecessorOfS = incomingBlock;
+                break;
+              }
+            }
+
+            if (actualEmptyPredecessorOfS) {
+              // 获取 Phi 节点原本从 actualEmptyPredecessorOfS 接收的值
+              Value *valueFromEmptyPredecessor = phiInst->getIncomingValue(actualEmptyPredecessorOfS);
+
+              // 追溯这个值，找到它在非空块中的最终来源
+              // currentBlock 是 P
+              // oldTarget 是 E1 (链的起点)
+              // actualEmptyPredecessorOfS 是 En (链的终点，S 的前驱)
+              Value *ultimateSourceValue = getUltimateSourceValue(valueFromEmptyPredecessor, actualEmptyPredecessorOfS);
+
+              // 替换 Phi 节点的传入块和传入值
+              if (ultimateSourceValue) { // 确保成功追溯到有效来源
+                phiInst->replaceIncoming(actualEmptyPredecessorOfS, currentBlock, ultimateSourceValue);
+              } else {
+                assert(false && "[DelEmptyBlock] Unable to trace a valid source for Phi instruction");
+                // 无法追溯到有效来源，这可能是个错误或特殊情况
+                // 此时可能需要移除该 Phi 项，或者插入一个 undef 值
+                phiInst->removeIncoming(actualEmptyPredecessorOfS);
+              }
+            }
           } else {
-            // Phi 指令通常在基本块的开头，如果不是 Phi 指令就停止检查
             break;
           }
         }
       }
 
-      func->removeBasicBlock((iter++)->get());
-      changed = true;
-    } else {
-      ++iter;
+    } else if (lastInst->getKind() == Instruction::kCondBr) { // 条件跳转
+      CondBrInst *condBrInst = dynamic_cast<CondBrInst *>(lastInst);
+      BasicBlock *oldThenTarget = dynamic_cast<BasicBlock *>(condBrInst->getThenBlock());
+      BasicBlock *oldElseTarget = dynamic_cast<BasicBlock *>(condBrInst->getElseBlock());
+
+      bool thenPathChanged = false;
+      bool elsePathChanged = false;
+
+      // 处理 Then 分支
+      if (emptyBlockRedirectMap.count(oldThenTarget)) {
+        BasicBlock *newThenTarget = emptyBlockRedirectMap[oldThenTarget];
+        condBrInst->replaceOperand(1, newThenTarget); // 更新跳转指令操作数
+
+        currentBlock->removeSuccessor(oldThenTarget);
+        oldThenTarget->removePredecessor(currentBlock);
+        currentBlock->addSuccessor(newThenTarget);
+        newThenTarget->addPredecessor(currentBlock);
+        thenPathChanged = true;
+        changed = true;
+
+        // 处理新 Then 目标块中的 Phi 指令
+        // for (auto &phiInstPtr : newThenTarget->getInstructions()) {
+        //   if (phiInstPtr->getKind() == Instruction::kPhi) {
+        //     dynamic_cast<PhiInst *>(phiInstPtr.get())->delBlk(oldThenTarget);
+        //   } else {
+        //     break;
+        //   }
+        // }
+        for (auto &phiInstPtr : newThenTarget->getInstructions()) {
+          if (phiInstPtr->getKind() == Instruction::kPhi) {
+            PhiInst *phiInst = dynamic_cast<PhiInst *>(phiInstPtr.get());
+            BasicBlock *actualEmptyPredecessorOfS = nullptr;
+            for (size_t i = 0; i < phiInst->getNumOperands(); i += 2) {
+              BasicBlock *incomingBlock = dynamic_cast<BasicBlock *>(phiInst->getOperand(i + 1));
+              if (incomingBlock && emptyBlockRedirectMap.count(incomingBlock) &&
+                  emptyBlockRedirectMap[incomingBlock] == newThenTarget) {
+                actualEmptyPredecessorOfS = incomingBlock;
+                break;
+              }
+            }
+
+            if (actualEmptyPredecessorOfS) {
+              // 获取 Phi 节点原本从 actualEmptyPredecessorOfS 接收的值
+              Value *valueFromEmptyPredecessor = phiInst->getIncomingValue(actualEmptyPredecessorOfS);
+
+              // 追溯这个值，找到它在非空块中的最终来源
+              // currentBlock 是 P
+              // oldTarget 是 E1 (链的起点)
+              // actualEmptyPredecessorOfS 是 En (链的终点，S 的前驱)
+              Value *ultimateSourceValue = getUltimateSourceValue(valueFromEmptyPredecessor, actualEmptyPredecessorOfS);
+
+              // 替换 Phi 节点的传入块和传入值
+              if (ultimateSourceValue) { // 确保成功追溯到有效来源
+                phiInst->replaceIncoming(actualEmptyPredecessorOfS, currentBlock, ultimateSourceValue);
+              } else {
+                assert(false && "[DelEmptyBlock] Unable to trace a valid source for Phi instruction");
+                // 无法追溯到有效来源，这可能是个错误或特殊情况
+                // 此时可能需要移除该 Phi 项，或者插入一个 undef 值
+                phiInst->removeIncoming(actualEmptyPredecessorOfS);
+              }
+            }
+          } else {
+            break;
+          }
+        }
+
+      }
+
+      // 处理 Else 分支
+      if (emptyBlockRedirectMap.count(oldElseTarget)) {
+        BasicBlock *newElseTarget = emptyBlockRedirectMap[oldElseTarget];
+        condBrInst->replaceOperand(2, newElseTarget); // 更新跳转指令操作数
+
+        currentBlock->removeSuccessor(oldElseTarget);
+        oldElseTarget->removePredecessor(currentBlock);
+        currentBlock->addSuccessor(newElseTarget);
+        newElseTarget->addPredecessor(currentBlock);
+        elsePathChanged = true;
+        changed = true;
+
+        // 处理新 Else 目标块中的 Phi 指令
+        // for (auto &phiInstPtr : newElseTarget->getInstructions()) {
+        //   if (phiInstPtr->getKind() == Instruction::kPhi) {
+        //     dynamic_cast<PhiInst *>(phiInstPtr.get())->delBlk(oldElseTarget);
+        //   } else {
+        //     break;
+        //   }
+        // }
+        for (auto &phiInstPtr : newElseTarget->getInstructions()) {
+          if (phiInstPtr->getKind() == Instruction::kPhi) {
+            PhiInst *phiInst = dynamic_cast<PhiInst *>(phiInstPtr.get());
+            BasicBlock *actualEmptyPredecessorOfS = nullptr;
+            for (size_t i = 0; i < phiInst->getNumOperands(); i += 2) {
+              BasicBlock *incomingBlock = dynamic_cast<BasicBlock *>(phiInst->getOperand(i + 1));
+              if (incomingBlock && emptyBlockRedirectMap.count(incomingBlock) &&
+                  emptyBlockRedirectMap[incomingBlock] == newElseTarget) {
+                actualEmptyPredecessorOfS = incomingBlock;
+                break;
+              }
+            }
+
+            if (actualEmptyPredecessorOfS) {
+              // 获取 Phi 节点原本从 actualEmptyPredecessorOfS 接收的值
+              Value *valueFromEmptyPredecessor = phiInst->getIncomingValue(actualEmptyPredecessorOfS);
+
+              // 追溯这个值，找到它在非空块中的最终来源
+              // currentBlock 是 P
+              // oldTarget 是 E1 (链的起点)
+              // actualEmptyPredecessorOfS 是 En (链的终点，S 的前驱)
+              Value *ultimateSourceValue = getUltimateSourceValue(valueFromEmptyPredecessor, actualEmptyPredecessorOfS);
+
+              // 替换 Phi 节点的传入块和传入值
+              if (ultimateSourceValue) { // 确保成功追溯到有效来源
+                phiInst->replaceIncoming(actualEmptyPredecessorOfS, currentBlock, ultimateSourceValue);
+              } else {
+                assert(false && "[DelEmptyBlock] Unable to trace a valid source for Phi instruction");
+                // 无法追溯到有效来源，这可能是个错误或特殊情况
+                // 此时可能需要移除该 Phi 项，或者插入一个 undef 值
+                phiInst->removeIncoming(actualEmptyPredecessorOfS);
+              }
+            }
+          } else {
+            break;
+          }
+        }
+      }
+
+      // 额外处理：如果条件跳转的两个分支现在指向同一个块，则可以简化为无条件跳转
+      if (condBrInst->getThenBlock() == condBrInst->getElseBlock()) {
+        BasicBlock *commonTarget = dynamic_cast<BasicBlock *>(condBrInst->getThenBlock());
+        SysYIROptUtils::usedelete(lastInst); // 删除旧的条件跳转指令
+        pBuilder->setPosition(currentBlock, currentBlock->end());
+        pBuilder->createUncondBrInst(commonTarget); // 插入新的无条件跳转指令
+
+        // 更安全地更新 CFG 关系
+        std::set<BasicBlock *> currentSuccessors;
+        currentSuccessors.insert(oldThenTarget);
+        currentSuccessors.insert(oldElseTarget);
+
+        // 移除旧的后继关系
+        for (BasicBlock *succ : currentSuccessors) {
+          currentBlock->removeSuccessor(succ);
+          succ->removePredecessor(currentBlock);
+        }
+        // 添加新的后继关系
+        currentBlock->addSuccessor(commonTarget);
+        commonTarget->addPredecessor(currentBlock);
+
+        changed = true;
+      }
     }
   }
-  
+
+  // 步骤 4: 真正地删除空基本块
+  // 注意：只能在所有跳转和 Phi 指令都更新完毕后才能删除这些块
+  for (auto blockIter = func->getBasicBlocks().begin(); blockIter != func->getBasicBlocks().end();) {
+    BasicBlock *currentBlock = blockIter->get();
+    if (emptyBlockRedirectMap.count(currentBlock)) { // 如果在空块映射中
+      // 入口块不应该被删除，即使它符合空块定义，因为函数需要一个入口
+      if (currentBlock == func->getEntryBlock()) {
+        ++blockIter;
+        continue;
+      }
+
+      // 在删除块之前，确保其内部指令被正确删除（虽然这类块指令很少）
+      for (auto instIter = currentBlock->getInstructions().begin();
+           instIter != currentBlock->getInstructions().end();) {
+        instIter = SysYIROptUtils::usedelete(instIter);
+      }
+
+      // 移除块
+      func->removeBasicBlock((blockIter++)->get());
+      changed = true;
+    } else {
+      ++blockIter;
+    }
+  }
+
   return changed;
 }
 
 // 如果函数没有返回指令，则添加一个默认返回指令(主要解决void函数没有返回指令的问题)
-bool SysYCFGOptUtils::SysYAddReturn(Function *func, IRBuilder* pBuilder) {
+bool SysYCFGOptUtils::SysYAddReturn(Function *func, IRBuilder *pBuilder) {
   bool changed = false;
   auto basicBlocks = func->getBasicBlocks();
   for (auto &block : basicBlocks) {
@@ -460,7 +574,8 @@ bool SysYCFGOptUtils::SysYAddReturn(Function *func, IRBuilder* pBuilder) {
         auto thelastinst = block->getInstructions().end();
         --thelastinst;
         if (thelastinst->get()->getKind() != Instruction::kReturn) {
-          // std::cout << "Warning: Function " << func->getName() << " has no return instruction, adding default return." << std::endl;
+          // std::cout << "Warning: Function " << func->getName() << " has no return instruction, adding default
+          // return." << std::endl;
 
           pBuilder->setPosition(block.get(), block->end());
           // TODO: 如果int float函数缺少返回值是否需要报错
@@ -476,7 +591,7 @@ bool SysYCFGOptUtils::SysYAddReturn(Function *func, IRBuilder* pBuilder) {
       }
     }
   }
-  
+
   return changed;
 }
 
@@ -484,18 +599,18 @@ bool SysYCFGOptUtils::SysYAddReturn(Function *func, IRBuilder* pBuilder) {
 // 主要针对已知条件值的分支转换为无条件分支
 // 例如 if (cond) { ... } else { ... } 中的 cond 已经
 // 确定为 true 或 false 的情况
-bool SysYCFGOptUtils::SysYCondBr2Br(Function *func, IRBuilder* pBuilder) {
+bool SysYCFGOptUtils::SysYCondBr2Br(Function *func, IRBuilder *pBuilder) {
   bool changed = false;
 
   for (auto &basicblock : func->getBasicBlocks()) {
     if (basicblock->getNumInstructions() == 0)
       continue;
-    
-    auto thelast = basicblock->getInstructions().end();
-    --thelast;
 
-    if (thelast->get()->isConditional()){
-      ConstantValue *constOperand = dynamic_cast<ConstantValue *>(thelast->get()->getOperand(0));
+    auto thelast = basicblock->terminator();
+
+    if (thelast->get()->isConditional()) {
+      auto condBrInst = dynamic_cast<CondBrInst *>(thelast->get());
+      ConstantValue *constOperand = dynamic_cast<ConstantValue *>(condBrInst->getCondition());
       std::string opname;
       int constint = 0;
       float constfloat = 0.0F;
@@ -514,27 +629,27 @@ bool SysYCFGOptUtils::SysYCondBr2Br(Function *func, IRBuilder* pBuilder) {
       if (constfloat_Use || constint_Use) {
         changed = true;
 
-        auto thenBlock = dynamic_cast<BasicBlock *>(thelast->get()->getOperand(1));
-        auto elseBlock = dynamic_cast<BasicBlock *>(thelast->get()->getOperand(2));
+        auto thenBlock = dynamic_cast<BasicBlock *>(condBrInst->getThenBlock());
+        auto elseBlock = dynamic_cast<BasicBlock *>(condBrInst->getElseBlock());
         thelast = SysYIROptUtils::usedelete(thelast);
         if ((constfloat_Use && constfloat == 1.0F) || (constint_Use && constint == 1)) {
           // cond为true或非0
           pBuilder->setPosition(basicblock.get(), basicblock->end());
           pBuilder->createUncondBrInst(thenBlock);
-          
+
           // 更新CFG关系
           basicblock->removeSuccessor(elseBlock);
           elseBlock->removePredecessor(basicblock.get());
-          
+
           // 删除elseBlock的phi指令中对应的basicblock.get()的传入值
           for (auto &phiinst : elseBlock->getInstructions()) {
             if (phiinst->getKind() != Instruction::kPhi) {
               break;
             }
             // 使用 delBlk 方法删除 basicblock.get() 对应的传入值
-            dynamic_cast<PhiInst *>(phiinst.get())->delBlk(basicblock.get());
+            dynamic_cast<PhiInst *>(phiinst.get())->removeIncoming(basicblock.get());
           }
-          
+
         } else { // cond为false或0
 
           pBuilder->setPosition(basicblock.get(), basicblock->end());
@@ -550,9 +665,8 @@ bool SysYCFGOptUtils::SysYCondBr2Br(Function *func, IRBuilder* pBuilder) {
               break;
             }
             // 使用 delBlk 方法删除 basicblock.get() 对应的传入值
-            dynamic_cast<PhiInst *>(phiinst.get())->delBlk(basicblock.get());
+            dynamic_cast<PhiInst *>(phiinst.get())->removeIncoming(basicblock.get());
           }
-
         }
       }
     }
@@ -565,28 +679,28 @@ bool SysYCFGOptUtils::SysYCondBr2Br(Function *func, IRBuilder* pBuilder) {
 // 独立的CFG优化遍的实现
 // ======================================================================
 
-bool SysYDelInstAfterBrPass::runOnFunction(Function *F, AnalysisManager& AM) {
+bool SysYDelInstAfterBrPass::runOnFunction(Function *F, AnalysisManager &AM) {
   return SysYCFGOptUtils::SysYDelInstAfterBr(F);
 }
 
-bool SysYDelEmptyBlockPass::runOnFunction(Function *F, AnalysisManager& AM) {
+bool SysYDelEmptyBlockPass::runOnFunction(Function *F, AnalysisManager &AM) {
   return SysYCFGOptUtils::SysYDelEmptyBlock(F, pBuilder);
 }
 
-bool SysYDelNoPreBLockPass::runOnFunction(Function *F, AnalysisManager& AM) {
+bool SysYDelNoPreBLockPass::runOnFunction(Function *F, AnalysisManager &AM) {
   return SysYCFGOptUtils::SysYDelNoPreBLock(F);
 }
 
-bool SysYBlockMergePass::runOnFunction(Function *F, AnalysisManager& AM) {
-  return SysYCFGOptUtils::SysYBlockMerge(F);
+bool SysYBlockMergePass::runOnFunction(Function *F, AnalysisManager &AM) { 
+  return SysYCFGOptUtils::SysYBlockMerge(F); 
 }
 
-bool SysYAddReturnPass::runOnFunction(Function *F, AnalysisManager& AM) {
+bool SysYAddReturnPass::runOnFunction(Function *F, AnalysisManager &AM) {
   return SysYCFGOptUtils::SysYAddReturn(F, pBuilder);
 }
 
-bool SysYCondBr2BrPass::runOnFunction(Function *F, AnalysisManager& AM) {
+bool SysYCondBr2BrPass::runOnFunction(Function *F, AnalysisManager &AM) {
   return SysYCFGOptUtils::SysYCondBr2Br(F, pBuilder);
 }
 
-}  // namespace sysy
+} // namespace sysy

src/midend/Pass/Pass.cpp

@@ -58,14 +58,14 @@ void PassManager::runOptimizationPipeline(Module* moduleIR, IRBuilder* builderIR
       if (DEBUG) std::cout << "Applying -O1 optimizations.\n";
       if (DEBUG) std::cout << "--- Running custom optimization sequence ---\n";
 
-      this->clearPasses(); 
-      this->addPass(&SysYDelInstAfterBrPass::ID);
-      this->addPass(&SysYDelNoPreBLockPass::ID);
-      this->addPass(&SysYBlockMergePass::ID);
-      this->addPass(&SysYDelEmptyBlockPass::ID);
-      this->addPass(&SysYCondBr2BrPass::ID);
-      this->addPass(&SysYAddReturnPass::ID);
-      this->run(); 
+      // this->clearPasses(); 
+      // this->addPass(&SysYDelInstAfterBrPass::ID);
+      // this->addPass(&SysYDelNoPreBLockPass::ID);
+      // this->addPass(&SysYBlockMergePass::ID);
+      // this->addPass(&SysYDelEmptyBlockPass::ID);
+      // this->addPass(&SysYCondBr2BrPass::ID);
+      // this->addPass(&SysYAddReturnPass::ID);
+      // this->run(); 
 
       if(DEBUG) {
         std::cout << "=== IR After CFGOpt Optimizations ===\n";
@@ -108,6 +108,10 @@ void PassManager::runOptimizationPipeline(Module* moduleIR, IRBuilder* builderIR
         printPasses();
       }
 
+      this->clearPasses();
+      this->addPass(&DCE::ID); 
+      this->run();
+
       if (DEBUG) std::cout << "--- Custom optimization sequence finished ---\n";
     }
 

src/midend/SysYIRGenerator.cpp

@@ -586,7 +586,18 @@ std::any SysYIRGenerator::visitConstDecl(SysYParser::ConstDeclContext *ctx) {
 
     // 显式地为局部常量在栈上分配空间
     // alloca 的类型将是指针指向常量类型，例如 `int*` 或 `int[2][3]*`
+    // 将 alloca 全部集中到entry函数中
+    // 记录当前位置
+    BasicBlock *curBB = builder.getBasicBlock();
+    auto curPos =builder.getPosition();
+    Function *currentFunction = builder.getBasicBlock()->getParent();
+    BasicBlock *entryBB = currentFunction->getEntryBlock();
+    // 在terminator前插入
+    auto entryPos = entryBB->terminator();
+    builder.setPosition(entryBB, entryPos);
     AllocaInst *alloca = builder.createAllocaInst(Type::getPointerType(variableType), name);
+    // 恢复当前位置
+    builder.setPosition(curBB, curPos);
 
     ArrayValueTree *root = std::any_cast<ArrayValueTree *>(constDef->constInitVal()->accept(this));
     ValueCounter values;
@@ -653,7 +664,44 @@ std::any SysYIRGenerator::visitConstDecl(SysYParser::ConstDeclContext *ctx) {
           Value *currentValue = counterValues[k];
           unsigned currentRepeatNum = counterNumbers[k];
 
+          // 检查是否是0，并且重复次数足够大（例如 >16），才用 memset
+          if (ConstantInteger *constInt = dynamic_cast<ConstantInteger *>(currentValue)) {
+            if (constInt->getInt() == 0 && currentRepeatNum >= 16) { // 阈值可调整（如16、32等）
+              // 计算 memset 的起始地址（基于当前线性偏移量）
+              std::vector<Value *> memsetStartIndices;
+              int tempLinearIndex = linearIndexOffset;
+
+              // 将线性索引转换为多维索引
+              for (int dimIdx = dimSizes.size() - 1; dimIdx >= 0; --dimIdx) {
+                memsetStartIndices.insert(memsetStartIndices.begin(),
+                                          ConstantInteger::get(static_cast<int>(tempLinearIndex % dimSizes[dimIdx])));
+                tempLinearIndex /= dimSizes[dimIdx];
+              }
+
+              // 构造 GEP 计算 memset 的起始地址
+              std::vector<Value *> gepIndicesForMemset;
+              gepIndicesForMemset.push_back(ConstantInteger::get(0)); // 跳过 alloca 类型
+              gepIndicesForMemset.insert(gepIndicesForMemset.end(), memsetStartIndices.begin(),
+                                         memsetStartIndices.end());
+
+              Value *memsetPtr = builder.createGetElementPtrInst(alloca, gepIndicesForMemset);
+
+              // 计算 memset 的字节数 = 元素个数 × 元素大小
+              Type *elementType = type;;
+              uint64_t elementSize = elementType->getSize();
+              Value *size = ConstantInteger::get(currentRepeatNum * elementSize);
+
+              // 生成 memset 指令（假设你的 IRBuilder 有 createMemset 方法）
+              builder.createMemsetInst(memsetPtr, ConstantInteger::get(0), size, ConstantInteger::get(0));
+
+              // 跳过这些已处理的0
+              linearIndexOffset += currentRepeatNum;
+              continue; // 直接进入下一次循环
+            }
+          }
+
           for (unsigned i = 0; i < currentRepeatNum; ++i) {
+            // 对于非零值，生成对应的 store 指令
             std::vector<Value *> currentIndices;
             int tempLinearIndex = linearIndexOffset + i; // 使用偏移量和当前重复次数内的索引
 
@@ -706,8 +754,20 @@ std::any SysYIRGenerator::visitVarDecl(SysYParser::VarDeclContext *ctx) {
 
     // 对于数组，alloca 的类型将是指针指向数组类型，例如 `int[2][3]*`
     // 对于标量，alloca 的类型将是指针指向标量类型，例如 `int*`
-    AllocaInst* alloca =
-        builder.createAllocaInst(Type::getPointerType(variableType), name);
+
+    BasicBlock *curBB = builder.getBasicBlock();
+    auto curPos =builder.getPosition();
+    Function *currentFunction = builder.getBasicBlock()->getParent();
+    BasicBlock *entryBB = currentFunction->getEntryBlock();
+    // 在terminator前插入
+    auto entryPos = entryBB->terminator();
+    builder.setPosition(entryBB, entryPos);
+    AllocaInst *alloca = builder.createAllocaInst(Type::getPointerType(variableType), name);
+    // 恢复当前位置
+    builder.setPosition(curBB, curPos);
+
+    // AllocaInst* alloca =
+    //     builder.createAllocaInst(Type::getPointerType(variableType), name);
 
     if (varDef->initVal() != nullptr) {
       ValueCounter values;
@@ -761,39 +821,73 @@ std::any SysYIRGenerator::visitVarDecl(SysYParser::VarDeclContext *ctx) {
               ConstantInteger::get(0));
         }
         else {
-          
+
           int linearIndexOffset = 0; // 用于追踪当前处理的线性索引的偏移量
           for (int k = 0; k < counterValues.size(); ++k) {
-              // 当前 Value 的值和重复次数
-              Value* currentValue = counterValues[k];
-              unsigned currentRepeatNum = counterNumbers[k];
+            // 当前 Value 的值和重复次数
+            Value *currentValue = counterValues[k];
+            unsigned currentRepeatNum = counterNumbers[k];
+            // 检查是否是0，并且重复次数足够大（例如 >16），才用 memset
+            if (ConstantInteger *constInt = dynamic_cast<ConstantInteger *>(currentValue)) {
+              if (constInt->getInt() == 0 && currentRepeatNum >= 16) { // 阈值可调整（如16、32等）
+                // 计算 memset 的起始地址（基于当前线性偏移量）
+                std::vector<Value *> memsetStartIndices;
+                int tempLinearIndex = linearIndexOffset;
 
-              for (unsigned i = 0; i < currentRepeatNum; ++i) {
-                  std::vector<Value *> currentIndices;
-                  int tempLinearIndex = linearIndexOffset + i; // 使用偏移量和当前重复次数内的索引
+                // 将线性索引转换为多维索引
+                for (int dimIdx = dimSizes.size() - 1; dimIdx >= 0; --dimIdx) {
+                  memsetStartIndices.insert(memsetStartIndices.begin(),
+                                            ConstantInteger::get(static_cast<int>(tempLinearIndex % dimSizes[dimIdx])));
+                  tempLinearIndex /= dimSizes[dimIdx];
+                }
 
-                  // 将线性索引转换为多维索引
-                  for (int dimIdx = dimSizes.size() - 1; dimIdx >= 0; --dimIdx) {
-                      currentIndices.insert(currentIndices.begin(),
-                                          ConstantInteger::get(static_cast<int>(tempLinearIndex % dimSizes[dimIdx])));
-                      tempLinearIndex /= dimSizes[dimIdx];
-                  }
-                  
-                  // 对于局部数组，alloca 本身就是 GEP 的基指针。
-                  // GEP 的第一个索引必须是 0，用于“步过”整个数组。
-                  std::vector<Value*> gepIndicesForInit;
-                  gepIndicesForInit.push_back(ConstantInteger::get(0));
-                  gepIndicesForInit.insert(gepIndicesForInit.end(), currentIndices.begin(), currentIndices.end());
-                  
-                  // 计算元素的地址
-                  Value* elementAddress = getGEPAddressInst(alloca, gepIndicesForInit);
-                  // 生成 store 指令
-                  builder.createStoreInst(currentValue, elementAddress);
+                // 构造 GEP 计算 memset 的起始地址
+                std::vector<Value *> gepIndicesForMemset;
+                gepIndicesForMemset.push_back(ConstantInteger::get(0)); // 跳过 alloca 类型
+                gepIndicesForMemset.insert(gepIndicesForMemset.end(), memsetStartIndices.begin(),
+                                           memsetStartIndices.end());
+
+                Value *memsetPtr = builder.createGetElementPtrInst(alloca, gepIndicesForMemset);
+
+                // 计算 memset 的字节数 = 元素个数 × 元素大小
+                Type *elementType = type;
+                ;
+                uint64_t elementSize = elementType->getSize();
+                Value *size = ConstantInteger::get(currentRepeatNum * elementSize);
+
+                // 生成 memset 指令（假设你的 IRBuilder 有 createMemset 方法）
+                builder.createMemsetInst(memsetPtr, ConstantInteger::get(0), size, ConstantInteger::get(0));
+
+                // 跳过这些已处理的0
+                linearIndexOffset += currentRepeatNum;
+                continue; // 直接进入下一次循环
               }
-              // 更新线性索引偏移量，以便下一次迭代从正确的位置开始
-              linearIndexOffset += currentRepeatNum;
-          }
+            }
+            for (unsigned i = 0; i < currentRepeatNum; ++i) {
+              std::vector<Value *> currentIndices;
+              int tempLinearIndex = linearIndexOffset + i; // 使用偏移量和当前重复次数内的索引
 
+              // 将线性索引转换为多维索引
+              for (int dimIdx = dimSizes.size() - 1; dimIdx >= 0; --dimIdx) {
+                currentIndices.insert(currentIndices.begin(),
+                                      ConstantInteger::get(static_cast<int>(tempLinearIndex % dimSizes[dimIdx])));
+                tempLinearIndex /= dimSizes[dimIdx];
+              }
+
+              // 对于局部数组，alloca 本身就是 GEP 的基指针。
+              // GEP 的第一个索引必须是 0，用于“步过”整个数组。
+              std::vector<Value *> gepIndicesForInit;
+              gepIndicesForInit.push_back(ConstantInteger::get(0));
+              gepIndicesForInit.insert(gepIndicesForInit.end(), currentIndices.begin(), currentIndices.end());
+
+              // 计算元素的地址
+              Value *elementAddress = getGEPAddressInst(alloca, gepIndicesForInit);
+              // 生成 store 指令
+              builder.createStoreInst(currentValue, elementAddress);
+            }
+            // 更新线性索引偏移量，以便下一次迭代从正确的位置开始
+            linearIndexOffset += currentRepeatNum;
+          }
         }
       }
     }
@@ -895,7 +989,7 @@ std::any SysYIRGenerator::visitFuncDef(SysYParser::FuncDefContext *ctx){
         currentParamDims.push_back(ConstantInteger::get(-1)); // 标记第一个维度为未知
         for (const auto &exp : param->exp()) {
           // 访问表达式以获取维度大小，这些维度必须是常量
-          Value* dimVal = std::any_cast<Value *>(visitExp(exp));
+          Value* dimVal = computeExp(exp);
           // 确保维度是常量整数，否则 buildArrayType 会断言失败
           assert(dynamic_cast<ConstantInteger*>(dimVal) && "Array dimension in parameter must be a constant integer!");
           currentParamDims.push_back(dimVal);
@@ -966,6 +1060,7 @@ std::any SysYIRGenerator::visitFuncDef(SysYParser::FuncDefContext *ctx){
   
   // 从 entryBB 无条件跳转到 funcBodyEntry
   builder.createUncondBrInst(funcBodyEntry);
+  BasicBlock::conectBlocks(entry, funcBodyEntry); // 连接 entryBB 和 funcBodyEntry
   builder.setPosition(funcBodyEntry,funcBodyEntry->end()); // 将插入点设置到 funcBodyEntry
 
   for (auto item : ctx->blockStmt()->blockItem()) {