[deploy]部署版本3

注册遍模板函数重构（针对遍的不同构造方法），
修复phi指令更新引起的旧代码错误，
将CFG优化适配到现有终端框架中，
独立CFG优化方法使得其他优化遍能独立调用，
usedelete方法回调取消删除功能。
IRGenerator代码风格修改。

.gitignore

@@ -23,7 +23,6 @@
 # Compiled Static libraries
 *.lai
 *.la
-*.a
 *.lib
 
 # Executables
@@ -53,4 +52,5 @@ __init__.py
 
 .DS_*
 
-antlr/
+antlr/
+.clang-format

Pass_ID_List.md

@@ -0,0 +1,6 @@
+# 记录中端遍的开发进度
+
+| 名称       | 优化级别     | 开发进度   |
+| ------------ | ------------ | ---------- |
+| CFG优化     | 函数级   | 已完成     |
+| DCE         | 函数级   | 待测试     |

README.md

@@ -37,4 +37,38 @@ mysysy/ $ bash setup.sh
     ```
 
 ### 配套脚本
-   （TODO: 需要完善）
+   （TODO: 需要完善）
+
+
+### TODO_list:
+
+除开注释中的TODO后续时间充足可以考虑的TODO:
+
+- store load指令由于gep指令的引入, 维度信息的记录是非必须的, 考虑删除
+
+- use def关系经过mem2reg和phi函数明确转换为ssa形式, 以及函数参数通过value数组明确定义, 使得基本块的args参数信息记录非必须, 考虑删除
+
+---
+
+## 编译器后端 TODO 列表
+
+### 1. `CALL` 指令处理不完善 (高优先级)
+
+* **问题描述**：当前 `RISCv64RegAlloc::getInstrUseDef()` 方法中，对 `CALL` 指令的 `use`/`def` 分析不完整。它正确识别了返回值为 `def` 和参数为 `use`，但**没有将所有调用者保存 (Caller-saved) 的物理寄存器（`T0-T6`, `A0-A7`）标记为隐式 `def` (即 `CALL` 会破坏它们)**。
+* **潜在后果**：
+    * **活跃性分析错误**：寄存器分配器可能会错误地认为某个跨函数调用活跃的虚拟寄存器是安全的，并将其分配给 `T` 或 `A` 寄存器。
+    * **值被破坏**：在 `CALL` 指令执行后，这些 `T` 或 `A` 寄存器中本应保留的值会被被调用的函数破坏，导致程序行为异常。
+* **参考文件**：`RISCv64RegAlloc.cpp` (在 `getInstrUseDef` 函数中对 `RVOpcodes::CALL` 的处理)。
+
+### 2. `T6` 寄存器作为溢出寄存器的问题 (中等优先级)
+
+* **问题描述**：`RISCv64RegAlloc::rewriteFunction()` 方法中，所有未能成功着色并被溢出 (spilled) 的虚拟寄存器，都被统一替换为物理寄存器 `T6`。
+* **问题 2.1：`T6` 是调用者保存寄存器，但未被调用者保存**：
+    * `T6` 属于调用者保存寄存器 (`T0-T6` 范围)。
+    * 标准 ABI 要求，如果一个调用者保存寄存器在函数调用前后都活跃（例如，它存储了一个被溢出的变量，而这个变量在 `CALL` 指令之后还需要用到），那么**调用者**有责任在 `CALL` 前保存该寄存器，并在 `CALL` 后恢复它。
+    * 目前的 `rewriteFunction` 没有为 `T6` 插入这种保存/恢复逻辑。
+    * **潜在后果**：如果一个溢出变量被分配到 `T6`，并且它跨函数调用活跃，那么 `putint` 或其他任何被调用的函数可能会随意使用 `T6`，从而破坏该溢出变量的值。
+* **问题 2.2：所有溢出变量共用一个 `T6`**：
+    * 将所有溢出变量映射到同一个物理寄存器 `T6` 是一种简化的溢出策略。
+    * **潜在后果**：这意味着，每当需要使用一个溢出变量时，其值必须从栈中加载到 `T6`；每当一个溢出变量被定义时，其值必须从 `T6` 存储回栈。这会引入大量的 `load`/`store` 指令，并导致 `T6` 本身成为一个高度冲突的寄存器，严重降低代码效率。
+* **参考文件**：`RISCv64RegAlloc.cpp` (在 `rewriteFunction` 函数中处理 `spilled_vregs` 的部分)。

src/CMakeLists.txt

@@ -21,9 +21,11 @@ add_executable(sysyc
   IR.cpp
   SysYIRGenerator.cpp
   SysYIRPrinter.cpp
-  SysYIROptPre.cpp
-  SysYIRAnalyser.cpp
-  # DeadCodeElimination.cpp
+  SysYIRCFGOpt.cpp
+  Pass.cpp
+  Dom.cpp
+  Liveness.cpp
+  DCE.cpp
   AddressCalculationExpansion.cpp
   # Mem2Reg.cpp
   # Reg2Mem.cpp
@@ -31,7 +33,11 @@ add_executable(sysyc
   RISCv64ISel.cpp
   RISCv64RegAlloc.cpp
   RISCv64AsmPrinter.cpp
-  RISCv64Passes.cpp
+  RISCv64Peephole.cpp
+  PreRA_Scheduler.cpp
+  PostRA_Scheduler.cpp
+  CalleeSavedHandler.cpp
+  RISCv64LLIR.cpp
 )
 
 # 设置 include 路径，包含 ANTLR 运行时库和项目头文件

src/CalleeSavedHandler.cpp

@@ -0,0 +1,123 @@
+#include "CalleeSavedHandler.h"
+#include <set>
+#include <algorithm>
+
+namespace sysy {
+
+char CalleeSavedHandler::ID = 0;
+
+bool CalleeSavedHandler::runOnFunction(Function *F, AnalysisManager& AM) {
+    // This pass works on MachineFunction level, not IR level
+    return false;
+}
+
+void CalleeSavedHandler::runOnMachineFunction(MachineFunction* mfunc) {
+    // 【最终方案】: 此 Pass 负责分析、分配栈空间并插入 callee-saved 寄存器的保存/恢复指令。
+    // 它通过与 FrameInfo 协作，确保为 callee-saved 寄存器分配的空间与局部变量/溢出槽的空间不冲突。
+    // 这样做可以使生成的 sd/ld 指令能被后续的优化 Pass (如 PostRA-Scheduler) 处理。
+
+    StackFrameInfo& frame_info = mfunc->getFrameInfo();
+    std::set<PhysicalReg> used_callee_saved;
+
+    // 1. 扫描所有指令，找出被使用的s寄存器 (s1-s11)
+    for (auto& mbb : mfunc->getBlocks()) {
+        for (auto& instr : mbb->getInstructions()) {
+            for (auto& op : instr->getOperands()) {
+                auto check_and_insert_reg = [&](RegOperand* reg_op) {
+                    if (!reg_op->isVirtual()) {
+                        PhysicalReg preg = reg_op->getPReg();
+                        if (preg >= PhysicalReg::S1 && preg <= PhysicalReg::S11) {
+                            used_callee_saved.insert(preg);
+                        }
+                    }
+                };
+                if (op->getKind() == MachineOperand::KIND_REG) {
+                    check_and_insert_reg(static_cast<RegOperand*>(op.get()));
+                } else if (op->getKind() == MachineOperand::KIND_MEM) {
+                    check_and_insert_reg(static_cast<MemOperand*>(op.get())->getBase());
+                }
+            }
+        }
+    }
+
+    if (used_callee_saved.empty()) {
+        frame_info.callee_saved_size = 0; // 确保大小被初始化
+        return; // 无需操作
+    }
+
+    // 2. 计算为 callee-saved 寄存器分配的栈空间
+    //    这里的关键是，偏移的基准点要在局部变量和溢出槽之下。
+    int callee_saved_size = used_callee_saved.size() * 8;
+    frame_info.callee_saved_size = callee_saved_size; // 将大小存入 FrameInfo
+
+    // 3. 计算无冲突的栈偏移
+    //    栈向下增长，所以偏移是负数。
+    //    ra/s0 占用 -8 和 -16。局部变量和溢出区在它们之下。callee-saved 区在更下方。
+    //    我们使用相对于 s0 的偏移。s0 将指向栈顶 (sp + total_size)。
+    int base_offset = -16 - frame_info.locals_size - frame_info.spill_size;
+
+    // 为了栈帧布局确定性，对寄存器进行排序
+    std::vector<PhysicalReg> sorted_regs(used_callee_saved.begin(), used_callee_saved.end());
+    std::sort(sorted_regs.begin(), sorted_regs.end());
+    
+    // 4. 在函数序言插入保存指令
+    MachineBasicBlock* entry_block = mfunc->getBlocks().front().get();
+    auto& entry_instrs = entry_block->getInstructions();
+    auto prologue_end = entry_instrs.begin();
+    
+    // 找到序言结束的位置（通常是addi s0, sp, size之后，但为了让优化器看到，我们插在更前面）
+    // 合理的位置是在 IR 指令开始之前，即在任何非序言指令（如第一个标签）之前。
+    // 为简单起见，我们直接插入到块的开头，后续重排 pass 会处理。
+    // (更优的实现会寻找一个特定的插入点)
+
+    int current_offset = base_offset;
+    for (PhysicalReg reg : sorted_regs) {
+        auto sd = std::make_unique<MachineInstr>(RVOpcodes::SD);
+        sd->addOperand(std::make_unique<RegOperand>(reg));
+        sd->addOperand(std::make_unique<MemOperand>(
+            std::make_unique<RegOperand>(PhysicalReg::S0), // 基址为帧指针 s0
+            std::make_unique<ImmOperand>(current_offset)
+        ));
+        // 从头部插入，但要放在函数标签之后
+        entry_instrs.insert(entry_instrs.begin() + 1, std::move(sd)); 
+        current_offset -= 8;
+    }
+
+    // 5. 【已修复】在函数结尾（ret之前）插入恢复指令，使用反向遍历来避免迭代器失效
+    for (auto& mbb : mfunc->getBlocks()) {
+        // 使用手动控制的反向循环
+        for (auto it = mbb->getInstructions().begin(); it != mbb->getInstructions().end(); ++it) {
+            if ((*it)->getOpcode() == RVOpcodes::RET) {
+                // 1. 创建一个临时vector来存储所有需要插入的恢复指令
+                std::vector<std::unique_ptr<MachineInstr>> restore_instrs;
+                
+                int current_offset_load = base_offset;
+                // 以相同的顺序（例如 s1, s2, ...）创建恢复指令
+                for (PhysicalReg reg : sorted_regs) {
+                    auto ld = std::make_unique<MachineInstr>(RVOpcodes::LD);
+                    ld->addOperand(std::make_unique<RegOperand>(reg));
+                    ld->addOperand(std::make_unique<MemOperand>(
+                        std::make_unique<RegOperand>(PhysicalReg::S0),
+                        std::make_unique<ImmOperand>(current_offset_load)
+                    ));
+                    restore_instrs.push_back(std::move(ld));
+                    current_offset_load -= 8;
+                }
+
+                // 2. 使用 make_move_iterator 一次性将所有恢复指令插入到 RET 指令之前
+                //    这可以高效地转移指令的所有权，并且只让迭代器失效一次。
+                if (!restore_instrs.empty()) {
+                    mbb->getInstructions().insert(it, 
+                        std::make_move_iterator(restore_instrs.begin()),
+                        std::make_move_iterator(restore_instrs.end())
+                    );
+                }
+
+                // 找到了RET并处理完毕后，就可以跳出内层循环，继续寻找下一个基本块
+                break; 
+            }
+        }
+    }
+}
+
+} // namespace sysy

src/DCE.cpp

@@ -0,0 +1,140 @@
+#include "DCE.h"            // 包含DCE遍的头文件
+#include "IR.h"             // 包含IR相关的定义
+#include "SysYIROptUtils.h" // 包含SysY IR优化工具类的定义
+#include <cassert>          // 用于断言
+#include <iostream>         // 用于调试输出
+#include <set>              // 包含set，虽然DCEContext内部用unordered_set，但这里保留
+
+namespace sysy {
+
+// DCE 遍的静态 ID
+void *DCE::ID = (void *)&DCE::ID;
+
+// ======================================================================
+// DCEContext 类的实现
+// 封装了 DCE 遍的核心逻辑和状态，确保每次函数优化运行时状态独立
+// ======================================================================
+
+// DCEContext 的 run 方法实现
+void DCEContext::run(Function *func, AnalysisManager *AM, bool &changed) {
+  // 清空活跃指令集合，确保每次运行都是新的状态
+  alive_insts.clear();
+
+  // 第一次遍历：扫描所有指令，识别“天然活跃”的指令并将其及其依赖标记为活跃
+  // 使用 func->getBasicBlocks() 获取基本块列表，保留用户风格
+  auto basicBlocks = func->getBasicBlocks();
+  for (auto &basicBlock : basicBlocks) {
+    // 确保基本块有效
+    if (!basicBlock)
+      continue;
+    // 使用 basicBlock->getInstructions() 获取指令列表，保留用户风格
+    for (auto &inst : basicBlock->getInstructions()) {
+      // 确保指令有效
+      if (!inst)
+        continue;
+      // 调用 DCEContext 自身的 isAlive 和 addAlive 方法
+      if (isAlive(inst.get())) {
+        addAlive(inst.get());
+      }
+    }
+  }
+
+  // 第二次遍历：删除所有未被标记为活跃的指令。
+  for (auto &basicBlock : basicBlocks) {
+    if (!basicBlock)
+      continue;
+    // 使用传统的迭代器循环，并手动管理迭代器，
+    // 以便在删除元素后正确前进。保留用户风格
+    for (auto instIter = basicBlock->getInstructions().begin(); instIter != basicBlock->getInstructions().end();) {
+      auto &inst = *instIter;
+      Instruction *currentInst = inst.get();
+      // 如果指令不在活跃集合中，则删除它。
+      // 分支和返回指令由 isAlive 处理，并会被保留。
+      if (alive_insts.count(currentInst) == 0) {
+        // 删除指令，保留用户风格的 SysYIROptUtils::usedelete 和 erase
+        changed = true; // 标记 IR 已被修改
+        SysYIROptUtils::usedelete(currentInst);
+        instIter = basicBlock->getInstructions().erase(instIter); // 删除后返回下一个迭代器
+      } else {
+        ++instIter; // 指令活跃，移动到下一个
+      }
+    }
+  }
+}
+
+// 判断指令是否是“天然活跃”的实现
+// 只有具有副作用的指令（如存储、函数调用、原子操作）
+// 和控制流指令（如分支、返回）是天然活跃的。
+bool DCEContext::isAlive(Instruction *inst) {
+  // TODO: 后续程序并发考虑原子操作
+  // 其结果不被其他指令使用的指令（例如 StoreInst, BranchInst, ReturnInst）。
+  // dynamic_cast<ir::CallInst>(inst) 检查是否是函数调用指令，
+  // 函数调用通常有副作用。
+  // 终止指令 (BranchInst, ReturnInst) 必须是活跃的，因为它控制了程序的执行流程。
+  // 保留用户提供的 isAlive 逻辑
+  bool isBranchOrReturn = inst->isBranch() || inst->isReturn();
+  bool isCall = inst->isCall();
+  bool isStoreOrMemset = inst->isStore() || inst->isMemset(); 
+  return isBranchOrReturn || isCall || isStoreOrMemset;
+}
+
+// 递归地将活跃指令及其依赖加入到 alive_insts 集合中
+void DCEContext::addAlive(Instruction *inst) {
+  // 如果指令已经存在于活跃集合中，则无需重复处理
+  if (alive_insts.count(inst) > 0) {
+    return;
+  }
+  // 将当前指令标记为活跃
+  alive_insts.insert(inst);
+  // 遍历当前指令的所有操作数
+  // 保留用户提供的 getOperands() 和 getValue()
+  for (auto operand : inst->getOperands()) {
+    // 如果操作数是一个指令（即它是一个值的定义），
+    // 并且它还没有被标记为活跃
+    if (auto opInst = dynamic_cast<Instruction *>(operand->getValue())) {
+      addAlive(opInst); // 递归地将操作数指令标记为活跃
+    }
+  }
+}
+
+// ======================================================================
+// DCE Pass 类的实现
+// 主要负责与 PassManager 交互，创建 DCEContext 实例并运行优化
+// ======================================================================
+
+// DCE 遍的 runOnFunction 方法实现
+bool DCE::runOnFunction(Function *func, AnalysisManager &AM) {
+
+  DCEContext ctx;
+  bool changed = false;
+  ctx.run(func, &AM, changed); // 运行 DCE 优化
+
+  // 如果 IR 被修改，则使相关的分析结果失效
+  if (changed) {
+    // DCE 会删除指令，这会影响数据流分析，尤其是活跃性分析。
+    // 如果删除导致基本块变空，也可能间接影响 CFG 和支配树。
+    // AM.invalidateAnalysis(&LivenessAnalysisPass::ID, func); // 活跃性分析失效
+    // AM.invalidateAnalysis(&DominatorTreeAnalysisPass::ID, func); // 支配树分析可能失效
+    // 其他所有依赖于数据流或 IR 结构的分析都可能失效。
+  }
+  return changed;
+}
+
+// 声明DCE遍的分析依赖和失效信息
+void DCE::getAnalysisUsage(std::set<void *> &analysisDependencies, std::set<void *> &analysisInvalidations) const {
+  // DCE不依赖特定的分析结果，它通过遍历和副作用判断来工作。
+
+  // DCE会删除指令，这会影响许多分析结果。
+  // 至少，它会影响活跃性分析、支配树、控制流图（如果删除导致基本块为空并被合并）。
+  // 假设存在LivenessAnalysisPass和DominatorTreeAnalysisPass
+  // analysisInvalidations.insert(&LivenessAnalysisPass::ID);
+  // analysisInvalidations.insert(&DominatorTreeAnalysisPass::ID);
+  // 任何改变IR结构的优化，都可能导致通用分析（如活跃性、支配树、循环信息）失效。
+  // 最保守的做法是使所有函数粒度的分析失效，或者只声明你明确知道会受影响的分析。
+  // 考虑到这个DCE仅删除指令，如果它不删除基本块，CFG可能不变，但数据流分析会失效。
+  // 对于更激进的DCE（如ADCE），CFG也会改变。
+  // 这里我们假设它主要影响数据流分析，并且可能间接影响CFG相关分析。
+  // 如果有SideEffectInfo，它也可能被修改，但通常SideEffectInfo是静态的，不因DCE而变。
+}
+
+} // namespace sysy

src/Dom.cpp

@@ -0,0 +1,180 @@
+#include "Dom.h"
+#include <limits> // for std::numeric_limits
+#include <queue>
+
+namespace sysy {
+
+// 初始化 支配树静态 ID
+void *DominatorTreeAnalysisPass::ID = (void *)&DominatorTreeAnalysisPass::ID;
+// ==============================================================
+// DominatorTree 结果类的实现
+// ==============================================================
+
+DominatorTree::DominatorTree(Function *F) : AssociatedFunction(F) {
+  // 构造时可以不计算，在分析遍运行里计算并填充
+}
+
+const std::set<BasicBlock *> *DominatorTree::getDominators(BasicBlock *BB) const {
+  auto it = Dominators.find(BB);
+  if (it != Dominators.end()) {
+    return &(it->second);
+  }
+  return nullptr;
+}
+
+BasicBlock *DominatorTree::getImmediateDominator(BasicBlock *BB) const {
+  auto it = IDoms.find(BB);
+  if (it != IDoms.end()) {
+    return it->second;
+  }
+  return nullptr;
+}
+
+const std::set<BasicBlock *> *DominatorTree::getDominanceFrontier(BasicBlock *BB) const {
+  auto it = DominanceFrontiers.find(BB);
+  if (it != DominanceFrontiers.end()) {
+    return &(it->second);
+  }
+  return nullptr;
+}
+
+void DominatorTree::computeDominators(Function *F) {
+  // 经典的迭代算法计算支配者集合
+  // TODO: 可以替换为更高效的算法，如 Lengauer-Tarjan 算法
+  BasicBlock *entryBlock = F->getEntryBlock();
+
+  for (const auto &bb_ptr : F->getBasicBlocks()) {
+    BasicBlock *bb = bb_ptr.get();
+    if (bb == entryBlock) {
+      Dominators[bb].insert(bb);
+    } else {
+      for (const auto &all_bb_ptr : F->getBasicBlocks()) {
+        Dominators[bb].insert(all_bb_ptr.get());
+      }
+    }
+  }
+
+  bool changed = true;
+  while (changed) {
+    changed = false;
+    for (const auto &bb_ptr : F->getBasicBlocks()) {
+      BasicBlock *bb = bb_ptr.get();
+      if (bb == entryBlock)
+        continue;
+
+      std::set<BasicBlock *> newDom;
+      bool firstPred = true;
+      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;
+          }
+        }
+      }
+      newDom.insert(bb);
+
+      if (newDom != Dominators[bb]) {
+        Dominators[bb] = newDom;
+        changed = true;
+      }
+    }
+  }
+}
+
+void DominatorTree::computeIDoms(Function *F) {
+  // 采用与之前类似的简化实现。TODO:Lengauer-Tarjan等算法。
+  BasicBlock *entryBlock = F->getEntryBlock();
+  IDoms[entryBlock] = nullptr;
+
+  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;
+      }
+    }
+    IDoms[bb] = currentIDom;
+  }
+}
+
+void DominatorTree::computeDominanceFrontiers(Function *F) {
+  // 经典的支配边界计算算法
+  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);
+          }
+        }
+      }
+    }
+  }
+}
+
+// ==============================================================
+// DominatorTreeAnalysisPass 的实现
+// ==============================================================
+
+
+bool DominatorTreeAnalysisPass::runOnFunction(Function* F, AnalysisManager &AM) {
+  CurrentDominatorTree = std::make_unique<DominatorTree>(F);
+  CurrentDominatorTree->computeDominators(F);
+  CurrentDominatorTree->computeIDoms(F);
+  CurrentDominatorTree->computeDominanceFrontiers(F);
+  return false;
+}
+
+std::unique_ptr<AnalysisResultBase> DominatorTreeAnalysisPass::getResult() {
+  // 返回计算好的 DominatorTree 实例，所有权转移给 AnalysisManager
+  return std::move(CurrentDominatorTree);
+}
+
+} // namespace sysy

src/IR.cpp

@@ -49,6 +49,11 @@ auto Type::getFunctionType(Type *returnType, const std::vector<Type *> &paramTyp
   return FunctionType::get(returnType, paramTypes);
 }
 
+auto Type::getArrayType(Type *elementType, unsigned numElements) -> Type * {
+  // forward to ArrayType
+  return ArrayType::get(elementType, numElements);
+}
+
 auto Type::getSize() const -> unsigned {
   switch (kind) {
     case kInt:
@@ -58,6 +63,10 @@ auto Type::getSize() const -> unsigned {
     case kPointer:
     case kFunction:
       return 8;
+    case Kind::kArray: {
+      const ArrayType* arrType = static_cast<const ArrayType*>(this);
+      return arrType->getElementType()->getSize() * arrType->getNumElements();
+    }
     case kVoid:
       return 0;
   }
@@ -95,6 +104,20 @@ FunctionType*FunctionType::get(Type *returnType, const std::vector<Type *> &para
   return result.first->get();
 }
 
+ArrayType *ArrayType::get(Type *elementType, unsigned numElements) {
+  static std::set<std::unique_ptr<ArrayType>> arrayTypes;
+  auto iter = std::find_if(arrayTypes.begin(), arrayTypes.end(), [&](const std::unique_ptr<ArrayType> &type) -> bool {
+    return elementType == type->getElementType() && numElements == type->getNumElements();
+  });
+  if (iter != arrayTypes.end()) {
+    return iter->get();
+  }
+  auto type = new ArrayType(elementType, numElements);
+  assert(type);
+  auto result = arrayTypes.emplace(type);
+  return result.first->get();
+}
+
 void Value::replaceAllUsesWith(Value *value) {
   for (auto &use : uses) {
     use->getUser()->setOperand(use->getIndex(), value);
@@ -465,44 +488,7 @@ Function * Function::clone(const std::string &suffix) const  {
         break;
       }
 
-      case Instruction::kLa: {
-        auto oldLaInst = dynamic_cast<LaInst *>(inst);
-        auto oldPointer = oldLaInst->getPointer();
-        Value *newPointer;
-        std::vector<Value *> newIndices;
-        newPointer = oldNewValueMap.at(oldPointer);
-
-        for (const auto &index : oldLaInst->getIndices()) {
-          newIndices.emplace_back(oldNewValueMap.at(index->getValue()));
-        }
-        ss << oldLaInst->getName() << suffix;
-        auto newLaInst = new LaInst(newPointer, newIndices, oldNewBlockMap.at(oldLaInst->getParent()), ss.str());
-        ss.str("");
-        oldNewValueMap.emplace(oldLaInst, newLaInst);
-        break;
-      }
-
-      case Instruction::kGetSubArray: {
-        auto oldGetSubArrayInst = dynamic_cast<GetSubArrayInst *>(inst);
-        auto oldFather = oldGetSubArrayInst->getFatherArray();
-        auto oldChild = oldGetSubArrayInst->getChildArray();
-        Value *newFather;
-        Value *newChild;
-        std::vector<Value *> newIndices;
-        newFather = oldNewValueMap.at(oldFather);
-        newChild = oldNewValueMap.at(oldChild);
-
-        for (const auto &index : oldGetSubArrayInst->getIndices()) {
-          newIndices.emplace_back(oldNewValueMap.at(index->getValue()));
-        }
-        ss << oldGetSubArrayInst->getName() << suffix;
-        auto newGetSubArrayInst =
-            new GetSubArrayInst(dynamic_cast<LVal *>(newFather), dynamic_cast<LVal *>(newChild), newIndices,
-                                oldNewBlockMap.at(oldGetSubArrayInst->getParent()), ss.str());
-        ss.str("");
-        oldNewValueMap.emplace(oldGetSubArrayInst, newGetSubArrayInst);
-        break;
-      }
+      // TODO：复制GEP指令
 
       case Instruction::kMemset: {
         auto oldMemsetInst = dynamic_cast<MemsetInst *>(inst);
@@ -544,8 +530,14 @@ Function * Function::clone(const std::string &suffix) const  {
     }
   }
 
-  for (const auto &param : blocks.front()->getArguments()) {
-    newFunction->getEntryBlock()->insertArgument(dynamic_cast<AllocaInst *>(oldNewValueMap.at(param)));
+  // for (const auto &param : blocks.front()->getArguments()) {
+  //   newFunction->getEntryBlock()->insertArgument(dynamic_cast<AllocaInst *>(oldNewValueMap.at(param)));
+  // }
+  for (const auto &arg : arguments) {
+    auto newArg = dynamic_cast<Argument *>(oldNewValueMap.at(arg));
+    if (newArg != nullptr) {
+      newFunction->insertArgument(newArg);
+    }
   }
 
   return newFunction;
@@ -661,7 +653,7 @@ Function * CallInst::getCallee() const { return dynamic_cast<Function *>(getOper
 /**
  * 获取变量指针
  */
-auto SymbolTable::getVariable(const std::string &name) const -> User * {
+auto SymbolTable::getVariable(const std::string &name) const -> Value * {
   auto node = curNode;
   while (node != nullptr) {
     auto iter = node->varList.find(name);
@@ -676,8 +668,8 @@ auto SymbolTable::getVariable(const std::string &name) const -> User * {
 /**
  * 添加变量到符号表
  */
-auto SymbolTable::addVariable(const std::string &name, User *variable) -> User * {
-  User *result = nullptr;
+auto SymbolTable::addVariable(const std::string &name, Value *variable) -> Value * {
+  Value *result = nullptr;
   if (curNode != nullptr) {
     std::stringstream ss;
     auto iter = variableIndex.find(name);

src/Liveness.cpp

@@ -0,0 +1,160 @@
+#include "Liveness.h"
+#include <algorithm> // For std::set_union, std::set_difference
+#include <iostream>
+#include <queue> // Potentially for worklist, though not strictly needed for the iterative approach below
+#include <set>   // For std::set
+
+namespace sysy {
+
+// 初始化静态 ID
+void *LivenessAnalysisPass::ID = (void *)&LivenessAnalysisPass::ID;
+// ==============================================================
+// LivenessAnalysisResult 结果类的实现
+// ==============================================================
+
+const std::set<Value *> *LivenessAnalysisResult::getLiveIn(BasicBlock *BB) const {
+  auto it = liveInSets.find(BB);
+  if (it != liveInSets.end()) {
+    return &(it->second);
+  }
+  // 返回一个空集合，表示未找到或不存在
+  static const std::set<Value *> emptySet;
+  return &emptySet;
+}
+
+const std::set<Value *> *LivenessAnalysisResult::getLiveOut(BasicBlock *BB) const {
+  auto it = liveOutSets.find(BB);
+  if (it != liveOutSets.end()) {
+    return &(it->second);
+  }
+  static const std::set<Value *> emptySet;
+  return &emptySet;
+}
+
+void LivenessAnalysisResult::computeDefUse(BasicBlock *BB, std::set<Value *> &def, std::set<Value *> &use) {
+  def.clear(); // 将持有在 BB 中定义的值
+  use.clear(); // 将持有在 BB 中使用但在其定义之前的值
+
+  // 临时集合，用于跟踪当前基本块中已经定义过的变量
+  std::set<Value *> defined_in_block_so_far;
+
+  // 按照指令在块中的顺序遍历
+  for (const auto &inst_ptr : BB->getInstructions()) {
+    Instruction *inst = inst_ptr.get();
+
+    // 1. 处理指令的操作数 (Use) - 在定义之前的使用
+    for (const auto &use_ptr : inst->getOperands()) { // 修正迭代器类型
+      Value *operand = use_ptr->getValue();           // 从 shared_ptr<Use> 获取 Value*
+
+      // 过滤掉常量和全局变量，因为它们通常不被视为活跃变量
+      ConstantValue *constValue = dynamic_cast<ConstantValue *>(operand);
+      GlobalValue *globalValue = dynamic_cast<GlobalValue *>(operand);
+      if (constValue || globalValue) {
+        continue; // 跳过常量和全局变量
+      }
+
+      // 如果操作数是一个变量（Instruction 或 Argument），并且它在此基本块的当前点之前尚未被定义
+      if (defined_in_block_so_far.find(operand) == defined_in_block_so_far.end()) {
+        use.insert(operand);
+      }
+    }
+
+    // 2. 处理指令自身产生的定义 (Def)
+    if (inst->isDefine()) { // 使用 isDefine() 方法
+      // 指令自身定义了一个值。将其添加到块的 def 集合，
+      // 并添加到当前块中已定义的值的临时集合。
+      def.insert(inst); // inst 本身就是被定义的值（例如，虚拟寄存器）
+      defined_in_block_so_far.insert(inst);
+    }
+  }
+}
+
+void LivenessAnalysisResult::computeLiveness(Function *F) {
+  // 每次计算前清空旧结果
+  liveInSets.clear();  // 直接清空 map，不再使用 F 作为键
+  liveOutSets.clear(); // 直接清空 map
+
+  // 初始化所有基本块的 LiveIn 和 LiveOut 集合为空
+  for (const auto &bb_ptr : F->getBasicBlocks()) {
+    BasicBlock *bb = bb_ptr.get();
+    liveInSets[bb] = {};  // 直接以 bb 为键
+    liveOutSets[bb] = {}; // 直接以 bb 为键
+  }
+
+  bool changed = true;
+  while (changed) {
+    changed = false;
+
+    // TODO : 目前为逆序遍历基本块，考虑反向拓扑序遍历基本块
+
+    // 逆序遍历基本块
+    // std::list<std::unique_ptr<BasicBlock>> basicBlocks(F->getBasicBlocks().begin(), F->getBasicBlocks().end());
+    // std::reverse(basicBlocks.begin(), basicBlocks.end());
+    // 然后遍历 basicBlocks
+    // 创建一个 BasicBlock* 的列表来存储指针，避免拷贝 unique_ptr
+    // Option 1: Using std::vector<BasicBlock*> (preferred for performance with reverse)
+    std::vector<BasicBlock*> basicBlocksPointers;
+    for (const auto& bb_ptr : F->getBasicBlocks()) {
+        basicBlocksPointers.push_back(bb_ptr.get());
+    }
+    std::reverse(basicBlocksPointers.begin(), basicBlocksPointers.end());
+
+    for (auto bb_iter = basicBlocksPointers.begin(); bb_iter != basicBlocksPointers.end(); ++bb_iter) {
+      BasicBlock *bb = *bb_iter; // 获取 BasicBlock 指针
+      if (!bb)
+        continue; // 避免空指针
+
+      std::set<Value *> oldLiveIn = liveInSets[bb];
+      std::set<Value *> oldLiveOut = liveOutSets[bb];
+
+      // 1. 计算 LiveOut(BB) = Union(LiveIn(Succ) for Succ in Successors(BB))
+      std::set<Value *> newLiveOut;
+      for (BasicBlock *succ : bb->getSuccessors()) {
+        const std::set<Value *> *succLiveIn = getLiveIn(succ); // 获取后继的 LiveIn
+        if (succLiveIn) {
+          newLiveOut.insert(succLiveIn->begin(), succLiveIn->end());
+        }
+      }
+      liveOutSets[bb] = newLiveOut;
+
+      // 2. 计算 LiveIn(BB) = Use(BB) Union (LiveOut(BB) - Def(BB))
+      std::set<Value *> defSet, useSet;
+      computeDefUse(bb, defSet, useSet); // 计算当前块的 Def 和 Use
+
+      std::set<Value *> liveOutMinusDef;
+      std::set_difference(newLiveOut.begin(), newLiveOut.end(), defSet.begin(), defSet.end(),
+                          std::inserter(liveOutMinusDef, liveOutMinusDef.begin()));
+
+      std::set<Value *> newLiveIn = useSet;
+      newLiveIn.insert(liveOutMinusDef.begin(), liveOutMinusDef.end());
+      liveInSets[bb] = newLiveIn;
+
+      // 检查是否发生变化
+      if (oldLiveIn != newLiveIn || oldLiveOut != newLiveOut) {
+        changed = true;
+      }
+    }
+  }
+}
+
+// ==============================================================
+// LivenessAnalysisPass 的实现
+// ==============================================================
+
+bool LivenessAnalysisPass::runOnFunction(Function *F, AnalysisManager &AM) {
+  // 每次运行创建一个新的 LivenessAnalysisResult 对象来存储结果
+  CurrentLivenessResult = std::make_unique<LivenessAnalysisResult>(F);
+
+  // 调用 LivenessAnalysisResult 内部的方法来计算分析结果
+  CurrentLivenessResult->computeLiveness(F);
+
+  // 分析遍通常不修改 IR，所以返回 false
+  return false;
+}
+
+std::unique_ptr<AnalysisResultBase> LivenessAnalysisPass::getResult() {
+  // 返回计算好的 LivenessAnalysisResult 实例，所有权转移给 AnalysisManager
+  return std::move(CurrentLivenessResult);
+}
+
+} // namespace sysy

src/Pass.cpp

@@ -0,0 +1,175 @@
+#include "Dom.h"
+#include "Liveness.h"
+#include "SysYIRCFGOpt.h"
+#include "SysYIRPrinter.h"
+#include "DCE.h"
+#include "Pass.h"
+#include <iostream>
+#include <queue>
+#include <map>
+#include <set>
+#include <algorithm>
+#include <vector>
+
+extern int DEBUG; // 全局调试标志
+namespace sysy {
+
+// ======================================================================
+// 封装优化流程的函数：包含Pass注册和迭代运行逻辑
+// ======================================================================
+
+void PassManager::runOptimizationPipeline(Module* moduleIR, IRBuilder* builderIR, int optLevel) {
+    if (DEBUG) std::cout << "--- Starting Middle-End Optimizations (Level -O" << optLevel << ") ---\n";
+
+    /*
+      中端开发框架基本流程：
+      1) 分析pass
+        1. 实现分析pass并引入Pass.cpp
+        2. 注册分析pass
+      2) 优化pass
+        1. 实现优化pass并引入Pass.cpp
+        2. 注册优化pass
+        3. 添加优化passid
+    */
+    // 注册分析遍
+    registerAnalysisPass<sysy::DominatorTreeAnalysisPass>();
+    registerAnalysisPass<sysy::LivenessAnalysisPass>();
+
+    // 注册优化遍
+    registerOptimizationPass<SysYDelInstAfterBrPass>();
+    registerOptimizationPass<SysYDelNoPreBLockPass>();
+    registerOptimizationPass<SysYBlockMergePass>();
+
+    registerOptimizationPass<SysYDelEmptyBlockPass>(builderIR);
+    registerOptimizationPass<SysYCondBr2BrPass>(builderIR);
+    registerOptimizationPass<SysYAddReturnPass>(builderIR);
+
+    if (optLevel >= 1) {
+      //经过设计安排优化遍的执行顺序以及执行逻辑
+      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(&DCE::ID); 
+      this->run();
+
+      if (DEBUG) std::cout << "--- Custom optimization sequence finished ---\n";
+    }
+
+    // 2. 创建遍管理器
+    // 3. 根据优化级别添加不同的优化遍
+    // TODO : 根据 optLevel 添加不同的优化遍
+    //        讨论 是不动点迭代进行优化遍还是手动客制化优化遍的顺序？
+
+
+    if (DEBUG) {
+      std::cout << "=== Final IR After Middle-End Optimizations (Level -O" << optLevel << ") ===\n";
+      SysYPrinter printer(moduleIR);
+      printer.printIR();
+    }
+}
+
+void PassManager::clearPasses() {
+  passes.clear();
+}
+
+void PassManager::addPass(void *passID) {
+
+  PassRegistry &registry = PassRegistry::getPassRegistry();
+  std::unique_ptr<Pass> P = registry.createPass(passID);
+  if (!P) {
+    // Error: Pass not found or failed to create
+    return;
+  }
+
+  passes.push_back(std::move(P));
+}
+
+// 运行所有注册的遍
+bool PassManager::run() {
+  bool changed = false;
+  for (const auto &p : passes) {
+    bool passChanged = false; // 记录当前遍是否修改了 IR
+
+    // 处理优化遍的分析依赖和失效
+    if (p->getPassKind() == Pass::PassKind::Optimization) {
+      OptimizationPass *optPass = static_cast<OptimizationPass *>(p.get());
+      std::set<void *> analysisDependencies;
+      std::set<void *> analysisInvalidations;
+      optPass->getAnalysisUsage(analysisDependencies, analysisInvalidations);
+
+      // PassManager 不显式运行分析依赖。
+      // 而是优化遍在 runOnFunction 内部通过 AnalysisManager.getAnalysisResult 按需请求。
+    }
+
+    if (p->getGranularity() == Pass::Granularity::Module) {
+      passChanged = p->runOnModule(pmodule, analysisManager);
+    } else if (p->getGranularity() == Pass::Granularity::Function) {
+      for (auto &funcPair : pmodule->getFunctions()) {
+        Function *F = funcPair.second.get();
+        passChanged = p->runOnFunction(F, analysisManager) || passChanged;
+
+        if (passChanged && p->getPassKind() == Pass::PassKind::Optimization) {
+          OptimizationPass *optPass = static_cast<OptimizationPass *>(p.get());
+          std::set<void *> analysisDependencies;
+          std::set<void *> analysisInvalidations;
+          optPass->getAnalysisUsage(analysisDependencies, analysisInvalidations);
+          for (void *invalidationID : analysisInvalidations) {
+            analysisManager.invalidateAnalysis(invalidationID, F);
+          }
+        }
+      }
+    } else if (p->getGranularity() == Pass::Granularity::BasicBlock) {
+      for (auto &funcPair : pmodule->getFunctions()) {
+        Function *F = funcPair.second.get();
+        for (auto &bbPtr : funcPair.second->getBasicBlocks()) {
+          passChanged = p->runOnBasicBlock(bbPtr.get(), analysisManager) || passChanged;
+
+          if (passChanged && p->getPassKind() == Pass::PassKind::Optimization) {
+            OptimizationPass *optPass = static_cast<OptimizationPass *>(p.get());
+            std::set<void *> analysisDependencies;
+            std::set<void *> analysisInvalidations;
+            optPass->getAnalysisUsage(analysisDependencies, analysisInvalidations);
+            for (void *invalidationID : analysisInvalidations) {
+              analysisManager.invalidateAnalysis(invalidationID, F);
+            }
+          }
+        }
+      }
+    }
+    changed = changed || passChanged;
+  }
+  return changed;
+
+}
+
+
+template <typename AnalysisPassType> void registerAnalysisPass() {
+  PassRegistry::getPassRegistry().registerPass(&AnalysisPassType::ID,
+                                               []() { return std::make_unique<AnalysisPassType>(); });
+}
+
+template <typename OptimizationPassType, typename std::enable_if<
+    std::is_constructible<OptimizationPassType, IRBuilder*>::value, int>::type>
+void registerOptimizationPass(IRBuilder* builder) {
+    PassRegistry::getPassRegistry().registerPass(&OptimizationPassType::ID,
+                                                 [builder]() { return std::make_unique<OptimizationPassType>(builder); });
+}
+
+template <typename OptimizationPassType, typename std::enable_if<
+    !std::is_constructible<OptimizationPassType, IRBuilder*>::value, int>::type>
+void registerOptimizationPass() {
+    PassRegistry::getPassRegistry().registerPass(&OptimizationPassType::ID,
+                                                 []() { return std::make_unique<OptimizationPassType>(); });
+}
+
+} // namespace sysy

src/PostRA_Scheduler.cpp

@@ -0,0 +1,383 @@
+#include "PostRA_Scheduler.h"
+#include <set>
+#include <map>
+#include <vector>
+#include <algorithm>
+#define MAX_SCHEDULING_BLOCK_SIZE 10000 // 限制调度块大小，避免过大导致性能问题
+
+namespace sysy {
+
+char PostRA_Scheduler::ID = 0;
+
+// 检查指令是否是加载指令 (LW, LD)
+bool isLoadInstr(MachineInstr* instr) {
+    RVOpcodes opcode = instr->getOpcode();
+    return opcode == RVOpcodes::LW || opcode == RVOpcodes::LD || 
+           opcode == RVOpcodes::LH || opcode == RVOpcodes::LB || 
+           opcode == RVOpcodes::LHU || opcode == RVOpcodes::LBU || 
+           opcode == RVOpcodes::LWU;
+}
+
+// 检查指令是否是存储指令 (SW, SD)
+bool isStoreInstr(MachineInstr* instr) {
+    RVOpcodes opcode = instr->getOpcode();
+    return opcode == RVOpcodes::SW || opcode == RVOpcodes::SD || 
+           opcode == RVOpcodes::SH || opcode == RVOpcodes::SB;
+}
+
+// 检查指令是否为控制流指令
+bool isControlFlowInstr(MachineInstr* instr) {
+    RVOpcodes opcode = instr->getOpcode();
+    return opcode == RVOpcodes::RET || opcode == RVOpcodes::J || 
+           opcode == RVOpcodes::BEQ || opcode == RVOpcodes::BNE ||
+           opcode == RVOpcodes::BLT || opcode == RVOpcodes::BGE ||
+           opcode == RVOpcodes::BLTU || opcode == RVOpcodes::BGEU ||
+           opcode == RVOpcodes::CALL;
+}
+
+// 获取指令定义的寄存器 - 修复版本
+std::set<PhysicalReg> getDefinedRegisters(MachineInstr* instr) {
+    std::set<PhysicalReg> defined_regs;
+    RVOpcodes opcode = instr->getOpcode();
+    
+    // 特殊处理CALL指令
+    if (opcode == RVOpcodes::CALL) {
+        // CALL指令可能定义返回值寄存器
+        if (!instr->getOperands().empty() && 
+            instr->getOperands().front()->getKind() == MachineOperand::KIND_REG) {
+            auto reg_op = static_cast<RegOperand*>(instr->getOperands().front().get());
+            if (!reg_op->isVirtual()) {
+                defined_regs.insert(reg_op->getPReg());
+            }
+        }
+        return defined_regs;
+    }
+    
+    // 存储指令不定义寄存器
+    if (isStoreInstr(instr)) {
+        return defined_regs;
+    }
+    
+    // 分支指令不定义寄存器
+    if (opcode == RVOpcodes::BEQ || opcode == RVOpcodes::BNE ||
+        opcode == RVOpcodes::BLT || opcode == RVOpcodes::BGE ||
+        opcode == RVOpcodes::BLTU || opcode == RVOpcodes::BGEU ||
+        opcode == RVOpcodes::J || opcode == RVOpcodes::RET) {
+        return defined_regs;
+    }
+    
+    // 对于其他指令，第一个寄存器操作数通常是定义的
+    if (!instr->getOperands().empty() && 
+        instr->getOperands().front()->getKind() == MachineOperand::KIND_REG) {
+        auto reg_op = static_cast<RegOperand*>(instr->getOperands().front().get());
+        if (!reg_op->isVirtual()) {
+            defined_regs.insert(reg_op->getPReg());
+        }
+    }
+    
+    return defined_regs;
+}
+
+// 获取指令使用的寄存器 - 修复版本
+std::set<PhysicalReg> getUsedRegisters(MachineInstr* instr) {
+    std::set<PhysicalReg> used_regs;
+    RVOpcodes opcode = instr->getOpcode();
+    
+    // 特殊处理CALL指令
+    if (opcode == RVOpcodes::CALL) {
+        bool first_reg_skipped = false;
+        for (const auto& op : instr->getOperands()) {
+            if (op->getKind() == MachineOperand::KIND_REG) {
+                if (!first_reg_skipped) {
+                    first_reg_skipped = true;
+                    continue; // 跳过返回值寄存器
+                }
+                auto reg_op = static_cast<RegOperand*>(op.get());
+                if (!reg_op->isVirtual()) {
+                    used_regs.insert(reg_op->getPReg());
+                }
+            }
+        }
+        return used_regs;
+    }
+    
+    // 对于存储指令，所有寄存器操作数都是使用的
+    if (isStoreInstr(instr)) {
+        for (const auto& op : instr->getOperands()) {
+            if (op->getKind() == MachineOperand::KIND_REG) {
+                auto reg_op = static_cast<RegOperand*>(op.get());
+                if (!reg_op->isVirtual()) {
+                    used_regs.insert(reg_op->getPReg());
+                }
+            } else if (op->getKind() == MachineOperand::KIND_MEM) {
+                auto mem_op = static_cast<MemOperand*>(op.get());
+                if (!mem_op->getBase()->isVirtual()) {
+                    used_regs.insert(mem_op->getBase()->getPReg());  
+                }
+            }
+        }
+        return used_regs;
+    }
+    
+    // 对于分支指令，所有寄存器操作数都是使用的
+    if (opcode == RVOpcodes::BEQ || opcode == RVOpcodes::BNE ||
+        opcode == RVOpcodes::BLT || opcode == RVOpcodes::BGE ||
+        opcode == RVOpcodes::BLTU || opcode == RVOpcodes::BGEU) {
+        for (const auto& op : instr->getOperands()) {
+            if (op->getKind() == MachineOperand::KIND_REG) {
+                auto reg_op = static_cast<RegOperand*>(op.get());
+                if (!reg_op->isVirtual()) {
+                    used_regs.insert(reg_op->getPReg());
+                }
+            }
+        }
+        return used_regs;
+    }
+    
+    // 对于其他指令，除了第一个寄存器操作数（通常是定义），其余都是使用的
+    bool first_reg = true;
+    for (const auto& op : instr->getOperands()) {
+        if (op->getKind() == MachineOperand::KIND_REG) {
+            if (first_reg) {
+                first_reg = false;
+                continue; // 跳过第一个寄存器（定义）
+            }
+            auto reg_op = static_cast<RegOperand*>(op.get());
+            if (!reg_op->isVirtual()) {
+                used_regs.insert(reg_op->getPReg());
+            }
+        } else if (op->getKind() == MachineOperand::KIND_MEM) {
+            auto mem_op = static_cast<MemOperand*>(op.get());
+            if (!mem_op->getBase()->isVirtual()) {
+                used_regs.insert(mem_op->getBase()->getPReg());
+            }
+        }
+    }
+    return used_regs;
+}
+
+// 获取内存访问的基址和偏移
+struct MemoryAccess {
+    PhysicalReg base_reg;
+    int64_t offset;
+    bool valid;
+    
+    MemoryAccess() : valid(false) {}
+    MemoryAccess(PhysicalReg base, int64_t off) : base_reg(base), offset(off), valid(true) {}
+};
+
+MemoryAccess getMemoryAccess(MachineInstr* instr) {
+    if (!isLoadInstr(instr) && !isStoreInstr(instr)) {
+        return MemoryAccess();
+    }
+    
+    // 查找内存操作数
+    for (const auto& op : instr->getOperands()) {
+        if (op->getKind() == MachineOperand::KIND_MEM) {
+            auto mem_op = static_cast<MemOperand*>(op.get());
+            if (!mem_op->getBase()->isVirtual()) {
+                return MemoryAccess(mem_op->getBase()->getPReg(), mem_op->getOffset()->getValue());
+            }
+        }
+    }
+    
+    return MemoryAccess();
+}
+
+// 检查内存依赖 - 加强版本
+bool hasMemoryDependency(MachineInstr* instr1, MachineInstr* instr2) {
+    // 如果都不是内存指令，没有内存依赖
+    if (!isLoadInstr(instr1) && !isStoreInstr(instr1) && 
+        !isLoadInstr(instr2) && !isStoreInstr(instr2)) {
+        return false;
+    }
+    
+    MemoryAccess mem1 = getMemoryAccess(instr1);
+    MemoryAccess mem2 = getMemoryAccess(instr2);
+    
+    if (!mem1.valid || !mem2.valid) {
+        // 如果无法确定内存访问模式，保守地认为存在依赖
+        return true;
+    }
+    
+    // 如果访问相同的内存位置
+    if (mem1.base_reg == mem2.base_reg && mem1.offset == mem2.offset) {
+        // Store->Load: RAW依赖
+        // Load->Store: WAR依赖  
+        // Store->Store: WAW依赖
+        return isStoreInstr(instr1) || isStoreInstr(instr2);
+    }
+    
+    // 不同内存位置通常没有依赖，但为了安全起见，
+    // 如果涉及store指令，我们需要更保守
+    if (isStoreInstr(instr1) && isLoadInstr(instr2)) {
+        // 保守处理：不同store和load之间可能有别名
+        return false; // 这里可以根据需要调整策略
+    }
+    
+    return false;
+}
+
+// 检查两个指令之间是否存在依赖关系 - 修复版本
+bool hasDependency(MachineInstr* instr1, MachineInstr* instr2) {
+    // 检查RAW依赖：instr1定义的寄存器是否被instr2使用
+    auto defined_regs1 = getDefinedRegisters(instr1);
+    auto used_regs2 = getUsedRegisters(instr2);
+    
+    for (const auto& reg : defined_regs1) {
+        if (used_regs2.find(reg) != used_regs2.end()) {
+            return true; // RAW依赖 - instr2读取instr1写入的值
+        }
+    }
+    
+    // 检查WAR依赖：instr1使用的寄存器是否被instr2定义
+    auto used_regs1 = getUsedRegisters(instr1);
+    auto defined_regs2 = getDefinedRegisters(instr2);
+    
+    for (const auto& reg : used_regs1) {
+        if (defined_regs2.find(reg) != defined_regs2.end()) {
+            return true; // WAR依赖 - instr2覆盖instr1需要的值
+        }
+    }
+    
+    // 检查WAW依赖：两个指令定义相同寄存器
+    for (const auto& reg : defined_regs1) {
+        if (defined_regs2.find(reg) != defined_regs2.end()) {
+            return true; // WAW依赖 - 两条指令写入同一寄存器
+        }
+    }
+    
+    // 检查内存依赖
+    if (hasMemoryDependency(instr1, instr2)) {
+        return true;
+    }
+    
+    return false;
+}
+
+// 检查是否可以安全地将instr1和instr2交换位置
+bool canSwapInstructions(MachineInstr* instr1, MachineInstr* instr2) {
+    // 不能移动控制流指令
+    if (isControlFlowInstr(instr1) || isControlFlowInstr(instr2)) {
+        return false;
+    }
+    
+    // 检查双向依赖关系
+    return !hasDependency(instr1, instr2) && !hasDependency(instr2, instr1);
+}
+
+// 新增：验证调度结果的正确性
+void validateSchedule(const std::vector<MachineInstr*>& instr_list) {
+    for (int i = 0; i < (int)instr_list.size(); i++) {
+        for (int j = i + 1; j < (int)instr_list.size(); j++) {
+            MachineInstr* earlier = instr_list[i];
+            MachineInstr* later = instr_list[j];
+            
+            // 检查是否存在被违反的依赖关系
+            auto defined_regs = getDefinedRegisters(earlier);
+            auto used_regs = getUsedRegisters(later);
+            
+            // 检查RAW依赖
+            for (const auto& reg : defined_regs) {
+                if (used_regs.find(reg) != used_regs.end()) {
+                    // 这是正常的依赖关系，earlier应该在later之前
+                    continue;
+                }
+            }
+            
+            // 检查内存依赖
+            if (hasMemoryDependency(earlier, later)) {
+                MemoryAccess mem1 = getMemoryAccess(earlier);
+                MemoryAccess mem2 = getMemoryAccess(later);
+                
+                if (mem1.valid && mem2.valid && 
+                    mem1.base_reg == mem2.base_reg && mem1.offset == mem2.offset) {
+                    if (isStoreInstr(earlier) && isLoadInstr(later)) {
+                        // Store->Load依赖，顺序正确
+                        continue;
+                    }
+                }
+            }
+        }
+    }
+}
+
+// 在基本块内对指令进行调度优化 - 完全重写版本
+void scheduleBlock(MachineBasicBlock* mbb) {
+    auto& instructions = mbb->getInstructions();
+    if (instructions.size() <= 1) return;
+    if (instructions.size() > MAX_SCHEDULING_BLOCK_SIZE) {
+      return; // 跳过超大块，防止卡住
+    }
+    
+    std::vector<MachineInstr*> instr_list;
+    for (auto& instr : instructions) {
+        instr_list.push_back(instr.get());
+    }
+    
+    // 使用更严格的调度策略，避免破坏依赖关系
+    bool changed = true;
+    int max_iterations = 10; // 限制迭代次数避免死循环
+    int iteration = 0;
+    
+    while (changed && iteration < max_iterations) {
+        changed = false;
+        iteration++;
+        
+        for (int i = 0; i < (int)instr_list.size() - 1; i++) {
+            MachineInstr* instr1 = instr_list[i];
+            MachineInstr* instr2 = instr_list[i + 1];
+            
+            // 只进行非常保守的优化
+            bool should_swap = false;
+            
+            // 策略1: 将load指令提前，减少load-use延迟
+            if (isLoadInstr(instr2) && !isLoadInstr(instr1) && !isStoreInstr(instr1)) {
+                should_swap = canSwapInstructions(instr1, instr2);
+            }
+            // 策略2: 将非关键store指令延后，为其他指令让路
+            else if (isStoreInstr(instr1) && !isLoadInstr(instr2) && !isStoreInstr(instr2)) {
+                should_swap = canSwapInstructions(instr1, instr2);
+            }
+            
+            if (should_swap) {
+                std::swap(instr_list[i], instr_list[i + 1]);
+                changed = true;
+                
+                // 调试输出
+                // std::cout << "Swapped instructions at positions " << i << " and " << (i+1) << std::endl;
+            }
+        }
+    }
+    
+    // 验证调度结果的正确性
+    validateSchedule(instr_list);
+    
+    // 将调度后的指令顺序写回
+    std::map<MachineInstr*, std::unique_ptr<MachineInstr>> instr_map;
+    for (auto& instr : instructions) {
+        instr_map[instr.get()] = std::move(instr);
+    }
+    
+    instructions.clear();
+    for (auto instr : instr_list) {
+        instructions.push_back(std::move(instr_map[instr]));
+    }
+}
+
+bool PostRA_Scheduler::runOnFunction(Function *F, AnalysisManager& AM) {
+    // 这个函数在IR级别运行，但我们需要在机器指令级别运行
+    // 所以我们返回false，表示没有对IR进行修改
+    return false;
+}
+
+void PostRA_Scheduler::runOnMachineFunction(MachineFunction *mfunc) {
+    // std::cout << "Running Post-RA Local Scheduler... " << std::endl;
+    
+    // 遍历每个机器基本块
+    for (auto& mbb : mfunc->getBlocks()) {
+        scheduleBlock(mbb.get());
+    }
+}
+
+} // namespace sysy

src/PreRA_Scheduler.cpp

@@ -0,0 +1,36 @@
+#include "PreRA_Scheduler.h"
+
+namespace sysy {
+
+char PreRA_Scheduler::ID = 0;
+
+bool PreRA_Scheduler::runOnFunction(Function *F, AnalysisManager& AM) {
+  // TODO: 在此实现寄存器分配前的指令调度。
+  // 遍历mfunc中的每一个MachineBasicBlock。
+  // 对每个基本块内的MachineInstr列表进行重排。
+  //
+  // 实现思路:
+  // 1. 分析每个基本块内指令的数据依赖关系，构建依赖图(DAG)。
+  // 2.
+  // 根据目标处理器的流水线特性（指令延迟等），使用列表调度等算法对指令进行重排。
+  // 3. 此时操作的是虚拟寄存器，只存在真依赖，调度自由度最大。
+  //
+  // std::cout << "Running Pre-RA Instruction Scheduler..." << std::endl;
+  return false;
+}
+
+void PreRA_Scheduler::runOnMachineFunction(MachineFunction *mfunc) {
+  // TODO: 在此实现寄存器分配前的指令调度。
+  // 遍历mfunc中的每一个MachineBasicBlock。
+  // 对每个基本块内的MachineInstr列表进行重排。
+  //
+  // 实现思路:
+  // 1. 分析每个基本块内指令的数据依赖关系，构建依赖图(DAG)。
+  // 2.
+  // 根据目标处理器的流水线特性（指令延迟等），使用列表调度等算法对指令进行重排。
+  // 3. 此时操作的是虚拟寄存器，只存在真依赖，调度自由度最大。
+  //
+  // std::cout << "Running Pre-RA Instruction Scheduler..." << std::endl;
+}
+
+} // namespace sysy

src/RISCv64AsmPrinter.cpp

@@ -31,37 +31,32 @@ void RISCv64AsmPrinter::run(std::ostream& os, bool debug) {
     }
 }
 
+// 在 RISCv64AsmPrinter.cpp 文件中
+
 void RISCv64AsmPrinter::printPrologue() {
     StackFrameInfo& frame_info = MFunc->getFrameInfo();
-    // 序言需要为保存ra和s0预留16字节
-    int total_stack_size = frame_info.locals_size + frame_info.spill_size + 16;
+    // 计算总栈帧大小。
+    // 包含三部分：局部变量区、寄存器溢出区、以及为被调用者保存(callee-saved)寄存器预留的区域。
+    // 最后再加上为保存 ra 和 s0 固定的16字节。
+    int total_stack_size = frame_info.locals_size + 
+                           frame_info.spill_size + 
+                           frame_info.callee_saved_size + 
+                           16; 
+    
+    // 保持栈指针16字节对齐
     int aligned_stack_size = (total_stack_size + 15) & ~15;
-    frame_info.total_size = aligned_stack_size;
+    frame_info.total_size = aligned_stack_size; // 更新最终的栈大小
 
+    // 只有在需要分配栈空间时才生成指令
     if (aligned_stack_size > 0) {
+        // 1. 一次性分配整个栈帧
         *OS << "    addi sp, sp, -" << aligned_stack_size << "\n";
+        // 2. 在新的栈顶附近保存 ra 和 s0
         *OS << "    sd ra, " << (aligned_stack_size - 8) << "(sp)\n";
         *OS << "    sd s0, " << (aligned_stack_size - 16) << "(sp)\n";
+        // 3. 设置新的帧指针 s0，使其指向栈帧的底部（高地址）
         *OS << "    addi s0, sp, " << aligned_stack_size << "\n";
     }
-
-    // 忠实还原保存函数入口参数的逻辑
-    Function* F = MFunc->getFunc();
-    if (F && F->getEntryBlock()) {
-        int arg_idx = 0;
-        RISCv64ISel* isel = MFunc->getISel();
-        for (AllocaInst* alloca_for_param : F->getEntryBlock()->getArguments()) {
-            if (arg_idx >= 8) break;
-            
-            unsigned vreg = isel->getVReg(alloca_for_param);
-            if (frame_info.alloca_offsets.count(vreg)) {
-                int offset = frame_info.alloca_offsets.at(vreg);
-                auto arg_reg = static_cast<PhysicalReg>(static_cast<int>(PhysicalReg::A0) + arg_idx);
-                *OS << "    sw " << regToString(arg_reg) << ", " << offset << "(s0)\n";
-            }
-            arg_idx++;
-        }
-    }
 }
 
 void RISCv64AsmPrinter::printEpilogue() {
@@ -131,19 +126,36 @@ void RISCv64AsmPrinter::printInstruction(MachineInstr* instr, bool debug) {
         case RVOpcodes::MV:    *OS << "mv ";    break; case RVOpcodes::NEG:   *OS << "neg ";   break;
         case RVOpcodes::NEGW:  *OS << "negw ";  break; case RVOpcodes::SEQZ:  *OS << "seqz ";  break;
         case RVOpcodes::SNEZ:  *OS << "snez ";  break;
-        case RVOpcodes::CALL:  *OS << "call ";  break;
+        case RVOpcodes::CALL: { // [核心修改] 为CALL指令添加特殊处理逻辑
+            *OS << "call ";
+            // 遍历所有操作数，只寻找并打印函数名标签
+            for (const auto& op : instr->getOperands()) {
+                if (op->getKind() == MachineOperand::KIND_LABEL) {
+                    printOperand(op.get());
+                    break; // 找到标签后即可退出
+                }
+            }
+            *OS << "\n";
+            return; // 处理完毕，直接返回，不再执行后续的通用操作数打印
+        }
         case RVOpcodes::LABEL:
-            // printOperand(instr->getOperands()[0].get());
-            // *OS << ":";
             break;
-        case RVOpcodes::FRAME_LOAD:
+        case RVOpcodes::FRAME_LOAD_W:
             // It should have been eliminated by RegAlloc
             if (!debug) throw std::runtime_error("FRAME pseudo-instruction not eliminated before AsmPrinter");
-            *OS << "frame_load ";  break;
-        case RVOpcodes::FRAME_STORE:
+            *OS << "frame_load_w ";  break;
+        case RVOpcodes::FRAME_LOAD_D:
             // It should have been eliminated by RegAlloc
             if (!debug) throw std::runtime_error("FRAME pseudo-instruction not eliminated before AsmPrinter");
-            *OS << "frame_store ";  break;
+            *OS << "frame_load_d ";  break;
+        case RVOpcodes::FRAME_STORE_W:
+            // It should have been eliminated by RegAlloc
+            if (!debug) throw std::runtime_error("FRAME pseudo-instruction not eliminated before AsmPrinter");
+            *OS << "frame_store_w ";  break;
+        case RVOpcodes::FRAME_STORE_D:
+            // It should have been eliminated by RegAlloc
+            if (!debug) throw std::runtime_error("FRAME pseudo-instruction not eliminated before AsmPrinter");
+            *OS << "frame_store_d ";  break;
         case RVOpcodes::FRAME_ADDR:
             // It should have been eliminated by RegAlloc
             if (!debug) throw std::runtime_error("FRAME pseudo-instruction not eliminated before AsmPrinter");

src/RISCv64Backend.cpp

@@ -16,13 +16,59 @@ std::string RISCv64CodeGen::code_gen() {
 std::string RISCv64CodeGen::module_gen() {
     std::stringstream ss;
     
-    // 1. 处理全局变量 (.data段)
-    if (!module->getGlobals().empty()) {
-        ss << ".data\n";
-        for (const auto& global : module->getGlobals()) {
+    // --- [新逻辑] 步骤1：将全局变量分为.data和.bss两组 ---
+    std::vector<GlobalValue*> data_globals;
+    std::vector<GlobalValue*> bss_globals;
+
+    for (const auto& global_ptr : module->getGlobals()) {
+        GlobalValue* global = global_ptr.get();
+        const auto& init_values = global->getInitValues();
+        
+        // 判断是否为大型零初始化数组，以便放入.bss段
+        bool is_large_zero_array = false;
+        // 规则：初始化列表只有一项，且该项是值为0的整数，且数量大于一个阈值（例如16）
+        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;
+                }
+            }
+        }
+
+        if (is_large_zero_array) {
+            bss_globals.push_back(global);
+        } else {
+            data_globals.push_back(global);
+        }
+    }
+
+    // --- [新逻辑] 步骤2：生成 .bss 段的代码 ---
+    if (!bss_globals.empty()) {
+        ss << ".bss\n"; // 切换到 .bss 段
+        for (GlobalValue* global : bss_globals) {
+            // 获取数组总大小（元素个数 * 元素大小）
+            // 在SysY中，我们假设元素都是4字节（int或float）
+            unsigned count = global->getInitValues().getNumbers()[0];
+            unsigned total_size = count * 4;
+
+            ss << "    .align 3\n"; // 8字节对齐 (2^3)
+            ss << ".globl " << global->getName() << "\n";
+            ss << ".type " << global->getName() << ", @object\n";
+            ss << ".size " << global->getName() << ", " << total_size << "\n";
+            ss << global->getName() << ":\n";
+            // 使用 .space 指令来预留指定大小的零填充空间
+            ss << "    .space " << total_size << "\n";
+        }
+    }
+    
+    // --- [旧逻辑保留] 步骤3：生成 .data 段的代码 ---
+    if (!data_globals.empty()) {
+        ss << ".data\n"; // 切换到 .data 段
+        for (GlobalValue* global : data_globals) {
             ss << ".globl " << global->getName() << "\n";
             ss << global->getName() << ":\n";
             const auto& init_values = global->getInitValues();
+            // 使用您原有的逻辑来处理显式初始化的值
             for (size_t i = 0; i < init_values.getValues().size(); ++i) {
                 auto val = init_values.getValues()[i];
                 auto count = init_values.getNumbers()[i];
@@ -41,7 +87,7 @@ std::string RISCv64CodeGen::module_gen() {
         }
     }
 
-    // 2. 处理函数 (.text段)
+    // --- 处理函数 (.text段) 的逻辑保持不变 ---
     if (!module->getFunctions().empty()) {
         ss << ".text\n";
         for (const auto& func_pair : module->getFunctions()) {
@@ -73,6 +119,10 @@ std::string RISCv64CodeGen::function_gen(Function* func) {
     RISCv64RegAlloc reg_alloc(mfunc.get());
     reg_alloc.run();
 
+    // 阶段 3.5: 处理被调用者保存寄存器
+    CalleeSavedHandler callee_handler;
+    callee_handler.runOnMachineFunction(mfunc.get());
+
     // 阶段 4: 窥孔优化 (Peephole Optimization)
     PeepholeOptimizer peephole;
     peephole.runOnMachineFunction(mfunc.get());
@@ -85,7 +135,7 @@ std::string RISCv64CodeGen::function_gen(Function* func) {
     std::stringstream ss;
     RISCv64AsmPrinter printer(mfunc.get());
     printer.run(ss);
-    if (DEBUG) ss << ss1.str(); // 将指令选择阶段的结果也包含在最终输出中
+    if (DEBUG) ss << "\n" << ss1.str(); // 将指令选择阶段的结果也包含在最终输出中
     return ss.str();
 }
 

src/RISCv64ISel.cpp

@@ -10,7 +10,7 @@ namespace sysy {
 
 // DAG节点定义 (内部实现)
 struct RISCv64ISel::DAGNode {
-    enum NodeKind { CONSTANT, LOAD, STORE, BINARY, CALL, RETURN, BRANCH, ALLOCA_ADDR, UNARY, MEMSET };
+    enum NodeKind {ARGUMENT, CONSTANT, LOAD, STORE, BINARY, CALL, RETURN, BRANCH, ALLOCA_ADDR, UNARY, MEMSET, GET_ELEMENT_PTR};
     NodeKind kind;
     Value* value = nullptr;
     std::vector<DAGNode*> operands;
@@ -51,22 +51,28 @@ std::unique_ptr<MachineFunction> RISCv64ISel::runOnFunction(Function* func) {
 
 // 指令选择主流程
 void RISCv64ISel::select() {
+    // 遍历基本块，为它们创建对应的MachineBasicBlock
     for (const auto& bb_ptr : F->getBasicBlocks()) {
         auto mbb = std::make_unique<MachineBasicBlock>(bb_ptr->getName(), MFunc.get());
         bb_map[bb_ptr.get()] = mbb.get();
         MFunc->addBlock(std::move(mbb));
     }
     
-    if (F->getEntryBlock()) {
-        for (auto* arg_alloca : F->getEntryBlock()->getArguments()) {
-            getVReg(arg_alloca);
+    // 遍历Argument对象，为它们分配虚拟寄存器。
+    if (F) {
+        for (Argument* arg : F->getArguments()) {
+            // getVReg会为每个代表参数的Argument对象在vreg_map中创建一个条目。
+            // 这样，当后续的store指令使用这个参数时，就能找到对应的vreg。
+            getVReg(arg);
         }
     }
 
+    // 遍历基本块，进行指令选择
     for (const auto& bb_ptr : F->getBasicBlocks()) {
         selectBasicBlock(bb_ptr.get());
     }
     
+    // 链接MachineBasicBlock的前驱和后继
     for (const auto& bb_ptr : F->getBasicBlocks()) {
         CurMBB = bb_map.at(bb_ptr.get());
         for (auto succ : bb_ptr->getSuccessors()) {
@@ -133,10 +139,10 @@ void RISCv64ISel::selectNode(DAGNode* node) {
     // 因此，这里我们只处理当前节点。
 
     switch (node->kind) {
-        // [V2优点] 采纳“延迟物化”（Late Materialization）思想。
-        // 这两个节点仅作为标记，不直接生成指令。它们的目的是在DAG中保留类型信息。
+        // “延迟物化”（Late Materialization）思想。
+        // 这三种节点仅作为标记，不直接生成指令。它们的目的是在DAG中保留类型信息。
         // 加载其值的责任，被转移给了使用它们的父节点（如STORE, BINARY等）。
-        // 这修复了之前版本中“使用未初始化虚拟寄存器”的根本性bug。
+        case DAGNode::ARGUMENT:
         case DAGNode::CONSTANT:
         case DAGNode::ALLOCA_ADDR:
             if (node->value) {
@@ -149,38 +155,51 @@ void RISCv64ISel::selectNode(DAGNode* node) {
             auto dest_vreg = getVReg(node->value);
             Value* ptr_val = node->operands[0]->value;
 
-            // [V1设计保留] 对于从栈变量加载，继续使用伪指令 FRAME_LOAD。
-            // 这种设计将栈帧布局的具体计算推迟到后续的 `eliminateFrameIndices` 阶段，保持了模块化。
+            // --- 修改点 ---
+            // 1. 获取加载结果的类型 (即这个LOAD指令自身的类型)
+            Type* loaded_type = node->value->getType();
+            
+            // 2. 根据类型选择正确的伪指令或真实指令操作码
+            RVOpcodes frame_opcode = loaded_type->isPointer() ? RVOpcodes::FRAME_LOAD_D : RVOpcodes::FRAME_LOAD_W;
+            RVOpcodes real_opcode = loaded_type->isPointer() ? RVOpcodes::LD : RVOpcodes::LW;
+
+
             if (auto alloca = dynamic_cast<AllocaInst*>(ptr_val)) {
-                auto instr = std::make_unique<MachineInstr>(RVOpcodes::FRAME_LOAD);
+                // 3. 创建使用新的、区分宽度的伪指令
+                auto instr = std::make_unique<MachineInstr>(frame_opcode);
                 instr->addOperand(std::make_unique<RegOperand>(dest_vreg));
                 instr->addOperand(std::make_unique<RegOperand>(getVReg(alloca)));
                 CurMBB->addInstruction(std::move(instr));
+
             } else if (auto global = dynamic_cast<GlobalValue*>(ptr_val)) {
-                // 对于全局变量，先用 la 加载其地址，再用 lw 加载其值。
+                // 对于全局变量，先用 la 加载其地址
                 auto addr_vreg = getNewVReg();
                 auto la = std::make_unique<MachineInstr>(RVOpcodes::LA);
                 la->addOperand(std::make_unique<RegOperand>(addr_vreg));
                 la->addOperand(std::make_unique<LabelOperand>(global->getName()));
                 CurMBB->addInstruction(std::move(la));
 
-                auto lw = std::make_unique<MachineInstr>(RVOpcodes::LW);
-                lw->addOperand(std::make_unique<RegOperand>(dest_vreg));
-                lw->addOperand(std::make_unique<MemOperand>(
+                // 然后根据类型使用 ld 或 lw 加载其值
+                auto load_instr = std::make_unique<MachineInstr>(real_opcode); 
+                load_instr->addOperand(std::make_unique<RegOperand>(dest_vreg));
+                load_instr->addOperand(std::make_unique<MemOperand>(
                     std::make_unique<RegOperand>(addr_vreg),
                     std::make_unique<ImmOperand>(0)
                 ));
-                CurMBB->addInstruction(std::move(lw));
+                CurMBB->addInstruction(std::move(load_instr));
+
             } else {
-                // 对于已经在虚拟寄存器中的指针地址，直接通过该地址加载。
+                // 对于已经在虚拟寄存器中的指针地址，直接通过该地址加载
                 auto ptr_vreg = getVReg(ptr_val);
-                auto lw = std::make_unique<MachineInstr>(RVOpcodes::LW);
-                lw->addOperand(std::make_unique<RegOperand>(dest_vreg));
-                lw->addOperand(std::make_unique<MemOperand>(
+                
+                // 根据类型使用 ld 或 lw
+                auto load_instr = std::make_unique<MachineInstr>(real_opcode); 
+                load_instr->addOperand(std::make_unique<RegOperand>(dest_vreg));
+                load_instr->addOperand(std::make_unique<MemOperand>(
                     std::make_unique<RegOperand>(ptr_vreg),
                     std::make_unique<ImmOperand>(0)
                 ));
-                CurMBB->addInstruction(std::move(lw));
+                CurMBB->addInstruction(std::move(load_instr));
             }
             break;
         }
@@ -189,13 +208,8 @@ void RISCv64ISel::selectNode(DAGNode* node) {
             Value* val_to_store = node->operands[0]->value;
             Value* ptr_val = node->operands[1]->value;
 
-            // [V2优点] 在STORE节点内部负责加载作为源的常量。
-            // 如果要存储的值是一个常量，就在这里生成 `li` 指令加载它。
+            // 如果要存储的值是一个常量，就在这里生成 `li` 指令加载它
             if (auto val_const = dynamic_cast<ConstantValue*>(val_to_store)) {
-                if (DEBUG) {
-                    std::cout << "[DEBUG] selectNode-BINARY: Found constant operand with value " << val_const->getInt()
-                            << ". Generating LI instruction." << std::endl;
-                }
                 auto li = std::make_unique<MachineInstr>(RVOpcodes::LI);
                 li->addOperand(std::make_unique<RegOperand>(getVReg(val_const)));
                 li->addOperand(std::make_unique<ImmOperand>(val_const->getInt()));
@@ -203,37 +217,50 @@ void RISCv64ISel::selectNode(DAGNode* node) {
             }
             auto val_vreg = getVReg(val_to_store);
 
-            // [V1设计保留] 同样，对于向栈变量的存储，使用 FRAME_STORE 伪指令。
+            // --- 修改点 ---
+            // 1. 获取被存储的值的类型
+            Type* stored_type = val_to_store->getType();
+
+            // 2. 根据类型选择正确的伪指令或真实指令操作码
+            RVOpcodes frame_opcode = stored_type->isPointer() ? RVOpcodes::FRAME_STORE_D : RVOpcodes::FRAME_STORE_W;
+            RVOpcodes real_opcode = stored_type->isPointer() ? RVOpcodes::SD : RVOpcodes::SW;
+
             if (auto alloca = dynamic_cast<AllocaInst*>(ptr_val)) {
-                auto instr = std::make_unique<MachineInstr>(RVOpcodes::FRAME_STORE);
+                // 3. 创建使用新的、区分宽度的伪指令
+                auto instr = std::make_unique<MachineInstr>(frame_opcode);
                 instr->addOperand(std::make_unique<RegOperand>(val_vreg));
                 instr->addOperand(std::make_unique<RegOperand>(getVReg(alloca)));
                 CurMBB->addInstruction(std::move(instr));
+
             } else if (auto global = dynamic_cast<GlobalValue*>(ptr_val)) {
-                // 向全局变量存储。
+                // 向全局变量存储
                 auto addr_vreg = getNewVReg();
                 auto la = std::make_unique<MachineInstr>(RVOpcodes::LA);
                 la->addOperand(std::make_unique<RegOperand>(addr_vreg));
                 la->addOperand(std::make_unique<LabelOperand>(global->getName()));
                 CurMBB->addInstruction(std::move(la));
 
-                auto sw = std::make_unique<MachineInstr>(RVOpcodes::SW);
-                sw->addOperand(std::make_unique<RegOperand>(val_vreg));
-                sw->addOperand(std::make_unique<MemOperand>(
+                // 根据类型使用 sd 或 sw
+                auto store_instr = std::make_unique<MachineInstr>(real_opcode);
+                store_instr->addOperand(std::make_unique<RegOperand>(val_vreg));
+                store_instr->addOperand(std::make_unique<MemOperand>(
                     std::make_unique<RegOperand>(addr_vreg),
                     std::make_unique<ImmOperand>(0)
                 ));
-                CurMBB->addInstruction(std::move(sw));
+                CurMBB->addInstruction(std::move(store_instr));
+
             } else {
-                // 向一个指针（存储在虚拟寄存器中）指向的地址存储。
+                // 向一个指针（存储在虚拟寄存器中）指向的地址存储
                 auto ptr_vreg = getVReg(ptr_val);
-                auto sw = std::make_unique<MachineInstr>(RVOpcodes::SW);
-                sw->addOperand(std::make_unique<RegOperand>(val_vreg));
-                sw->addOperand(std::make_unique<MemOperand>(
+                
+                // 根据类型使用 sd 或 sw
+                auto store_instr = std::make_unique<MachineInstr>(real_opcode);
+                store_instr->addOperand(std::make_unique<RegOperand>(val_vreg));
+                store_instr->addOperand(std::make_unique<MemOperand>(
                     std::make_unique<RegOperand>(ptr_vreg),
                     std::make_unique<ImmOperand>(0)
                 ));
-                CurMBB->addInstruction(std::move(sw));
+                CurMBB->addInstruction(std::move(store_instr));
             }
             break;
         }
@@ -555,7 +582,22 @@ void RISCv64ISel::selectNode(DAGNode* node) {
             }
 
             auto call_instr = std::make_unique<MachineInstr>(RVOpcodes::CALL);
+            // [协议] 如果函数有返回值，将它的目标虚拟寄存器作为第一个操作数
+            if (!call->getType()->isVoid()) {
+                unsigned dest_vreg = getVReg(call);
+                call_instr->addOperand(std::make_unique<RegOperand>(dest_vreg));
+            }
+            
+            // 将函数名标签作为后续操作数
             call_instr->addOperand(std::make_unique<LabelOperand>(call->getCallee()->getName()));
+            
+            // 将所有参数的虚拟寄存器也作为后续操作数，供getInstrUseDef分析
+            for (size_t i = 0; i < num_operands; ++i) {
+                if (node->operands[i]->kind != DAGNode::CONSTANT) { // 常量参数已直接加载，无需作为use
+                    call_instr->addOperand(std::make_unique<RegOperand>(getVReg(node->operands[i]->value)));
+                }
+            }
+
             CurMBB->addInstruction(std::move(call_instr));
             
             if (num_operands > 8) {
@@ -569,12 +611,12 @@ void RISCv64ISel::selectNode(DAGNode* node) {
                 CurMBB->addInstruction(std::move(dealloc_instr));
             }
             // 处理返回值，从a0移动到目标虚拟寄存器
-            if (!call->getType()->isVoid()) {
-                auto mv_instr = std::make_unique<MachineInstr>(RVOpcodes::MV);
-                mv_instr->addOperand(std::make_unique<RegOperand>(getVReg(call)));
-                mv_instr->addOperand(std::make_unique<RegOperand>(PhysicalReg::A0));
-                CurMBB->addInstruction(std::move(mv_instr));
-            }
+            // if (!call->getType()->isVoid()) {
+            //     auto mv_instr = std::make_unique<MachineInstr>(RVOpcodes::MV);
+            //     mv_instr->addOperand(std::make_unique<RegOperand>(getVReg(call)));
+            //     mv_instr->addOperand(std::make_unique<RegOperand>(PhysicalReg::A0));
+            //     CurMBB->addInstruction(std::move(mv_instr));
+            // }
             break;
         }
 
@@ -792,6 +834,108 @@ void RISCv64ISel::selectNode(DAGNode* node) {
             break;
         }
 
+        case DAGNode::GET_ELEMENT_PTR: {
+            auto gep = dynamic_cast<GetElementPtrInst*>(node->value);
+            auto result_vreg = getVReg(gep);
+
+            // --- Step 1: 获取基地址 (此部分逻辑正确，保持不变) ---
+            auto base_ptr_node = node->operands[0];
+            auto current_addr_vreg = getNewVReg();
+
+            if (auto alloca_base = dynamic_cast<AllocaInst*>(base_ptr_node->value)) {
+                auto frame_addr_instr = std::make_unique<MachineInstr>(RVOpcodes::FRAME_ADDR);
+                frame_addr_instr->addOperand(std::make_unique<RegOperand>(current_addr_vreg));
+                frame_addr_instr->addOperand(std::make_unique<RegOperand>(getVReg(alloca_base)));
+                CurMBB->addInstruction(std::move(frame_addr_instr));
+            } else if (auto global_base = dynamic_cast<GlobalValue*>(base_ptr_node->value)) {
+                auto la_instr = std::make_unique<MachineInstr>(RVOpcodes::LA);
+                la_instr->addOperand(std::make_unique<RegOperand>(current_addr_vreg));
+                la_instr->addOperand(std::make_unique<LabelOperand>(global_base->getName()));
+                CurMBB->addInstruction(std::move(la_instr));
+            } else {
+                auto base_vreg = getVReg(base_ptr_node->value);
+                auto mv = std::make_unique<MachineInstr>(RVOpcodes::MV);
+                mv->addOperand(std::make_unique<RegOperand>(current_addr_vreg));
+                mv->addOperand(std::make_unique<RegOperand>(base_vreg));
+                CurMBB->addInstruction(std::move(mv));
+            }
+
+            // --- Step 2: [最终权威版] 遵循LLVM GEP语义迭代计算地址 ---
+            
+            // 初始被索引的类型，是基指针指向的那个类型 (例如, [2 x i32])
+            Type* current_type = gep->getBasePointer()->getType()->as<PointerType>()->getBaseType();
+
+            // 迭代处理 GEP 的每一个索引
+            for (size_t i = 0; i < gep->getNumIndices(); ++i) {
+                Value* indexValue = gep->getIndex(i);
+
+                // GEP的第一个索引以整个 `current_type` 的大小为步长。
+                // 后续的索引则以 `current_type` 的元素大小为步长。
+                // 这一步是计算地址偏移的关键。
+                unsigned stride = getTypeSizeInBytes(current_type);
+                
+                // 如果步长为0（例如对一个void类型或空结构体索引），则不产生任何偏移
+                if (stride != 0) {
+                    // --- 为当前索引和步长生成偏移计算指令 ---
+                    auto offset_vreg = getNewVReg();
+                    auto index_vreg = getVReg(indexValue);
+
+                    // 如果索引是常量，先用 LI 指令加载到虚拟寄存器
+                    if (auto const_index = dynamic_cast<ConstantValue*>(indexValue)) {
+                        auto li = std::make_unique<MachineInstr>(RVOpcodes::LI);
+                        li->addOperand(std::make_unique<RegOperand>(index_vreg));
+                        li->addOperand(std::make_unique<ImmOperand>(const_index->getInt()));
+                        CurMBB->addInstruction(std::move(li));
+                    }
+                    
+                    // 优化：如果步长是1，可以直接移动(MV)作为偏移量，无需乘法
+                    if (stride == 1) {
+                        auto mv = std::make_unique<MachineInstr>(RVOpcodes::MV);
+                        mv->addOperand(std::make_unique<RegOperand>(offset_vreg));
+                        mv->addOperand(std::make_unique<RegOperand>(index_vreg));
+                        CurMBB->addInstruction(std::move(mv));
+                    } else {
+                        // 步长不为1，需要生成乘法指令
+                        auto size_vreg = getNewVReg();
+                        auto li_size = std::make_unique<MachineInstr>(RVOpcodes::LI);
+                        li_size->addOperand(std::make_unique<RegOperand>(size_vreg));
+                        li_size->addOperand(std::make_unique<ImmOperand>(stride));
+                        CurMBB->addInstruction(std::move(li_size));
+                        
+                        auto mul = std::make_unique<MachineInstr>(RVOpcodes::MULW);
+                        mul->addOperand(std::make_unique<RegOperand>(offset_vreg));
+                        mul->addOperand(std::make_unique<RegOperand>(index_vreg));
+                        mul->addOperand(std::make_unique<RegOperand>(size_vreg));
+                        CurMBB->addInstruction(std::move(mul));
+                    }
+
+                    // 将计算出的偏移量累加到当前地址上
+                    auto add = std::make_unique<MachineInstr>(RVOpcodes::ADD);
+                    add->addOperand(std::make_unique<RegOperand>(current_addr_vreg));
+                    add->addOperand(std::make_unique<RegOperand>(current_addr_vreg));
+                    add->addOperand(std::make_unique<RegOperand>(offset_vreg));
+                    CurMBB->addInstruction(std::move(add));
+                }
+
+                // --- 为下一次迭代更新类型：深入一层 ---
+                if (auto array_type = current_type->as<ArrayType>()) {
+                    current_type = array_type->getElementType();
+                } else if (auto ptr_type = current_type->as<PointerType>()) {
+                    // 这种情况不应该在第二次迭代后发生，但为了逻辑健壮性保留
+                    current_type = ptr_type->getBaseType();
+                }
+                // 如果`current_type`已经是i32等基本类型，它会保持不变，
+                // 但下一次循环如果还有索引，`getTypeSizeInBytes(i32)`仍然能正确计算步长。
+            }
+            
+            // --- Step 3: 将最终计算出的地址存入GEP的目标虚拟寄存器 (保持不变) ---
+            auto final_mv = std::make_unique<MachineInstr>(RVOpcodes::MV);
+            final_mv->addOperand(std::make_unique<RegOperand>(result_vreg));
+            final_mv->addOperand(std::make_unique<RegOperand>(current_addr_vreg));
+            CurMBB->addInstruction(std::move(final_mv));
+            break;
+        }
+
         default:
             throw std::runtime_error("Unsupported DAGNode kind in ISel");
     }
@@ -814,6 +958,7 @@ RISCv64ISel::DAGNode* RISCv64ISel::create_node(int kind_int, Value* val, std::ma
 }
 
 RISCv64ISel::DAGNode* RISCv64ISel::get_operand_node(Value* val_ir, std::map<Value*, DAGNode*>& value_to_node, std::vector<std::unique_ptr<DAGNode>>& nodes_storage) {
+    // 规则1：如果这个Value已经有对应的节点，直接返回
     if (value_to_node.count(val_ir)) {
         return value_to_node[val_ir];
     } else if (dynamic_cast<ConstantValue*>(val_ir)) {
@@ -822,7 +967,14 @@ RISCv64ISel::DAGNode* RISCv64ISel::get_operand_node(Value* val_ir, std::map<Valu
         return create_node(DAGNode::CONSTANT, val_ir, value_to_node, nodes_storage);
     } else if (dynamic_cast<AllocaInst*>(val_ir)) {
         return create_node(DAGNode::ALLOCA_ADDR, val_ir, value_to_node, nodes_storage);
+    } else if (dynamic_cast<Argument*>(val_ir)) { 
+        // Argument 是一个叶子节点，它代表一个在函数入口就可用的值。
+        return create_node(DAGNode::ARGUMENT, val_ir, value_to_node, nodes_storage);
     }
+     // 默认行为：如果一个操作数不是上面任何一种叶子节点，
+    // 并且没有在value_to_node中找到（意味着它不是由另一条指令定义的），
+    // 这是一个逻辑问题。但为了保持向前兼容，我们暂时保留旧的LOAD行为，
+    // 尽管在修复Argument后，它不应该再被错误触发。
     return create_node(DAGNode::LOAD, val_ir, value_to_node, nodes_storage);
 }
 
@@ -850,6 +1002,21 @@ std::vector<std::unique_ptr<RISCv64ISel::DAGNode>> RISCv64ISel::build_dag(BasicB
                     std::cout << "  -> Operand " << i << " has kind: " << memset_node->operands[i]->kind << std::endl;
                 }
             }
+        } else if (auto gep = dynamic_cast<GetElementPtrInst*>(inst)) {
+            // 如果这个GEP指令已经创建过节点，则跳过
+            if(value_to_node.count(gep)) continue;
+
+            // 创建一个新的 GET_ELEMENT_PTR 类型的节点
+            auto gep_node = create_node(DAGNode::GET_ELEMENT_PTR, gep, value_to_node, nodes_storage);
+            
+            // 第一个操作数是基指针（即数组本身）
+            gep_node->operands.push_back(get_operand_node(gep->getBasePointer(), value_to_node, nodes_storage));
+            
+            // 依次添加所有索引作为后续的操作数
+            for (auto index : gep->getIndices()) {
+                // [修复] 从 Use 对象中获取真正的 Value*
+                gep_node->operands.push_back(get_operand_node(index->getValue(), value_to_node, nodes_storage));
+            }
         } else if (auto load = dynamic_cast<LoadInst*>(inst)) {
             auto load_node = create_node(DAGNode::LOAD, load, value_to_node, nodes_storage);
             load_node->operands.push_back(get_operand_node(load->getPointer(), value_to_node, nodes_storage));
@@ -892,6 +1059,43 @@ std::vector<std::unique_ptr<RISCv64ISel::DAGNode>> RISCv64ISel::build_dag(BasicB
     return nodes_storage;
 }
 
+/**
+ * @brief 计算一个类型在内存中占用的字节数。
+ * @param type 需要计算大小的IR类型。
+ * @return 该类型占用的字节数。
+ */
+unsigned RISCv64ISel::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;
+    }
+}
+
 // [新] 打印DAG图以供调试的辅助函数
 void RISCv64ISel::print_dag(const std::vector<std::unique_ptr<DAGNode>>& dag, const std::string& bb_name) {
     // 检查是否有DEBUG宏或者全局变量，避免在非调试模式下打印
@@ -910,6 +1114,7 @@ void RISCv64ISel::print_dag(const std::vector<std::unique_ptr<DAGNode>>& dag, co
     // 将NodeKind枚举转换为字符串的辅助函数
     auto get_kind_string = [](DAGNode::NodeKind kind) {
         switch (kind) {
+            case DAGNode::ARGUMENT: return "ARGUMENT";
             case DAGNode::CONSTANT: return "CONSTANT";
             case DAGNode::LOAD: return "LOAD";
             case DAGNode::STORE: return "STORE";

src/RISCv64LLIR.cpp

@@ -0,0 +1,6 @@
+#include "RISCv64LLIR.h"
+#include <vector>
+
+namespace sysy {
+
+}

src/RISCv64Passes.cpp

@@ -1,54 +0,0 @@
-#include "RISCv64Passes.h"
-#include <iostream>
-
-namespace sysy {
-
-// --- 寄存器分配前优化 ---
-
-void PreRA_Scheduler::runOnMachineFunction(MachineFunction* mfunc) {
-    // TODO: 在此实现寄存器分配前的指令调度。
-    // 遍历mfunc中的每一个MachineBasicBlock。
-    // 对每个基本块内的MachineInstr列表进行重排。
-    //
-    // 实现思路:
-    // 1. 分析每个基本块内指令的数据依赖关系，构建依赖图(DAG)。
-    // 2. 根据目标处理器的流水线特性（指令延迟等），使用列表调度等算法对指令进行重排。
-    // 3. 此时操作的是虚拟寄存器，只存在真依赖，调度自由度最大。
-    //
-    // std::cout << "Running Pre-RA Instruction Scheduler..." << std::endl;
-}
-
-
-// --- 寄存器分配后优化 ---
-
-void PeepholeOptimizer::runOnMachineFunction(MachineFunction* mfunc) {
-    // TODO: 在此实现窥孔优化。
-    // 遍历mfunc中的每一个MachineBasicBlock。
-    // 对每个基本块内的MachineInstr列表进行扫描和替换。
-    //
-    // 实现思路:
-    // 1. 维护一个大小固定（例如3-5条指令）的滑动窗口。
-    // 2. 识别特定的冗余模式，例如:
-    //    - `mv a0, a1` 后紧跟 `mv a1, a0` (可消除的交换)
-    //    - `sw t0, 12(s0)` 后紧跟 `lw t1, 12(s0)` (冗余加载)
-    //    - 强度削减: `mul x, x, 2` -> `slli x, x, 1`
-    // 3. 识别后，直接修改MachineInstr列表（删除、替换或插入指令）。
-    //
-    // std::cout << "Running Post-RA Peephole Optimizer..." << std::endl;
-}
-
-void PostRA_Scheduler::runOnMachineFunction(MachineFunction* mfunc) {
-    // TODO: 在此实现寄存器分配后的局部指令调度。
-    // 遍历mfunc中的每一个MachineBasicBlock。
-    // 重点关注由寄存器分配器插入的spill/fill代码。
-    //
-    // 实现思路:
-    // 1. 识别出用于spill/fill的lw/sw指令。
-    // 2. 在不违反数据依赖（包括物理寄存器引入的伪依赖）的前提下，
-    //    尝试将lw指令向上移动，使其与使用它的指令之间有足够的距离，以隐藏访存延迟。
-    // 3. 同样，可以尝试将sw指令向下移动。
-    //
-    // std::cout << "Running Post-RA Local Scheduler..." << std::endl;
-}
-
-} // namespace sysy

src/RISCv64Peephole.cpp

@@ -0,0 +1,652 @@
+#include "RISCv64Peephole.h"
+#include <functional>
+
+namespace sysy {
+
+char PeepholeOptimizer::ID = 0;
+
+bool PeepholeOptimizer::runOnFunction(Function *F, AnalysisManager& AM) {
+    // This pass works on MachineFunction level, not IR level
+    return false;
+}
+
+void PeepholeOptimizer::runOnMachineFunction(MachineFunction *mfunc) {
+  if (!mfunc)
+    return;
+  using namespace sysy;
+
+  // areRegsEqual: 检查两个寄存器操作数是否相等（考虑虚拟和物理寄存器）。
+  auto areRegsEqual = [](RegOperand *r1, RegOperand *r2) {
+    if (!r1 || !r2 || r1->isVirtual() != r2->isVirtual()) {
+      return false;
+    }
+    if (r1->isVirtual()) {
+      return r1->getVRegNum() == r2->getVRegNum();
+    } else {
+      return r1->getPReg() == r2->getPReg();
+    }
+  };
+
+  // 改进的 isRegUsedLater 函数 - 更完整和准确的实现
+  auto isRegUsedLater =
+      [&](const std::vector<std::unique_ptr<MachineInstr>> &instrs,
+          RegOperand *reg, size_t start_idx) -> bool {
+    for (size_t j = start_idx; j < instrs.size(); ++j) {
+      auto *instr = instrs[j].get();
+      auto opcode = instr->getOpcode();
+
+      // 检查所有操作数
+      for (size_t k = 0; k < instr->getOperands().size(); ++k) {
+        bool isDefOperand = false;
+
+        // 更完整的定义操作数判断逻辑
+        if (k == 0) { // 第一个操作数通常是目标寄存器
+          switch (opcode) {
+          // 算术和逻辑指令 - 第一个操作数是定义
+          case RVOpcodes::MV:
+          case RVOpcodes::ADDI:
+          case RVOpcodes::SLLI:
+          case RVOpcodes::SRLI:
+          case RVOpcodes::SRAI:
+          case RVOpcodes::SLTI:
+          case RVOpcodes::SLTIU:
+          case RVOpcodes::XORI:
+          case RVOpcodes::ORI:
+          case RVOpcodes::ANDI:
+          case RVOpcodes::ADD:
+          case RVOpcodes::SUB:
+          case RVOpcodes::SLL:
+          case RVOpcodes::SLT:
+          case RVOpcodes::SLTU:
+          case RVOpcodes::XOR:
+          case RVOpcodes::SRL:
+          case RVOpcodes::SRA:
+          case RVOpcodes::OR:
+          case RVOpcodes::AND:
+          case RVOpcodes::MUL:
+          case RVOpcodes::DIV:
+          case RVOpcodes::REM:
+          case RVOpcodes::LW:
+          case RVOpcodes::LH:
+          case RVOpcodes::LB:
+          case RVOpcodes::LHU:
+          case RVOpcodes::LBU:
+
+          // 存储指令 - 第一个操作数是使用（要存储的值）
+          case RVOpcodes::SW:
+          case RVOpcodes::SH:
+          case RVOpcodes::SB:
+          // 分支指令 - 第一个操作数是使用
+          case RVOpcodes::BEQ:
+          case RVOpcodes::BNE:
+          case RVOpcodes::BLT:
+          case RVOpcodes::BGE:
+          case RVOpcodes::BLTU:
+          case RVOpcodes::BGEU:
+          // 跳转指令 - 可能使用寄存器
+          case RVOpcodes::JALR:
+            isDefOperand = false;
+            break;
+
+          default:
+            // 对于未知指令，保守地假设第一个操作数可能是使用
+            isDefOperand = false;
+            break;
+          }
+        }
+
+        // 如果不是定义操作数，检查是否使用了目标寄存器
+        if (!isDefOperand) {
+          if (instr->getOperands()[k]->getKind() == MachineOperand::KIND_REG) {
+            auto *use_reg =
+                static_cast<RegOperand *>(instr->getOperands()[k].get());
+            if (areRegsEqual(reg, use_reg))
+              return true;
+          }
+          // 检查内存操作数中的基址寄存器
+          if (instr->getOperands()[k]->getKind() == MachineOperand::KIND_MEM) {
+            auto *mem =
+                static_cast<MemOperand *>(instr->getOperands()[k].get());
+            if (areRegsEqual(reg, mem->getBase()))
+              return true;
+          }
+        }
+      }
+    }
+    return false;
+  };
+
+  // 检查寄存器是否在指令中被重新定义（用于更精确的分析）
+  auto isRegRedefinedAt =
+      [](MachineInstr *instr, RegOperand *reg,
+         const std::function<bool(RegOperand *, RegOperand *)> &areRegsEqual)
+      -> bool {
+    if (instr->getOperands().empty())
+      return false;
+
+    auto opcode = instr->getOpcode();
+    // 只有当第一个操作数是定义操作数时才检查
+    switch (opcode) {
+    case RVOpcodes::MV:
+    case RVOpcodes::ADDI:
+    case RVOpcodes::ADD:
+    case RVOpcodes::SUB:
+    case RVOpcodes::MUL:
+    case RVOpcodes::LW:
+      // ... 其他定义指令
+      if (instr->getOperands()[0]->getKind() == MachineOperand::KIND_REG) {
+        auto *def_reg =
+            static_cast<RegOperand *>(instr->getOperands()[0].get());
+        return areRegsEqual(reg, def_reg);
+      }
+      break;
+    default:
+      break;
+    }
+    return false;
+  };
+
+  // 检查是否为存储-加载模式，支持不同大小的访问
+  auto isStoreLoadPattern = [](MachineInstr *store_instr,
+                               MachineInstr *load_instr) -> bool {
+    auto store_op = store_instr->getOpcode();
+    auto load_op = load_instr->getOpcode();
+
+    // 检查存储-加载对应关系
+    return (store_op == RVOpcodes::SW && load_op == RVOpcodes::LW) || // 32位
+           (store_op == RVOpcodes::SH &&
+            load_op == RVOpcodes::LH) || // 16位有符号
+           (store_op == RVOpcodes::SH &&
+            load_op == RVOpcodes::LHU) || // 16位无符号
+           (store_op == RVOpcodes::SB &&
+            load_op == RVOpcodes::LB) || // 8位有符号
+           (store_op == RVOpcodes::SB &&
+            load_op == RVOpcodes::LBU) ||                           // 8位无符号
+           (store_op == RVOpcodes::SD && load_op == RVOpcodes::LD); // 64位
+  };
+
+  // 检查两个内存访问是否访问相同的内存位置
+  auto areMemoryAccessesEqual =
+      [&areRegsEqual](MachineInstr *store_instr, MemOperand *store_mem,
+                      MachineInstr *load_instr, MemOperand *load_mem) -> bool {
+    // 基址寄存器必须相同
+    if (!areRegsEqual(store_mem->getBase(), load_mem->getBase())) {
+      return false;
+    }
+
+    // 偏移量必须相同
+    if (store_mem->getOffset()->getValue() !=
+        load_mem->getOffset()->getValue()) {
+      return false;
+    }
+
+    // 检查访问大小是否兼容
+    auto store_op = store_instr->getOpcode();
+    auto load_op = load_instr->getOpcode();
+
+    // 获取访问大小（字节数）
+    auto getAccessSize = [](RVOpcodes opcode) -> int {
+      switch (opcode) {
+      case RVOpcodes::LB:
+      case RVOpcodes::LBU:
+      case RVOpcodes::SB:
+        return 1; // 8位
+      case RVOpcodes::LH:
+      case RVOpcodes::LHU:
+      case RVOpcodes::SH:
+        return 2; // 16位
+      case RVOpcodes::LW:
+      case RVOpcodes::SW:
+        return 4; // 32位
+      case RVOpcodes::LD:
+      case RVOpcodes::SD:
+        return 8; // 64位
+      default:
+        return -1; // 未知
+      }
+    };
+
+    int store_size = getAccessSize(store_op);
+    int load_size = getAccessSize(load_op);
+
+    // 只有访问大小完全匹配时才能进行优化
+    // 这避免了部分重叠访问的复杂情况
+    return store_size > 0 && store_size == load_size;
+  };
+
+  // 简单的内存别名分析：检查两个内存访问之间是否可能有冲突的内存操作
+  auto isMemoryAccessSafe =
+      [&](const std::vector<std::unique_ptr<MachineInstr>> &instrs,
+          size_t store_idx, size_t load_idx, MemOperand *mem) -> bool {
+    // 检查存储和加载之间是否有可能影响内存的指令
+    for (size_t j = store_idx + 1; j < load_idx; ++j) {
+      auto *between_instr = instrs[j].get();
+      auto between_op = between_instr->getOpcode();
+
+      // 检查是否有其他内存写入操作
+      switch (between_op) {
+      case RVOpcodes::SW:
+      case RVOpcodes::SH:
+      case RVOpcodes::SB:
+      case RVOpcodes::SD: {
+        // 如果有其他存储操作，需要检查是否可能访问相同的内存
+        if (between_instr->getOperands().size() >= 2 &&
+            between_instr->getOperands()[1]->getKind() ==
+                MachineOperand::KIND_MEM) {
+
+          auto *other_mem =
+              static_cast<MemOperand *>(between_instr->getOperands()[1].get());
+
+          // 保守的别名分析：如果使用不同的基址寄存器，假设可能别名
+          if (!areRegsEqual(mem->getBase(), other_mem->getBase())) {
+            return false; // 可能的别名，不安全
+          }
+
+          // 如果基址相同但偏移量不同，检查是否重叠
+          int64_t offset1 = mem->getOffset()->getValue();
+          int64_t offset2 = other_mem->getOffset()->getValue();
+
+          // 获取访问大小来检查重叠
+          auto getAccessSize = [](RVOpcodes opcode) -> int {
+            switch (opcode) {
+            case RVOpcodes::SB:
+              return 1;
+            case RVOpcodes::SH:
+              return 2;
+            case RVOpcodes::SW:
+              return 4;
+            case RVOpcodes::SD:
+              return 8;
+            default:
+              return 4; // 默认假设4字节
+            }
+          };
+
+          int size1 = getAccessSize(RVOpcodes::SW); // 从原存储指令推断
+          int size2 = getAccessSize(between_op);
+
+          // 检查内存区域是否重叠
+          bool overlaps =
+              !(offset1 + size1 <= offset2 || offset2 + size2 <= offset1);
+          if (overlaps) {
+            return false; // 内存重叠，不安全
+          }
+        }
+        break;
+      }
+
+      // 函数调用可能有副作用
+      case RVOpcodes::JAL:
+      case RVOpcodes::JALR:
+        return false; // 函数调用可能修改内存，不安全
+
+      // 原子操作或其他可能修改内存的指令
+      // 根据具体的RISC-V扩展添加更多指令
+      default:
+        // 对于未知指令，采用保守策略
+        // 可以根据具体需求调整
+        break;
+      }
+    }
+
+    return true; // 没有发现潜在的内存冲突
+  };
+
+  // isPowerOfTwo: 检查数值是否为2的幂次，并返回其指数。
+  auto isPowerOfTwo = [](int64_t n) -> int {
+    if (n <= 0 || (n & (n - 1)) != 0)
+      return -1;
+    int shift = 0;
+    while (n > 1) {
+      n >>= 1;
+      shift++;
+    }
+    return shift;
+  };
+
+  for (auto &mbb_uptr : mfunc->getBlocks()) {
+    auto &mbb = *mbb_uptr;
+    auto &instrs = mbb.getInstructions();
+    if (instrs.size() < 2)
+      continue; // 基本块至少需要两条指令进行窥孔
+
+    // 遍历指令序列进行窥孔优化
+    for (size_t i = 0; i + 1 < instrs.size();) {
+      auto *mi1 = instrs[i].get();
+      auto *mi2 = instrs[i + 1].get();
+      bool changed = false;
+
+      // 1. 消除冗余交换移动: mv a, b; mv b, a  -> mv a, b
+      if (mi1->getOpcode() == RVOpcodes::MV &&
+          mi2->getOpcode() == RVOpcodes::MV) {
+        if (mi1->getOperands().size() == 2 && mi2->getOperands().size() == 2) {
+          if (mi1->getOperands()[0]->getKind() == MachineOperand::KIND_REG &&
+              mi1->getOperands()[1]->getKind() == MachineOperand::KIND_REG &&
+              mi2->getOperands()[0]->getKind() == MachineOperand::KIND_REG &&
+              mi2->getOperands()[1]->getKind() == MachineOperand::KIND_REG) {
+            auto *dst1 = static_cast<RegOperand *>(mi1->getOperands()[0].get());
+            auto *src1 = static_cast<RegOperand *>(mi1->getOperands()[1].get());
+            auto *dst2 = static_cast<RegOperand *>(mi2->getOperands()[0].get());
+            auto *src2 = static_cast<RegOperand *>(mi2->getOperands()[1].get());
+            if (areRegsEqual(dst1, src2) && areRegsEqual(src1, dst2)) {
+              instrs.erase(instrs.begin() + i + 1); // 移除第二条指令
+              changed = true;
+            }
+          }
+        }
+      }
+      // 2. 冗余加载消除: sw t0, offset(base); lw t1, offset(base) -> 替换或消除
+      // lw 添加ld sd支持
+      else if (isStoreLoadPattern(mi1, mi2)) {
+        if (mi1->getOperands().size() == 2 && mi2->getOperands().size() == 2) {
+          if (mi1->getOperands()[0]->getKind() == MachineOperand::KIND_REG &&
+              mi1->getOperands()[1]->getKind() == MachineOperand::KIND_MEM &&
+              mi2->getOperands()[0]->getKind() == MachineOperand::KIND_REG &&
+              mi2->getOperands()[1]->getKind() == MachineOperand::KIND_MEM) {
+
+            auto *store_val =
+                static_cast<RegOperand *>(mi1->getOperands()[0].get());
+            auto *store_mem =
+                static_cast<MemOperand *>(mi1->getOperands()[1].get());
+            auto *load_val =
+                static_cast<RegOperand *>(mi2->getOperands()[0].get());
+            auto *load_mem =
+                static_cast<MemOperand *>(mi2->getOperands()[1].get());
+
+            // 检查内存访问是否匹配（基址、偏移量和访问大小）
+            if (areMemoryAccessesEqual(mi1, store_mem, mi2, load_mem)) {
+              // 进行简单的内存别名分析
+              if (isMemoryAccessSafe(instrs, i, i + 1, store_mem)) {
+                if (areRegsEqual(store_val, load_val)) {
+                  // sw r1, mem; lw r1, mem -> 消除冗余的lw
+                  instrs.erase(instrs.begin() + i + 1);
+                  changed = true;
+                } else {
+                  // sw r1, mem; lw r2, mem -> 替换lw为mv r2, r1
+                  auto newInstr = std::make_unique<MachineInstr>(RVOpcodes::MV);
+                  newInstr->addOperand(std::make_unique<RegOperand>(*load_val));
+                  newInstr->addOperand(
+                      std::make_unique<RegOperand>(*store_val));
+                  instrs[i + 1] = std::move(newInstr);
+                  changed = true;
+                }
+              }
+            }
+          }
+        }
+      }
+      // 3. 强度削减: mul y, x, 2^n -> slli y, x, n
+      else if (mi1->getOpcode() == RVOpcodes::MUL &&
+               mi1->getOperands().size() == 3) {
+        auto *dst_op = mi1->getOperands()[0].get();
+        auto *src1_op = mi1->getOperands()[1].get();
+        auto *src2_op = mi1->getOperands()[2].get();
+
+        if (dst_op->getKind() == MachineOperand::KIND_REG) {
+          auto *dst_reg = static_cast<RegOperand *>(dst_op);
+          RegOperand *src_reg = nullptr;
+          int shift = -1;
+
+          if (src1_op->getKind() == MachineOperand::KIND_REG &&
+              src2_op->getKind() == MachineOperand::KIND_IMM) {
+            shift =
+                isPowerOfTwo(static_cast<ImmOperand *>(src2_op)->getValue());
+            if (shift >= 0)
+              src_reg = static_cast<RegOperand *>(src1_op);
+          } else if (src1_op->getKind() == MachineOperand::KIND_IMM &&
+                     src2_op->getKind() == MachineOperand::KIND_REG) {
+            shift =
+                isPowerOfTwo(static_cast<ImmOperand *>(src1_op)->getValue());
+            if (shift >= 0)
+              src_reg = static_cast<RegOperand *>(src2_op);
+          }
+
+          if (src_reg && shift >= 0 &&
+              shift <= 31) { // RISC-V 移位量限制 (0-31)
+            auto newInstr = std::make_unique<MachineInstr>(RVOpcodes::SLLI);
+            newInstr->addOperand(std::make_unique<RegOperand>(*dst_reg));
+            newInstr->addOperand(std::make_unique<RegOperand>(*src_reg));
+            newInstr->addOperand(std::make_unique<ImmOperand>(shift));
+            instrs[i] = std::move(newInstr);
+            changed = true;
+          }
+        }
+      }
+      // 4. 地址计算优化: addi dst, base, imm1; lw/sw val, imm2(dst) -> lw/sw
+      // val, (imm1+imm2)(base)
+      else if (mi1->getOpcode() == RVOpcodes::ADDI &&
+               mi1->getOperands().size() == 3) {
+        auto opcode2 = mi2->getOpcode();
+        if (opcode2 == RVOpcodes::LW || opcode2 == RVOpcodes::SW) {
+          if (mi2->getOperands().size() == 2 &&
+              mi2->getOperands()[1]->getKind() == MachineOperand::KIND_MEM &&
+              mi1->getOperands()[0]->getKind() == MachineOperand::KIND_REG &&
+              mi1->getOperands()[1]->getKind() == MachineOperand::KIND_REG &&
+              mi1->getOperands()[2]->getKind() == MachineOperand::KIND_IMM) {
+
+            auto *addi_dst =
+                static_cast<RegOperand *>(mi1->getOperands()[0].get());
+            auto *addi_base =
+                static_cast<RegOperand *>(mi1->getOperands()[1].get());
+            auto *addi_imm =
+                static_cast<ImmOperand *>(mi1->getOperands()[2].get());
+
+            auto *mem_op =
+                static_cast<MemOperand *>(mi2->getOperands()[1].get());
+            auto *mem_base = mem_op->getBase();
+            auto *mem_imm = mem_op->getOffset();
+
+            // 检查 ADDI 的目标寄存器是否是内存操作的基址
+            if (areRegsEqual(addi_dst, mem_base)) {
+              // 改进的使用检查：考虑寄存器可能在后续被重新定义的情况
+              bool canOptimize = true;
+
+              // 检查从 i+2 开始的指令
+              for (size_t j = i + 2; j < instrs.size(); ++j) {
+                auto *later_instr = instrs[j].get();
+
+                // 如果寄存器被重新定义，那么它后面的使用就不相关了
+                if (isRegRedefinedAt(later_instr, addi_dst, areRegsEqual)) {
+                  break; // 寄存器被重新定义，可以安全优化
+                }
+
+                // 如果寄存器被使用，则不能优化
+                if (isRegUsedLater(instrs, addi_dst, j)) {
+                  canOptimize = false;
+                  break;
+                }
+              }
+
+              if (canOptimize) {
+                int64_t new_offset = addi_imm->getValue() + mem_imm->getValue();
+                // 检查新偏移量是否符合 RISC-V 12位有符号立即数范围
+                if (new_offset >= -2048 && new_offset <= 2047) {
+                  auto new_mem_op = std::make_unique<MemOperand>(
+                      std::make_unique<RegOperand>(*addi_base),
+                      std::make_unique<ImmOperand>(new_offset));
+                  mi2->getOperands()[1] = std::move(new_mem_op);
+                  instrs.erase(instrs.begin() + i);
+                  changed = true;
+                }
+              }
+            }
+          }
+        }
+      }
+      // 5. 冗余移动指令消除: mv x, y; op z, x, ... -> op z, y, ... (如果 x
+      // 之后不再使用)
+      else if (mi1->getOpcode() == RVOpcodes::MV &&
+               mi1->getOperands().size() == 2) {
+        if (mi1->getOperands()[0]->getKind() == MachineOperand::KIND_REG &&
+            mi1->getOperands()[1]->getKind() == MachineOperand::KIND_REG) {
+
+          auto *mv_dst = static_cast<RegOperand *>(mi1->getOperands()[0].get());
+          auto *mv_src = static_cast<RegOperand *>(mi1->getOperands()[1].get());
+
+          // 检查第二条指令是否使用了 mv 的目标寄存器
+          std::vector<size_t> use_positions;
+          for (size_t k = 1; k < mi2->getOperands().size(); ++k) {
+            if (mi2->getOperands()[k]->getKind() == MachineOperand::KIND_REG) {
+              auto *use_reg =
+                  static_cast<RegOperand *>(mi2->getOperands()[k].get());
+              if (areRegsEqual(mv_dst, use_reg)) {
+                use_positions.push_back(k);
+              }
+            }
+            // 也检查内存操作数中的基址寄存器
+            else if (mi2->getOperands()[k]->getKind() ==
+                     MachineOperand::KIND_MEM) {
+              auto *mem =
+                  static_cast<MemOperand *>(mi2->getOperands()[k].get());
+              if (areRegsEqual(mv_dst, mem->getBase())) {
+                // 对于内存操作数，我们需要创建新的MemOperand
+                auto new_mem = std::make_unique<MemOperand>(
+                    std::make_unique<RegOperand>(*mv_src),
+                    std::make_unique<ImmOperand>(mem->getOffset()->getValue()));
+                mi2->getOperands()[k] = std::move(new_mem);
+                use_positions.push_back(k); // 标记已处理
+              }
+            }
+          }
+
+          if (!use_positions.empty()) {
+            // 改进的后续使用检查
+            bool canOptimize = true;
+            for (size_t j = i + 2; j < instrs.size(); ++j) {
+              auto *later_instr = instrs[j].get();
+
+              // 如果寄存器被重新定义，后续使用就不相关了
+              if (isRegRedefinedAt(later_instr, mv_dst, areRegsEqual)) {
+                break;
+              }
+
+              // 检查是否还有其他使用
+              if (isRegUsedLater(instrs, mv_dst, j)) {
+                canOptimize = false;
+                break;
+              }
+            }
+
+            if (canOptimize) {
+              // 替换所有寄存器使用（内存操作数已在上面处理）
+              for (size_t pos : use_positions) {
+                if (mi2->getOperands()[pos]->getKind() ==
+                    MachineOperand::KIND_REG) {
+                  mi2->getOperands()[pos] =
+                      std::make_unique<RegOperand>(*mv_src);
+                }
+              }
+              instrs.erase(instrs.begin() + i);
+              changed = true;
+            }
+          }
+        }
+      }
+      // 6. 连续加法指令合并: addi t1, t0, imm1; addi t2, t1, imm2 -> addi t2,
+      // t0, (imm1+imm2)
+      else if (mi1->getOpcode() == RVOpcodes::ADDI &&
+               mi2->getOpcode() == RVOpcodes::ADDI) {
+        if (mi1->getOperands().size() == 3 && mi2->getOperands().size() == 3) {
+          if (mi1->getOperands()[0]->getKind() == MachineOperand::KIND_REG &&
+              mi1->getOperands()[1]->getKind() == MachineOperand::KIND_REG &&
+              mi1->getOperands()[2]->getKind() == MachineOperand::KIND_IMM &&
+              mi2->getOperands()[0]->getKind() == MachineOperand::KIND_REG &&
+              mi2->getOperands()[1]->getKind() == MachineOperand::KIND_REG &&
+              mi2->getOperands()[2]->getKind() == MachineOperand::KIND_IMM) {
+
+            auto *addi1_dst =
+                static_cast<RegOperand *>(mi1->getOperands()[0].get());
+            auto *addi1_src =
+                static_cast<RegOperand *>(mi1->getOperands()[1].get());
+            auto *addi1_imm =
+                static_cast<ImmOperand *>(mi1->getOperands()[2].get());
+
+            auto *addi2_dst =
+                static_cast<RegOperand *>(mi2->getOperands()[0].get());
+            auto *addi2_src =
+                static_cast<RegOperand *>(mi2->getOperands()[1].get());
+            auto *addi2_imm =
+                static_cast<ImmOperand *>(mi2->getOperands()[2].get());
+
+            // 检查第一个ADDI的目标是否是第二个ADDI的源
+            if (areRegsEqual(addi1_dst, addi2_src)) {
+              // 改进的中间寄存器使用检查
+              bool canOptimize = true;
+              for (size_t j = i + 2; j < instrs.size(); ++j) {
+                auto *later_instr = instrs[j].get();
+
+                // 如果中间寄存器被重新定义，后续使用不相关
+                if (isRegRedefinedAt(later_instr, addi1_dst, areRegsEqual)) {
+                  break;
+                }
+
+                // 检查是否有其他使用
+                if (isRegUsedLater(instrs, addi1_dst, j)) {
+                  canOptimize = false;
+                  break;
+                }
+              }
+
+              if (canOptimize) {
+                int64_t new_imm = addi1_imm->getValue() + addi2_imm->getValue();
+                // 检查新立即数范围
+                if (new_imm >= -2048 && new_imm <= 2047) {
+                  auto newInstr =
+                      std::make_unique<MachineInstr>(RVOpcodes::ADDI);
+                  newInstr->addOperand(
+                      std::make_unique<RegOperand>(*addi2_dst));
+                  newInstr->addOperand(
+                      std::make_unique<RegOperand>(*addi1_src));
+                  newInstr->addOperand(std::make_unique<ImmOperand>(new_imm));
+                  instrs[i + 1] = std::move(newInstr);
+                  instrs.erase(instrs.begin() + i);
+                  changed = true;
+                }
+              }
+            }
+          }
+        }
+      }
+
+      // 7. ADD with zero optimization: add r1, r2, zero -> mv r1, r2
+      else if (mi1->getOpcode() == RVOpcodes::ADD &&
+               mi1->getOperands().size() == 3) {
+        if (mi1->getOperands()[0]->getKind() == MachineOperand::KIND_REG &&
+            mi1->getOperands()[1]->getKind() == MachineOperand::KIND_REG &&
+            mi1->getOperands()[2]->getKind() == MachineOperand::KIND_REG) {
+
+          auto *add_dst =
+              static_cast<RegOperand *>(mi1->getOperands()[0].get());
+          auto *add_src1 =
+              static_cast<RegOperand *>(mi1->getOperands()[1].get());
+          auto *add_src2 =
+              static_cast<RegOperand *>(mi1->getOperands()[2].get());
+
+          // 检查第二个源操作数是否为ZERO寄存器
+          if (!add_src2->isVirtual() &&
+              add_src2->getPReg() == PhysicalReg::ZERO) {
+            // 创建新的 MV 指令
+            auto newInstr = std::make_unique<MachineInstr>(RVOpcodes::MV);
+            newInstr->addOperand(std::make_unique<RegOperand>(*add_dst));
+            newInstr->addOperand(std::make_unique<RegOperand>(*add_src1));
+            instrs[i] = std::move(newInstr);
+            changed = true;
+          }
+        }
+      }
+
+      // 根据是否发生变化调整遍历索引
+      if (!changed) {
+        ++i; // 没有优化，继续检查下一对指令
+      } else {
+        // 发生变化，适当回退以捕获新的优化机会。
+        // 这是一种安全的回退策略，可以触发连锁优化，且不会导致无限循环。
+        if (i > 0) {
+          --i;
+        }
+      }
+    }
+  }
+}
+
+} // namespace sysy

src/RISCv64RegAlloc.cpp

@@ -1,7 +1,10 @@
 #include "RISCv64RegAlloc.h"
 #include "RISCv64ISel.h"
+#include "RISCv64AsmPrinter.h" // For DEBUG output
 #include <algorithm>
 #include <vector>
+#include <iostream> // For DEBUG output
+#include <cassert>  // For assert
 
 namespace sysy {
 
@@ -15,87 +18,217 @@ RISCv64RegAlloc::RISCv64RegAlloc(MachineFunction* mfunc) : MFunc(mfunc) {
         PhysicalReg::S4, PhysicalReg::S5, PhysicalReg::S6, PhysicalReg::S7,
         PhysicalReg::S8, PhysicalReg::S9, PhysicalReg::S10, PhysicalReg::S11,
     };
+
+    // 映射物理寄存器到特殊的虚拟寄存器ID，用于干扰图中的物理寄存器节点
+    // 确保这些特殊ID不会与vreg_counter生成的常规虚拟寄存器ID冲突
+    for (PhysicalReg preg : allocable_int_regs) {
+        preg_to_vreg_id_map[preg] = static_cast<unsigned>(PhysicalReg::PHYS_REG_START_ID) + static_cast<unsigned>(preg);
+    }
 }
 
+// 寄存器分配的主入口点
 void RISCv64RegAlloc::run() {
+    // 阶段 1: 处理函数调用约定（参数寄存器预着色）
+    handleCallingConvention();    
+    // 阶段 2: 消除帧索引（为局部变量和栈参数分配栈偏移）
     eliminateFrameIndices();
-    analyzeLiveness();
-    buildInterferenceGraph();
-    colorGraph();
-    rewriteFunction();
+    { // 使用大括号创建一个局部作用域，避免printer变量泄露
+        if (DEBUG) {
+            std::cerr   << "\n===== LLIR after eliminateFrameIndices for function: " 
+                        << MFunc->getName() << " =====\n";
+            // 1. 创建一个 AsmPrinter 实例，传入当前的 MachineFunction
+            RISCv64AsmPrinter printer(MFunc);
+            // 2. 调用 run 方法，将结果打印到标准错误流 (std::cerr)
+            // 3. 必须将 debug 参数设为 true！
+            //    因为此时指令中仍然包含虚拟寄存器 (%vreg)，
+            //    debug模式下的 AsmPrinter 才能正确处理它们而不会报错。
+            printer.run(std::cerr, true);
+            std::cerr << "===== End of LLIR =====\n\n";
+        }
+    }
+    // 阶段 3: 活跃性分析
+    analyzeLiveness();            
+    // 阶段 4: 构建干扰图（包含CALL指令对调用者保存寄存器的影响）
+    buildInterferenceGraph();     
+    // 阶段 5: 图着色算法分配物理寄存器
+    colorGraph();                 
+    // 阶段 6: 重写函数（插入溢出/填充代码，替换虚拟寄存器为物理寄存器）
+    rewriteFunction();            
 }
 
-void RISCv64RegAlloc::eliminateFrameIndices() {
-    StackFrameInfo& frame_info = MFunc->getFrameInfo();
-    int current_offset = 20;    // 这里写20是为了在$s0和第一个变量之间留出20字节的安全区，
-                                // 以防止一些函数调用方面的恶性bug。
+/**
+ * @brief 处理调用约定，预先为函数参数和调用返回值分配物理寄存器。
+ * 这个函数现在负责处理调用约定的两个方面：
+ * 1. 作为被调用者(callee)，如何接收传入的参数。
+ * 2. 作为调用者(caller)，如何接收调用的其他函数的返回值。
+ */
+void RISCv64RegAlloc::handleCallingConvention() {
     Function* F = MFunc->getFunc();
     RISCv64ISel* isel = MFunc->getISel();
+    
+    // --- 部分1：处理函数传入参数的预着色 ---
+    // 获取函数的Argument对象列表
+    if (F) {
+        auto& args = F->getArguments();
+        // RISC-V RV64G调用约定：前8个整型/指针参数通过 a0-a7 传递
+        int arg_idx = 0;
+        // 遍历 Argument* 列表
+        for (Argument* arg : args) {
+            if (arg_idx >= 8) {
+                break;
+            }
+            // 获取该 Argument 对象对应的虚拟寄存器ID
+            // 通过 MachineFunction -> RISCv64ISel -> vreg_map 来获取
+            const auto& vreg_map_from_isel = MFunc->getISel()->getVRegMap();
+            assert(vreg_map_from_isel.count(arg) && "Argument not found in ISel's vreg_map!"); 
+            // 1. 获取该 Argument 对象对应的虚拟寄存器
+            unsigned vreg = isel->getVReg(arg);
+            
+            // 2. 根据参数索引，确定对应的物理寄存器 (a0, a1, ...)
+            auto preg = static_cast<PhysicalReg>(static_cast<int>(PhysicalReg::A0) + arg_idx);
+            
+            // 3. 在 color_map 中，将 vreg "预着色" 为对应的物理寄存器
+            color_map[vreg] = preg;
 
+            arg_idx++;
+        }
+    }
+
+    // // --- 部分2：[新逻辑] 遍历所有指令，为CALL指令的返回值预着色为 a0 ---
+    // // 这是为了强制寄存器分配器知道，call的结果物理上出现在a0寄存器。
+    for (auto& mbb : MFunc->getBlocks()) {
+        for (auto& instr : mbb->getInstructions()) {
+            if (instr->getOpcode() == RVOpcodes::CALL) {
+                // 根据协议，如果CALL有返回值，其目标vreg是第一个操作数
+                if (!instr->getOperands().empty() && 
+                    instr->getOperands().front()->getKind() == MachineOperand::KIND_REG) 
+                {
+                    auto reg_op = static_cast<RegOperand*>(instr->getOperands().front().get());
+                    if (reg_op->isVirtual()) {
+                        unsigned ret_vreg = reg_op->getVRegNum();
+                        // 强制将这个虚拟寄存器预着色为 a0
+                        color_map[ret_vreg] = PhysicalReg::A0;
+                        if (DEBUG) {
+                            std::cout << "[DEBUG] Pre-coloring vreg" << ret_vreg 
+                                      << " to a0 for CALL instruction." << std::endl;
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+/**
+ * @brief 消除帧索引，为局部变量和栈参数分配栈偏移量，并展开伪指令。
+ */
+void RISCv64RegAlloc::eliminateFrameIndices() {
+    StackFrameInfo& frame_info = MFunc->getFrameInfo();
+    // 初始偏移量，为保存ra和s0留出空间。
+    // 假设序言是 addi sp, sp, -stack_size; sd ra, stack_size-8(sp); sd s0, stack_size-16(sp);    
+    int current_offset = 16;
+    
+    Function* F = MFunc->getFunc();
+    RISCv64ISel* isel = MFunc->getISel();
+    
+    // 在处理局部变量前，首先为栈参数计算偏移量。
+    if (F) {
+        int arg_idx = 0;
+        for (Argument* arg : F->getArguments()) {
+            // 我们只关心第8个索引及之后的参数（即第9个参数开始）
+            if (arg_idx >= 8) {
+                // 计算偏移量：第一个栈参数(idx=8)在0(s0)，第二个(idx=9)在8(s0)，以此类推。
+                int offset = (arg_idx - 8) * 8;
+                unsigned vreg = isel->getVReg(arg);
+
+                // 将这个vreg和它的栈偏移存入map。
+                // 我们可以复用alloca_offsets，因为它们都代表“vreg到栈偏移”的映射。
+                frame_info.alloca_offsets[vreg] = offset;
+            }
+            arg_idx++;
+        }
+    }
+
+    // 处理局部变量
+    // 遍历AllocaInst来计算局部变量所需的总空间
     for (auto& bb : F->getBasicBlocks()) {
         for (auto& inst : bb->getInstructions()) {
             if (auto alloca = dynamic_cast<AllocaInst*>(inst.get())) {
-                int size = 4;
-                if (!alloca->getDims().empty()) {
-                    int num_elements = 1;
-                    for (const auto& dim_use : alloca->getDims()) {
-                        if (auto const_dim = dynamic_cast<ConstantValue*>(dim_use->getValue())) {
-                            num_elements *= const_dim->getInt();
-                        }
-                    }
-                    size *= num_elements;
-                }
+                // 获取Alloca指令指向的类型 (例如 alloca i32* 中，获取 i32)
+                Type* allocated_type = alloca->getType()->as<PointerType>()->getBaseType();
+                int size = getTypeSizeInBytes(allocated_type);
+                
+                // RISC-V要求栈地址8字节对齐
+                size = (size + 7) & ~7;
+                if (size == 0) size = 8; // 至少分配8字节
+
                 current_offset += size;
                 unsigned alloca_vreg = isel->getVReg(alloca);
+                // 局部变量使用相对于s0的负向偏移
                 frame_info.alloca_offsets[alloca_vreg] = -current_offset;
             }
         }
     }
     frame_info.locals_size = current_offset;
 
+    // 遍历所有机器指令，将伪指令展开为真实指令
     for (auto& mbb : MFunc->getBlocks()) {
         std::vector<std::unique_ptr<MachineInstr>> new_instructions;
         for (auto& instr_ptr : mbb->getInstructions()) {
-            if (instr_ptr->getOpcode() == RVOpcodes::FRAME_LOAD) {
+            RVOpcodes opcode = instr_ptr->getOpcode();
+
+            // --- MODIFICATION START: 处理区分宽度的伪指令 ---
+            if (opcode == RVOpcodes::FRAME_LOAD_W || opcode == RVOpcodes::FRAME_LOAD_D) {
+                // 确定要生成的真实加载指令是 lw 还是 ld
+                RVOpcodes real_load_op = (opcode == RVOpcodes::FRAME_LOAD_W) ? RVOpcodes::LW : RVOpcodes::LD;
+
                 auto& operands = instr_ptr->getOperands();
                 unsigned dest_vreg = static_cast<RegOperand*>(operands[0].get())->getVRegNum();
                 unsigned alloca_vreg = static_cast<RegOperand*>(operands[1].get())->getVRegNum();
                 int offset = frame_info.alloca_offsets.at(alloca_vreg);
                 auto addr_vreg = isel->getNewVReg();
 
+                // 展开为: addi addr_vreg, s0, offset
                 auto addi = std::make_unique<MachineInstr>(RVOpcodes::ADDI);
                 addi->addOperand(std::make_unique<RegOperand>(addr_vreg));
                 addi->addOperand(std::make_unique<RegOperand>(PhysicalReg::S0));
                 addi->addOperand(std::make_unique<ImmOperand>(offset));
                 new_instructions.push_back(std::move(addi));
 
-                auto lw = std::make_unique<MachineInstr>(RVOpcodes::LW);
-                lw->addOperand(std::make_unique<RegOperand>(dest_vreg));
-                lw->addOperand(std::make_unique<MemOperand>(
+                // 展开为: lw/ld dest_vreg, 0(addr_vreg)
+                auto load_instr = std::make_unique<MachineInstr>(real_load_op);
+                load_instr->addOperand(std::make_unique<RegOperand>(dest_vreg));
+                load_instr->addOperand(std::make_unique<MemOperand>(
                     std::make_unique<RegOperand>(addr_vreg),
                     std::make_unique<ImmOperand>(0)));
-                new_instructions.push_back(std::move(lw));
+                new_instructions.push_back(std::move(load_instr));
+
+            } else if (opcode == RVOpcodes::FRAME_STORE_W || opcode == RVOpcodes::FRAME_STORE_D) {
+                // 确定要生成的真实存储指令是 sw 还是 sd
+                RVOpcodes real_store_op = (opcode == RVOpcodes::FRAME_STORE_W) ? RVOpcodes::SW : RVOpcodes::SD;
 
-            } else if (instr_ptr->getOpcode() == RVOpcodes::FRAME_STORE) {
                 auto& operands = instr_ptr->getOperands();
                 unsigned src_vreg = static_cast<RegOperand*>(operands[0].get())->getVRegNum();
                 unsigned alloca_vreg = static_cast<RegOperand*>(operands[1].get())->getVRegNum();
                 int offset = frame_info.alloca_offsets.at(alloca_vreg);
                 auto addr_vreg = isel->getNewVReg();
                 
+                // 展开为: addi addr_vreg, s0, offset
                 auto addi = std::make_unique<MachineInstr>(RVOpcodes::ADDI);
                 addi->addOperand(std::make_unique<RegOperand>(addr_vreg));
                 addi->addOperand(std::make_unique<RegOperand>(PhysicalReg::S0));
                 addi->addOperand(std::make_unique<ImmOperand>(offset));
                 new_instructions.push_back(std::move(addi));
 
-                auto sw = std::make_unique<MachineInstr>(RVOpcodes::SW);
-                sw->addOperand(std::make_unique<RegOperand>(src_vreg));
-                sw->addOperand(std::make_unique<MemOperand>(
+                // 展开为: sw/sd src_vreg, 0(addr_vreg)
+                auto store_instr = std::make_unique<MachineInstr>(real_store_op);
+                store_instr->addOperand(std::make_unique<RegOperand>(src_vreg));
+                store_instr->addOperand(std::make_unique<MemOperand>(
                     std::make_unique<RegOperand>(addr_vreg),
                     std::make_unique<ImmOperand>(0)));
-                new_instructions.push_back(std::move(sw));
-            } else if (instr_ptr->getOpcode() == RVOpcodes::FRAME_ADDR) { // [新] 处理FRAME_ADDR
+                new_instructions.push_back(std::move(store_instr));
+
+            } else if (instr_ptr->getOpcode() == RVOpcodes::FRAME_ADDR) { 
                 auto& operands = instr_ptr->getOperands();
                 unsigned dest_vreg = static_cast<RegOperand*>(operands[0].get())->getVRegNum();
                 unsigned alloca_vreg = static_cast<RegOperand*>(operands[1].get())->getVRegNum();
@@ -104,97 +237,275 @@ void RISCv64RegAlloc::eliminateFrameIndices() {
                 // 将 `frame_addr rd, rs` 展开为 `addi rd, s0, offset`
                 auto addi = std::make_unique<MachineInstr>(RVOpcodes::ADDI);
                 addi->addOperand(std::make_unique<RegOperand>(dest_vreg));
-                addi->addOperand(std::make_unique<RegOperand>(PhysicalReg::S0)); // 基地址是帧指针 s0
+                addi->addOperand(std::make_unique<RegOperand>(PhysicalReg::S0));
                 addi->addOperand(std::make_unique<ImmOperand>(offset));
                 new_instructions.push_back(std::move(addi));
             } else {
                 new_instructions.push_back(std::move(instr_ptr));
             }
+            // --- MODIFICATION END ---
         }
         mbb->getInstructions() = std::move(new_instructions);
     }
 }
 
+/**
+ * @brief 计算给定 MachineInstr 的 Use (读取) 和 Def (写入) 寄存器集合。
+ * 这是活跃性分析的基础。
+ * @param instr 要分析的机器指令。
+ * @param use 存储 Use 寄存器（虚拟寄存器 ID）的集合。
+ * @param def 存储 Def 寄存器（虚拟寄存器 ID）的集合。
+ */
 void RISCv64RegAlloc::getInstrUseDef(MachineInstr* instr, LiveSet& use, LiveSet& def) {
-    bool is_def = true;
+    bool first_reg_is_def = true; // 默认情况下，指令的第一个寄存器操作数是定义 (def)
     auto opcode = instr->getOpcode();
 
-    // 预定义def和use规则
+    // 1. 特殊指令的 `is_def` 标志调整
+    // 这些指令的第一个寄存器操作数是源操作数 (use)，而不是目标操作数 (def)。
     if (opcode == RVOpcodes::SW || opcode == RVOpcodes::SD || 
         opcode == RVOpcodes::BEQ || opcode == RVOpcodes::BNE || 
         opcode == RVOpcodes::BLT || opcode == RVOpcodes::BGE ||
+        opcode == RVOpcodes::BLTU || opcode == RVOpcodes::BGEU ||
         opcode == RVOpcodes::RET || opcode == RVOpcodes::J) {
-        is_def = false;
+        first_reg_is_def = false;
     }
-    if (opcode == RVOpcodes::CALL) {
-        // CALL会杀死所有调用者保存寄存器，这是一个简化处理
-        // 同时也使用了传入a0-a7的参数
+
+    // JAL 和 JALR 指令定义 ra (x1)
+    if (opcode == RVOpcodes::JAL || opcode == RVOpcodes::JALR) {
+        // 使用 ra 对应的特殊虚拟寄存器ID
+        def.insert(preg_to_vreg_id_map.at(PhysicalReg::RA)); 
+        first_reg_is_def = false; // JAL/JALR 的第一个操作数是 ra，已经处理为 def
     }
     
+    // 2. CALL 指令的特殊处理
+    if (opcode == RVOpcodes::CALL) {
+        // 根据 s1 分支 ISel 定义的协议来解析操作数列表
+        bool first_reg_operand_is_def = true;
+        for (auto& op : instr->getOperands()) {
+            if (op->getKind() == MachineOperand::KIND_REG) {
+                auto reg_op = static_cast<RegOperand*>(op.get());
+                if (reg_op->isVirtual()) {
+                    // 协议：第一个寄存器操作数是返回值 (def)
+                    if (first_reg_operand_is_def) {
+                        def.insert(reg_op->getVRegNum());
+                        first_reg_operand_is_def = false;
+                    } else {
+                        // 后续所有寄存器操作数都是参数 (use)
+                        use.insert(reg_op->getVRegNum());
+                    }
+                } else { // [修复] CALL指令也可能定义物理寄存器（如a0）
+                    if (first_reg_operand_is_def) {
+                         if (preg_to_vreg_id_map.count(reg_op->getPReg())) {
+                            def.insert(preg_to_vreg_id_map.at(reg_op->getPReg()));
+                        }
+                        first_reg_operand_is_def = false;
+                    } else {
+                         if (preg_to_vreg_id_map.count(reg_op->getPReg())) {
+                            use.insert(preg_to_vreg_id_map.at(reg_op->getPReg()));
+                        }
+                    }
+                }
+            }
+        }
+        return; // CALL 指令处理完毕
+    }
+    
+    // 3. 对其他所有指令的通用处理逻辑 [已重构和修复]
     for (const auto& op : instr->getOperands()) {
         if (op->getKind() == MachineOperand::KIND_REG) {
             auto reg_op = static_cast<RegOperand*>(op.get());
-            if (reg_op->isVirtual()) {
-                if (is_def) {
+            
+            if (first_reg_is_def) {
+                // --- 处理定义（Def） ---
+                if (reg_op->isVirtual()) {
                     def.insert(reg_op->getVRegNum());
-                    is_def = false; 
-                } else {
+                } else { // 物理寄存器也可以是 Def
+                    if (preg_to_vreg_id_map.count(reg_op->getPReg())) {
+                        def.insert(preg_to_vreg_id_map.at(reg_op->getPReg()));
+                    }
+                }
+                first_reg_is_def = false; // **关键**：处理完第一个寄存器后，立即更新标志
+            } else {
+                // --- 处理使用（Use） ---
+                if (reg_op->isVirtual()) {
                     use.insert(reg_op->getVRegNum());
+                } else { // 物理寄存器也可以是 Use
+                    if (preg_to_vreg_id_map.count(reg_op->getPReg())) {
+                        use.insert(preg_to_vreg_id_map.at(reg_op->getPReg()));
+                    }
                 }
             }
         } else if (op->getKind() == MachineOperand::KIND_MEM) {
+            // [保持不变] 内存操作数的处理逻辑看起来是正确的
             auto mem_op = static_cast<MemOperand*>(op.get());
-            if (mem_op->getBase()->isVirtual()) {
-                use.insert(mem_op->getBase()->getVRegNum());
+            auto base_reg = mem_op->getBase();
+            if (base_reg->isVirtual()) {
+                use.insert(base_reg->getVRegNum());
+            } else {
+                PhysicalReg preg = base_reg->getPReg();
+                if (preg_to_vreg_id_map.count(preg)) {
+                    use.insert(preg_to_vreg_id_map.at(preg));
+                }
+            }
+            
+            // 对于存储内存指令 (SW, SD)，要存储的值（第一个操作数）也是 `use`
+            if ((opcode == RVOpcodes::SW || opcode == RVOpcodes::SD) && 
+                 !instr->getOperands().empty() &&
+                 instr->getOperands().front()->getKind() == MachineOperand::KIND_REG) {
+                auto src_reg_op = static_cast<RegOperand*>(instr->getOperands().front().get());
+                if (src_reg_op->isVirtual()) {
+                    use.insert(src_reg_op->getVRegNum());
+                } else {
+                    if (preg_to_vreg_id_map.count(src_reg_op->getPReg())) {
+                       use.insert(preg_to_vreg_id_map.at(src_reg_op->getPReg()));
+                    }
+                }
             }
         }
     }
 }
 
+/**
+ * @brief 计算一个类型在内存中占用的字节数。
+ * @param type 需要计算大小的IR类型。
+ * @return 该类型占用的字节数。
+ */
+unsigned RISCv64RegAlloc::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;
+    }
+}
+
 void RISCv64RegAlloc::analyzeLiveness() {
+    // === 阶段 1: 预计算每个基本块的 use 和 def 集合 ===
+    // 这样可以避免在主循环中重复计算
+    std::map<MachineBasicBlock*, LiveSet> block_uses;
+    std::map<MachineBasicBlock*, LiveSet> block_defs;
+    for (auto& mbb_ptr : MFunc->getBlocks()) {
+        MachineBasicBlock* mbb = mbb_ptr.get();
+        LiveSet uses, defs;
+        for (auto& instr_ptr : mbb->getInstructions()) {
+            LiveSet instr_use, instr_def;
+            getInstrUseDef(instr_ptr.get(), instr_use, instr_def);
+            // use[B] = use[B] U (instr_use - def[B])
+            for (unsigned u : instr_use) {
+                if (defs.find(u) == defs.end()) {
+                    uses.insert(u);
+                }
+            }
+            // def[B] = def[B] U instr_def
+            defs.insert(instr_def.begin(), instr_def.end());
+        }
+        block_uses[mbb] = uses;
+        block_defs[mbb] = defs;
+    }
+
+    // === 阶段 2: 在“块”粒度上进行迭代数据流分析，直到收敛 ===
+    std::map<MachineBasicBlock*, LiveSet> block_live_in;
+    std::map<MachineBasicBlock*, LiveSet> block_live_out;
     bool changed = true;
     while (changed) {
         changed = false;
+        // 以逆后序遍历基本块，可以加速收敛，但简单的逆序对于大多数情况也有效
         for (auto it = MFunc->getBlocks().rbegin(); it != MFunc->getBlocks().rend(); ++it) {
             auto& mbb = *it;
-            LiveSet live_out;
+            
+            // 2.1 计算 live_out[B] = U_{S in succ(B)} live_in[S]
+            LiveSet new_live_out;
             for (auto succ : mbb->successors) {
-                if (!succ->getInstructions().empty()) {
-                    auto first_instr = succ->getInstructions().front().get();
-                    if (live_in_map.count(first_instr)) {
-                        live_out.insert(live_in_map.at(first_instr).begin(), live_in_map.at(first_instr).end());
-                    }
-                }
+                new_live_out.insert(block_live_in[succ].begin(), block_live_in[succ].end());
             }
 
-            for (auto instr_it = mbb->getInstructions().rbegin(); instr_it != mbb->getInstructions().rend(); ++instr_it) {
-                MachineInstr* instr = instr_it->get();
-                LiveSet old_live_in = live_in_map[instr];
-                live_out_map[instr] = live_out;
-                
-                LiveSet use, def;
-                getInstrUseDef(instr, use, def);
-
-                LiveSet live_in = use;
-                LiveSet diff = live_out;
-                for (auto vreg : def) {
-                    diff.erase(vreg);
-                }
-                live_in.insert(diff.begin(), diff.end());
-                live_in_map[instr] = live_in;
-                
-                live_out = live_in;
-
-                if (live_in_map[instr] != old_live_in) {
-                    changed = true;
-                }
+            // 2.2 计算 live_in[B] = use[B] U (live_out[B] - def[B])
+            LiveSet live_out_minus_def = new_live_out;
+            for (unsigned d : block_defs[mbb.get()]) {
+                live_out_minus_def.erase(d);
             }
+            LiveSet new_live_in = block_uses[mbb.get()];
+            new_live_in.insert(live_out_minus_def.begin(), live_out_minus_def.end());
+
+            // 2.3 检查 live_in 和 live_out 是否变化，以判断是否达到不动点
+            if (block_live_out[mbb.get()] != new_live_out) {
+                changed = true;
+                block_live_out[mbb.get()] = new_live_out;
+            }
+            if (block_live_in[mbb.get()] != new_live_in) {
+                changed = true;
+                block_live_in[mbb.get()] = new_live_in;
+            }
+        }
+    }
+
+    // === 阶段 3: 进行一次指令粒度的遍历，填充最终的 live_in_map 和 live_out_map ===
+    // 此时块级别的活跃信息已经稳定，我们只需遍历一次即可
+    for (auto& mbb_ptr : MFunc->getBlocks()) {
+        MachineBasicBlock* mbb = mbb_ptr.get();
+        LiveSet live_out = block_live_out[mbb]; // 从已收敛的块级 live_out 开始
+
+        for (auto instr_it = mbb->getInstructions().rbegin(); instr_it != mbb->getInstructions().rend(); ++instr_it) {
+            MachineInstr* instr = instr_it->get();
+            live_out_map[instr] = live_out;
+
+            LiveSet use, def;
+            getInstrUseDef(instr, use, def);
+
+            LiveSet live_in = use;
+            LiveSet diff = live_out;
+            for (auto vreg : def) {
+                diff.erase(vreg);
+            }
+            live_in.insert(diff.begin(), diff.end());
+            live_in_map[instr] = live_in;
+            
+            // 更新 live_out，为块内的上一条指令做准备
+            live_out = live_in;
         }
     }
 }
 
+// 辅助函数，用于清晰地打印寄存器集合。可以放在 .cpp 文件的顶部。
+void RISCv64RegAlloc::printLiveSet(const LiveSet& s, const std::string& name, std::ostream& os) {
+    os << "    " << name << ": { ";
+    for (unsigned vreg : s) {
+        // 为了可读性，将物理寄存器对应的特殊ID进行转换
+        if (vreg >= static_cast<unsigned>(sysy::PhysicalReg::PHYS_REG_START_ID)) {
+            os << "preg(" << (vreg - static_cast<unsigned>(sysy::PhysicalReg::PHYS_REG_START_ID)) << ") ";
+        } else {
+            os << "%vreg" << vreg << " ";
+        }
+    }
+    os << "}\n";
+}
+
 void RISCv64RegAlloc::buildInterferenceGraph() {
     std::set<unsigned> all_vregs;
+    // 收集所有虚拟寄存器和物理寄存器在干扰图中的节点ID
     for (auto& mbb : MFunc->getBlocks()) {
         for(auto& instr : mbb->getInstructions()) {
             LiveSet use, def;
@@ -203,23 +514,100 @@ void RISCv64RegAlloc::buildInterferenceGraph() {
             for(auto d : def) all_vregs.insert(d);
         }
     }
+    // 添加所有物理寄存器对应的特殊虚拟寄存器ID到all_vregs，作为干扰图节点
+    for (auto preg : allocable_int_regs) {
+        all_vregs.insert(preg_to_vreg_id_map.at(preg));
+    }
 
+    // 初始化干扰图邻接表
     for (auto vreg : all_vregs) { interference_graph[vreg] = {}; }
 
-    for (auto& mbb : MFunc->getBlocks()) {
-        for (auto& instr : mbb->getInstructions()) {
-            LiveSet def, use;
-            getInstrUseDef(instr.get(), use, def);
-            const LiveSet& live_out = live_out_map.at(instr.get());
+    // 创建一个临时的AsmPrinter用于打印指令，方便调试
+    RISCv64AsmPrinter temp_printer(MFunc);
+    temp_printer.setStream(std::cerr);
 
+    for (auto& mbb : MFunc->getBlocks()) {
+        if (DEEPDEBUG) std::cerr << "--- Building Graph for Basic Block: " << mbb->getName() << " ---\n";
+        for (auto& instr_ptr : mbb->getInstructions()) {
+            MachineInstr* instr = instr_ptr.get();
+            if (DEEPDEBUG) {
+                // 打印当前正在处理的指令
+                std::cerr << "  Instr: ";
+                temp_printer.printInstruction(instr, true); // 使用 true 来打印虚拟寄存器
+            }
+            
+            LiveSet def, use;
+            getInstrUseDef(instr, use, def);
+            const LiveSet& live_out = live_out_map.at(instr);
+
+            // [新增调试逻辑] 打印所有相关的寄存器集合
+            if (DEEPDEBUG) {
+                printLiveSet(use, "Use     ", std::cerr);
+                printLiveSet(def, "Def     ", std::cerr);
+                printLiveSet(live_out, "Live_Out", std::cerr); // 这是我们最关心的信息
+            }
+
+            // 标准干扰图构建：def 与 live_out 中的其他变量干扰
             for (unsigned d : def) {
                 for (unsigned l : live_out) {
                     if (d != l) {
+                        // [新增调试逻辑] 打印添加的干扰边及其原因
+                        if (DEEPDEBUG && interference_graph[d].find(l) == interference_graph[d].end()) {
+                           std::cerr << "    Edge (Def-LiveOut): %vreg" << d << " <-> %vreg" << l << "\n";
+                        }
                         interference_graph[d].insert(l);
                         interference_graph[l].insert(d);
                     }
                 }
             }
+
+            // 在非move指令中，def 与 use 互相干扰
+            if (instr->getOpcode() != RVOpcodes::MV) {
+                for (unsigned d : def) {
+                    for (unsigned u : use) {
+                        if (d != u) {
+                            // [新增调试逻辑] 打印添加的干扰边及其原因
+                            if (DEEPDEBUG && interference_graph[d].find(u) == interference_graph[d].end()) {
+                                std::cerr << "    Edge (Def-Use)    : %vreg" << d << " <-> %vreg" << u << "\n";
+                            }
+                            interference_graph[d].insert(u);
+                            interference_graph[u].insert(d);
+                        }
+                    }
+                }
+            }
+
+            // *** 处理 CALL 指令的隐式 def ***
+            if (instr->getOpcode() == RVOpcodes::CALL) {
+                // 你的原始CALL调试信息
+                if (DEEPDEBUG) {
+                    std::string live_out_str;
+                    for (unsigned vreg : live_out) {
+                        live_out_str += "%vreg" + std::to_string(vreg) + " ";
+                    }
+                    std::cerr << "[DEEPDEBUG] buildInterferenceGraph: CALL instruction found. Live out set is: {" 
+                              << live_out_str << "}" << std::endl;
+                }
+                // CALL 指令会定义（杀死）所有调用者保存的寄存器。
+                // 因此，所有调用者保存的物理寄存器都与 CALL 指令的 live_out 中的所有变量冲突。
+                const std::vector<PhysicalReg>& caller_saved_regs = getCallerSavedIntRegs();
+                for (PhysicalReg cs_reg : caller_saved_regs) {
+                    unsigned cs_vreg_id = preg_to_vreg_id_map.at(cs_reg); // 获取物理寄存器对应的特殊vreg ID
+                    
+                    // 将这个物理寄存器节点与 CALL 指令的 live_out 中的所有虚拟寄存器添加干扰边。
+                    for (unsigned live_vreg_out : live_out) {
+                        if (cs_vreg_id != live_vreg_out) { // 避免自己和自己干扰
+                            // [新增调试逻辑] 打印添加的干扰边及其原因
+                            if (DEEPDEBUG && interference_graph[cs_vreg_id].find(live_vreg_out) == interference_graph[cs_vreg_id].end()) {
+                                std::cerr << "    Edge (CALL)       : preg(" << static_cast<int>(cs_reg) << ") <-> %vreg" << live_vreg_out << "\n";
+                            }
+                            interference_graph[cs_vreg_id].insert(live_vreg_out);
+                            interference_graph[live_vreg_out].insert(cs_vreg_id);
+                        }
+                    }
+                }
+            }
+            if (DEEPDEBUG) std::cerr << "  ----------------\n";
         }
     }
 }
@@ -227,18 +615,32 @@ void RISCv64RegAlloc::buildInterferenceGraph() {
 void RISCv64RegAlloc::colorGraph() {
     std::vector<unsigned> sorted_vregs;
     for (auto const& [vreg, neighbors] : interference_graph) {
-        sorted_vregs.push_back(vreg);
+        // 只为未预着色的虚拟寄存器排序和着色
+        if (color_map.find(vreg) == color_map.end() && vreg < static_cast<unsigned>(PhysicalReg::PHYS_REG_START_ID)) {
+            sorted_vregs.push_back(vreg);
+        }
     }
 
+    // 排序
     std::sort(sorted_vregs.begin(), sorted_vregs.end(), [&](unsigned a, unsigned b) {
         return interference_graph[a].size() > interference_graph[b].size();
     });
 
+    // 着色
     for (unsigned vreg : sorted_vregs) {
         std::set<PhysicalReg> used_colors;
-        for (unsigned neighbor : interference_graph.at(vreg)) {
-            if (color_map.count(neighbor)) {
-                used_colors.insert(color_map.at(neighbor));
+        for (unsigned neighbor_id : interference_graph.at(vreg)) {
+            // --- 关键改进 (来自 rec 分支) ---
+            
+            // 情况 1: 邻居是一个已经被着色的虚拟寄存器
+            if (color_map.count(neighbor_id)) {
+                used_colors.insert(color_map.at(neighbor_id));
+            } 
+            // 情况 2: 邻居本身就是一个代表物理寄存器的节点
+            else if (neighbor_id >= static_cast<unsigned>(PhysicalReg::PHYS_REG_START_ID)) {
+                // 从特殊ID反向解析出是哪个物理寄存器
+                PhysicalReg neighbor_preg = static_cast<PhysicalReg>(neighbor_id - static_cast<unsigned>(PhysicalReg::PHYS_REG_START_ID));
+                used_colors.insert(neighbor_preg);
             }
         }
         
@@ -259,8 +661,21 @@ void RISCv64RegAlloc::colorGraph() {
 void RISCv64RegAlloc::rewriteFunction() {
     StackFrameInfo& frame_info = MFunc->getFrameInfo();
     int current_offset = frame_info.locals_size;
+
+    // --- FIX 1: 动态计算溢出槽大小 ---
+    // 根据溢出虚拟寄存器的真实类型，为其在栈上分配正确大小的空间。
     for (unsigned vreg : spilled_vregs) {
-        current_offset += 4;
+        // 从反向映射中查找 vreg 对应的 IR Value
+        assert(vreg_to_value_map.count(vreg) && "Spilled vreg not found in map!");
+        Value* val = vreg_to_value_map.at(vreg);
+        
+        // 使用辅助函数获取类型大小
+        int size = getTypeSizeInBytes(val->getType());
+        
+        // 保持栈8字节对齐
+        current_offset += size;
+        current_offset = (current_offset + 7) & ~7;
+
         frame_info.spill_offsets[vreg] = -current_offset;
     }
     frame_info.spill_size = current_offset - frame_info.locals_size;
@@ -271,10 +686,16 @@ void RISCv64RegAlloc::rewriteFunction() {
             LiveSet use, def;
             getInstrUseDef(instr_ptr.get(), use, def);
 
+            // --- FIX 2: 为溢出的 'use' 操作数插入正确的加载指令 ---
             for (unsigned vreg : use) {
                 if (spilled_vregs.count(vreg)) {
+                    // 同样地，根据 vreg 的类型决定使用 lw 还是 ld
+                    assert(vreg_to_value_map.count(vreg));
+                    Value* val = vreg_to_value_map.at(vreg);
+                    RVOpcodes load_op = val->getType()->isPointer() ? RVOpcodes::LD : RVOpcodes::LW;
+
                     int offset = frame_info.spill_offsets.at(vreg);
-                    auto load = std::make_unique<MachineInstr>(RVOpcodes::LW);
+                    auto load = std::make_unique<MachineInstr>(load_op);
                     load->addOperand(std::make_unique<RegOperand>(vreg));
                     load->addOperand(std::make_unique<MemOperand>(
                         std::make_unique<RegOperand>(PhysicalReg::S0),
@@ -286,10 +707,16 @@ void RISCv64RegAlloc::rewriteFunction() {
 
             new_instructions.push_back(std::move(instr_ptr));
 
+            // --- FIX 3: 为溢出的 'def' 操作数插入正确的存储指令 ---
             for (unsigned vreg : def) {
                 if (spilled_vregs.count(vreg)) {
+                    // 根据 vreg 的类型决定使用 sw 还是 sd
+                    assert(vreg_to_value_map.count(vreg));
+                    Value* val = vreg_to_value_map.at(vreg);
+                    RVOpcodes store_op = val->getType()->isPointer() ? RVOpcodes::SD : RVOpcodes::SW;
+
                     int offset = frame_info.spill_offsets.at(vreg);
-                    auto store = std::make_unique<MachineInstr>(RVOpcodes::SW);
+                    auto store = std::make_unique<MachineInstr>(store_op);
                     store->addOperand(std::make_unique<RegOperand>(vreg));
                     store->addOperand(std::make_unique<MemOperand>(
                         std::make_unique<RegOperand>(PhysicalReg::S0),
@@ -302,29 +729,43 @@ void RISCv64RegAlloc::rewriteFunction() {
         mbb->getInstructions() = std::move(new_instructions);
     }
     
+    // 最后的虚拟寄存器到物理寄存器的替换过程保持不变
     for (auto& mbb : MFunc->getBlocks()) {
         for (auto& instr_ptr : mbb->getInstructions()) {
             for (auto& op_ptr : instr_ptr->getOperands()) {
+
+                // 情况一：操作数本身就是一个寄存器 (例如 add rd, rs1, rs2 中的所有操作数)
                 if(op_ptr->getKind() == MachineOperand::KIND_REG) {
                     auto reg_op = static_cast<RegOperand*>(op_ptr.get());
                     if (reg_op->isVirtual()) {
                         unsigned vreg = reg_op->getVRegNum();
                         if (color_map.count(vreg)) {
-                            reg_op->setPReg(color_map.at(vreg));
+                            PhysicalReg preg = color_map.at(vreg);
+                            reg_op->setPReg(preg);
                         } else if (spilled_vregs.count(vreg)) {
-                            reg_op->setPReg(PhysicalReg::T6); // 溢出统一用t6
+                            // 如果vreg被溢出，替换为专用的溢出物理寄存器t6
+                            reg_op->setPReg(PhysicalReg::T6);
                         }
                     }
-                } else if (op_ptr->getKind() == MachineOperand::KIND_MEM) {
+                } 
+                // 情况二：操作数是一个内存地址 (例如 lw rd, offset(rs1) 中的 offset(rs1))
+                else if (op_ptr->getKind() == MachineOperand::KIND_MEM) {
                     auto mem_op = static_cast<MemOperand*>(op_ptr.get());
+                    // 获取内存操作数内部的“基址寄存器”
                     auto base_reg_op = mem_op->getBase();
+
+                    // 对这个基址寄存器，执行与情况一完全相同的替换逻辑
                     if(base_reg_op->isVirtual()){
-                         unsigned vreg = base_reg_op->getVRegNum();
-                         if(color_map.count(vreg)) {
-                             base_reg_op->setPReg(color_map.at(vreg));
-                         } else if (spilled_vregs.count(vreg)) {
-                             base_reg_op->setPReg(PhysicalReg::T6);
-                         }
+                        unsigned vreg = base_reg_op->getVRegNum();
+                        if(color_map.count(vreg)) {
+                            // 如果基址vreg被成功着色，替换
+                            PhysicalReg preg = color_map.at(vreg);
+                            base_reg_op->setPReg(preg);
+
+                        } else if (spilled_vregs.count(vreg)) {
+                            // 如果基址vreg被溢出，替换为t6
+                            base_reg_op->setPReg(PhysicalReg::T6);
+                        }
                     }
                 }
             }

src/SysYIRAnalyser.cpp

@@ -1,532 +0,0 @@
-#include "SysYIRAnalyser.h"
-#include <iostream>
-
-
-namespace sysy {
-
-
-void ControlFlowAnalysis::init() {
-  // 初始化分析器
-  auto &functions = pModule->getFunctions();
-  for (const auto &function : functions) {
-    auto func = function.second.get();
-    auto basicBlocks = func->getBasicBlocks();
-    for (auto &basicBlock : basicBlocks) {
-      blockAnalysisInfo[basicBlock.get()] = new BlockAnalysisInfo();
-      blockAnalysisInfo[basicBlock.get()]->clear();
-    }
-    functionAnalysisInfo[func] = new FunctionAnalysisInfo();
-    functionAnalysisInfo[func]->clear();
-  }
-}
-
-void ControlFlowAnalysis::runControlFlowAnalysis() {
-  // 运行控制流分析
-  clear();  // 清空之前的分析结果
-  init();  // 初始化分析器
-  computeDomNode();
-  computeDomTree();
-  computeDomFrontierAllBlk();
-}
-
-void ControlFlowAnalysis::intersectOP4Dom(std::unordered_set<BasicBlock *> &dom, const std::unordered_set<BasicBlock *> &other) {
-  // 计算交集
-  for (auto it = dom.begin(); it != dom.end();) {
-    if (other.find(*it) == other.end()) {
-      // 如果other中没有这个基本块，则从dom中删除
-      it = dom.erase(it);
-    } else {
-      ++it;
-    }
-  }
-}
-
-auto ControlFlowAnalysis::findCommonDominator(BasicBlock *a, BasicBlock *b) -> BasicBlock * {
-  // 查找两个基本块的共同支配结点
-  while (a != b) {
-    BlockAnalysisInfo* infoA = blockAnalysisInfo[a];
-    BlockAnalysisInfo* infoB = blockAnalysisInfo[b];
-    // 如果深度不同，则向上移动到直接支配结点
-    // TODO：空间换时间倍增优化，优先级较低
-    while (infoA->getDomDepth() > infoB->getDomDepth()) {
-      a = const_cast<BasicBlock*>(infoA->getIdom());
-      infoA = blockAnalysisInfo[a];
-    }
-    while (infoB->getDomDepth() > infoA->getDomDepth()) {
-      b = const_cast<BasicBlock*>(infoB->getIdom());
-      infoB = blockAnalysisInfo[b];
-    }
-    if (a == b) break;
-    a = const_cast<BasicBlock*>(infoA->getIdom());
-    b = const_cast<BasicBlock*>(infoB->getIdom());
-  }
-  return a;
-}
-
-void ControlFlowAnalysis::computeDomNode(){
-  auto &functions = pModule->getFunctions();
-  // 分析每个函数内的基本块
-  for (const auto &function : functions) {
-    auto func = function.second.get();
-    auto basicBlocks = func->getBasicBlocks();
-    std::unordered_set<BasicBlock *> domSetTmp;
-    // 一开始把domSetTmp置为所有block
-    auto entry_block = func->getEntryBlock();
-    entry_block->setName("Entry");
-    blockAnalysisInfo[entry_block]->addDominants(entry_block);
-    for (auto &basicBlock : basicBlocks) {
-      domSetTmp.emplace(basicBlock.get());
-    }
-    // 初始化
-    for (auto &basicBlock : basicBlocks) {
-      if (basicBlock.get() != entry_block) {
-        blockAnalysisInfo[basicBlock.get()]->setDominants(domSetTmp);
-        // 先把所有block的必经结点都设为N
-      }
-    }
-
-    // 支配节点计算公式
-    //DOM[B]={B}∪ {⋂P∈pred(B) DOM[P]} 
-    // 其中pred(B)是B的所有前驱结点
-    // 迭代计算支配结点，直到不再变化
-    // 这里使用迭代法，直到支配结点不再变化
-    // TODO：Lengauer-Tarjan 算法可以更高效地计算支配结点 
-    // 或者按照CFG拓扑序遍历效率更高
-    bool changed = true;
-    while (changed) {
-      changed = false;
-      // 循环非start结点
-      for (auto &basicBlock : basicBlocks) {
-        if (basicBlock.get() != entry_block) {
-          auto olddom = 
-            blockAnalysisInfo[basicBlock.get()]->getDominants();
-
-          std::unordered_set<BasicBlock *> dom = 
-            blockAnalysisInfo[basicBlock->getPredecessors().front()]->getDominants();
-
-          // 对于每个基本块，计算其支配结点
-          // 取其前驱结点的支配结点的交集和自己
-          for (auto pred : basicBlock->getPredecessors()) {
-            intersectOP4Dom(dom, blockAnalysisInfo[pred]->getDominants());
-          }
-          dom.emplace(basicBlock.get());
-          blockAnalysisInfo[basicBlock.get()]->setDominants(dom);
-          
-          if (dom != olddom) {
-            changed = true;
-          }
-        }
-      }
-    }
-  }
-}
-
-// TODO： SEMI-NCA算法改进
-void ControlFlowAnalysis::computeDomTree() {
-  // 构造支配树
-  auto &functions = pModule->getFunctions();
-  for (const auto &function : functions) {
-    auto func = function.second.get();
-    auto basicBlocks = func->getBasicBlocks();
-    auto entry_block = func->getEntryBlock();
-
-    blockAnalysisInfo[entry_block]->setIdom(entry_block);
-    blockAnalysisInfo[entry_block]->setDomDepth(0); // 入口块深度为0
-
-    bool changed = true;
-    while (changed) {
-      changed = false;
-      
-      for (auto &basicBlock : basicBlocks) {
-        if (basicBlock.get() == entry_block) continue;
-        
-        BasicBlock *new_idom = nullptr;
-        for (auto pred : basicBlock->getPredecessors()) {
-          // 跳过未处理的前驱
-          if (blockAnalysisInfo[pred]->getIdom() == nullptr) continue;
-          // new_idom = (new_idom == nullptr) ? pred : findCommonDominator(new_idom, pred);
-          if (new_idom == nullptr) 
-            new_idom = pred;
-          else
-            new_idom = findCommonDominator(new_idom, pred); 
-        }
-        // 更新直接支配节点
-        if (new_idom && new_idom != blockAnalysisInfo[basicBlock.get()]->getIdom()) {
-          // 移除旧的支配关系
-          if (blockAnalysisInfo[basicBlock.get()]->getIdom()) {
-            blockAnalysisInfo[const_cast<BasicBlock*>(blockAnalysisInfo[basicBlock.get()]->getIdom())]->removeSdoms(basicBlock.get());
-          }
-          // 设置新的支配关系
-          
-          // std::cout << "Block: " << basicBlock->getName()
-          //           << " New Idom: " << new_idom->getName() << std::endl;
-
-          blockAnalysisInfo[basicBlock.get()]->setIdom(new_idom);
-          blockAnalysisInfo[new_idom]->addSdoms(basicBlock.get());
-          // 更新深度 = 直接支配节点深度 + 1
-          blockAnalysisInfo[basicBlock.get()]->setDomDepth(
-            blockAnalysisInfo[new_idom]->getDomDepth() + 1);
-          
-          changed = true;
-        }
-      }
-    }
-  }
-  // for (auto &basicBlock : basicBlocks) {
-    //   if (basicBlock.get() != func->getEntryBlock()) {
-    //     auto dominats = 
-    //       blockAnalysisInfo[basicBlock.get()]->getDominants();
-    //     bool found = false;
-    //     // 从前驱结点开始寻找直接支配结点
-    //     std::queue<BasicBlock *> q;
-    //     for (auto pred : basicBlock->getPredecessors()) {
-    //       q.push(pred);
-    //     }
-    //     // BFS遍历前驱结点，直到找到直接支配结点
-    //     while (!found && !q.empty()) {
-    //       auto curr = q.front();
-    //       q.pop();
-    //       if (curr == basicBlock.get()) 
-    //         continue;
-    //       if (dominats.count(curr) != 0U) {
-    //         blockAnalysisInfo[basicBlock.get()]->setIdom(curr);
-    //         blockAnalysisInfo[curr]->addSdoms(basicBlock.get());
-    //         found = true;
-    //       } else {
-    //         for (auto pred : curr->getPredecessors()) {
-    //           q.push(pred);
-    //         }
-    //       }
-    //     }
-    //   }
-    // }
-}
-
-// std::unordered_set<BasicBlock *> ControlFlowAnalysis::computeDomFrontier(BasicBlock *block) {
-//   std::unordered_set<BasicBlock *> ret_list;
-//   // 计算 localDF
-//   for (auto local_successor : block->getSuccessors()) {
-//     if (local_successor->getIdom() != block) {
-//       ret_list.emplace(local_successor);
-//     }
-//   }
-//   // 计算 upDF
-//   for (auto up_successor : block->getSdoms()) {
-//     auto childrenDF = computeDF(up_successor);
-//     for (auto w : childrenDF) {
-//       if (block != w->getIdom() || block == w) {
-//         ret_list.emplace(w);
-//       }
-//     }
-//   }
-
-//   return ret_list;
-// }
-
-void ControlFlowAnalysis::computeDomFrontierAllBlk() {
-  auto &functions = pModule->getFunctions();
-  for (const auto &function : functions) {
-    auto func = function.second.get();
-    auto basicBlocks = func->getBasicBlocks();
-    
-    // 按支配树深度排序（从深到浅）
-    std::vector<BasicBlock *> orderedBlocks;
-    for (auto &bb : basicBlocks) {
-      orderedBlocks.push_back(bb.get());
-    }
-    std::sort(orderedBlocks.begin(), orderedBlocks.end(), 
-      [this](BasicBlock *a, BasicBlock *b) {
-        return blockAnalysisInfo[a]->getDomDepth() > blockAnalysisInfo[b]->getDomDepth();
-      });
-    
-    // 计算支配边界
-    for (auto block : orderedBlocks) {
-      std::unordered_set<BasicBlock *> df;
-      
-      // Local DF: 直接后继中不被当前块支配的
-      for (auto succ : block->getSuccessors()) {
-        // 当前块不支配该后继（即不是其直接支配节点）
-        if (blockAnalysisInfo[succ]->getIdom() != block) {
-          df.insert(succ);
-        }
-      }
-      
-      // Up DF: 从支配子树中继承
-      for (auto child : blockAnalysisInfo[block]->getSdoms()) {
-        for (auto w : blockAnalysisInfo[child]->getDomFrontiers()) {
-          // 如果w不被当前块支配
-          if (block != blockAnalysisInfo[w]->getIdom()) {
-            df.insert(w);
-          }
-        }
-      }
-      
-      blockAnalysisInfo[block]->setDomFrontiers(df);
-    }
-  }
-}
-
-// ==========================
-// dataflow analysis utils
-// ==========================
-
-// 先引用学长的代码
-// TODO: Worklist 增加逆后序遍历机制
-void DataFlowAnalysisUtils::forwardAnalyze(Module *pModule){
-  std::map<DataFlowAnalysis *, bool> workAnalysis;
-  for (auto &dataflow : forwardAnalysisList) {
-    dataflow->init(pModule);
-  }
-
-  for (const auto &function : pModule->getFunctions()) {
-    for (auto &dataflow : forwardAnalysisList) {
-      workAnalysis.emplace(dataflow, false);
-    }
-    while (!workAnalysis.empty()) {
-      for (const auto &block : function.second->getBasicBlocks()) {
-        for (auto &elem : workAnalysis) {
-          if (elem.first->analyze(pModule, block.get())) {
-            elem.second = true;
-          }
-        }
-      }
-      std::map<DataFlowAnalysis *, bool> tmp;
-      std::remove_copy_if(workAnalysis.begin(), workAnalysis.end(), std::inserter(tmp, tmp.end()),
-                          [](const std::pair<DataFlowAnalysis *, bool> &elem) -> bool { return !elem.second; });
-      workAnalysis.swap(tmp);
-
-      for (auto &elem : workAnalysis) {
-        elem.second = false;
-      }
-    }
-  }
-}
-
-void DataFlowAnalysisUtils::backwardAnalyze(Module *pModule) {
-  std::map<DataFlowAnalysis *, bool> workAnalysis;
-  for (auto &dataflow : backwardAnalysisList) {
-    dataflow->init(pModule);
-  }
-
-  for (const auto &function : pModule->getFunctions()) {
-    for (auto &dataflow : backwardAnalysisList) {
-      workAnalysis.emplace(dataflow, false);
-    }
-    while (!workAnalysis.empty()) {
-      for (const auto &block : function.second->getBasicBlocks()) {
-        for (auto &elem : workAnalysis) {
-          if (elem.first->analyze(pModule, block.get())) {
-            elem.second = true;
-          }
-        }
-      }
-      std::map<DataFlowAnalysis *, bool> tmp;
-      std::remove_copy_if(workAnalysis.begin(), workAnalysis.end(), std::inserter(tmp, tmp.end()),
-                          [](const std::pair<DataFlowAnalysis *, bool> &elem) -> bool { return !elem.second; });
-      workAnalysis.swap(tmp);
-
-      for (auto &elem : workAnalysis) {
-        elem.second = false;
-      }
-    }
-  }
-}
-
-
-std::set<User *> ActiveVarAnalysis::getUsedSet(Instruction *inst) {
-  using Kind = Instruction::Kind;
-  std::vector<User *> operands;
-  for (const auto &operand : inst->getOperands()) {
-    operands.emplace_back(dynamic_cast<User *>(operand->getValue()));
-  }
-  std::set<User *> result;
-  switch (inst->getKind()) {
-    // phi op
-    case Kind::kPhi:
-    case Kind::kCall:
-      result.insert(std::next(operands.begin()), operands.end());
-      break;
-    case Kind::kCondBr:
-      result.insert(operands[0]);
-      break;
-    case Kind::kBr:
-    case Kind::kAlloca:
-      break;
-    // mem op
-    case Kind::kStore:
-      // StoreInst 的第一个操作数是被存储的值，第二个操作数是存储的变量
-      // 后续的是可能的数组维度
-      result.insert(operands[0]);
-      result.insert(operands.begin() + 2, operands.end());
-      break;
-    case Kind::kLoad:
-    case Kind::kLa: {
-      auto variable = dynamic_cast<AllocaInst *>(operands[0]);
-      auto global = dynamic_cast<GlobalValue *>(operands[0]);
-      auto constArray = dynamic_cast<ConstantVariable *>(operands[0]);
-      if ((variable != nullptr && variable->getNumDims() == 0) || (global != nullptr && global->getNumDims() == 0) ||
-          (constArray != nullptr && constArray->getNumDims() == 0)) {
-        result.insert(operands[0]);
-      }
-      result.insert(std::next(operands.begin()), operands.end());
-      break;
-    }
-    case Kind::kGetSubArray: {
-      for (unsigned i = 2; i < operands.size(); i++) {
-        // 数组的维度信息
-        result.insert(operands[i]);
-      }
-      break;
-    }
-    case Kind::kMemset: {
-      result.insert(std::next(operands.begin()), operands.end());
-      break;
-    }
-    case Kind::kInvalid:
-    // Binary
-    case Kind::kAdd:
-    case Kind::kSub:
-    case Kind::kMul:
-    case Kind::kDiv:
-    case Kind::kRem:
-    case Kind::kICmpEQ:
-    case Kind::kICmpNE:
-    case Kind::kICmpLT:
-    case Kind::kICmpLE:
-    case Kind::kICmpGT:
-    case Kind::kICmpGE:
-    case Kind::kFAdd:
-    case Kind::kFSub:
-    case Kind::kFMul:
-    case Kind::kFDiv:
-    case Kind::kFCmpEQ:
-    case Kind::kFCmpNE:
-    case Kind::kFCmpLT:
-    case Kind::kFCmpLE:
-    case Kind::kFCmpGT:
-    case Kind::kFCmpGE:
-    case Kind::kAnd:
-    case Kind::kOr:
-    // Unary
-    case Kind::kNeg:
-    case Kind::kNot:
-    case Kind::kFNot:
-    case Kind::kFNeg:
-    case Kind::kFtoI:
-    case Kind::kItoF:
-    // terminator
-    case Kind::kReturn:
-      result.insert(operands.begin(), operands.end());
-      break;
-    default:
-      assert(false);
-      break;
-  }
-  result.erase(nullptr);
-  return result;
-}
-
-User * ActiveVarAnalysis::getDefine(Instruction *inst) {
-  User *result = nullptr;
-  if (inst->isStore()) {
-    StoreInst* store = dynamic_cast<StoreInst *>(inst);
-    auto operand = store->getPointer();
-    AllocaInst* variable = dynamic_cast<AllocaInst *>(operand);
-    GlobalValue* global = dynamic_cast<GlobalValue *>(operand);
-    if ((variable != nullptr && variable->getNumDims() != 0) || (global != nullptr && global->getNumDims() != 0)) {
-      // 如果是数组变量或者全局变量，则不返回定义
-      // TODO：兼容数组变量
-      result = nullptr;
-    } else {
-      result = dynamic_cast<User *>(operand);
-    }
-  } else if (inst->isPhi()) {
-    result = dynamic_cast<User *>(inst->getOperand(0));
-  } else if (inst->isBinary() || inst->isUnary() || inst->isCall() ||
-             inst->isLoad() || inst->isLa()) {
-    result = dynamic_cast<User *>(inst);
-  }
-  return result;
-}
-
-void ActiveVarAnalysis::init(Module *pModule) {
-  for (const auto &function : pModule->getFunctions()) {
-    for (const auto &block : function.second->getBasicBlocks()) {
-      activeTable.emplace(block.get(), std::vector<std::set<User *>>{});
-      for (unsigned i = 0; i < block->getNumInstructions() + 1; i++)
-        activeTable.at(block.get()).emplace_back();
-    }
-  }
-}
-
-// 活跃变量分析公式 每个块内的分析动作供分析器调用
-bool ActiveVarAnalysis::analyze(Module *pModule, BasicBlock *block) {
-  bool changed = false;  // 标记数据流结果是否有变化
-  std::set<User *> activeSet{};  // 当前计算的活跃变量集合
-
-  // 步骤1: 计算基本块出口的活跃变量集 (OUT[B])
-  // 公式: OUT[B] = ∪_{S ∈ succ(B)} IN[S]
-  for (const auto &succ : block->getSuccessors()) {
-    // 获取后继块入口的活跃变量集 (IN[S])
-    auto succActiveSet = activeTable.at(succ).front();
-    // 合并所有后继块的入口活跃变量
-    activeSet.insert(succActiveSet.begin(), succActiveSet.end());
-  }
-
-  // 步骤2: 处理基本块出口处的活跃变量集
-  const auto &instructions = block->getInstructions();
-  const auto numInstructions = instructions.size();
-  
-  // 获取旧的出口活跃变量集 (block出口对应索引numInstructions)
-  const auto &oldEndActiveSet = activeTable.at(block)[numInstructions];
-  
-  // 检查出口活跃变量集是否有变化
-  if (!std::equal(activeSet.begin(), activeSet.end(), 
-                 oldEndActiveSet.begin(), oldEndActiveSet.end())) 
-  {
-    changed = true;  // 标记变化
-    activeTable.at(block)[numInstructions] = activeSet;  // 更新出口活跃变量集
-  }
-
-  // 步骤3: 逆序遍历基本块中的指令
-  // 从最后一条指令开始向前计算每个程序点的活跃变量
-  auto instructionIter = instructions.end();
-  instructionIter--;  // 指向最后一条指令
-  
-  // 从出口向入口遍历 (索引从numInstructions递减到1)
-  for (unsigned i = numInstructions; i > 0; i--) {
-    auto inst = instructionIter->get();  // 当前指令
-    
-    auto used = getUsedSet(inst);
-    User *defined = getDefine(inst);
-    
-    // 步骤3.3: 计算指令入口的活跃变量 (IN[i])
-    // 公式: IN[i] = use_i ∪ (OUT[i] - def_i)
-    activeSet.erase(defined);    // 移除被定义的变量 (OUT[i] - def_i)
-    activeSet.insert(used.begin(), used.end());  // 添加使用的变量
-    
-    // 获取旧的入口活跃变量集 (位置i-1对应当前指令的入口)
-    const auto &oldActiveSet = activeTable.at(block)[i - 1];
-    
-    // 检查活跃变量集是否有变化
-    if (!std::equal(activeSet.begin(), activeSet.end(), 
-                   oldActiveSet.begin(), oldActiveSet.end())) 
-    {
-      changed = true;  // 标记变化
-      activeTable.at(block)[i - 1] = activeSet;  // 更新入口活跃变量集
-    }
-    
-    instructionIter--;  // 移动到前一条指令
-  }
-
-  return changed;  // 返回数据流结果是否变化
-}
-
-
-auto ActiveVarAnalysis::getActiveTable() const -> const std::map<BasicBlock *, std::vector<std::set<User *>>> & {
-  return activeTable;
-}
-
-
-} // namespace sysy
-

src/SysYIRCFGOpt.cpp

@@ -0,0 +1,600 @@
+#include "SysYIRCFGOpt.h"
+#include "SysYIROptUtils.h"
+#include <cassert>
+#include <list>
+#include <map>
+#include <memory>
+#include <string>
+#include <iostream>
+#include <queue> // 引入队列，SysYDelNoPreBLock需要
+
+namespace sysy {
+
+// 定义静态ID
+void *SysYDelInstAfterBrPass::ID = (void *)&SysYDelInstAfterBrPass::ID;
+void *SysYDelEmptyBlockPass::ID = (void *)&SysYDelEmptyBlockPass::ID;
+void *SysYDelNoPreBLockPass::ID = (void *)&SysYDelNoPreBLockPass::ID;
+void *SysYBlockMergePass::ID = (void *)&SysYBlockMergePass::ID;
+void *SysYAddReturnPass::ID = (void *)&SysYAddReturnPass::ID;
+void *SysYCondBr2BrPass::ID = (void *)&SysYCondBr2BrPass::ID;
+
+
+// ======================================================================
+// SysYCFGOptUtils: 辅助工具类，包含实际的CFG优化逻辑
+// ======================================================================
+
+// 删除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()){
+        Branch = true;
+        Branchiter = iter;
+        break;
+      }
+    }
+    if (Branchiter != instructions.end()) ++Branchiter;
+    while (Branchiter != instructions.end()) {
+      changed = true;
+      Branchiter = instructions.erase(Branchiter);
+    }
+    
+    if (Branch) {  // 更新前驱后继关系
+      auto thelastinstinst = basicBlock->getInstructions().end();
+      --thelastinstinst;
+      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));
+        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));
+        basicBlock->addSuccessor(thenBlock);
+        basicBlock->addSuccessor(elseBlock);
+        thenBlock->addPredecessor(basicBlock.get());
+        elseBlock->addPredecessor(basicBlock.get());
+      }
+    }
+  }
+
+  return changed;
+}
+
+// 合并基本块
+bool SysYCFGOptUtils::SysYBlockMerge(Function *func) {
+  bool changed = false;
+
+  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];
+        // auto nextarguments = nextBlock->getArguments();
+        // 删除br指令
+        if (block->getNumInstructions() != 0) {
+          auto thelastinstinst = block->end();
+          (--thelastinstinst);
+          if (thelastinstinst->get()->isUnconditional()) {
+            SysYIROptUtils::usedelete(thelastinstinst->get());
+            thelastinstinst = block->getInstructions().erase(thelastinstinst);
+          } else if (thelastinstinst->get()->isConditional()) {
+            // 如果是条件分支，判断条件是否相同，主要优化相同布尔表达式
+            if (thelastinstinst->get()->getOperand(1)->getName() == thelastinstinst->get()->getOperand(1)->getName()) {
+              SysYIROptUtils::usedelete(thelastinstinst->get());
+              thelastinstinst = block->getInstructions().erase(thelastinstinst); 
+            }
+          }
+        }
+        // 将后继块的指令移动到当前块
+        // 并将后继块的父指针改为当前块
+        for (auto institer = nextBlock->begin(); institer != nextBlock->end();) {
+          institer->get()->setParent(block);
+          block->getInstructions().emplace_back(institer->release());
+          institer = nextBlock->getInstructions().erase(institer);   
+        }
+        // 更新前驱后继关系，类似树节点操作
+        block->removeSuccessor(nextBlock);
+        nextBlock->removePredecessor(block);
+        std::list<BasicBlock *> succshoulddel;
+        for (auto &succ : nextBlock->getSuccessors()) {
+          block->addSuccessor(succ);
+          succ->replacePredecessor(nextBlock, block);
+          succshoulddel.push_back(succ);
+        }
+        for (auto del : succshoulddel) {
+          nextBlock->removeSuccessor(del);
+        }
+
+        func->removeBasicBlock(nextBlock);
+        changed = true;
+
+      } else {
+        blockiter++;
+      }
+    } else {
+      blockiter++;
+    }
+  }
+
+  return changed;
+}
+
+// 删除无前驱块，兼容SSA后的处理
+bool SysYCFGOptUtils::SysYDelNoPreBLock(Function *func) {
+  
+  bool changed = false;
+
+  for (auto &block : func->getBasicBlocks()) {
+    block->setreachableFalse();
+  }
+  // 对函数基本块做一个拓扑排序，排查不可达基本块
+  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);
+      }
+    }
+  }
+
+  // 删除不可达基本块指令
+  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();) {
+        SysYIROptUtils::usedelete(instIter->get());
+        instIter = blockIter->get()->getInstructions().erase(instIter);
+      }
+    }
+  }
+
+  
+  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());
+        }
+      }
+      // 删除不可达基本块，注意迭代器不可达问题
+      func->removeBasicBlock((blockIter++)->get());
+      changed = true;
+    } else {
+      blockIter++;
+    }
+  }
+  
+  return changed;
+}
+
+// 删除空块
+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();
+    }
+  }
+  // 更新基本块信息，增加必要指令
+  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], {});
+      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 {
+          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));
+        SysYIROptUtils::usedelete(thelastinst->get());
+        thelastinst = basicBlock->getInstructions().erase(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;
+          }
+       }
+      }
+
+      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));
+        SysYIROptUtils::usedelete(thelastinst->get());
+        thelastinst = basicBlock->getInstructions().erase(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;
+      }
+
+      for (auto instIter = iter->get()->getInstructions().begin();
+         instIter != iter->get()->getInstructions().end();) {
+        SysYIROptUtils::usedelete(instIter->get()); // 仅删除 use 关系
+        // 显式地从基本块中删除指令并更新迭代器
+        instIter = iter->get()->getInstructions().erase(instIter);
+      }
+      // 删除不可达基本块的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());
+          } else {
+            // Phi 指令通常在基本块的开头，如果不是 Phi 指令就停止检查
+            break;
+          }
+        }
+      }
+
+      func->removeBasicBlock((iter++)->get());
+      changed = true;
+    } else {
+      ++iter;
+    }
+  }
+  
+  return changed;
+}
+
+// 如果函数没有返回指令，则添加一个默认返回指令(主要解决void函数没有返回指令的问题)
+bool SysYCFGOptUtils::SysYAddReturn(Function *func, IRBuilder* pBuilder) {
+  bool changed = false;
+  auto basicBlocks = func->getBasicBlocks();
+  for (auto &block : basicBlocks) {
+    if (block->getNumSuccessors() == 0) {
+      // 如果基本块没有后继块，则添加一个返回指令
+      if (block->getNumInstructions() == 0) {
+        pBuilder->setPosition(block.get(), block->end());
+        pBuilder->createReturnInst();
+        changed = true; // 标记IR被修改
+      } else {
+        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;
+
+          pBuilder->setPosition(block.get(), block->end());
+          // TODO: 如果int float函数缺少返回值是否需要报错
+          if (func->getReturnType()->isInt()) {
+            pBuilder->createReturnInst(ConstantInteger::get(0));
+          } else if (func->getReturnType()->isFloat()) {
+            pBuilder->createReturnInst(ConstantFloating::get(0.0F));
+          } else {
+            pBuilder->createReturnInst();
+          }
+          changed = true; // 标记IR被修改
+        }
+      }
+    }
+  }
+  
+  return changed;
+}
+
+// 条件分支转换为无条件分支
+// 主要针对已知条件值的分支转换为无条件分支
+// 例如 if (cond) { ... } else { ... } 中的 cond 已经
+// 确定为 true 或 false 的情况
+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));
+      std::string opname;
+      int constint = 0;
+      float constfloat = 0.0F;
+      bool constint_Use = false;
+      bool constfloat_Use = false;
+      if (constOperand != nullptr) {
+        if (constOperand->isFloat()) {
+          constfloat = constOperand->getFloat();
+          constfloat_Use = true;
+        } else {
+          constint = constOperand->getInt();
+          constint_Use = true;
+        }
+      }
+      // 如果可以计算
+      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));
+        SysYIROptUtils::usedelete(thelast->get());
+        thelast = basicblock->getInstructions().erase(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());
+          }
+          
+        } else { // cond为false或0
+
+          pBuilder->setPosition(basicblock.get(), basicblock->end());
+          pBuilder->createUncondBrInst(elseBlock, {});
+
+          // 更新CFG关系
+          basicblock->removeSuccessor(thenBlock);
+          thenBlock->removePredecessor(basicblock.get());
+
+          // 删除thenBlock的phi指令中对应的basicblock.get()的传入值
+          for (auto &phiinst : thenBlock->getInstructions()) {
+            if (phiinst->getKind() != Instruction::kPhi) {
+              break;
+            }
+            // 使用 delBlk 方法删除 basicblock.get() 对应的传入值
+            dynamic_cast<PhiInst *>(phiinst.get())->delBlk(basicblock.get());
+          }
+
+        }
+      }
+    }
+  }
+
+  return changed;
+}
+
+// ======================================================================
+// 独立的CFG优化遍的实现
+// ======================================================================
+
+bool SysYDelInstAfterBrPass::runOnFunction(Function *F, AnalysisManager& AM) {
+  return SysYCFGOptUtils::SysYDelInstAfterBr(F);
+}
+
+bool SysYDelEmptyBlockPass::runOnFunction(Function *F, AnalysisManager& AM) {
+  return SysYCFGOptUtils::SysYDelEmptyBlock(F, pBuilder);
+}
+
+bool SysYDelNoPreBLockPass::runOnFunction(Function *F, AnalysisManager& AM) {
+  return SysYCFGOptUtils::SysYDelNoPreBLock(F);
+}
+
+bool SysYBlockMergePass::runOnFunction(Function *F, AnalysisManager& AM) {
+  return SysYCFGOptUtils::SysYBlockMerge(F);
+}
+
+bool SysYAddReturnPass::runOnFunction(Function *F, AnalysisManager& AM) {
+  return SysYCFGOptUtils::SysYAddReturn(F, pBuilder);
+}
+
+bool SysYCondBr2BrPass::runOnFunction(Function *F, AnalysisManager& AM) {
+  return SysYCFGOptUtils::SysYCondBr2Br(F, pBuilder);
+}
+
+}  // namespace sysy

src/SysYIRGenerator.cpp

@@ -15,6 +15,46 @@
 using namespace std;
 namespace sysy {
 
+
+Type* SysYIRGenerator::buildArrayType(Type* baseType, const std::vector<Value*>& dims){
+  Type* currentType = baseType;
+    // 从最内层维度开始构建 ArrayType
+    // 例如对于 int arr[2][3]，先处理 [3]，再处理 [2]
+    // 注意：SysY 的 dims 是从最外层到最内层，所以我们需要反向迭代
+    // 或者调整逻辑，使得从内到外构建 ArrayType
+    // 假设 dims 列表是 [dim1, dim2, dim3...] (例如 [2, 3] for int[2][3])
+    // 我们需要从最内层维度开始向外构建 ArrayType
+    for (int i = dims.size() - 1; i >= 0; --i) {
+        // 维度大小必须是常量，否则无法构建 ArrayType
+        ConstantInteger* constDim = dynamic_cast<ConstantInteger*>(dims[i]);
+        if (constDim == nullptr) {
+            // 如果维度不是常量，可能需要特殊处理，例如将其视为指针
+            // 对于函数参数 int arr[] 这种，第一个维度可以为未知
+            // 在这里，我们假设所有声明的数组维度都是常量
+            assert(false && "Array dimension must be a constant integer!");
+            return nullptr;
+        }
+        unsigned dimSize = constDim->getInt();
+        currentType = Type::getArrayType(currentType, dimSize);
+    }
+    return currentType;
+}
+
+// @brief: 获取 GEP 指令的地址
+// @param basePointer: GEP 的基指针，已经过适当的加载/处理，类型为 LLVM IR 中的指针类型。
+//                     例如，对于局部数组，它是 AllocaInst；对于参数数组，它是 LoadInst 的结果。
+// @param indices: 已经包含了所有必要的偏移索引 (包括可能的初始 0 索引，由 visitLValue 准备)。
+// @return: 计算得到的地址值 (也是一个指针类型)
+Value* SysYIRGenerator::getGEPAddressInst(Value* basePointer, const std::vector<Value*>& indices) {
+    // 检查 basePointer 是否为指针类型
+    assert(basePointer->getType()->isPointer() && "Base pointer must be a pointer type!");
+
+    // `indices` 向量现在由调用方（如 visitLValue, visitVarDecl, visitAssignStmt）负责完整准备，
+    // 包括是否需要添加初始的 `0` 索引。
+    // 所以这里直接将其传递给 `builder.createGetElementPtrInst`。
+    return builder.createGetElementPtrInst(basePointer, indices);
+}
+
 /*
  * @brief: visit compUnit
  * @details:
@@ -79,7 +119,11 @@ std::any SysYIRGenerator::visitGlobalVarDecl(SysYParser::GlobalVarDeclContext *c
       delete root;
     }
     // 创建全局变量，并更新符号表
-    module->createGlobalValue(name, Type::getPointerType(type), dims, values);
+    Type* variableType = type;
+    if (!dims.empty()) { // 如果有维度，说明是数组
+        variableType = buildArrayType(type, dims); // 构建完整的 ArrayType
+    }
+    module->createGlobalValue(name, Type::getPointerType(variableType), dims, values);
   }
   return std::any();
 }
@@ -118,24 +162,28 @@ std::any SysYIRGenerator::visitVarDecl(SysYParser::VarDeclContext *ctx) {
       }
     }
 
+    Type* variableType = type;
+    if (!dims.empty()) { // 如果有维度，说明是数组
+        variableType = buildArrayType(type, dims); // 构建完整的 ArrayType
+    }
+
+    // 对于数组，alloca 的类型将是指针指向数组类型，例如 `int[2][3]*`
+    // 对于标量，alloca 的类型将是指针指向标量类型，例如 `int*`
     AllocaInst* alloca =
-        builder.createAllocaInst(Type::getPointerType(type), dims, name);
+        builder.createAllocaInst(Type::getPointerType(variableType), {}, name);
 
     if (varDef->initVal() != nullptr) {
       ValueCounter values;
-      // 这里的varDef->initVal()可能是ScalarInitValue或ArrayInitValue
       ArrayValueTree* root = std::any_cast<ArrayValueTree *>(varDef->initVal()->accept(this));
       Utils::tree2Array(type, root, dims, dims.size(), values, &builder);
       delete root;
-      if (dims.empty()) {
-        builder.createStoreInst(values.getValue(0), alloca);
-      } else{ 
-        // **数组变量初始化**
-        const std::vector<sysy::Value *> &counterValues = values.getValues();
 
-        // 计算数组的**总元素数量**和**总字节大小**
+      if (dims.empty()) { // 标量变量初始化
+        builder.createStoreInst(values.getValue(0), alloca);
+      } else { // 数组变量初始化
+        const std::vector<sysy::Value *> &counterValues = values.getValues();
+        const std::vector<unsigned> &counterNumbers = values.getNumbers();
         int numElements = 1;
-        // 存储每个维度的实际整数大小，用于索引计算
         std::vector<int> dimSizes;
         for (Value *dimVal : dims) {
           if (ConstantInteger *constInt = dynamic_cast<ConstantInteger *>(dimVal)) {
@@ -145,12 +193,11 @@ std::any SysYIRGenerator::visitVarDecl(SysYParser::VarDeclContext *ctx) {
           }
           // TODO else 错误处理：数组维度必须是常量（对于静态分配）
         }
-        unsigned int elementSizeInBytes = type->getSize(); // 获取单个元素的大小（字节）
+        unsigned int elementSizeInBytes = type->getSize();
         unsigned int totalSizeInBytes = numElements * elementSizeInBytes;
 
-        // **判断是否可以进行全零初始化优化**
         bool allValuesAreZero = false;
-        if (counterValues.empty()) { // 例如 int arr[3] = {}; 或 int arr[3][4] = {};
+        if (counterValues.empty()) {
           allValuesAreZero = true;
         }
         else {
@@ -163,7 +210,6 @@ std::any SysYIRGenerator::visitVarDecl(SysYParser::VarDeclContext *ctx) {
               }
             }
             else{
-              // 如果值不是常量，我们通常不能确定它是否为零，所以不进行 memset 优化
               allValuesAreZero = false;
               break;
             }
@@ -171,64 +217,67 @@ std::any SysYIRGenerator::visitVarDecl(SysYParser::VarDeclContext *ctx) {
         }
 
         if (allValuesAreZero) {
-          // 如果所有初始化值都是零（或没有明确初始化但语法允许），使用 memset 优化
           builder.createMemsetInst(
-              alloca,                   // 目标数组的起始地址
-              ConstantInteger::get(0),  // 偏移量（通常为0），后续删除
+              alloca,
+              ConstantInteger::get(0),
               ConstantInteger::get(totalSizeInBytes),
-              ConstantInteger::get(0)); // 填充的总字节数
+              ConstantInteger::get(0));
         }
         else {
-          // **逐元素存储：遍历所有初始值，并为每个值生成一个 store 指令**
-          for (size_t k = 0; k < counterValues.size(); ++k) {
-            // 用于存储当前元素的索引列表
-            std::vector<Value *> currentIndices;
-            int tempLinearIndex = k; // 临时线性索引，用于计算多维索引
+          
+          int linearIndexOffset = 0; // 用于追踪当前处理的线性索引的偏移量
+          for (int k = 0; k < counterValues.size(); ++k) {
+              // 当前 Value 的值和重复次数
+              Value* currentValue = counterValues[k];
+              unsigned currentRepeatNum = counterNumbers[k];
 
-            // **将线性索引转换为多维索引**
-            // 这个循环从最内层维度开始倒推，计算每个维度的索引
-            // 假设是行主序（row-major order），这是 C/C++ 数组的标准存储方式
-            for (int dimIdx = dimSizes.size() - 1; dimIdx >= 0; --dimIdx)
-            {
-              // 计算当前维度的索引，并插入到列表的最前面
-              currentIndices.insert(currentIndices.begin(),
-                                    ConstantInteger::get(static_cast<int>(tempLinearIndex % dimSizes[dimIdx])));
-              // 更新线性索引，用于计算下一个更高维度的索引
-              tempLinearIndex /= dimSizes[dimIdx];
-            }
+              for (unsigned i = 0; i < currentRepeatNum; ++i) {
+                  std::vector<Value *> currentIndices;
+                  int tempLinearIndex = linearIndexOffset + i; // 使用偏移量和当前重复次数内的索引
 
-            // **生成 store 指令，传入值、基指针和计算出的索引列表**
-            // 你的 builder.createStoreInst 签名需要能够接受这些参数
-            // 假设你的 builder.createStoreInst(Value *val, Value *ptr, const std::vector<Value *> &indices, ...)
-            builder.createStoreInst(counterValues[k], alloca, currentIndices);
+                  // 将线性索引转换为多维索引
+                  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;
           }
+
         }
       }
     }
-    else
-    { // **如果没有显式初始化值，默认对数组进行零初始化**
-      if (!dims.empty())
-      { // 只有数组才需要默认的零初始化
+    else { // 如果没有显式初始化值，默认对数组进行零初始化
+      if (!dims.empty()) { // 只有数组才需要默认的零初始化
         int numElements = 1;
-        for (Value *dimVal : dims)
-        {
-          if (ConstantInteger *constInt = dynamic_cast<ConstantInteger *>(dimVal))
-          {
+        for (Value *dimVal : dims) {
+          if (ConstantInteger *constInt = dynamic_cast<ConstantInteger *>(dimVal)) {
             numElements *= constInt->getInt();
           }
         }
         unsigned int elementSizeInBytes = type->getSize();
         unsigned int totalSizeInBytes = numElements * elementSizeInBytes;
 
-        // 使用 memset 将整个数组清零
         builder.createMemsetInst(
             alloca,
             ConstantInteger::get(0),
             ConstantInteger::get(totalSizeInBytes),
             ConstantInteger::get(0)
-          ); // 填充的总字节数
+          );
       }
-      // 标量变量如果没有初始化值，通常不生成额外的初始化指令，因为其内存已分配但未赋值。
     }
 
     module->addVariable(name, alloca);
@@ -284,58 +333,119 @@ std::any SysYIRGenerator::visitFuncType(SysYParser::FuncTypeContext *ctx) {
 std::any SysYIRGenerator::visitFuncDef(SysYParser::FuncDefContext *ctx){
   // 更新作用域
   module->enterNewScope();
-  HasReturnInst = false;
 
   auto name = ctx->Ident()->getText();
-  std::vector<Type *> paramTypes;
+  std::vector<Type *> paramActualTypes;
   std::vector<std::string> paramNames;
   std::vector<std::vector<Value *>> paramDims;
 
   if (ctx->funcFParams() != nullptr) {
     auto params = ctx->funcFParams()->funcFParam();
     for (const auto &param : params) {
-      paramTypes.push_back(std::any_cast<Type *>(visitBType(param->bType())));
-      paramNames.push_back(param->Ident()->getText());
-      std::vector<Value *> dims = {};
-      if (!param->LBRACK().empty()) {
-        dims.push_back(ConstantInteger::get(-1)); // 第一个维度不确定
+      Type* baseBType = std::any_cast<Type *>(visitBType(param->bType()));
+      std::string paramName = param->Ident()->getText();
+      
+      // 用于收集当前参数的维度信息（如果它是数组）
+      std::vector<Value *> currentParamDims; 
+      if (!param->LBRACK().empty()) { // 如果参数声明中有方括号，说明是数组
+        // SysY 数组参数的第一个维度可以是未知的（例如 int arr[] 或 int arr[][10]）
+        // 这里的 ConstantInteger::get(-1) 表示未知维度，但对于 LLVM 类型构建，我们主要关注已知维度
+        currentParamDims.push_back(ConstantInteger::get(-1)); // 标记第一个维度为未知
         for (const auto &exp : param->exp()) {
-          dims.push_back(std::any_cast<Value *>(visitExp(exp)));
+          // 访问表达式以获取维度大小，这些维度必须是常量
+          Value* dimVal = std::any_cast<Value *>(visitExp(exp));
+          // 确保维度是常量整数，否则 buildArrayType 会断言失败
+          assert(dynamic_cast<ConstantInteger*>(dimVal) && "Array dimension in parameter must be a constant integer!");
+          currentParamDims.push_back(dimVal);
         }
       }
-      paramDims.emplace_back(dims);
+
+      // 根据解析出的信息，确定参数在 LLVM IR 中的实际类型
+      Type* actualParamType;
+      if (currentParamDims.empty()) { // 情况1：标量参数 (e.g., int x)
+        actualParamType = baseBType; // 实际类型就是基本类型
+      } else { // 情况2&3：数组参数 (e.g., int arr[] 或 int arr[][10])
+        // 数组参数在函数传递时会退化为指针。
+        // 这个指针指向的类型是除第一维外，由后续维度构成的数组类型。
+        
+        // 从 currentParamDims 中移除第一个标记未知维度的 -1
+        std::vector<Value*> fixedDimsForTypeBuilding;
+        if (currentParamDims.size() > 1) { // 如果有固定维度 (e.g., int arr[][10])
+            // 复制除第一个 -1 之外的所有维度
+            fixedDimsForTypeBuilding.assign(currentParamDims.begin() + 1, currentParamDims.end());
+        }
+        
+        Type* pointedToArrayType = baseBType; // 从基本类型开始构建
+        // 从最内层维度向外层构建数组类型
+        // buildArrayType 期望 dims 是从最外层到最内层，但它内部反向迭代，所以这里直接传入
+        // 例如，对于 int arr[][10]，fixedDimsForTypeBuilding 包含 [10]，构建出 [10 x i32]
+        if (!fixedDimsForTypeBuilding.empty()) {
+          pointedToArrayType = buildArrayType(baseBType, fixedDimsForTypeBuilding);
+        }
+        
+        // 实际参数类型是指向这个构建好的数组类型的指针
+        actualParamType = Type::getPointerType(pointedToArrayType); // e.g., i32* 或 [10 x i32]*
+      }
+      
+      paramActualTypes.push_back(actualParamType); // 存储参数的实际 LLVM IR 类型
+      paramNames.push_back(paramName); // 存储参数名称
+    
     }
   }
 
   Type* returnType = std::any_cast<Type *>(visitFuncType(ctx->funcType()));
-  Type* funcType = Type::getFunctionType(returnType, paramTypes);
+  Type* funcType = Type::getFunctionType(returnType, paramActualTypes);
   Function* function = module->createFunction(name, funcType);
   BasicBlock* entry = function->getEntryBlock();
   builder.setPosition(entry, entry->end());
 
-  for (size_t i = 0; i < paramTypes.size(); ++i) {
-    AllocaInst* alloca = builder.createAllocaInst(Type::getPointerType(paramTypes[i]),
-                                           paramDims[i], paramNames[i]);
-    entry->insertArgument(alloca);
+  for(int i = 0; i < paramActualTypes.size(); ++i) {
+    Argument* arg = new Argument(paramActualTypes[i], function, i, paramNames[i]);
+    function->insertArgument(arg);
+
+  }
+
+  auto funcArgs = function->getArguments();
+  std::vector<AllocaInst *> allocas;
+  for (int i = 0; i < paramActualTypes.size(); ++i) {
+    AllocaInst *alloca = builder.createAllocaInst(Type::getPointerType(paramActualTypes[i]), {}, paramNames[i]);
+    allocas.push_back(alloca);
     module->addVariable(paramNames[i], alloca);
   }
 
+  for(int i = 0; i < paramActualTypes.size(); ++i) {
+    Value *argValue = funcArgs[i];
+    builder.createStoreInst(argValue, allocas[i]);
+  }
+
+  // 在处理函数体之前，创建一个新的基本块作为函数体的实际入口
+  // 这样 entryBB 就可以在完成初始化后跳转到这里
+  BasicBlock* funcBodyEntry = function->addBasicBlock("funcBodyEntry_" + name);
+  
+  // 从 entryBB 无条件跳转到 funcBodyEntry
+  builder.createUncondBrInst(funcBodyEntry, {});
+  builder.setPosition(funcBodyEntry,funcBodyEntry->end()); // 将插入点设置到 funcBodyEntry
+
   for (auto item : ctx->blockStmt()->blockItem()) {
     visitBlockItem(item);
   }
 
-  if(HasReturnInst == false) {
-    // 如果没有return语句，则默认返回0
-    if (returnType != Type::getVoidType()) {
-      Value* returnValue = ConstantInteger::get(0);
-      if (returnType == Type::getFloatType()) {
-        returnValue = ConstantFloating::get(0.0f);
-      }
-      builder.createReturnInst(returnValue);
+  // 如果函数没有显式的返回语句，且返回类型不是 void，则需要添加一个默认的返回值
+  ReturnInst* retinst = nullptr;
+  retinst = dynamic_cast<ReturnInst*>(builder.getBasicBlock()->terminator()->get());
+
+  if (!retinst) {
+    if (returnType->isVoid()) {
+        builder.createReturnInst();
+    } else if (returnType->isInt()) {
+        builder.createReturnInst(ConstantInteger::get(0)); // 默认返回 0
+    } else if (returnType->isFloat()) {
+        builder.createReturnInst(ConstantFloating::get(0.0f)); // 默认返回 0.0f
     } else {
-      builder.createReturnInst();
+        assert(false && "Function with no explicit return and non-void type should return a value.");
     }
   }
+
   module->leaveScope();
 
   return std::any();
@@ -352,33 +462,79 @@ std::any SysYIRGenerator::visitBlockStmt(SysYParser::BlockStmtContext *ctx) {
 std::any SysYIRGenerator::visitAssignStmt(SysYParser::AssignStmtContext *ctx) {
   auto lVal = ctx->lValue();
   std::string name = lVal->Ident()->getText();
-  std::vector<Value *> dims;
-  for (const auto &exp : lVal->exp()) {
-    dims.push_back(std::any_cast<Value *>(visitExp(exp)));
+  Value* LValue = nullptr;
+  Value* variable = module->getVariable(name); // 左值
+
+  vector<Value *> indices;
+  if (lVal->exp().size() > 0) {
+    // 如果有下标，访问表达式获取下标值
+    for (const auto &exp : lVal->exp()) {
+      Value* indexValue = std::any_cast<Value *>(visitExp(exp));
+      indices.push_back(indexValue);
+    }
+  }
+  if (indices.empty()) {
+    // variable 本身就是指向标量的指针 (e.g., int* %a)
+    if (dynamic_cast<AllocaInst*>(variable) || dynamic_cast<GlobalValue*>(variable)) {
+        LValue = variable;
+    }
+  }
+  else {
+    // 对于数组或多维数组的左值处理
+    // 需要获取 GEP 地址
+    Value* gepBasePointer = nullptr;
+    std::vector<Value*> gepIndices; 
+    if (AllocaInst *alloc = dynamic_cast<AllocaInst *>(variable)) {
+      Type* allocatedType = alloc->getType()->as<PointerType>()->getBaseType(); 
+      if (allocatedType->isPointer()) {
+        gepBasePointer = builder.createLoadInst(alloc); 
+        gepIndices = indices; 
+      } else {
+        gepBasePointer = alloc;
+        gepIndices.push_back(ConstantInteger::get(0));
+        gepIndices.insert(gepIndices.end(), indices.begin(), indices.end());
+      }
+    } else if (GlobalValue *glob = dynamic_cast<GlobalValue *>(variable)) {
+      // 情况 B: 全局变量 (GlobalValue)
+      gepBasePointer = glob; 
+      gepIndices.push_back(ConstantInteger::get(0));
+      gepIndices.insert(gepIndices.end(), indices.begin(), indices.end());
+    } else if (ConstantVariable *constV = dynamic_cast<ConstantVariable *>(variable)) {
+      gepBasePointer = constV;
+      gepIndices.push_back(ConstantInteger::get(0));
+      gepIndices.insert(gepIndices.end(), indices.begin(), indices.end());
+    } 
+    // 左值为地址
+    LValue = getGEPAddressInst(gepBasePointer, gepIndices);
   }
 
-  auto variable = module->getVariable(name);
-  Value* value = std::any_cast<Value *>(visitExp(ctx->exp()));
-  Type* variableType = dynamic_cast<PointerType *>(variable->getType())->getBaseType();
+  Value* RValue = std::any_cast<Value *>(visitExp(ctx->exp())); // 右值
 
-  // 左值右值类型不同处理
-  if (variableType != value->getType()) {
-    ConstantValue * constValue = dynamic_cast<ConstantValue *>(value);
+  // 先推断 LValue 的类型
+  // 如果 LValue 是指向数组的指针，则需要根据 indices 获取正确的类型
+  // 如果 LValue 是标量，则直接使用其类型
+  // 注意：LValue 的类型可能是指向数组的指针 (e.g., int(*)[3]) 或者指向标量的指针 (e.g., int*) 也能推断
+  Type* LType = builder.getIndexedType(variable->getType(), indices);
+  Type* RType = RValue->getType();
+
+  if (LType != RType) {
+    ConstantValue * constValue = dynamic_cast<ConstantValue *>(RValue);
     if (constValue != nullptr) {
-      if (variableType == Type::getFloatType()) {
-        value = ConstantInteger::get(static_cast<float>(constValue->getInt()));
-      } else {
-        value = ConstantFloating::get(static_cast<int>(constValue->getFloat()));
+      if (LType == Type::getFloatType()) {
+        RValue = ConstantFloating::get(static_cast<float>(constValue->getFloat()));
+      } else { // 假设如果不是浮点型，就是整型
+        RValue = ConstantInteger::get(static_cast<int>(constValue->getInt()));
       }
     } else {
-      if (variableType == Type::getFloatType()) {
-        value = builder.createIToFInst(value);
-      } else {
-        value = builder.createFtoIInst(value);
+      if (LType == Type::getFloatType()) {
+        RValue = builder.createIToFInst(RValue);
+      } else { // 假设如果不是浮点型，就是整型
+        RValue = builder.createFtoIInst(RValue);
       }
     }
   }
-  builder.createStoreInst(value, variable, dims, variable->getName());
+
+  builder.createStoreInst(RValue, LValue);
 
   return std::any();
 }
@@ -466,6 +622,7 @@ std::any SysYIRGenerator::visitIfStmt(SysYParser::IfStmtContext *ctx) {
       ctx->stmt(0)->accept(this);
       module->leaveScope();
     }
+    builder.createUncondBrInst(exitBlock, {});
     BasicBlock::conectBlocks(builder.getBasicBlock(), exitBlock);
 
     labelstring << "if_exit.L" << builder.getLabelIndex();
@@ -487,6 +644,7 @@ std::any SysYIRGenerator::visitWhileStmt(SysYParser::WhileStmtContext *ctx) {
   labelstring << "while_head.L" << builder.getLabelIndex();
   BasicBlock *headBlock = function->addBasicBlock(labelstring.str());
   labelstring.str("");
+  builder.createUncondBrInst(headBlock, {});
   BasicBlock::conectBlocks(curBlock, headBlock);
   builder.setPosition(headBlock, headBlock->end());
 
@@ -571,56 +729,141 @@ std::any SysYIRGenerator::visitReturnStmt(SysYParser::ReturnStmtContext *ctx) {
       }
     }
   builder.createReturnInst(returnValue);
-  HasReturnInst = true;
+
   return std::any();
 }
 
 
+// 辅助函数：计算给定类型中嵌套的数组维度数量
+// 例如：
+// - 对于 i32* 类型，它指向 i32，维度为 0。
+// - 对于 [10 x i32]* 类型，它指向 [10 x i32]，维度为 1。
+// - 对于 [20 x [10 x i32]]* 类型，它指向 [20 x [10 x i32]]，维度为 2。
+unsigned SysYIRGenerator::countArrayDimensions(Type* type) {
+    unsigned dims = 0;
+    Type* currentType = type;
+
+    // 如果是指针类型，先获取它指向的基础类型
+    if (currentType->isPointer()) {
+        currentType = currentType->as<PointerType>()->getBaseType();
+    }
+
+    // 递归地计算数组的维度层数
+    while (currentType && currentType->isArray()) {
+        dims++;
+        currentType = currentType->as<ArrayType>()->getElementType();
+    }
+    return dims;
+}
+
 std::any SysYIRGenerator::visitLValue(SysYParser::LValueContext *ctx) {
   std::string name = ctx->Ident()->getText();
-  User* variable = module->getVariable(name);
+  Value* variable = module->getVariable(name);
 
   Value* value = nullptr;
+
   std::vector<Value *> dims;
   for (const auto &exp : ctx->exp()) {
     dims.push_back(std::any_cast<Value *>(visitExp(exp)));
   }
 
-  if (variable == nullptr) {
-    throw std::runtime_error("Variable " + name + " not found.");
-  }
-  
-  bool indicesConstant = true;
-  for (const auto &dim : dims) {
-    if (dynamic_cast<ConstantValue *>(dim) == nullptr) {
-      indicesConstant = false;
-      break;
-    }
-  }
+  // 1. 获取变量的声明维度数量
+  unsigned declaredNumDims = countArrayDimensions(variable->getType());
 
+  // 2. 处理常量变量 (ConstantVariable) 且所有索引都是常量的情况
   ConstantVariable* constVar = dynamic_cast<ConstantVariable *>(variable);
-  GlobalValue* globalVar = dynamic_cast<GlobalValue *>(variable);
-  AllocaInst* localVar = dynamic_cast<AllocaInst *>(variable);
-  if (constVar != nullptr && indicesConstant) {
-    // 如果是常量变量，且索引是常量，则直接获取子数组
-    value = constVar->getByIndices(dims);
-  } else if (module->isInGlobalArea() && (globalVar != nullptr)) {
-    assert(indicesConstant);
-    value = globalVar->getByIndices(dims);
-  } else {
-    if ((globalVar != nullptr && globalVar->getNumDims() > dims.size()) ||
-        (localVar != nullptr && localVar->getNumDims() > dims.size()) ||
-        (constVar != nullptr && constVar->getNumDims() > dims.size())) {
-      // value = builder.createLaInst(variable, indices);
-      // 如果变量是全局变量或局部变量，且索引数量小于维度数量，则创建createGetSubArray获取子数组
-      auto getArrayInst =
-          builder.createGetSubArray(dynamic_cast<LVal *>(variable), dims);
-      value = getArrayInst->getChildArray();
-    } else {
-      value = builder.createLoadInst(variable, dims);
+  if (constVar != nullptr) {
+    bool allIndicesConstant = true;
+    for (const auto &dim : dims) {
+      if (dynamic_cast<ConstantValue *>(dim) == nullptr) {
+        allIndicesConstant = false;
+        break;
+      }
+    }
+    if (allIndicesConstant) {
+      // 如果是常量变量且所有索引都是常量，直接通过 getByIndices 获取编译时值
+      // 这个方法会根据索引深度返回最终的标量值或指向子数组的指针 (作为 ConstantValue/Variable)
+      return constVar->getByIndices(dims);
     }
   }
 
+  // 3. 处理可变变量 (AllocaInst/GlobalValue) 或带非常量索引的常量变量
+  // 这里区分标量访问和数组元素/子数组访问
+
+  // 检查是否是访问标量变量本身（没有索引，且声明维度为0）
+  if (dims.empty() && declaredNumDims == 0) {
+    // 对于标量变量，直接加载其值。
+    // variable 本身就是指向标量的指针 (e.g., int* %a)
+    if (dynamic_cast<AllocaInst*>(variable) || dynamic_cast<GlobalValue*>(variable)) {
+        value = builder.createLoadInst(variable);
+    } else {
+        // 如果走到这里且不是AllocaInst/GlobalValue，但dims为空且declaredNumDims为0，
+        // 且又不是ConstantVariable (前面已处理)，则可能是错误情况。
+        assert(false && "Unhandled scalar variable type in LValue access.");
+        return static_cast<Value*>(nullptr);
+    }
+  } else {
+    // 访问数组元素或子数组（有索引，或变量本身是数组/多维指针）
+    Value* gepBasePointer = nullptr;
+    std::vector<Value*> gepIndices; // 准备传递给 getGEPAddressInst 的索引列表
+    // GEP 的基指针就是变量本身（它是一个指向内存的指针）
+    if (AllocaInst *alloc = dynamic_cast<AllocaInst *>(variable)) {
+      // 情况 A: 局部变量 (AllocaInst)
+      // 获取 AllocaInst 分配的内存的实际类型。
+      // 例如：对于 `int b[10][20];`，`allocatedType` 是 `[10 x [20 x i32]]`。
+      // 对于 `int b[][20]` 的函数参数，其 AllocaInst 存储的是一个指针，
+      // 此时 `allocatedType` 是 `[20 x i32]*`。
+      Type* allocatedType = alloc->getType()->as<PointerType>()->getBaseType(); 
+
+      if (allocatedType->isPointer()) {
+        // 如果 AllocaInst 分配的是一个指针类型 (例如，用于存储函数参数的指针，如 int b[][20] 中的 b)
+        // 即 `allocatedType` 是一个指向数组指针的指针 (e.g., [20 x i32]**)
+        // 那么 GEP 的基指针是加载这个指针变量的值。
+        gepBasePointer = builder.createLoadInst(alloc); // 加载出实际的指针值 (e.g., [20 x i32]*)
+        // 对于这种参数指针，用户提供的索引直接作用于它。不需要额外的 0。
+        gepIndices = dims; 
+      } else {
+        // 如果 AllocaInst 分配的是实际的数组数据 (例如，int b[10][20] 中的 b)
+        // 那么 AllocaInst 本身就是 GEP 的基指针。
+        // 这里的 `alloc` 是指向数组的指针 (e.g., [10 x [20 x i32]]*)
+        gepBasePointer = alloc; // 类型是 [10 x [20 x i32]]*
+        // 对于这种完整的数组分配，GEP 的第一个索引必须是 0，用于“步过”整个数组。
+        gepIndices.push_back(ConstantInteger::get(0));
+        gepIndices.insert(gepIndices.end(), dims.begin(), dims.end());
+      }
+    } else if (GlobalValue *glob = dynamic_cast<GlobalValue *>(variable)) {
+      // 情况 B: 全局变量 (GlobalValue)
+      // GlobalValue 总是指向全局数据的指针。
+      gepBasePointer = glob; // 类型是 [61 x [67 x i32]]*
+      // 对于全局数组，GEP 的第一个索引必须是 0，用于“步过”整个数组。
+      gepIndices.push_back(ConstantInteger::get(0));
+      gepIndices.insert(gepIndices.end(), dims.begin(), dims.end());
+    } else if (ConstantVariable *constV = dynamic_cast<ConstantVariable *>(variable)) {
+      // 情况 C: 常量变量 (ConstantVariable)，如果它代表全局数组常量
+      // 假设 ConstantVariable 可以直接作为 GEP 的基指针。
+      gepBasePointer = constV;
+      // 对于常量数组，也需要 0 索引来“步过”整个数组。
+      // 这里可以进一步检查 constV->getType()->as<PointerType>()->getBaseType()->isArray()
+      // 但为了简洁，假设所有 ConstantVariable 作为 GEP 基指针时都需要此 0。
+      gepIndices.push_back(ConstantInteger::get(0));
+      gepIndices.insert(gepIndices.end(), dims.begin(), dims.end());
+    } else {
+      assert(false && "LValue variable type not supported for GEP base pointer.");
+      return static_cast<Value *>(nullptr);
+    }
+
+    // 现在调用 getGEPAddressInst，传入正确准备的基指针和索引列表
+    Value *targetAddress = getGEPAddressInst(gepBasePointer, gepIndices);
+
+    // 如果提供的索引数量少于声明的维度数量，则表示访问的是子数组，返回其地址
+    if (dims.size() < declaredNumDims) {
+        value = targetAddress;
+    } else {
+        // 否则，表示访问的是最终的标量元素，加载其值
+        // 假设 createLoadInst 接受 Value* pointer
+        value = builder.createLoadInst(targetAddress);
+    }
+  }
   return value;
 }
 
@@ -662,32 +905,63 @@ std::any SysYIRGenerator::visitCall(SysYParser::CallContext *ctx) {
 
   std::vector<Value *> args = {};
   if (funcName == "starttime" || funcName == "stoptime") {
-    // 如果是starttime或stoptime函数
-    // TODO: 这里需要处理starttime和stoptime函数的参数
-    // args.emplace_back()
+    args.emplace_back(
+        ConstantInteger::get(static_cast<int>(ctx->getStart()->getLine())));
   } else {
     if (ctx->funcRParams() != nullptr) {
       args = std::any_cast<std::vector<Value *>>(visitFuncRParams(ctx->funcRParams()));
     }
 
-    auto params = function->getEntryBlock()->getArguments();
-    for (size_t i = 0; i < args.size(); i++) {
-      // 参数类型转换
-      if (params[i]->getType() != args[i]->getType() &&
-          (params[i]->getNumDims() != 0 ||
-           params[i]->getType()->as<PointerType>()->getBaseType() != args[i]->getType())) {
-        ConstantValue * constValue = dynamic_cast<ConstantValue *>(args[i]);
+    // 获取形参列表。`getArguments()` 返回的是 `Argument*` 的集合，
+    // 每个 `Argument` 代表一个函数形参，其 `getType()` 就是指向形参的类型的指针类型。
+    auto formalParams = function->getArguments();
+
+    // 检查实参和形参数量是否匹配。
+    if (args.size() != formalParams.size()) {
+      std::cerr << "Error: Function call argument count mismatch for function '" << funcName << "'." << std::endl;
+      assert(false && "Function call argument count mismatch!");
+    }
+
+    for (int i = 0; i < args.size(); i++) {
+      // 形参的类型 (e.g., i32, float, i32*, [10 x i32]*)
+      Type* formalParamExpectedValueType = formalParams[i]->getType();
+      // 实参的实际类型 (e.g., i32, float, i32*, [67 x i32]*)
+      Type* actualArgType = args[i]->getType();
+      // 如果实参类型与形参类型不匹配，则尝试进行类型转换
+      if (formalParamExpectedValueType != actualArgType) {
+        ConstantValue *constValue = dynamic_cast<ConstantValue *>(args[i]);
         if (constValue != nullptr) {
-          if (params[i]->getType() == Type::getPointerType(Type::getFloatType())) {
-            args[i] = ConstantInteger::get(static_cast<float>(constValue->getInt()));
+          if (formalParamExpectedValueType->isInt() && actualArgType->isFloat()) {
+            args[i] = ConstantInteger::get(static_cast<int>(constValue->getFloat()));
+          } else if (formalParamExpectedValueType->isFloat() && actualArgType->isInt()) {
+            args[i] = ConstantFloating::get(static_cast<float>(constValue->getInt()));
           } else {
-            args[i] = ConstantFloating::get(static_cast<int>(constValue->getFloat()));
+            // 如果是常量但不是简单的 int/float 标量转换，
+            // 或者是指针常量需要 bitcast，则让它进入非常量转换逻辑。
+            // 例如，一个常量数组的地址，需要 bitcast 成另一种指针类型。
+            // 目前不知道样例有没有这种情况，所以这里不做处理。
           }
-        } else {
-          if (params[i]->getType() == Type::getPointerType(Type::getFloatType())) {
-            args[i] = builder.createIToFInst(args[i]);
-          } else {
+        } 
+        else {
+          // 1. 标量值类型转换 (例如：int_reg 到 float_reg，float_reg 到 int_reg)
+          if (formalParamExpectedValueType->isInt() && actualArgType->isFloat()) {
             args[i] = builder.createFtoIInst(args[i]);
+          } else if (formalParamExpectedValueType->isFloat() && actualArgType->isInt()) {
+            args[i] = builder.createIToFInst(args[i]);
+          }
+          // 2. 指针类型转换 (例如数组退化：`[N x T]*` 到 `T*`，或兼容指针类型之间) TODO：不清楚有没有这种样例
+          // 这种情况常见于数组参数，实参可能是一个更具体的数组指针类型，
+          // 而形参是其退化后的基础指针类型。LLVM 的 `bitcast` 指令可以用于
+          // 在相同大小的指针类型之间进行转换，这对于数组退化至关重要。
+          // else if (formalParamType->isPointer() && actualArgType->isPointer()) {
+            // 检查指针基类型是否兼容，或者是否是数组退化导致的类型不同。
+            // 使用 bitcast，
+            // args[i] = builder.createBitCastInst(args[i], formalParamType);
+          // }
+          // 3. 其他未预期的类型不匹配
+          // 如果代码执行到这里，说明存在编译器前端未处理的类型不兼容或错误。
+          else {
+            // assert(false && "Unhandled type mismatch for function call argument.");
           }
         }
       }
@@ -757,7 +1031,7 @@ std::any SysYIRGenerator::visitFuncRParams(SysYParser::FuncRParamsContext *ctx)
 std::any SysYIRGenerator::visitMulExp(SysYParser::MulExpContext *ctx) {
   Value * result = std::any_cast<Value *>(visitUnaryExp(ctx->unaryExp(0)));
  
-  for (size_t i = 1; i < ctx->unaryExp().size(); i++) {
+  for (int i = 1; i < ctx->unaryExp().size(); i++) {
     auto opNode = dynamic_cast<antlr4::tree::TerminalNode*>(ctx->children[2*i-1]);
     int opType = opNode->getSymbol()->getType();
 
@@ -833,7 +1107,7 @@ std::any SysYIRGenerator::visitMulExp(SysYParser::MulExpContext *ctx) {
 std::any SysYIRGenerator::visitAddExp(SysYParser::AddExpContext *ctx) {
   Value* result = std::any_cast<Value *>(visitMulExp(ctx->mulExp(0)));
 
-  for (size_t i = 1; i < ctx->mulExp().size(); i++) {
+  for (int i = 1; i < ctx->mulExp().size(); i++) {
     auto opNode = dynamic_cast<antlr4::tree::TerminalNode*>(ctx->children[2*i-1]);
     int opType = opNode->getSymbol()->getType();
 
@@ -894,7 +1168,7 @@ std::any SysYIRGenerator::visitAddExp(SysYParser::AddExpContext *ctx) {
 std::any SysYIRGenerator::visitRelExp(SysYParser::RelExpContext *ctx) {
   Value* result = std::any_cast<Value *>(visitAddExp(ctx->addExp(0)));
 
-  for (size_t i = 1; i < ctx->addExp().size(); i++) {
+  for (int i = 1; i < ctx->addExp().size(); i++) {
     auto opNode = dynamic_cast<antlr4::tree::TerminalNode*>(ctx->children[2*i-1]);
     int opType = opNode->getSymbol()->getType();
 
@@ -966,7 +1240,7 @@ std::any SysYIRGenerator::visitRelExp(SysYParser::RelExpContext *ctx) {
 std::any SysYIRGenerator::visitEqExp(SysYParser::EqExpContext *ctx) {
   Value * result = std::any_cast<Value *>(visitRelExp(ctx->relExp(0)));
 
-  for (size_t i = 1; i < ctx->relExp().size(); i++) {
+  for (int i = 1; i < ctx->relExp().size(); i++) {
     auto opNode = dynamic_cast<antlr4::tree::TerminalNode*>(ctx->children[2*i-1]);
     int opType = opNode->getSymbol()->getType();
 
@@ -1040,7 +1314,7 @@ std::any SysYIRGenerator::visitLAndExp(SysYParser::LAndExpContext *ctx){
   BasicBlock *falseBlock = builder.getFalseBlock();
   auto conds = ctx->eqExp();
 
-  for (size_t i = 0; i < conds.size() - 1; i++) {
+  for (int i = 0; i < conds.size() - 1; i++) {
 
     labelstring << "AND.L" << builder.getLabelIndex();
     BasicBlock *newtrueBlock = function->addBasicBlock(labelstring.str());
@@ -1071,7 +1345,7 @@ auto SysYIRGenerator::visitLOrExp(SysYParser::LOrExpContext *ctx) -> std::any {
   Function *function = curBlock->getParent();
   auto conds = ctx->lAndExp();
 
-  for (size_t i = 0; i < conds.size() - 1; i++) {
+  for (int i = 0; i < conds.size() - 1; i++) {
     labelstring << "OR.L" << builder.getLabelIndex();
     BasicBlock *newFalseBlock = function->addBasicBlock(labelstring.str());
     labelstring.str("");
@@ -1088,6 +1362,7 @@ auto SysYIRGenerator::visitLOrExp(SysYParser::LOrExpContext *ctx) -> std::any {
   return std::any();
 }
 
+// attention : 这里的type是数组元素的type
 void Utils::tree2Array(Type *type, ArrayValueTree *root,
                         const std::vector<Value *> &dims, unsigned numDims,
                         ValueCounter &result, IRBuilder *builder) {
@@ -1158,11 +1433,13 @@ void Utils::createExternalFunction(
   auto entry = function->getEntryBlock();
   pBuilder->setPosition(entry, entry->end());
 
-  for (size_t i = 0; i < paramTypes.size(); ++i) {
+  for (int i = 0; i < paramTypes.size(); ++i) {
+    auto arg = new Argument(paramTypes[i], function, i, paramNames[i]);
     auto alloca = pBuilder->createAllocaInst(
-        Type::getPointerType(paramTypes[i]), paramDims[i], paramNames[i]);
-    entry->insertArgument(alloca);
-    // pModule->addVariable(paramNames[i], alloca);
+        Type::getPointerType(paramTypes[i]), {}, paramNames[i]);
+    function->insertArgument(arg);
+    auto store = pBuilder->createStoreInst(arg, alloca);
+    pModule->addVariable(paramNames[i], alloca);
   }
 }
 

src/SysYIROptPre.cpp

@@ -1,484 +0,0 @@
-#include "SysYIROptPre.h"
-#include <cassert>
-#include <list>
-#include <map>
-#include <memory>
-#include <string>
-#include <iostream>
-#include "IR.h"
-#include "IRBuilder.h"
-
-namespace sysy {
-
-/**
- * use删除operand,以免扰乱后续分析
- * instr: 要删除的指令
- */
-void SysYOptPre::usedelete(Instruction *instr) {
-  for (auto &use : instr->getOperands()) {
-    Value* val = use->getValue();
-    // std::cout << delete << val->getName() << std::endl;
-    val->removeUse(use);
-  }
-}
-
-
-// 删除br后的无用指令
-void SysYOptPre::SysYDelInstAfterBr() {
-  auto &functions = pModule->getFunctions();
-  for (auto &function : functions) {
-    auto basicBlocks = function.second->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 (Branch) 
-          usedelete(iter->get());
-        else if ((*iter)->isTerminator()){
-          Branch = true;
-          Branchiter = iter;
-        }
-      }
-      if (Branchiter != instructions.end()) ++Branchiter;
-      while (Branchiter != instructions.end()) 
-        Branchiter = instructions.erase(Branchiter);
-      
-      if (Branch) {  // 更新前驱后继关系
-        auto thelastinstinst = basicBlock->getInstructions().end();
-        --thelastinstinst;
-        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));
-          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));
-          basicBlock->addSuccessor(thenBlock);
-          basicBlock->addSuccessor(elseBlock);
-          thenBlock->addPredecessor(basicBlock.get());
-          elseBlock->addPredecessor(basicBlock.get());
-        }
-      }
-    }
-  }
-}
-
-
-void SysYOptPre::SysYBlockMerge() {
-  auto &functions = pModule->getFunctions(); //std::map<std::string, std::unique_ptr<Function>>
-  for (auto &function : functions) {
-    // auto basicBlocks = function.second->getBasicBlocks();
-    auto &func = function.second;
-    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];
-          auto nextarguments = nextBlock->getArguments();
-          // 删除br指令
-          if (block->getNumInstructions() != 0) {
-            auto thelastinstinst = block->end();
-            (--thelastinstinst);
-            if (thelastinstinst->get()->isUnconditional()) {
-              usedelete(thelastinstinst->get());
-              block->getInstructions().erase(thelastinstinst);
-            } else if (thelastinstinst->get()->isConditional()) {
-              // 如果是条件分支，判断条件是否相同，主要优化相同布尔表达式
-              if (thelastinstinst->get()->getOperand(1)->getName() == thelastinstinst->get()->getOperand(1)->getName()) {
-                usedelete(thelastinstinst->get());
-                block->getInstructions().erase(thelastinstinst);
-              }
-            }
-          }
-          // 将后继块的指令移动到当前块
-          // 并将后继块的父指针改为当前块
-          for (auto institer = nextBlock->begin(); institer != nextBlock->end();) {
-            institer->get()->setParent(block);
-            block->getInstructions().emplace_back(institer->release());
-            institer = nextBlock->getInstructions().erase(institer);   
-          }
-          // 合并参数
-          // TODO：是否需要去重?
-          for (auto &argm : nextarguments) {
-            argm->setParent(block);
-            block->insertArgument(argm);
-          }
-          // 更新前驱后继关系，类似树节点操作
-          block->removeSuccessor(nextBlock);
-          nextBlock->removePredecessor(block);
-          std::list<BasicBlock *> succshoulddel;
-          for (auto &succ : nextBlock->getSuccessors()) {
-            block->addSuccessor(succ);
-            succ->replacePredecessor(nextBlock, block);
-            succshoulddel.push_back(succ);
-          }
-          for (auto del : succshoulddel) {
-            nextBlock->removeSuccessor(del);
-          }
-
-          func->removeBasicBlock(nextBlock);
-
-        } else {
-          blockiter++;
-        }
-      } else {
-        blockiter++;
-      }
-    }
-  }
-}
-
-// 删除无前驱块，兼容SSA后的处理
-void SysYOptPre::SysYDelNoPreBLock() {
-  
-  auto &functions = pModule->getFunctions(); // std::map<std::string, std::unique_ptr<sysy::Function>>
-  for (auto &function : functions) {
-    auto &func = function.second;
-
-    for (auto &block : func->getBasicBlocks()) {
-      block->setreachableFalse();
-    }
-    // 对函数基本块做一个拓扑排序，排查不可达基本块
-    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);
-        }
-      }
-    }
-
-    // 删除不可达基本块指令
-    for (auto blockIter = func->getBasicBlocks().begin(); blockIter != func->getBasicBlocks().end();blockIter++) {
-      
-      if (!blockIter->get()->getreachable()) 
-        for (auto &iterInst : blockIter->get()->getInstructions()) 
-          usedelete(iterInst.get());
-    
-    }
-
-    
-    for (auto blockIter = func->getBasicBlocks().begin(); blockIter != func->getBasicBlocks().end();) {
-      if (!blockIter->get()->getreachable()) {
-        for (auto succblock : blockIter->get()->getSuccessors()) {
-          int indexphi = 1;
-          for (auto pred : succblock->getPredecessors()) {
-            if (pred == blockIter->get()) {
-              break;
-            }
-            indexphi++;
-          }
-          for (auto &phiinst : succblock->getInstructions()) {
-            if (phiinst->getKind() != Instruction::kPhi) {
-              break;
-            }
-            phiinst->removeOperand(indexphi);
-          }
-        }
-        // 删除不可达基本块，注意迭代器不可达问题
-        func->removeBasicBlock((blockIter++)->get());
-      } else {
-        blockIter++;
-      }
-    }
-  }
-}
-
-void SysYOptPre::SysYDelEmptyBlock() {
-  auto &functions = pModule->getFunctions();
-  for (auto &function : functions) {
-    // 收集不可达基本块
-    // 这里的不可达基本块是指没有实际指令的基本块
-    // 当一个基本块没有实际指令例如只有phi指令和一个uncondbr指令时，也会被视作不可达
-    auto basicBlocks = function.second->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)
-          EmptyBlocks[basicBlock.get()] = basicBlock->getSuccessors().front();
-      }
-      
-      
-    }
-    // 更新基本块信息，增加必要指令
-    for (auto &basicBlock : basicBlocks) {
-      // 把空块转换成只有跳转指令的不可达块
-      if (distance(basicBlock->begin(), basicBlock->end()) == 0) {
-        if (basicBlock->getNumSuccessors() == 0) {
-          continue;
-        }
-        if (basicBlock->getNumSuccessors() > 1) {
-          assert("");
-        }
-        pBuilder->setPosition(basicBlock.get(), basicBlock->end());
-        pBuilder->createUncondBrInst(basicBlock->getSuccessors()[0], {});
-        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.find(dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(0))) !=
-               EmptyBlocks.end()) {
-          thelastBlockOld = dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(0));
-          thelastinst->get()->replaceOperand(0, EmptyBlocks[thelastBlockOld]);
-        }
-
-        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());
-
-        if (thelastBlockOld != nullptr) {
-          int indexphi = 0;
-          for (auto &pred : dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(0))->getPredecessors()) {
-            if (pred == thelastBlockOld) {
-              break;
-            }
-            indexphi++;
-          }
-
-          // 更新phi指令的操作数
-          // 移除thelastBlockOld对应的phi操作数
-          for (auto &InstInNew : dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(0))->getInstructions()) {
-            if (InstInNew->isPhi()) {
-              dynamic_cast<PhiInst *>(InstInNew.get())->removeOperand(indexphi + 1);
-            } else {
-              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));
-
-        BasicBlock *thelastBlockOld = nullptr;
-        while (EmptyBlocks.find(dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(1))) !=
-               EmptyBlocks.end()) {
-          thelastBlockOld = dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(1));
-          thelastinst->get()->replaceOperand(
-              1, EmptyBlocks[dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(1))]);
-        }
-        basicBlock->removeSuccessor(OldThenBlock);
-        OldThenBlock->removePredecessor(basicBlock.get());
-        // 处理 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));
-          usedelete(thelastinst->get());
-          thelastinst = basicBlock->getInstructions().erase(thelastinst);
-          pBuilder->setPosition(basicBlock.get(), basicBlock->end());
-          pBuilder->createUncondBrInst(thebrBlock, {});
-          continue;
-        }
-        basicBlock->addSuccessor(dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(1)));
-        dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(1))->addPredecessor(basicBlock.get());
-        // auto indexInNew = dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(0))->getPredecessors().
-
-        if (thelastBlockOld != nullptr) {
-          int indexphi = 0;
-          for (auto &pred : dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(1))->getPredecessors()) {
-            if (pred == thelastBlockOld) {
-              break;
-            }
-            indexphi++;
-          }
-
-          for (auto &InstInNew : dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(1))->getInstructions()) {
-            if (InstInNew->isPhi()) {
-              dynamic_cast<PhiInst *>(InstInNew.get())->removeOperand(indexphi + 1);
-            } else {
-              break;
-            }
-          }
-        }
-
-        thelastBlockOld = nullptr;
-        while (EmptyBlocks.find(dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(2))) !=
-               EmptyBlocks.end()) {
-          thelastBlockOld = dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(2));
-          thelastinst->get()->replaceOperand(
-              2, EmptyBlocks[dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(2))]);
-        }
-        basicBlock->removeSuccessor(OldElseBlock);
-        OldElseBlock->removePredecessor(basicBlock.get());
-        // 处理 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));
-          usedelete(thelastinst->get());
-          thelastinst = basicBlock->getInstructions().erase(thelastinst);
-          pBuilder->setPosition(basicBlock.get(), basicBlock->end());
-          pBuilder->createUncondBrInst(thebrBlock, {});
-          continue;
-        }
-        basicBlock->addSuccessor(dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(2)));
-        dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(2))->addPredecessor(basicBlock.get());
-
-        if (thelastBlockOld != nullptr) {
-          int indexphi = 0;
-          for (auto &pred : dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(2))->getPredecessors()) {
-            if (pred == thelastBlockOld) {
-              break;
-            }
-            indexphi++;
-          }
-          for (auto &InstInNew : dynamic_cast<BasicBlock *>(thelastinst->get()->getOperand(2))->getInstructions()) {
-            if (InstInNew->isPhi()) {
-              dynamic_cast<PhiInst *>(InstInNew.get())->removeOperand(indexphi + 1);
-            } else {
-              break;
-            }
-          }
-        }
-      } else {
-        if (basicBlock->getNumSuccessors() == 1) {
-          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());
-          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 = function.second->getBasicBlocks().begin(); iter != function.second->getBasicBlocks().end();) {
-      
-      if (EmptyBlocks.find(iter->get()) != EmptyBlocks.end()) {
-        // EntryBlock跳过
-        if (iter->get() == function.second->getEntryBlock()) {
-          ++iter;
-          continue;
-        }
-
-        for (auto &iterInst : iter->get()->getInstructions()) 
-          usedelete(iterInst.get());
-        // 删除不可达基本块的phi指令的操作数
-        for (auto &succ : iter->get()->getSuccessors()) {
-          int index = 0;
-          for (auto &pred : succ->getPredecessors()) {
-            if (pred == iter->get()) {
-              break;
-            }
-            index++;
-          }
-
-          for (auto &instinsucc : succ->getInstructions()) {
-            if (instinsucc->isPhi()) {
-              dynamic_cast<PhiInst *>(instinsucc.get())->removeOperand(index);
-            } else {
-              break;
-            }
-          }
-        }
-
-        function.second->removeBasicBlock((iter++)->get());
-      } else {
-        ++iter;
-      }
-    }
-  }
-}
-
-// 如果函数没有返回指令，则添加一个默认返回指令(主要解决void函数没有返回指令的问题)
-void SysYOptPre::SysYAddReturn() {
-  auto &functions = pModule->getFunctions();
-  for (auto &function : functions) {
-    auto &func = function.second;
-    auto basicBlocks = func->getBasicBlocks();
-    for (auto &block : basicBlocks) {
-      if (block->getNumSuccessors() == 0) {
-        // 如果基本块没有后继块，则添加一个返回指令
-        if (block->getNumInstructions() == 0) {
-          pBuilder->setPosition(block.get(), block->end());
-          pBuilder->createReturnInst();
-        }
-        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;
-
-          pBuilder->setPosition(block.get(), block->end());
-          // TODO: 如果int float函数缺少返回值是否需要报错
-          if (func->getReturnType()->isInt()) {
-            pBuilder->createReturnInst(ConstantInteger::get(0));
-          } else if (func->getReturnType()->isFloat()) {
-            pBuilder->createReturnInst(ConstantFloating::get(0.0F));
-          } else {
-            pBuilder->createReturnInst();
-          }
-        }
-      }
-    }
-  }
-}
-
-}  // namespace sysy

src/SysYIRPrinter.cpp

@@ -3,12 +3,11 @@
 #include <fstream>
 #include <iostream>
 #include <string>
-#include "IR.h"
+#include "IR.h" // 确保IR.h包含了ArrayType、GetElementPtrInst等的定义
 
 namespace sysy {
 
 void SysYPrinter::printIR() {
-
   const auto &functions = pModule->getFunctions();
 
   //TODO: Print target datalayout and triple (minimal required by LLVM)
@@ -36,11 +35,18 @@ std::string SysYPrinter::getTypeString(Type *type) {
     return "i32";
   } else if (type->isFloat()) {
     return "float";
-    
   } else if (auto ptrType = dynamic_cast<PointerType*>(type)) {
+    // 递归打印指针指向的类型，然后加上 '*'
     return getTypeString(ptrType->getBaseType()) + "*";
-  } else if (auto ptrType = dynamic_cast<FunctionType*>(type)) {
-    return getTypeString(ptrType->getReturnType());
+  } else if (auto funcType = dynamic_cast<FunctionType*>(type)) {
+    // 对于函数类型，打印其返回类型
+    // 注意：这里可能需要更完整的函数签名打印，取决于你的IR表示方式
+    // 比如：`retType (paramType1, paramType2, ...)`
+    // 但为了简化和LLVM IR兼容性，通常在定义时完整打印
+    return getTypeString(funcType->getReturnType());
+  } else if (auto arrayType = dynamic_cast<ArrayType*>(type)) { // 新增：处理数组类型
+    // 打印格式为 [num_elements x element_type]
+    return "[" + std::to_string(arrayType->getNumElements()) + " x " + getTypeString(arrayType->getElementType()) + "]";
   }
   assert(false && "Unsupported type");
   return "";
@@ -51,15 +57,25 @@ std::string SysYPrinter::getValueName(Value *value) {
     return "@" + global->getName();
   } else if (auto inst = dynamic_cast<Instruction*>(value)) {
     return "%" + inst->getName();
-  } else if (auto constVal = dynamic_cast<ConstantValue*>(value)) {
-    if (constVal->isFloat()) {
-      return std::to_string(constVal->getFloat());
+  } else if (auto constInt = dynamic_cast<ConstantInteger*>(value)) { // 优先匹配具体的常量类型
+    return std::to_string(constInt->getInt());
+  } else if (auto constFloat = dynamic_cast<ConstantFloating*>(value)) { // 优先匹配具体的常量类型
+    return std::to_string(constFloat->getFloat());
+  } else if (auto constUndef = dynamic_cast<UndefinedValue*>(value)) { // 如果有Undef类型
+    return "undef";
+  } else if (auto constVal = dynamic_cast<ConstantValue*>(value)) { // fallback for generic ConstantValue
+    // 这里的逻辑可能需要根据你ConstantValue的实际设计调整
+    // 确保它能处理所有可能的ConstantValue
+    if (constVal->getType()->isFloat()) {
+        return std::to_string(constVal->getFloat());
     }
     return std::to_string(constVal->getInt());
   } else if (auto constVar = dynamic_cast<ConstantVariable*>(value)) {
-    return constVar->getName();
+    return constVar->getName(); // 假设ConstantVariable有自己的名字或通过getByIndices获取值
+  } else if (auto argVar = dynamic_cast<Argument*>(value)) {
+    return "%" + argVar->getName(); // 假设ArgumentVariable有自己的名字
   }
-  assert(false && "Unknown value type");
+  assert(false && "Unknown value type or unable to get value name");
   return "";
 }
 
@@ -77,44 +93,35 @@ void SysYPrinter::printGlobalVariable() {
   for (const auto &global : globals) {
     std::cout << "@" << global->getName() << " = global ";
     
-    auto baseType = dynamic_cast<PointerType *>(global->getType())->getBaseType();
-    printType(baseType);
-    
-    if (global->getNumDims() > 0) {
-      // Array type
-      std::cout << " [";
-      for (unsigned i = 0; i < global->getNumDims(); i++) {
-        if (i > 0) std::cout << " x ";
-        std::cout << getValueName(global->getDim(i));
-      }
-      std::cout << "]";
-    }
+    // 全局变量的类型是一个指针，指向其基类型 (可能是 ArrayType 或 Integer/FloatType)
+    auto globalVarBaseType = dynamic_cast<PointerType *>(global->getType())->getBaseType();
+    printType(globalVarBaseType); // 打印全局变量的实际类型 (例如 i32 或 [10 x i32])
     
     std::cout << " ";
     
-    if (global->getNumDims() > 0) {
-      // Array initializer
-      std::cout << "[";
-      auto values = global->getInitValues();
-      auto counterValues = values.getValues();
-      auto counterNumbers = values.getNumbers();
+    // 检查是否是数组类型 (通过检查 globalVarBaseType 是否是 ArrayType)
+    if (globalVarBaseType->isArray()) {
+      // 数组初始化器
+      std::cout << "["; // LLVM IR 数组初始化器格式: [type value, type value, ...]
+      auto values = global->getInitValues(); // 假设 getInitValues() 返回一个 ValueCounter
+      const std::vector<sysy::Value *> &counterValues = values.getValues(); // 获取所有值
       
-      for (size_t i = 0; i < counterNumbers.size(); i++) {
+      for (size_t i = 0; i < counterValues.size(); i++) {
         if (i > 0) std::cout << ", ";
-        if (baseType->isFloat()) {
-          std::cout << "float " << dynamic_cast<ConstantValue*>(counterValues[i])->getFloat();
-        } else {
-          std::cout << "i32 " << dynamic_cast<ConstantValue*>(counterValues[i])->getInt();
-        }
+        // 打印元素类型，这个元素类型应该是数组的最终元素类型，例如 i32 或 float
+        // 可以从 globalVarBaseType 逐层剥离得到最终元素类型，但这里简化为直接从值获取
+        printType(counterValues[i]->getType());
+        std::cout << " ";
+        printValue(counterValues[i]);
       }
       std::cout << "]";
     } else {
-      // Scalar initializer
-      if (baseType->isFloat()) {
-        std::cout << "float " << dynamic_cast<ConstantValue*>(global->getByIndex(0))->getFloat();
-      } else {
-        std::cout << "i32 " << dynamic_cast<ConstantValue*>(global->getByIndex(0))->getInt();
-      }
+      // 标量初始化器
+      // 假设标量全局变量的初始化值通过 getByIndex(0) 获取
+      Value* initVal = global->getByIndex(0);
+      printType(initVal->getType()); // 打印标量值的类型
+      std::cout << " ";
+      printValue(initVal); // 打印标量值
     }
     
     std::cout << ", align 4" << std::endl;
@@ -129,7 +136,7 @@ void SysYPrinter::printFunction(Function *function) {
   
   auto entryBlock = function->getEntryBlock();
   const auto &args_types = function->getParamTypes();
-  auto &args = entryBlock->getArguments();
+  auto &args = function->getArguments();
   
   int i = 0;
   for (const auto &args_type : args_types) {
@@ -145,9 +152,7 @@ void SysYPrinter::printFunction(Function *function) {
   for (const auto &blockIter : function->getBasicBlocks()) {
     // Basic block label
     BasicBlock* blockPtr = blockIter.get();
-    if (blockPtr == function->getEntryBlock()) {
-      std::cout << "entry:" << std::endl;
-    } else if (!blockPtr->getName().empty()) {
+    if (!blockPtr->getName().empty()) {
       std::cout << blockPtr->getName() << ":" << std::endl;
     }
     
@@ -209,19 +214,19 @@ void SysYPrinter::printInst(Instruction *pInst) {
         case Kind::kFDiv: std::cout << "fdiv"; break;
         case Kind::kICmpEQ: std::cout << "icmp eq"; break;
         case Kind::kICmpNE: std::cout << "icmp ne"; break;
-        case Kind::kICmpLT: std::cout << "icmp slt"; break;
+        case Kind::kICmpLT: std::cout << "icmp slt"; break; // LLVM uses slt/sgt for signed less/greater than
         case Kind::kICmpGT: std::cout << "icmp sgt"; break;
         case Kind::kICmpLE: std::cout << "icmp sle"; break;
         case Kind::kICmpGE: std::cout << "icmp sge"; break;
-        case Kind::kFCmpEQ: std::cout << "fcmp oeq"; break;
-        case Kind::kFCmpNE: std::cout << "fcmp one"; break;
-        case Kind::kFCmpLT: std::cout << "fcmp olt"; break;
-        case Kind::kFCmpGT: std::cout << "fcmp ogt"; break;
-        case Kind::kFCmpLE: std::cout << "fcmp ole"; break;
-        case Kind::kFCmpGE: std::cout << "fcmp oge"; break;
+        case Kind::kFCmpEQ: std::cout << "fcmp oeq"; break; // oeq for ordered equal
+        case Kind::kFCmpNE: std::cout << "fcmp one"; break; // one for ordered not equal
+        case Kind::kFCmpLT: std::cout << "fcmp olt"; break; // olt for ordered less than
+        case Kind::kFCmpGT: std::cout << "fcmp ogt"; break; // ogt for ordered greater than
+        case Kind::kFCmpLE: std::cout << "fcmp ole"; break; // ole for ordered less than or equal
+        case Kind::kFCmpGE: std::cout << "fcmp oge"; break; // oge for ordered greater than or equal
         case Kind::kAnd: std::cout << "and"; break;
         case Kind::kOr: std::cout << "or"; break;
-        default: break;
+        default: break; // Should not reach here
       }
       
       // Types and operands
@@ -238,7 +243,6 @@ void SysYPrinter::printInst(Instruction *pInst) {
     case Kind::kNeg:
     case Kind::kNot:
     case Kind::kFNeg:
-    case Kind::kFNot:
     case Kind::kFtoI:
     case Kind::kBitFtoI:
     case Kind::kItoF:
@@ -250,31 +254,39 @@ void SysYPrinter::printInst(Instruction *pInst) {
       }
       
       switch (pInst->getKind()) {
-        case Kind::kNeg: std::cout << "sub "; break;
-        case Kind::kNot: std::cout << "not "; break;
-        case Kind::kFNeg: std::cout << "fneg "; break;
-        case Kind::kFNot: std::cout << "fneg "; break; // FNot not standard, map to fneg
-        case Kind::kFtoI: std::cout << "fptosi "; break;
-        case Kind::kBitFtoI: std::cout << "bitcast "; break;
-        case Kind::kItoF: std::cout << "sitofp "; break;
-        case Kind::kBitItoF: std::cout << "bitcast "; break;
-        default: break;
+        case Kind::kNeg: std::cout << "sub "; break; // integer negation is `sub i32 0, operand`
+        case Kind::kNot: std::cout << "xor "; break; // logical/bitwise NOT is `xor i32 -1, operand` or `xor i1 true, operand`
+        case Kind::kFNeg: std::cout << "fneg "; break; // float negation
+        case Kind::kFtoI: std::cout << "fptosi "; break; // float to signed integer
+        case Kind::kBitFtoI: std::cout << "bitcast "; break; // bitcast float to int
+        case Kind::kItoF: std::cout << "sitofp "; break; // signed integer to float
+        case Kind::kBitItoF: std::cout << "bitcast "; break; // bitcast int to float
+        default: break; // Should not reach here
       }
       
-      printType(unyInst->getType());
+      printType(unyInst->getOperand()->getType()); // Print operand type
       std::cout << " ";
       
-      // Special handling for negation
-      if (pInst->getKind() == Kind::kNeg || pInst->getKind() == Kind::kNot) {
-        std::cout << "i32 0, ";
+      // Special handling for integer negation and logical NOT
+      if (pInst->getKind() == Kind::kNeg) {
+        std::cout << "0, "; // for 'sub i32 0, operand'
+      } else if (pInst->getKind() == Kind::kNot) {
+        // For logical NOT (i1 -> i1), use 'xor i1 true, operand'
+        // For bitwise NOT (i32 -> i32), use 'xor i32 -1, operand'
+        if (unyInst->getOperand()->getType()->isInt()) { // Assuming i32 for bitwise NOT
+            std::cout << "NOT, "; // or specific bitmask for NOT
+        } else { // Assuming i1 for logical NOT
+            std::cout << "true, ";
+        }
       }
       
       printValue(pInst->getOperand(0));
       
-      // For bitcast, need to specify destination type
-      if (pInst->getKind() == Kind::kBitFtoI || pInst->getKind() == Kind::kBitItoF) {
+      // For type conversions (fptosi, sitofp, bitcast), need to specify destination type
+      if (pInst->getKind() == Kind::kFtoI || pInst->getKind() == Kind::kItoF ||
+          pInst->getKind() == Kind::kBitFtoI || pInst->getKind() == Kind::kBitItoF) {
         std::cout << " to ";
-        printType(unyInst->getType());
+        printType(unyInst->getType()); // Print result type
       }
       
       std::cout << std::endl;
@@ -289,7 +301,7 @@ void SysYPrinter::printInst(Instruction *pInst) {
       }
       
       std::cout << "call ";
-      printType(callInst->getType());
+      printType(callInst->getType()); // Return type of the call
       std::cout << " @" << function->getName() << "(";
       
       auto params = callInst->getArguments();
@@ -297,9 +309,9 @@ void SysYPrinter::printInst(Instruction *pInst) {
       for (auto &param : params) {
         if (!first) std::cout << ", ";
         first = false;
-        printType(param->getValue()->getType());
+        printType(param->getValue()->getType()); // Type of argument
         std::cout << " ";
-        printValue(param->getValue());
+        printValue(param->getValue()); // Value of argument
       }
       
       std::cout << ")" << std::endl;
@@ -307,7 +319,7 @@ void SysYPrinter::printInst(Instruction *pInst) {
     
     case Kind::kCondBr: {
       auto condBrInst = dynamic_cast<CondBrInst *>(pInst);
-      std::cout << "br i1 ";
+      std::cout << "br i1 "; // Condition type should be i1
       printValue(condBrInst->getCondition());
       std::cout << ", label %" << condBrInst->getThenBlock()->getName();
       std::cout << ", label %" << condBrInst->getElseBlock()->getName();
@@ -337,14 +349,17 @@ void SysYPrinter::printInst(Instruction *pInst) {
       auto allocaInst = dynamic_cast<AllocaInst *>(pInst);
       std::cout << "%" << allocaInst->getName() << " = alloca ";
       
-      auto baseType = dynamic_cast<PointerType *>(allocaInst->getType())->getBaseType();
-      printType(baseType);
+      // AllocaInst 的类型现在应该是一个 PointerType，指向正确的 ArrayType 或 ScalarType
+      // 例如：alloca i32, align 4  或者 alloca [10 x i32], align 4
+      auto allocatedType = dynamic_cast<PointerType *>(allocaInst->getType())->getBaseType();
+      printType(allocatedType);
       
-      if (allocaInst->getNumDims() > 0) {
+      // 仍然打印维度信息，如果存在的话
+      if (allocaInst->getNumDims() > 0) { 
         std::cout << ", ";
         for (size_t i = 0; i < allocaInst->getNumDims(); i++) {
           if (i > 0) std::cout << ", ";
-          printType(Type::getIntType());
+          printType(Type::getIntType()); // 维度大小通常是 i32 类型
           std::cout << " ";
           printValue(allocaInst->getDim(i));
         }
@@ -356,70 +371,74 @@ void SysYPrinter::printInst(Instruction *pInst) {
     case Kind::kLoad: {
       auto loadInst = dynamic_cast<LoadInst *>(pInst);
       std::cout << "%" << loadInst->getName() << " = load ";
-      printType(loadInst->getType());
+      printType(loadInst->getType()); // 加载的结果类型
       std::cout << ", ";
-      printType(loadInst->getPointer()->getType());
+      printType(loadInst->getPointer()->getType()); // 指针类型
       std::cout << " ";
-      printValue(loadInst->getPointer());
+      printValue(loadInst->getPointer()); // 要加载的地址
       
+      // 仍然打印索引信息，如果存在的话
       if (loadInst->getNumIndices() > 0) {
-        std::cout << ", ";
+        std::cout << ", indices "; // 或者其他分隔符，取决于你期望的格式
         for (size_t i = 0; i < loadInst->getNumIndices(); i++) {
-          if (i > 0) std::cout << ", ";
-          printType(Type::getIntType());
-          std::cout << " ";
-          printValue(loadInst->getIndex(i));
+            if (i > 0) std::cout << ", ";
+            printType(loadInst->getIndex(i)->getType());
+            std::cout << " ";
+            printValue(loadInst->getIndex(i));
         }
       }
       
       std::cout << ", align 4" << std::endl;
     } break;
     
-    case Kind::kLa: {
-      auto laInst = dynamic_cast<LaInst *>(pInst);
-      std::cout << "%" << laInst->getName() << " = getelementptr inbounds ";
-      
-      auto ptrType = dynamic_cast<PointerType*>(laInst->getPointer()->getType());
-      printType(ptrType->getBaseType());
-      std::cout << ", ";
-      printType(laInst->getPointer()->getType());
-      std::cout << " ";
-      printValue(laInst->getPointer());
-      std::cout << ", ";
-      
-      for (size_t i = 0; i < laInst->getNumIndices(); i++) {
-        if (i > 0) std::cout << ", ";
-        printType(Type::getIntType());
-        std::cout << " ";
-        printValue(laInst->getIndex(i));
-      }
-      
-      std::cout << std::endl;
-    } break;
-    
     case Kind::kStore: {
       auto storeInst = dynamic_cast<StoreInst *>(pInst);
       std::cout << "store ";
-      printType(storeInst->getValue()->getType());
+      printType(storeInst->getValue()->getType()); // 要存储的值的类型
       std::cout << " ";
-      printValue(storeInst->getValue());
+      printValue(storeInst->getValue()); // 要存储的值
       std::cout << ", ";
-      printType(storeInst->getPointer()->getType());
+      printType(storeInst->getPointer()->getType()); // 目标指针的类型
       std::cout << " ";
-      printValue(storeInst->getPointer());
+      printValue(storeInst->getPointer()); // 目标地址
       
+      // 仍然打印索引信息，如果存在的话
       if (storeInst->getNumIndices() > 0) {
-        std::cout << ", ";
+        std::cout << ", indices "; // 或者其他分隔符
         for (size_t i = 0; i < storeInst->getNumIndices(); i++) {
-          if (i > 0) std::cout << ", ";
-          printType(Type::getIntType());
-          std::cout << " ";
-          printValue(storeInst->getIndex(i));
+            if (i > 0) std::cout << ", ";
+            printType(storeInst->getIndex(i)->getType());
+            std::cout << " ";
+            printValue(storeInst->getIndex(i));
         }
       }
       
       std::cout << ", align 4" << std::endl;
     } break;
+
+    case Kind::kGetElementPtr: { // 新增：GetElementPtrInst 打印
+      auto gepInst = dynamic_cast<GetElementPtrInst*>(pInst);
+      std::cout << "%" << gepInst->getName() << " = getelementptr inbounds "; // 假设总是 inbounds
+      
+      // GEP 的第一个操作数是基指针，其类型是一个指向聚合类型的指针
+      // 第一个参数是基指针所指向的聚合类型的类型 (e.g., [10 x i32])
+      auto basePtrType = dynamic_cast<PointerType*>(gepInst->getBasePointer()->getType());
+      printType(basePtrType->getBaseType()); // 打印基指针指向的类型
+      
+      std::cout << ", ";
+      printType(gepInst->getBasePointer()->getType()); // 打印基指针自身的类型 (e.g., [10 x i32]*)
+      std::cout << " ";
+      printValue(gepInst->getBasePointer()); // 打印基指针
+      
+      // 打印所有索引
+      for (auto indexVal : gepInst->getIndices()) { // 使用 getIndices() 迭代器
+        std::cout << ", ";
+        printType(indexVal->getValue()->getType()); // 打印索引的类型 (通常是 i32)
+        std::cout << " ";
+        printValue(indexVal->getValue()); // 打印索引值
+      }
+      std::cout << std::endl;
+    } break;
     
     case Kind::kMemset: {
       auto memsetInst = dynamic_cast<MemsetInst *>(pInst);
@@ -433,51 +452,40 @@ void SysYPrinter::printInst(Instruction *pInst) {
       printValue(memsetInst->getValue());
       std::cout << ", i32 ";
       printValue(memsetInst->getSize());
-      std::cout << ", i1 false)" << std::endl;
+      std::cout << ", i1 false)" << std::endl; // alignment for memset is typically i1
     } break;
     
     case Kind::kPhi: {
       auto phiInst = dynamic_cast<PhiInst *>(pInst);
-      printValue(phiInst->getOperand(0));
-      std::cout << " = phi ";
-      printType(phiInst->getType());
+      // Phi 指令的名称通常是结果变量
+      std::cout << "%" << phiInst->getName() << " = phi ";
+      printType(phiInst->getType()); // Phi 结果类型
       
-      for (unsigned i = 1; i < phiInst->getNumOperands(); i++) {
-        if (i > 0) std::cout << ", ";
+      // Phi 指令的操作数是成对的 [value, basic_block]
+      // 这里假设 getOperands() 返回的是 (val1, block1, val2, block2...)
+      // 如果你的 PhiInst 存储方式是 getIncomingValues() 和 getIncomingBlocks()，请相应调整
+      // LLVM IR 格式: phi type [value1, block1], [value2, block2]
+      bool firstPair = true;
+      for (unsigned i = 0; i < phiInst->getNumOperands() / 2; ++i) { // 遍历成对的操作数
+        if (!firstPair) std::cout << ", ";
+        firstPair = false;
         std::cout << "[ ";
-        printValue(phiInst->getOperand(i));
+        printValue(phiInst->getOperand(i * 2)); // value
+        std::cout << ", %";
+        printValue(phiInst->getOperand(i * 2 + 1)); // block
         std::cout << " ]";
       }
       std::cout << std::endl;
     } break;
     
-    case Kind::kGetSubArray: {
-      auto getSubArrayInst = dynamic_cast<GetSubArrayInst *>(pInst);
-      std::cout << "%" << getSubArrayInst->getName() << " = getelementptr inbounds ";
-      
-      auto ptrType = dynamic_cast<PointerType*>(getSubArrayInst->getFatherArray()->getType());
-      printType(ptrType->getBaseType());
-      std::cout << ", ";
-      printType(getSubArrayInst->getFatherArray()->getType());
-      std::cout << " ";
-      printValue(getSubArrayInst->getFatherArray());
-      std::cout << ", ";
-      bool firstIndex = true;
-      for (auto &index : getSubArrayInst->getIndices()) {
-        if (!firstIndex) std::cout << ", ";
-        firstIndex = false;
-        printType(Type::getIntType());
-        std::cout << " ";
-        printValue(index->getValue());
-      }
-      
-      std::cout << std::endl;
-    } break;
+    // 以下两个 Kind 应该删除或替换为 kGEP
+    // case Kind::kLa: { /* REMOVED */ } break;
+    // case Kind::kGetSubArray: { /* REMOVED */ } break;
     
     default:
-      assert(false && "Unsupported instruction kind");
+      assert(false && "Unsupported instruction kind in SysYPrinter");
       break;
   }
 }
 
-}  // namespace sysy
+}  // namespace sysy

src/include/CalleeSavedHandler.h

@@ -0,0 +1,33 @@
+#ifndef CALLEE_SAVED_HANDLER_H
+#define CALLEE_SAVED_HANDLER_H
+
+#include "RISCv64LLIR.h"
+#include "Pass.h"
+
+namespace sysy {
+
+/**
+ * @class CalleeSavedHandler
+ * @brief 处理被调用者保存寄存器(Callee-Saved Registers)的Pass。
+ * * 这个Pass在寄存器分配之后运行。它的主要职责是：
+ * 1. 扫描整个函数，找出所有被使用的 `s` 系列寄存器。
+ * 2. 在函数序言中插入 `sd` 指令来保存这些寄存器。
+ * 3. 在函数结尾（ret指令前）插入 `ld` 指令来恢复这些寄存器。
+ * 4. 正确计算因保存这些寄存器而需要的额外栈空间，并更新StackFrameInfo。
+ */
+class CalleeSavedHandler : public Pass {
+public:
+    static char ID;
+    
+    CalleeSavedHandler() : Pass("callee-saved-handler", Granularity::Function, PassKind::Optimization) {}
+    
+    void *getPassID() const override { return &ID; }
+    
+    bool runOnFunction(Function *F, AnalysisManager& AM) override;
+    
+    void runOnMachineFunction(MachineFunction* mfunc);
+};
+
+} // namespace sysy
+
+#endif // CALLEE_SAVED_HANDLER_H

src/include/DCE.h

@@ -0,0 +1,63 @@
+#pragma once
+
+#include "Pass.h"
+#include "IR.h"
+#include "SysYIROptUtils.h"
+#include "Dom.h" 
+#include <unordered_set>
+#include <queue>
+
+namespace sysy {
+
+// 前向声明分析结果类，确保在需要时可以引用
+// class DominatorTreeAnalysisResult; // Pass.h 中已包含，这里不再需要
+class SideEffectInfoAnalysisResult; // 假设有副作用分析结果类
+
+// DCEContext 类，用于封装DCE的内部逻辑和状态
+// 这样可以避免静态变量在多线程或多次运行时的冲突，并保持代码的模块化
+class DCEContext {
+public:
+    // 运行DCE的主要方法
+    // func: 当前要优化的函数
+    // tp: 分析管理器，用于获取其他分析结果（如果需要）
+    void run(Function* func, AnalysisManager* AM, bool &changed);
+
+private:
+    // 存储活跃指令的集合
+    std::unordered_set<Instruction*> alive_insts;
+
+    // 判断指令是否是“天然活跃”的（即总是保留的）
+    // inst: 要检查的指令
+    // 返回值: 如果指令是天然活跃的，则为true，否则为false
+    bool isAlive(Instruction* inst);
+
+    // 递归地将活跃指令及其依赖加入到 alive_insts 集合中
+    // inst: 要标记为活跃的指令
+    void addAlive(Instruction* inst);
+};
+
+// DCE 优化遍类，继承自 OptimizationPass
+class DCE : public OptimizationPass {
+public:
+    // 构造函数
+    DCE() : OptimizationPass("DCE", Granularity::Function) {}
+
+    // 静态成员，作为该遍的唯一ID
+    static void *ID;
+
+    // 运行在函数上的优化逻辑
+    // F: 当前要优化的函数
+    // AM: 分析管理器，用于获取或使分析结果失效
+    // 返回值: 如果IR被修改，则为true，否则为false
+    bool runOnFunction(Function *F, AnalysisManager& AM) override;
+
+    // 声明该遍的分析依赖和失效信息
+    // analysisDependencies: 该遍运行前需要哪些分析结果
+    // analysisInvalidations: 该遍运行后会使哪些分析结果失效
+    void getAnalysisUsage(std::set<void *> &analysisDependencies, std::set<void *> &analysisInvalidations) const override;
+
+    // Pass 基类中的纯虚函数，必须实现
+    void *getPassID() const override { return &ID; }
+};
+
+} // namespace sysy

src/include/DeadCodeElimination.h

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

src/include/Dom.h

@@ -0,0 +1,52 @@
+#pragma once
+
+#include "Pass.h" // 包含 Pass 框架
+#include "IR.h"   // 包含 IR 定义
+#include <map>
+#include <set>
+#include <vector>
+#include <algorithm>
+
+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;
+    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);
+    void computeDominanceFrontiers(Function* F);
+private:
+    Function* AssociatedFunction;
+    std::map<BasicBlock*, std::set<BasicBlock*>> Dominators;
+    std::map<BasicBlock*, BasicBlock*> IDoms;
+    std::map<BasicBlock*, std::set<BasicBlock*>> DominanceFrontiers;
+};
+
+
+// 支配树分析遍
+class DominatorTreeAnalysisPass : public AnalysisPass {
+public:
+    // 唯一的 Pass ID
+    static void *ID;
+
+    DominatorTreeAnalysisPass() : AnalysisPass("DominatorTreeAnalysis", Pass::Granularity::Function) {}
+
+    // 实现 getPassID
+    void* getPassID() const override { return &ID; }
+
+    bool runOnFunction(Function* F, AnalysisManager &AM) override;
+
+    std::unique_ptr<AnalysisResultBase> getResult() override;
+
+private:
+    std::unique_ptr<DominatorTree> CurrentDominatorTree;
+};
+
+} // namespace sysy

src/include/IR.h

@@ -49,6 +49,7 @@ class Type {
     kLabel,
     kPointer,
     kFunction,
+    kArray,
   };
 
   Kind kind;  ///< 表示具体类型的变量
@@ -65,6 +66,7 @@ class Type {
   static Type* getPointerType(Type *baseType);  ///< 返回表示指向baseType类型的Pointer类型的Type指针
   static Type* getFunctionType(Type *returnType, const std::vector<Type *> &paramTypes = {});
   ///< 返回表示返回类型为returnType,形参类型列表为paramTypes的函数类型的Type指针
+  static Type* getArrayType(Type *elementType, unsigned numElements);
 
  public:
   Kind getKind() const { return kind; }                  ///< 返回Type对象代表原始标量类型
@@ -74,6 +76,7 @@ class Type {
   bool isLabel() const { return kind == kLabel; }        ///< 判定是否为Label类型
   bool isPointer() const { return kind == kPointer; }    ///< 判定是否为Pointer类型
   bool isFunction() const { return kind == kFunction; }  ///< 判定是否为Function类型
+  bool isArray() const { return kind == Kind::kArray; }
   unsigned getSize() const;                              ///< 返回类型所占的空间大小(字节)
   /// 尝试将一个变量转换为给定的Type及其派生类类型的变量
   template <typename T>
@@ -115,6 +118,22 @@ class FunctionType : public Type {
   unsigned getNumParams() const { return paramTypes.size(); }  ///< 获取形参数量
 };
 
+class ArrayType : public Type {
+ public:
+  // elements：数组的元素类型 (例如，int[3] 的 elementType 是 int)
+  // numElements：该维度的大小 (例如，int[3] 的 numElements 是 3)
+  static ArrayType *get(Type *elementType, unsigned numElements);
+
+  Type *getElementType() const { return elementType; }
+  unsigned getNumElements() const { return numElements; }
+
+ protected:
+  ArrayType(Type *elementType, unsigned numElements)
+      : Type(Kind::kArray), elementType(elementType), numElements(numElements) {}
+  Type *elementType;
+  unsigned numElements; // 当前维度的大小
+};
+
 /*!
  * @}
  */
@@ -449,7 +468,6 @@ public:
 
 // --- End of refactored ConstantValue and related classes ---
 
-
 class Instruction;
 class Function;
 class BasicBlock;
@@ -468,7 +486,6 @@ public:
 
   using inst_list = std::list<std::unique_ptr<Instruction>>;
   using iterator = inst_list::iterator;
-  using arg_list = std::vector<AllocaInst *>;
   using block_list = std::vector<BasicBlock *>;
   using block_set = std::unordered_set<BasicBlock *>;
 
@@ -476,7 +493,6 @@ protected:
 
   Function *parent;              ///< 从属的函数
   inst_list instructions;        ///< 拥有的指令序列
-  arg_list arguments;            ///< 分配空间后的形式参数列表
   block_list successors;         ///< 前驱列表
   block_list predecessors;       ///< 后继列表
   bool reachable = false;
@@ -496,19 +512,25 @@ public:
 public:
 
   unsigned getNumInstructions() const { return instructions.size(); }
-  unsigned getNumArguments() const { return arguments.size(); }
   unsigned getNumPredecessors() const { return predecessors.size(); }
   unsigned getNumSuccessors() const { return successors.size(); }
   Function* getParent() const { return parent; }
   void setParent(Function *func) { parent = func; }
   inst_list& getInstructions() { return instructions; }
-  arg_list& getArguments() { return arguments; }
-  const block_list& getPredecessors() const { return predecessors; }
+  auto getInstructions_Range() const { return make_range(instructions); }
+  block_list& getPredecessors() { return predecessors; }
+  void clearPredecessors() { predecessors.clear(); }
   block_list& getSuccessors() { return successors; }
+  void clearSuccessors() { successors.clear(); }
   iterator begin() { return instructions.begin(); }
   iterator end() { return instructions.end(); }
   iterator terminator() { return std::prev(end()); }
-  void insertArgument(AllocaInst *inst) { arguments.push_back(inst); }
+  bool hasSuccessor(BasicBlock *block) const {
+    return std::find(successors.begin(), successors.end(), block) != successors.end();
+  }  ///< 判断是否有后继块
+  bool hasPredecessor(BasicBlock *block) const {
+    return std::find(predecessors.begin(), predecessors.end(), block) != predecessors.end();
+  }  ///< 判断是否有前驱块
   void addPredecessor(BasicBlock *block) {
     if (std::find(predecessors.begin(), predecessors.end(), block) == predecessors.end()) {
       predecessors.push_back(block);
@@ -561,6 +583,15 @@ public:
     next->addPredecessor(prev);
   }
   void removeInst(iterator pos) { instructions.erase(pos); }
+  void removeInst(Instruction *inst) {
+    auto pos = std::find_if(instructions.begin(), instructions.end(),
+                            [inst](const std::unique_ptr<Instruction> &i) { return i.get() == inst; });
+    if (pos != instructions.end()) {
+      instructions.erase(pos);
+    } else {
+      assert(false && "Instruction not found in BasicBlock");
+    }
+  }  ///< 移除指定位置的指令
   iterator moveInst(iterator sourcePos, iterator targetPos, BasicBlock *block);
 };
 
@@ -602,49 +633,6 @@ class User : public Value {
   void setOperand(unsigned index, Value *value);      ///< 设置操作数
 };
 
-class GetSubArrayInst;
-/**
- * 左值 具有地址的对象
- */
-class LVal {
-  friend class GetSubArrayInst;
-
- protected:
-  LVal *fatherLVal{};                              ///< 父左值
-  std::list<std::unique_ptr<LVal>> childrenLVals;  ///< 子左值
-  GetSubArrayInst *defineInst{};                   /// 定义该左值的GetSubArray指令
-
- protected:
-  LVal() = default;
-
- public:
-  virtual ~LVal() = default;
-  virtual std::vector<Value *> getLValDims() const = 0;  ///< 获取左值的维度
-  virtual unsigned getLValNumDims() const  = 0;           ///< 获取左值的维度数量
-
- public:
-  LVal* getFatherLVal() const { return fatherLVal; }  ///< 获取父左值
-  const std::list<std::unique_ptr<LVal>>& getChildrenLVals() const {
-    return childrenLVals;
-  }  ///< 获取子左值列表
-  LVal* getAncestorLVal() const {
-    auto curLVal = const_cast<LVal *>(this);
-    while (curLVal->getFatherLVal() != nullptr) {
-      curLVal = curLVal->getFatherLVal();
-    }
-    return curLVal;
-  }                                                                  ///< 获取祖先左值
-  void setFatherLVal(LVal *father) { fatherLVal = father; }          ///< 设置父左值
-  void setDefineInst(GetSubArrayInst *inst) { defineInst = inst; }   ///< 设置定义指令
-  void addChild(LVal *child) { childrenLVals.emplace_back(child); }  ///< 添加子左值
-  void removeChild(LVal *child) {
-    auto iter = std::find_if(childrenLVals.begin(), childrenLVals.end(),
-                             [child](const std::unique_ptr<LVal> &ptr) { return ptr.get() == child; });
-    childrenLVals.erase(iter);
-  }                                                                       ///< 移除子左值
-  GetSubArrayInst* getDefineInst() const { return defineInst; }  ///< 获取定义指令
-};
-
 /*!
  * Base of all concrete instruction types.
  */
@@ -694,15 +682,15 @@ class Instruction : public User {
     kAlloca = 0x1UL << 33,
     kLoad = 0x1UL << 34,
     kStore = 0x1UL << 35,
-    kLa = 0x1UL << 36,
+    kGetElementPtr = 0x1UL << 36,
     kMemset = 0x1UL << 37,
-    kGetSubArray = 0x1UL << 38,
+    // kGetSubArray = 0x1UL << 38,
     // Constant Kind removed as Constants are now Values, not Instructions.
     // kConstant = 0x1UL << 37, // Conflicts with kMemset if kept as is
     // phi
     kPhi = 0x1UL << 39,
     kBitItoF = 0x1UL << 40,
-    kBitFtoI = 0x1UL << 41
+    kBitFtoI = 0x1UL << 41,
   };
 
 protected:
@@ -793,14 +781,12 @@ public:
         return "Load";
       case kStore:
         return "Store";
-      case kLa:
-        return "La";
+      case kGetElementPtr:
+        return "GetElementPtr";
       case kMemset:
         return "Memset";
       case kPhi:
         return "Phi";
-      case kGetSubArray:
-        return "GetSubArray";
       default:
         return "Unknown";
     }
@@ -853,9 +839,8 @@ public:
   bool isAlloca() const { return kind == kAlloca; }
   bool isLoad() const { return kind == kLoad; }
   bool isStore() const { return kind == kStore; }
-  bool isLa() const { return kind == kLa; }
+  bool isGetElementPtr() const { return kind == kGetElementPtr; }
   bool isMemset() const { return kind == kMemset; }
-  bool isGetSubArray() const { return kind == kGetSubArray; }
   bool isCall() const { return kind == kCall; }
   bool isReturn() const { return kind == kReturn; }
   bool isDefine() const {
@@ -867,26 +852,6 @@ public:
 class Function;
 //! Function call.
 
-class LaInst : public Instruction {
-  friend class Function;
-  friend class IRBuilder;
-
- protected:
-  explicit LaInst(Value *pointer, const std::vector<Value *> &indices = {}, BasicBlock *parent = nullptr,
-                  const std::string &name = "")
-      : Instruction(Kind::kLa, pointer->getType(), parent, name) {
-    assert(pointer);
-    addOperand(pointer);
-    addOperands(indices);
-  }
-
- public:
-  unsigned getNumIndices() const { return getNumOperands() - 1; }  ///< 获取索引长度
-  Value* getPointer() const { return getOperand(0); }             ///< 获取目标变量的Value指针
-  auto getIndices() const { return make_range(std::next(operand_begin()), operand_end()); }  ///< 获取索引列表
-  Value* getIndex(unsigned index) const { return getOperand(index + 1); }  ///< 获取位置为index的索引分量
-};
-
 class PhiInst : public Instruction {
   friend class IRBuilder;
   friend class Function;
@@ -1094,6 +1059,8 @@ public:
 }; // class UncondBrInst
 
 //! Conditional branch
+// 这里的args是指向条件分支的两个分支的参数列表但是现在弃用了
+// 通过mem2reg优化后，数据流分析将不会由arguments来传递
 class CondBrInst : public Instruction {
   friend class IRBuilder;
   friend class Function;
@@ -1119,22 +1086,22 @@ public:
   BasicBlock* getElseBlock() const {
     return dynamic_cast<BasicBlock *>(getOperand(2));
   }
-  auto getThenArguments() const {
-    auto begin = std::next(operand_begin(), 3);
-    auto end = std::next(begin, getThenBlock()->getNumArguments());
-    return make_range(begin, end);
-  }
-  auto getElseArguments() const {
-    auto begin =
-        std::next(operand_begin(), 3 + getThenBlock()->getNumArguments());
-    auto end = operand_end();
-    return make_range(begin, end);
-  }
+  // auto getThenArguments() const {
+  //   auto begin = std::next(operand_begin(), 3);
+  //   // auto end = std::next(begin, getThenBlock()->getNumArguments());
+  //   return make_range(begin, end);
+  // }
+  // auto getElseArguments() const {
+  //   auto begin =
+  //       std::next(operand_begin(), 3 + getThenBlock()->getNumArguments());
+  //   auto end = operand_end();
+  //   return make_range(begin, end);
+  // }
 
 }; // class CondBrInst
 
 //! Allocate memory for stack variables, used for non-global variable declartion
-class AllocaInst : public Instruction , public LVal {
+class AllocaInst : public Instruction {
   friend class IRBuilder;
   friend class Function;
 protected:
@@ -1145,14 +1112,6 @@ protected:
   }
 
 public:
-  std::vector<Value *> getLValDims() const override {
-    std::vector<Value *> dims;
-    for (const auto &dim : getOperands()) {
-      dims.emplace_back(dim->getValue());
-    }
-    return dims;
-  }  ///< 获取作为左值的维度数组
-  unsigned getLValNumDims() const override { return getNumOperands(); }
   
   int getNumDims() const { return getNumOperands(); }
   auto getDims() const { return getOperands(); }
@@ -1161,37 +1120,40 @@ public:
 }; // class AllocaInst
 
 
-class GetSubArrayInst : public Instruction {
+class GetElementPtrInst : public Instruction {
   friend class IRBuilder;
-  friend class Function;
 
- public:
-  GetSubArrayInst(LVal *fatherArray, LVal *childArray, const std::vector<Value *> &indices,
-                  BasicBlock *parent = nullptr, const std::string &name = "")
-      : Instruction(Kind::kGetSubArray, Type::getVoidType(), parent, name) {
-    auto predicate = [childArray](const std::unique_ptr<LVal> &child) -> bool { return child.get() == childArray; };
-    if (std::find_if(fatherArray->childrenLVals.begin(), fatherArray->childrenLVals.end(), predicate) ==
-        fatherArray->childrenLVals.end()) {
-      fatherArray->childrenLVals.emplace_back(childArray);
-    }
-    childArray->fatherLVal = fatherArray;
-    childArray->defineInst = this;
-    auto fatherArrayValue = dynamic_cast<Value *>(fatherArray);
-    auto childArrayValue = dynamic_cast<Value *>(childArray);
-    assert(fatherArrayValue);
-    assert(childArrayValue);
-    addOperand(fatherArrayValue);
-    addOperand(childArrayValue);
-    addOperands(indices);
+protected:
+  // GEP的构造函数：
+  // resultType: GEP计算出的地址的类型 (通常是指向目标元素类型的指针)
+  // basePointer: 基指针 (第一个操作数)
+  // indices: 索引列表 (后续操作数)
+  GetElementPtrInst(Type *resultType,
+                    Value *basePointer,
+                    const std::vector<Value *> &indices = {},
+                    BasicBlock *parent = nullptr, const std::string &name = "")
+      : Instruction(Kind::kGetElementPtr, resultType, parent, name) {
+    assert(basePointer && "GEP base pointer cannot be null!");
+    // TODO : 安全检查
+    assert(basePointer->getType()->isPointer() );
+    addOperand(basePointer); // 第一个操作数是基指针
+    addOperands(indices);    // 随后的操作数是索引
+  }
+public:
+  Value* getBasePointer() const { return getOperand(0); }
+  unsigned getNumIndices() const { return getNumOperands() - 1; }
+  auto getIndices() const { return make_range(std::next(operand_begin()), operand_end());}
+  Value* getIndex(unsigned index) const {
+    assert(index < getNumIndices() && "Index out of bounds for GEP!");
+    return getOperand(index + 1);
   }
 
- public:
-  Value* getFatherArray() const { return getOperand(0); }                              ///< 获取父数组
-  Value* getChildArray() const { return getOperand(1); }                               ///< 获取子数组
-  LVal* getFatherLVal() const { return dynamic_cast<LVal *>(getOperand(0)); }          ///< 获取父左值
-  LVal* getChildLVal() const { return dynamic_cast<LVal *>(getOperand(1)); }           ///< 获取子左值
-  auto getIndices() const { return make_range(std::next(operand_begin(), 2), operand_end()); }  ///< 获取索引
-  unsigned getNumIndices() const { return getNumOperands() - 2; }                       ///< 获取索引数量
+  // 静态工厂方法，用于创建GEP指令 (如果需要外部直接创建而非通过IRBuilder)
+  static GetElementPtrInst* create(Type *resultType, Value *basePointer,
+                                    const std::vector<Value *> &indices = {},
+                                    BasicBlock *parent = nullptr, const std::string &name = "") {
+    return new GetElementPtrInst(resultType, basePointer, indices, parent, name);
+  }
 };
 
 //! Load a value from memory address specified by a pointer value
@@ -1215,22 +1177,7 @@ public:
     return make_range(std::next(operand_begin()), operand_end());
   }
   Value* getIndex(int index) const { return getOperand(index + 1); }
-  std::list<Value *> getAncestorIndices() const {
-    std::list<Value *> indices;
-    for (const auto &index : getIndices()) {
-      indices.emplace_back(index->getValue());
-    }
-    auto curPointer = dynamic_cast<LVal *>(getPointer());
-    while (curPointer->getFatherLVal() != nullptr) {
-      auto inserter = std::next(indices.begin());
-      for (const auto &index : curPointer->getDefineInst()->getIndices()) {
-        indices.insert(inserter, index->getValue());
-      }
-      curPointer = curPointer->getFatherLVal();
-    }
-
-    return indices;
-  }  ///< 获取相对于祖先数组的索引列表
+  
 }; // class LoadInst
 
 //! Store a value to memory address specified by a pointer value
@@ -1256,22 +1203,6 @@ public:
     return make_range(std::next(operand_begin(), 2), operand_end());
   }
   Value* getIndex(int index) const { return getOperand(index + 2); }
-  std::list<Value *> getAncestorIndices() const {
-    std::list<Value *> indices;
-    for (const auto &index : getIndices()) {
-      indices.emplace_back(index->getValue());
-    }
-    auto curPointer = dynamic_cast<LVal *>(getPointer());
-    while (curPointer->getFatherLVal() != nullptr) {
-      auto inserter = std::next(indices.begin());
-      for (const auto &index : curPointer->getDefineInst()->getIndices()) {
-        indices.insert(inserter, index->getValue());
-      }
-      curPointer = curPointer->getFatherLVal();
-    }
-
-    return indices;
-  }  ///< 获取相对于祖先数组的索引列表
 
 }; // class StoreInst
 
@@ -1308,17 +1239,33 @@ public:
 class GlobalValue;
 
 
+class Argument : public Value {
+protected:
+  Function *func;
+  int index;
+
+public:
+  Argument(Type *type, Function *func, int index, const std::string &name = "")
+      : Value(type, name), func(func), index(index) {}
+
+public:
+  Function* getParent() const { return func; }
+  int getIndex() const { return index; }
+};
+
+
 class Module;
 //! Function definitionclass 
 class Function : public Value {
   friend class Module;
 protected:
   Function(Module *parent, Type *type, const std::string &name) : Value(type, name), parent(parent) {
-    blocks.emplace_back(new BasicBlock(this));
+    blocks.emplace_back(new BasicBlock(this, "entry_" + name));  ///< 创建一个入口基本块
   }
 
 public:
   using block_list = std::list<std::unique_ptr<BasicBlock>>;
+  using arg_list = std::vector<Argument *>;
   enum FunctionAttribute : uint64_t {
     PlaceHolder = 0x0UL,
     Pure = 0x1UL << 0,
@@ -1330,6 +1277,7 @@ public:
 protected:
   Module *parent;                                          ///< 函数的父模块
   block_list blocks;                                       ///< 函数包含的基本块列表
+  arg_list arguments;                                     ///< 函数参数列表
   FunctionAttribute attribute = PlaceHolder;  ///< 函数属性
   std::set<Function *> callees;               ///< 函数调用的函数集合
   public:
@@ -1354,6 +1302,16 @@ protected:
   auto getBasicBlocks() { return make_range(blocks); }
   block_list& getBasicBlocks_NoRange() { return blocks; }
   BasicBlock* getEntryBlock() { return blocks.front().get(); }
+  void insertArgument(Argument *arg) { arguments.push_back(arg); }
+  arg_list& getArguments() { return arguments; }
+  unsigned getNumArguments() const { return arguments.size(); }
+  Argument* getArgument(unsigned index) const {
+    assert(index < arguments.size() && "Argument index out of bounds");
+    return arguments[index];
+  }  ///< 获取位置为index的参数
+  auto getArgumentsRange() const {
+    return make_range(arguments.begin(), arguments.end());
+  }  ///< 获取参数列表的范围
   void removeBasicBlock(BasicBlock *blockToRemove) {
     auto is_same_ptr = [blockToRemove](const std::unique_ptr<BasicBlock> &ptr) { return ptr.get() == blockToRemove; };
     blocks.remove_if(is_same_ptr);
@@ -1373,7 +1331,7 @@ protected:
 };
 
 //! Global value declared at file scope
-class GlobalValue : public User, public LVal {
+class GlobalValue : public User {
   friend class Module;
 
 protected:
@@ -1407,16 +1365,6 @@ protected:
   }
 
 public:
-  unsigned getLValNumDims() const override { return numDims; }  ///< 获取作为左值的维度数量
-  std::vector<Value *> getLValDims() const override {
-    std::vector<Value *> dims;
-    for (const auto &dim : getOperands()) {
-      dims.emplace_back(dim->getValue());
-    }
-
-    return dims;
-  }  ///< 获取作为左值的维度列表
-
   unsigned getNumDims() const  { return numDims; }                     ///< 获取维度数量
   Value* getDim(unsigned index) const { return getOperand(index); }  ///< 获取位置为index的维度
   auto getDims() const { return getOperands(); }                              ///< 获取维度列表
@@ -1438,7 +1386,7 @@ public:
 }; // class GlobalValue
 
 
-class ConstantVariable : public User, public LVal {
+class ConstantVariable : public User {
   friend class Module;
 
  protected:
@@ -1457,15 +1405,6 @@ class ConstantVariable : public User, public LVal {
   }
 
  public:
-  unsigned getLValNumDims() const override { return numDims; }  ///< 获取作为左值的维度数量
-  std::vector<Value *> getLValDims() const override {
-    std::vector<Value *> dims;
-    for (const auto &dim : getOperands()) {
-      dims.emplace_back(dim->getValue());
-    }
-
-    return dims;
-  }  ///< 获取作为左值的维度列表
   Value* getByIndex(unsigned index) const { return initValues.getValue(index); }  ///< 通过一维位置index获取值
   Value* getByIndices(const std::vector<Value *> &indices) const {
     int index = 0;
@@ -1489,7 +1428,7 @@ class ConstantVariable : public User, public LVal {
 using SymbolTableNode = struct SymbolTableNode {
   SymbolTableNode *pNode;            ///< 父节点
   std::vector<SymbolTableNode *> children;  ///< 子节点列表
-  std::map<std::string, User *> varList;    ///< 变量列表
+  std::map<std::string, Value *> varList;    ///< 变量列表
 };
 
 
@@ -1504,8 +1443,8 @@ class SymbolTable {
  public:
   SymbolTable() = default;
 
-  User* getVariable(const std::string &name) const;  ///< 根据名字name以及当前作用域获取变量
-  User* addVariable(const std::string &name, User *variable);               ///< 添加变量
+  Value* getVariable(const std::string &name) const;  ///< 根据名字name以及当前作用域获取变量
+  Value* addVariable(const std::string &name, Value *variable);               ///< 添加变量
   std::vector<std::unique_ptr<GlobalValue>>& getGlobals();                  ///< 获取全局变量列表
   const std::vector<std::unique_ptr<ConstantVariable>>& getConsts() const;  ///< 获取常量列表
   void enterNewScope();                                                              ///< 进入新的作用域
@@ -1567,7 +1506,7 @@ class Module {
   void addVariable(const std::string &name, AllocaInst *variable) {
     variableTable.addVariable(name, variable);
   }  ///< 添加变量
-  User* getVariable(const std::string &name) {
+  Value* getVariable(const std::string &name) {
     return variableTable.getVariable(name);
   }  ///< 根据名字name和当前作用域获取变量
   Function* getFunction(const std::string &name) const {

src/include/IRBuilder.h

@@ -280,46 +280,6 @@ class IRBuilder {
     block->getInstructions().emplace(position, inst);
     return inst;
   }  ///< 创建load指令
-  LaInst * createLaInst(Value *pointer, const std::vector<Value *> &indices = {}, const std::string &name = "") {
-    std::string newName;
-    if (name.empty()) {
-      std::stringstream ss;
-      ss << tmpIndex;
-      newName = ss.str();
-      tmpIndex++;
-    } else {
-      newName = name;
-    }
-
-    auto inst = new LaInst(pointer, indices, block, newName);
-    assert(inst);
-    block->getInstructions().emplace(position, inst);
-    return inst;
-  }  ///< 创建la指令
-  GetSubArrayInst * createGetSubArray(LVal *fatherArray, const std::vector<Value *> &indices, const std::string &name = "") {
-    assert(fatherArray->getLValNumDims() > indices.size());
-    std::vector<Value *> subDims;
-    auto dims = fatherArray->getLValDims();
-    auto iter = std::next(dims.begin(), indices.size());
-    while (iter != dims.end()) {
-      subDims.emplace_back(*iter);
-      iter++;
-    }
-
-    std::string childArrayName;
-    std::stringstream ss;
-    ss << "A"
-       << "%" << tmpIndex;
-    childArrayName = ss.str();
-    tmpIndex++;
-
-    auto fatherArrayValue = dynamic_cast<Value *>(fatherArray);
-    auto childArray = new AllocaInst(fatherArrayValue->getType(), subDims, block, childArrayName);
-    auto inst = new GetSubArrayInst(fatherArray, childArray, indices, block, childArrayName);
-    assert(inst);
-    block->getInstructions().emplace(position, inst);
-    return inst;
-  }  ///< 创建获取部分数组指令
   MemsetInst * createMemsetInst(Value *pointer, Value *begin, Value *size, Value *value, const std::string &name = "") {
     auto inst = new MemsetInst(pointer, begin, size, value, block, name);
     assert(inst);
@@ -334,12 +294,102 @@ class IRBuilder {
     return inst;
   }  ///< 创建store指令
   PhiInst * createPhiInst(Type *type, const std::vector<Value*> &vals = {}, const std::vector<BasicBlock*> &blks = {}, const std::string &name = "") {
-    auto predNum = block->getNumPredecessors();
     auto inst = new PhiInst(type, vals, blks, block, name);
     assert(inst);
     block->getInstructions().emplace(block->begin(), inst);
     return inst;
   }  ///< 创建Phi指令
+  // GetElementPtrInst* createGetElementPtrInst(Value *basePointer,
+  //                                const std::vector<Value *> &indices = {},
+  //                                const std::string &name = "") {
+  //   std::string newName;
+  //   if (name.empty()) {
+  //     std::stringstream ss;
+  //     ss << tmpIndex;
+  //     newName = ss.str();
+  //     tmpIndex++;
+  //   } else {
+  //     newName = name;
+  //   }
+
+  //   auto inst = new GetElementPtrInst(basePointer, indices, block, newName);
+  //   assert(inst);
+  //   block->getInstructions().emplace(position, inst);
+  //   return inst;
+  // }
+  /**
+     * @brief 根据 LLVM 设计模式创建 GEP 指令。
+     * 它会自动推断返回类型，无需手动指定。
+     */
+  GetElementPtrInst *createGetElementPtrInst(Value *basePointer, const std::vector<Value *> &indices,
+                                             const std::string &name = "") {
+    Type *ResultElementType = getIndexedType(basePointer->getType(), indices);
+    if (!ResultElementType) {
+      assert(false && "Invalid GEP indexing!");
+      return nullptr;
+    }
+    Type *ResultType = PointerType::get(ResultElementType);
+    std::string newName;
+    if (name.empty()) {
+      std::stringstream ss;
+      ss << tmpIndex;
+      newName = ss.str();
+      tmpIndex++;
+    } else {
+      newName = name;
+    }
+
+    auto inst = new GetElementPtrInst(ResultType, basePointer, indices, block, newName);
+    assert(inst);
+    block->getInstructions().emplace(position, inst);
+    return inst;
+  }
+
+  static Type *getIndexedType(Type *pointerType, const std::vector<Value *> &indices) {
+    assert(pointerType->isPointer() && "base must be a pointer type!");
+    // GEP 的类型推断从基指针所指向的类型开始。
+    // 例如：
+    // - 如果 pointerType 是 `[20 x [10 x i32]]*`，`currentWalkType` 初始为 `[20 x [10 x i32]]`。
+    // - 如果 pointerType 是 `i32*`，`currentWalkType` 初始为 `i32`。
+    // - 如果 pointerType 是 `i32**`，`currentWalkType` 初始为 `i32*`。
+    Type *currentWalkType = pointerType->as<PointerType>()->getBaseType();
+
+    // 遍历所有索引来深入类型层次结构。
+    // `indices` 向量包含了所有 GEP 索引，包括由 `visitLValue` 等函数添加的初始 `0` 索引。
+    for (int i = 0; i < indices.size(); ++i) {
+        if (currentWalkType->isArray()) {
+            // 情况一：当前遍历类型是 `ArrayType`。
+            // 索引用于选择数组元素，`currentWalkType` 更新为数组的元素类型。
+            currentWalkType = currentWalkType->as<ArrayType>()->getElementType();
+        } else if (currentWalkType->isPointer()) {
+            // 情况二：当前遍历类型是 `PointerType`。
+            // 这意味着我们正在通过一个指针来访问其指向的内存。
+            // 索引用于选择该指针所指向的“数组”的元素。
+            // `currentWalkType` 更新为该指针所指向的基础类型。
+            // 例如：如果 `currentWalkType` 是 `i32*`，它将变为 `i32`。
+            // 如果 `currentWalkType` 是 `[10 x i32]*`，它将变为 `[10 x i32]`。
+            currentWalkType = currentWalkType->as<PointerType>()->getBaseType();
+        } else {
+            // 情况三：当前遍历类型是标量类型 (例如 `i32`, `float` 等非聚合、非指针类型)。
+            //
+            // 如果 `currentWalkType` 是标量，并且当前索引 `i` **不是** `indices` 向量中的最后一个索引，
+            // 这意味着尝试对一个标量类型进行进一步的结构性索引，这是**无效的**。
+            // 例如：`int x; x[0];` 对应的 GEP 链中，`x` 的类型是 `i32`，再加 `[0]` 索引就是错误。
+            //
+            // 如果 `currentWalkType` 是标量，且这是**最后一个索引** (`i == indices.size() - 1`)，
+            // 那么 GEP 是合法的，它只是计算一个偏移地址，最终的类型就是这个标量类型。
+            // 此时 `currentWalkType` 保持不变，循环结束。
+            if (i < indices.size() - 1) { 
+                assert(false && "Invalid GEP indexing: attempting to index into a non-aggregate/non-pointer type with further indices.");
+                return nullptr; // 返回空指针表示类型推断失败
+            }
+            // 如果是最后一个索引，且当前类型是标量，则类型保持不变，这是合法的。
+            // 循环会自然结束，返回正确的 `currentWalkType`。
+        }
+    }
+    // 所有索引处理完毕后，`currentWalkType` 就是 GEP 指令最终计算出的地址所指向的元素的类型。
+    return currentWalkType;
+  }
 };
 
 }  // namespace sysy

src/include/Liveness.h

@@ -0,0 +1,72 @@
+#pragma once
+
+#include "IR.h"      // 包含 IR 定义
+#include "Pass.h"    // 包含 Pass 框架
+#include <algorithm> // for std::set_union, std::set_difference
+#include <map>
+#include <set>
+#include <vector>
+
+namespace sysy {
+
+// 前向声明
+class Function;
+class BasicBlock;
+class Value;
+class Instruction;
+
+// 活跃变量分析结果类
+// 它将包含 LiveIn 和 LiveOut 集合
+class LivenessAnalysisResult : public AnalysisResultBase {
+public:
+  LivenessAnalysisResult(Function *F) : AssociatedFunction(F) {}
+  
+  // 获取给定基本块的 LiveIn 集合
+  const std::set<Value *> *getLiveIn(BasicBlock *BB) const;
+
+  // 获取给定基本块的 LiveOut 集合
+  const std::set<Value *> *getLiveOut(BasicBlock *BB) const;
+
+  // 暴露内部数据结构，如果需要更直接的访问
+  const std::map<BasicBlock *, std::set<Value *>> &getLiveInSets() const { return liveInSets; }
+  const std::map<BasicBlock *, std::set<Value *>> &getLiveOutSets() const { return liveOutSets; }
+
+  // 核心计算方法，由 LivenessAnalysisPass 调用
+  void computeLiveness(Function *F);
+
+private:
+  Function *AssociatedFunction; // 这个活跃变量分析是为哪个函数计算的
+  std::map<BasicBlock *, std::set<Value *>> liveInSets;
+  std::map<BasicBlock *, std::set<Value *>> liveOutSets;
+
+  // 辅助函数：计算基本块的 Def 和 Use 集合
+  // Def: 块内定义，且定义在所有使用之前的值
+  // Use: 块内使用，且使用在所有定义之前的值
+  void computeDefUse(BasicBlock *BB, std::set<Value *> &def, std::set<Value *> &use);
+};
+
+// 活跃变量分析遍
+class LivenessAnalysisPass : public AnalysisPass {
+public:
+  // 唯一的 Pass ID
+  static void *ID; // LLVM 风格的唯一 ID
+
+  LivenessAnalysisPass() : AnalysisPass("LivenessAnalysis", Pass::Granularity::Function) {}
+    
+  // 实现 getPassID
+  void *getPassID() const override { return &ID; }
+
+  // 运行分析并返回结果。现在接受 AnalysisManager& AM 参数
+  bool runOnFunction(Function *F, AnalysisManager &AM) override;
+
+  // 获取分析结果的指针。
+  // 注意：AnalysisManager 将会调用此方法来获取结果并进行缓存。
+  std::unique_ptr<AnalysisResultBase> getResult() override;
+
+private:
+  // 存储当前分析计算出的 LivenessAnalysisResult 实例
+  // runOnFunction 每次调用都会创建新的 LivenessAnalysisResult 对象
+  std::unique_ptr<LivenessAnalysisResult> CurrentLivenessResult;
+};
+
+} // namespace sysy

src/include/Mem2Reg.h

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

src/include/Pass.h

@@ -0,0 +1,316 @@
+#pragma once
+
+#include <functional> // For std::function
+#include <map>
+#include <memory>
+#include <set>
+#include <string>
+#include <typeindex> // For std::type_index (although void* ID is more common in LLVM)
+#include <vector>
+#include <type_traits>
+#include "IR.h"
+#include "IRBuilder.h"
+
+namespace sysy {
+
+//前向声明
+class PassManager;
+class AnalysisManager;
+
+// 抽象基类：分析结果
+class AnalysisResultBase {
+public:
+  virtual ~AnalysisResultBase() = default;
+};
+
+// 抽象基类：Pass
+class Pass {
+public:
+  enum class Granularity { Module, Function, BasicBlock };
+
+  enum class PassKind { Analysis, Optimization };
+
+  Pass(const std::string &name, Granularity g, PassKind k) : Name(name), G(g), K(k) {}
+  virtual ~Pass() = default;
+
+  const std::string &getName() const { return Name; }
+  Granularity getGranularity() const { return G; }
+  PassKind getPassKind() const { return K; }
+
+  virtual bool runOnModule(Module *M, AnalysisManager& AM) { return false; }
+  virtual bool runOnFunction(Function *F, AnalysisManager& AM) { return false; }
+  virtual bool runOnBasicBlock(BasicBlock *BB, AnalysisManager& AM) { return false; }
+
+  // 所有 Pass 都必须提供一个唯一的 ID
+  // 这通常是一个静态成员，并在 Pass 类外部定义
+  virtual void *getPassID() const = 0;
+
+protected:
+  std::string Name;
+  Granularity G;
+  PassKind K;
+};
+
+// 抽象基类：分析遍
+class AnalysisPass : public Pass {
+public:
+  AnalysisPass(const std::string &name, Granularity g) : Pass(name, g, PassKind::Analysis) {}
+
+  virtual std::unique_ptr<AnalysisResultBase> getResult() = 0;
+};
+
+// 抽象基类：优化遍
+class OptimizationPass : public Pass {
+public:
+  OptimizationPass(const std::string &name, Granularity g) : Pass(name, g, PassKind::Optimization) {}
+
+  virtual void getAnalysisUsage(std::set<void *> &analysisDependencies, std::set<void *> &analysisInvalidations) const {
+    // 默认不依赖也不修改任何分析
+  }
+};
+
+// ======================================================================
+// PassRegistry: 全局 Pass 注册表 (单例)
+// ======================================================================
+class PassRegistry {
+public:
+  // Pass 工厂函数类型：返回 Pass 的唯一指针
+  using PassFactory = std::function<std::unique_ptr<Pass>()>;
+
+  // 获取 PassRegistry 实例 (单例模式)
+  static PassRegistry &getPassRegistry() {
+    static PassRegistry instance;
+    return instance;
+  }
+
+  // 注册一个 Pass
+  // passID 是 Pass 类的唯一静态 ID (例如 MyPass::ID 的地址)
+  // factory 是一个 lambda 或函数指针，用于创建该 Pass 的实例
+  void registerPass(void *passID, PassFactory factory) {
+    if (factories.count(passID)) {
+      // Error: Pass with this ID already registered
+      // You might want to throw an exception or log an error
+      return;
+    }
+    factories[passID] = std::move(factory);
+  }
+
+  // 通过 Pass ID 创建一个 Pass 实例
+  std::unique_ptr<Pass> createPass(void *passID) {
+    auto it = factories.find(passID);
+    if (it == factories.end()) {
+      // Error: Pass with this ID not registered
+      return nullptr;
+    }
+    return it->second(); // 调用工厂函数创建实例
+  }
+
+private:
+  PassRegistry() = default; // 私有构造函数，实现单例
+  ~PassRegistry() = default;
+  PassRegistry(const PassRegistry &) = delete;            // 禁用拷贝构造
+  PassRegistry &operator=(const PassRegistry &) = delete; // 禁用赋值操作
+
+  std::map<void *, PassFactory> factories;
+};
+
+// ======================================================================
+// AnalysisManager: 负责管理和提供分析结果
+// ======================================================================
+class AnalysisManager {
+private:
+  Module *pModuleRef; // 指向被分析的Module
+
+  // 缓存不同粒度的分析结果
+  std::map<void *, std::unique_ptr<AnalysisResultBase>> moduleCachedResults;
+  std::map<std::pair<Function *, void *>, std::unique_ptr<AnalysisResultBase>> functionCachedResults;
+  std::map<std::pair<BasicBlock *, void *>, std::unique_ptr<AnalysisResultBase>> basicBlockCachedResults;
+
+
+public:
+  // 构造函数接收 Module 指针
+  AnalysisManager(Module *M) : pModuleRef(M) {}
+  AnalysisManager() = delete; // 禁止无参构造
+
+  ~AnalysisManager() = default;
+
+  // 获取分析结果的通用模板函数
+  // T 是 AnalysisResult 的具体类型，E 是 AnalysisPass 的具体类型
+  // F 和 BB 参数用于提供上下文，根据分析遍的粒度来使用
+  template <typename T, typename E> T *getAnalysisResult(Function *F = nullptr, BasicBlock *BB = nullptr) {
+    void *analysisID = E::ID; // 获取分析遍的唯一 ID
+
+    // 尝试从注册表创建分析遍实例
+    std::unique_ptr<Pass> basePass = PassRegistry::getPassRegistry().createPass(analysisID);
+    if (!basePass) {
+      // Error: Analysis pass not registered
+      std::cerr << "Error: Analysis pass with ID " << analysisID << " not registered.\n";
+      return nullptr;
+    }
+    AnalysisPass *analysisPass = static_cast<AnalysisPass *>(basePass.get());
+
+    // 根据分析遍的粒度处理
+    switch (analysisPass->getGranularity()) {
+      case Pass::Granularity::Module: {
+        // 检查是否已存在有效结果
+        auto it = moduleCachedResults.find(analysisID);
+        if (it != moduleCachedResults.end()) {
+          return static_cast<T *>(it->second.get()); // 返回缓存结果
+        }
+        // 运行模块级分析遍
+        if (!pModuleRef) {
+          std::cerr << "Error: Module reference not set for AnalysisManager to run Module Pass.\n";
+          return nullptr;
+        }
+        analysisPass->runOnModule(pModuleRef, *this);
+        // 获取结果并缓存
+        std::unique_ptr<AnalysisResultBase> result = analysisPass->getResult();
+        T *specificResult = static_cast<T *>(result.get());
+        moduleCachedResults[analysisID] = std::move(result); // 缓存结果
+        return specificResult;
+      }
+      case Pass::Granularity::Function: {
+        // 检查请求的上下文是否正确
+        if (!F) {
+          std::cerr << "Error: Function context required for Function-level Analysis Pass.\n";
+          return nullptr;
+        }
+        // 检查是否已存在有效结果
+        auto it = functionCachedResults.find({F, analysisID});
+        if (it != functionCachedResults.end()) {
+          return static_cast<T *>(it->second.get()); // 返回缓存结果
+        }
+        // 运行函数级分析遍
+        analysisPass->runOnFunction(F, *this);
+        // 获取结果并缓存
+        std::unique_ptr<AnalysisResultBase> result = analysisPass->getResult();
+        T *specificResult = static_cast<T *>(result.get());
+        functionCachedResults[{F, analysisID}] = std::move(result); // 缓存结果
+        return specificResult;
+      }
+      case Pass::Granularity::BasicBlock: {
+        // 检查请求的上下文是否正确
+        if (!BB) {
+          std::cerr << "Error: BasicBlock context required for BasicBlock-level Analysis Pass.\n";
+          return nullptr;
+        }
+        // 检查是否已存在有效结果
+        auto it = basicBlockCachedResults.find({BB, analysisID});
+        if (it != basicBlockCachedResults.end()) {
+          return static_cast<T *>(it->second.get()); // 返回缓存结果
+        }
+        // 运行基本块级分析遍
+        analysisPass->runOnBasicBlock(BB, *this);
+        // 获取结果并缓存
+        std::unique_ptr<AnalysisResultBase> result = analysisPass->getResult();
+        T *specificResult = static_cast<T *>(result.get());
+        basicBlockCachedResults[{BB, analysisID}] = std::move(result); // 缓存结果
+        return specificResult;
+      }
+    }
+    return nullptr; // 不会到达这里
+  }
+
+  // 使所有分析结果失效 (当 IR 被修改时调用)
+  void invalidateAllAnalyses() {
+    moduleCachedResults.clear();
+    functionCachedResults.clear();
+    basicBlockCachedResults.clear();
+  }
+
+  // 使特定分析结果失效
+  // void *analysisID: 要失效的分析的ID
+  // Function *F: 如果是函数级分析，指定函数；如果是模块级或基本块级，则为nullptr (取决于调用方式)
+  // BasicBlock *BB: 如果是基本块级分析，指定基本块；否则为nullptr
+  void invalidateAnalysis(void *analysisID, Function *F = nullptr, BasicBlock *BB = nullptr) {
+    if (BB) {
+      // 使特定基本块的特定分析结果失效
+      basicBlockCachedResults.erase({BB, analysisID});
+    } else if (F) {
+      // 使特定函数的特定分析结果失效 (也可能包含聚合的BasicBlock结果)
+      functionCachedResults.erase({F, analysisID});
+      // 遍历所有属于F的基本块，使其BasicBlockCache失效 (如果该分析是BasicBlock粒度的)
+      // 这需要遍历F的所有基本块，效率较低，更推荐在BasicBlockPass的invalidateAnalysisUsage中精确指定
+      // 或者在Function级别的invalidate时，清空该Function的所有BasicBlock分析
+      // 这里的实现简单地清空该Function下所有该ID的BasicBlock缓存
+      for (auto it = basicBlockCachedResults.begin(); it != basicBlockCachedResults.end(); ) {
+          // 假设BasicBlock::getParent()方法存在，可以获取所属Function
+          if (it->first.second == analysisID /* && it->first.first->getParent() == F */) { // 需要BasicBlock能获取其父函数
+              it = basicBlockCachedResults.erase(it);
+          } else {
+              ++it;
+          }
+      }
+
+    } else {
+      // 使所有函数的特定分析结果失效 (Module级和所有Function/BasicBlock级)
+      moduleCachedResults.erase(analysisID);
+      for (auto it = functionCachedResults.begin(); it != functionCachedResults.end(); ) {
+        if (it->first.second == analysisID) {
+          it = functionCachedResults.erase(it);
+        } else {
+          ++it;
+        }
+      }
+      for (auto it = basicBlockCachedResults.begin(); it != basicBlockCachedResults.end(); ) {
+        if (it->first.second == analysisID) {
+          it = basicBlockCachedResults.erase(it);
+        } else {
+          ++it;
+        }
+      }
+    }
+  }
+};
+
+// ======================================================================
+// PassManager：遍管理器
+// ======================================================================
+class PassManager {
+private:
+  std::vector<std::unique_ptr<Pass>> passes;
+  AnalysisManager analysisManager;
+  Module *pmodule;
+  IRBuilder *pBuilder;
+
+public:
+  PassManager() = default;
+  ~PassManager() = default;
+
+  PassManager(Module *module, IRBuilder *builder) : pmodule(module) ,pBuilder(builder), analysisManager(module) {}
+  
+  // 运行所有注册的遍
+  bool run();
+  
+  // 运行优化管道主要负责注册和运行优化遍
+  // 这里可以根据 optLevel 和 DEBUG 控制不同的优化遍
+  void runOptimizationPipeline(Module* moduleIR, IRBuilder* builder, int optLevel);
+
+  // 添加遍：现在接受 Pass 的 ID，而不是直接的 unique_ptr
+  void addPass(void *passID);
+
+  AnalysisManager &getAnalysisManager() { return analysisManager; }
+
+  void clearPasses();
+};
+
+// ======================================================================
+// 辅助宏或函数，用于简化 Pass 的注册
+// ======================================================================
+
+// 用于分析遍的注册
+template <typename AnalysisPassType> void registerAnalysisPass();
+
+// (1) 针对需要 IRBuilder 参数的优化遍的重载
+// 这个模板只在 OptimizationPassType 可以通过 IRBuilder* 构造时才有效
+template <typename OptimizationPassType, typename std::enable_if<
+    std::is_constructible<OptimizationPassType, IRBuilder*>::value, int>::type = 0>
+void registerOptimizationPass(IRBuilder* builder);
+
+// (2) 针对不需要 IRBuilder 参数的所有其他优化遍的重载
+// 这个模板只在 OptimizationPassType 不能通过 IRBuilder* 构造时才有效
+template <typename OptimizationPassType, typename std::enable_if<
+    !std::is_constructible<OptimizationPassType, IRBuilder*>::value, int>::type = 0>
+void registerOptimizationPass();
+
+} // namespace sysy

src/include/PostRA_Scheduler.h

@@ -0,0 +1,30 @@
+#ifndef POST_RA_SCHEDULER_H
+#define POST_RA_SCHEDULER_H
+
+#include "RISCv64LLIR.h"
+#include "Pass.h"
+
+namespace sysy {
+
+/**
+ * @class PostRA_Scheduler
+ * @brief 寄存器分配后的局部指令调度器
+ * * 主要目标是优化寄存器分配器插入的spill/fill代码(lw/sw)，
+ * 尝试将加载指令提前，以隐藏其访存延迟。
+ */
+class PostRA_Scheduler : public Pass {
+public:
+    static char ID;
+    
+    PostRA_Scheduler() : Pass("post-ra-scheduler", Granularity::Function, PassKind::Optimization) {}
+    
+    void *getPassID() const override { return &ID; }
+    
+    bool runOnFunction(Function *F, AnalysisManager& AM) override;
+    
+    void runOnMachineFunction(MachineFunction* mfunc);
+};
+
+} // namespace sysy
+
+#endif // POST_RA_SCHEDULER_H

src/include/PreRA_Scheduler.h

@@ -0,0 +1,30 @@
+#ifndef PRE_RA_SCHEDULER_H
+#define PRE_RA_SCHEDULER_H
+
+#include "RISCv64LLIR.h"
+#include "Pass.h"
+
+namespace sysy {
+
+/**
+ * @class PreRA_Scheduler
+ * @brief 寄存器分配前的指令调度器
+ * * 在虚拟寄存器上进行操作，此时调度自由度最大，
+ * 主要目标是隐藏指令延迟，提高流水线效率。
+ */
+class PreRA_Scheduler : public Pass {
+public:
+    static char ID;
+    
+    PreRA_Scheduler() : Pass("pre-ra-scheduler", Granularity::Function, PassKind::Optimization) {}
+    
+    void *getPassID() const override { return &ID; }
+    
+    bool runOnFunction(Function *F, AnalysisManager& AM) override;
+    
+    void runOnMachineFunction(MachineFunction* mfunc);
+};
+
+} // namespace sysy
+
+#endif // PRE_RA_SCHEDULER_H

src/include/RISCv64AsmPrinter.h

@@ -12,22 +12,25 @@ namespace sysy {
 class RISCv64AsmPrinter {
 public:
     RISCv64AsmPrinter(MachineFunction* mfunc);
+    
     // 主入口
     void run(std::ostream& os, bool debug = false);
-
+    void printInstruction(MachineInstr* instr, bool debug = false);
+    // 辅助函数
+    void setStream(std::ostream& os) { OS = &os; }
 private:
     // 打印各个部分
     void printPrologue();
     void printEpilogue();
     void printBasicBlock(MachineBasicBlock* mbb, bool debug = false);
-    void printInstruction(MachineInstr* instr, bool debug = false);
-    
+
     // 辅助函数
     std::string regToString(PhysicalReg reg);
     void printOperand(MachineOperand* op);
 
     MachineFunction* MFunc;
-    std::ostream* OS;
+    std::ostream* OS = nullptr;
+
 };
 
 } // namespace sysy

src/include/RISCv64ISel.h

@@ -17,6 +17,8 @@ public:
     // 公开接口，以便后续模块（如RegAlloc）可以查询或创建vreg
     unsigned getVReg(Value* val);
     unsigned getNewVReg() { return vreg_counter++; }
+    // 获取 vreg_map 的公共接口
+    const std::map<Value*, unsigned>& getVRegMap() const { return vreg_map; }
 
 private:
     // DAG节点定义，作为ISel的内部实现细节
@@ -33,6 +35,8 @@ private:
     std::vector<std::unique_ptr<DAGNode>> build_dag(BasicBlock* bb);
     DAGNode* get_operand_node(Value* val_ir, std::map<Value*, DAGNode*>&, std::vector<std::unique_ptr<DAGNode>>&);
     DAGNode* create_node(int kind, Value* val, std::map<Value*, DAGNode*>&, std::vector<std::unique_ptr<DAGNode>>&);
+    // 用于计算类型大小的辅助函数
+    unsigned getTypeSizeInBytes(Type* type);
     
     void print_dag(const std::vector<std::unique_ptr<DAGNode>>& dag, const std::string& bb_name);
     

src/include/RISCv64LLIR.h

@@ -18,8 +18,29 @@ namespace sysy {
 
 // 物理寄存器定义
 enum class PhysicalReg {
-    ZERO, RA, SP, GP, TP, T0, T1, T2, S0, S1, A0, A1, A2, A3, A4, A5, A6, A7, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, T3, T4, T5, T6,
-    F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15,F16, F17, F18, F19, F20, F21, F22, F23, F24, F25, F26, F27, F28, F29, F30, F31
+    // --- 特殊功能寄存器 ---
+    ZERO, RA, SP, GP, TP,
+
+    // --- 整数寄存器 (按调用约定分组) ---
+    // 临时寄存器 (调用者保存)
+    T0, T1, T2, T3, T4, T5, T6,
+    
+    // 保存寄存器 (被调用者保存)
+    S0, S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11,
+    
+    // 参数/返回值寄存器 (调用者保存)
+    A0, A1, A2, A3, A4, A5, A6, A7,
+
+    // --- 浮点寄存器 ---
+    // (保持您原有的 F0-F31 命名)
+    F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, 
+    F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, 
+    F22, F23, F24, F25, F26, F27, F28, F29, F30, F31,
+
+    // 用于内部表示物理寄存器在干扰图中的节点ID（一个简单的特殊ID，确保不与vreg_counter冲突）
+    // 假设 vreg_counter 不会达到这么大的值
+    PHYS_REG_START_ID = 100000, 
+    PHYS_REG_END_ID = PHYS_REG_START_ID + 320, // 预留足够的空间
 };
 
 // RISC-V 指令操作码枚举
@@ -44,11 +65,16 @@ enum class RVOpcodes {
     // 特殊标记，非指令
     LABEL,
     // 新增伪指令，用于解耦栈帧处理
-    FRAME_LOAD,  // 从栈帧加载 (AllocaInst)
-    FRAME_STORE, // 保存到栈帧 (AllocaInst)
-    FRAME_ADDR,  // [新] 获取栈帧变量的地址
+    FRAME_LOAD_W,  // 从栈帧加载 32位 Word (对应 lw)
+    FRAME_LOAD_D,  // 从栈帧加载 64位 Doubleword (对应 ld)
+    FRAME_STORE_W, // 保存 32位 Word 到栈帧 (对应 sw)
+    FRAME_STORE_D, // 保存 64位 Doubleword 到栈帧 (对应 sd)
+    FRAME_ADDR,  // 获取栈帧变量的地址
 };
 
+// 定义一个全局辅助函数或常量，提供调用者保存寄存器列表
+const std::vector<PhysicalReg>& getCallerSavedIntRegs();
+
 class MachineOperand;
 class RegOperand;
 class ImmOperand;
@@ -169,8 +195,10 @@ struct StackFrameInfo {
     int locals_size = 0; // 仅为AllocaInst分配的大小
     int spill_size = 0; // 仅为溢出分配的大小
     int total_size = 0; // 总大小
+    int callee_saved_size = 0; // 保存寄存器的大小
     std::map<unsigned, int> alloca_offsets; // <AllocaInst的vreg, 栈偏移>
     std::map<unsigned, int> spill_offsets;  // <溢出vreg, 栈偏移>
+    std::set<PhysicalReg> used_callee_saved_regs; // 使用的保存寄存器
 };
 
 // 机器函数
@@ -196,6 +224,15 @@ private:
     StackFrameInfo frame_info;
 };
 
+inline const std::vector<PhysicalReg>& getCallerSavedIntRegs() {
+    static const std::vector<PhysicalReg> regs = {
+        PhysicalReg::T0, PhysicalReg::T1, PhysicalReg::T2, PhysicalReg::T3,
+        PhysicalReg::T4, PhysicalReg::T5, PhysicalReg::T6,
+        PhysicalReg::A0, PhysicalReg::A1, PhysicalReg::A2, PhysicalReg::A3,
+        PhysicalReg::A4, PhysicalReg::A5, PhysicalReg::A6, PhysicalReg::A7
+    };
+    return regs;
+}
 } // namespace sysy
 
 #endif // RISCV64_LLIR_H

src/include/RISCv64Passes.h

@@ -2,60 +2,14 @@
 #define RISCV64_PASSES_H
 
 #include "RISCv64LLIR.h"
+#include "RISCv64Peephole.h"
+#include "PreRA_Scheduler.h"
+#include "PostRA_Scheduler.h"
+#include "CalleeSavedHandler.h"
+#include "Pass.h"
 
 namespace sysy {
 
-/**
- * @class Pass
- * @brief 所有优化Pass的抽象基类 (可选，但推荐)
- * * 定义一个通用的接口，所有优化都应该实现它。
- */
-class Pass {
-public:
-    virtual ~Pass() = default;
-    virtual void runOnMachineFunction(MachineFunction* mfunc) = 0;
-};
-
-
-// --- 寄存器分配前优化 ---
-
-/**
- * @class PreRA_Scheduler
- * @brief 寄存器分配前的指令调度器
- * * 在虚拟寄存器上进行操作，此时调度自由度最大，
- * 主要目标是隐藏指令延迟，提高流水线效率。
- */
-class PreRA_Scheduler : public Pass {
-public:
-    void runOnMachineFunction(MachineFunction* mfunc) override;
-};
-
-
-// --- 寄存器分配后优化 ---
-
-/**
- * @class PeepholeOptimizer
- * @brief 窥孔优化器
- * * 在已分配物理寄存器的指令流上，通过一个小的滑动窗口来查找
- * 并替换掉一些冗余或低效的指令模式。
- */
-class PeepholeOptimizer : public Pass {
-public:
-    void runOnMachineFunction(MachineFunction* mfunc) override;
-};
-
-/**
- * @class PostRA_Scheduler
- * @brief 寄存器分配后的局部指令调度器
- * * 主要目标是优化寄存器分配器插入的spill/fill代码(lw/sw)，
- * 尝试将加载指令提前，以隐藏其访存延迟。
- */
-class PostRA_Scheduler : public Pass {
-public:
-    void runOnMachineFunction(MachineFunction* mfunc) override;
-};
-
-
 } // namespace sysy
 
 #endif // RISCV64_PASSES_H

src/include/RISCv64Peephole.h

@@ -0,0 +1,30 @@
+#ifndef RISCV64_PEEPHOLE_H
+#define RISCV64_PEEPHOLE_H
+
+#include "RISCv64LLIR.h"
+#include "Pass.h"
+
+namespace sysy {
+
+/**
+ * @class PeepholeOptimizer
+ * @brief 窥孔优化器
+ * * 在已分配物理寄存器的指令流上，通过一个小的滑动窗口来查找
+ * 并替换掉一些冗余或低效的指令模式。
+ */
+class PeepholeOptimizer : public Pass {
+public:
+    static char ID;
+    
+    PeepholeOptimizer() : Pass("peephole-optimizer", Granularity::Function, PassKind::Optimization) {}
+    
+    void *getPassID() const override { return &ID; }
+    
+    bool runOnFunction(Function *F, AnalysisManager& AM) override;
+    
+    void runOnMachineFunction(MachineFunction* mfunc);
+};
+
+} // namespace sysy
+
+#endif // RISCV64_PEEPHOLE_H

src/include/RISCv64RegAlloc.h

@@ -2,6 +2,10 @@
 #define RISCV64_REGALLOC_H
 
 #include "RISCv64LLIR.h"
+#include "RISCv64ISel.h" // 包含 RISCv64ISel.h 以访问 ISel 和 Value 类型
+
+extern int DEBUG;
+extern int DEEPDEBUG;
 
 namespace sysy {
 
@@ -34,6 +38,9 @@ private:
     // 辅助函数，获取指令的Use/Def集合
     void getInstrUseDef(MachineInstr* instr, LiveSet& use, LiveSet& def);
 
+    // 辅助函数，处理调用约定
+    void handleCallingConvention();
+
     MachineFunction* MFunc;
     
     // 活跃性分析结果
@@ -49,6 +56,18 @@ private:
 
     // 可用的物理寄存器池
     std::vector<PhysicalReg> allocable_int_regs;
+
+    // 存储vreg到IR Value*的反向映射
+    // 这个map将在run()函数开始时被填充，并在rewriteFunction()中使用。
+    std::map<unsigned, Value*> vreg_to_value_map;
+    std::map<PhysicalReg, unsigned> preg_to_vreg_id_map; // 物理寄存器到特殊vreg ID的映射
+    
+    // 用于计算类型大小的辅助函数
+    unsigned getTypeSizeInBytes(Type* type);
+
+    // 辅助函数，用于打印集合
+    static void printLiveSet(const LiveSet& s, const std::string& name, std::ostream& os);
+    
 };
 
 } // namespace sysy

src/include/Reg2Mem.h

@@ -1,23 +0,0 @@
-#pragma once
-
-#include "IR.h"
-#include "IRBuilder.h"
-
-namespace sysy {
-/**
- * Reg2Mem(后端未做phi指令翻译)
- */
-class Reg2Mem {
-private:
-  Module *pModule;
-  IRBuilder *pBuilder;
-
-public:
-  Reg2Mem(Module *pMoudle, IRBuilder *pBuilder) : pModule(pMoudle), pBuilder(pBuilder) {}
-
-  void DeletePhiInst();
-  // 删除UD关系, 因为删除了phi指令会修改ud关系
-  void usedelete(Instruction *instr);
-};
-
-} // namespace sysy

src/include/SCCP.h

@@ -0,0 +1,196 @@
+#pragma once
+
+#include "IR.h"
+
+namespace sysy {
+
+// 稀疏条件常量传播类
+// Sparse Conditional Constant Propagation
+/*
+伪代码
+function SCCP_Optimization(Module):
+    for each Function in Module:
+        changed = true
+        while changed:
+            changed = false
+            // 阶段1: 常量传播与折叠
+            changed |= PropagateConstants(Function)
+            // 阶段2: 控制流简化
+            changed |= SimplifyControlFlow(Function)
+        end while
+    end for
+
+function PropagateConstants(Function):
+    // 初始化
+    executableBlocks = {entryBlock}
+    valueState = map<Value, State> // 值->状态映射
+    instWorkList = Queue()
+    edgeWorkList = Queue()
+    
+    // 初始化工作列表
+    for each inst in entryBlock:
+        instWorkList.push(inst)
+    
+    // 迭代处理
+    while !instWorkList.empty() || !edgeWorkList.empty():
+        // 处理指令工作列表
+        while !instWorkList.empty():
+            inst = instWorkList.pop()
+            // 如果指令是可执行基本块中的
+            if executableBlocks.contains(inst.parent):
+                ProcessInstruction(inst)
+        
+        // 处理边工作列表
+        while !edgeWorkList.empty():
+            edge = edgeWorkList.pop()
+            ProcessEdge(edge)
+    
+    // 应用常量替换
+    for each inst in Function:
+        if valueState[inst] == CONSTANT:
+            ReplaceWithConstant(inst, valueState[inst].constant)
+            changed = true
+    
+    return changed
+
+function ProcessInstruction(Instruction inst):
+    switch inst.type:
+        //二元操作
+        case BINARY_OP:
+            lhs = GetValueState(inst.operands[0])
+            rhs = GetValueState(inst.operands[1])
+            if lhs == CONSTANT && rhs == CONSTANT:
+                newState = ComputeConstant(inst.op, lhs.value, rhs.value)
+                UpdateState(inst, newState)
+            else if lhs == BOTTOM || rhs == BOTTOM:
+                UpdateState(inst, BOTTOM)
+        //phi
+        case PHI:
+            mergedState = ⊤
+            for each incoming in inst.incomings:
+            // 检查每个输入的状态
+                if executableBlocks.contains(incoming.block):
+                    incomingState = GetValueState(incoming.value)
+                    mergedState = Meet(mergedState, incomingState)
+            UpdateState(inst, mergedState)
+        // 条件分支
+        case COND_BRANCH:
+            cond = GetValueState(inst.condition)
+            if cond == CONSTANT:
+                // 判断条件分支
+                if cond.value == true:
+                    AddEdgeToWorkList(inst.parent, inst.trueTarget)
+                else:
+                    AddEdgeToWorkList(inst.parent, inst.falseTarget)
+            else if cond == BOTTOM:
+                AddEdgeToWorkList(inst.parent, inst.trueTarget)
+                AddEdgeToWorkList(inst.parent, inst.falseTarget)
+        
+        case UNCOND_BRANCH:
+            AddEdgeToWorkList(inst.parent, inst.target)
+        
+        // 其他指令处理...
+
+function ProcessEdge(Edge edge):
+    fromBB, toBB = edge
+    if !executableBlocks.contains(toBB):
+        executableBlocks.add(toBB)
+        for each inst in toBB:
+            if inst is PHI:
+                instWorkList.push(inst)
+            else:
+                instWorkList.push(inst) // 非PHI指令
+    
+    // 更新PHI节点的输入
+    for each phi in toBB.phis:
+        instWorkList.push(phi)
+
+function SimplifyControlFlow(Function):
+    changed = false
+    // 标记可达基本块
+    ReachableBBs = FindReachableBlocks(Function.entry)
+    
+    // 删除不可达块
+    for each bb in Function.blocks:
+        if !ReachableBBs.contains(bb):
+            RemoveDeadBlock(bb)
+            changed = true
+    
+    // 简化条件分支
+    for each bb in Function.blocks:
+        terminator = bb.terminator
+        if terminator is COND_BRANCH:
+            cond = GetValueState(terminator.condition)
+            if cond == CONSTANT:
+                SimplifyBranch(terminator, cond.value)
+                changed = true
+    
+    return changed
+
+function RemoveDeadBlock(BasicBlock bb):
+    // 1. 更新前驱块的分支指令
+    for each pred in bb.predecessors:
+        UpdateTerminator(pred, bb)
+    
+    // 2. 更新后继块的PHI节点
+    for each succ in bb.successors:
+        RemovePhiIncoming(succ, bb)
+    
+    // 3. 删除块内所有指令
+    for each inst in bb.instructions:
+        inst.remove()
+    
+    // 4. 从函数中移除基本块
+    Function.removeBlock(bb)
+
+function Meet(State a, State b):
+    if a == ⊤: return b
+    if b == ⊤: return a
+    if a == ⊥ || b == ⊥: return ⊥
+    if a.value == b.value: return a
+    return ⊥
+
+function UpdateState(Value v, State newState):
+    oldState = valueState.get(v, ⊤)
+    if newState != oldState:
+        valueState[v] = newState
+        for each user in v.users:
+            if user is Instruction:
+                instWorkList.push(user)
+
+*/
+
+enum class LatticeValue {
+  Top,       // ⊤ (Unknown)
+  Constant,  // c (Constant)
+  Bottom     // ⊥ (Undefined / Varying)
+};
+// LatticeValue: 用于表示值的状态，Top表示未知，Constant表示常量，Bottom表示未定义或变化的值。
+// 这里的LatticeValue用于跟踪每个SSA值（变量、指令结果）的状态，
+// 以便在SCCP过程中进行常量传播和控制流简化。
+
+//TODO: 下列数据结构考虑集成到类中，避免重命名问题
+static std::set<Instruction *> Worklist;
+static std::unordered_set<BasicBlock*> Executable_Blocks;
+static std::queue<std::pair<BasicBlock *, BasicBlock *> > Executable_Edges;
+static std::map<Value*, LatticeValue> valueState;
+
+class SCCP {
+private:
+  Module *pModule;
+
+public:
+  SCCP(Module *pMoudle) : pModule(pMoudle) {}
+
+  void run();
+  bool PropagateConstants(Function *function);
+  bool SimplifyControlFlow(Function *function);
+  void ProcessInstruction(Instruction *inst);
+  void ProcessEdge(const std::pair<BasicBlock *, BasicBlock *> &edge);
+  void RemoveDeadBlock(BasicBlock *bb);
+  void UpdateState(Value *v, LatticeValue newState);
+  LatticeValue Meet(LatticeValue a, LatticeValue b);
+  LatticeValue GetValueState(Value *v);
+};
+
+}  // namespace sysy

src/include/SysYFormatter.h

@@ -1,340 +0,0 @@
-#pragma once
-
-#include "SysYBaseVisitor.h"
-#include "SysYParser.h"
-#include <ostream>
-
-namespace sysy {
-
-class SysYFormatter : public SysYBaseVisitor {
-protected:
-  std::ostream &os;
-  int indent = 0;
-
-public:
-  SysYFormatter(std::ostream &os) : os(os), indent(0) {}
-
-protected:
-  struct Indentor {
-    static constexpr int TabSize = 2;
-    int &indent;
-    Indentor(int &indent) : indent(indent) { indent += TabSize; }
-    ~Indentor() { indent -= TabSize; }
-  };
-  std::ostream &space() { return os << std::string(indent, ' '); }
-  template <typename T>
-  std::ostream &interleave(const T &container, const std::string sep = ", ") {
-    auto b = container.begin(), e = container.end();
-    (*b)->accept(this);
-    for (b = std::next(b); b != e; b = std::next(b)) {
-      os << sep;
-      (*b)->accept(this);
-    }
-    return os;
-  }
-
-public:
-  //   virtual std::any visitModule(SysYParser::ModuleContext *ctx) override {
-  //     return visitChildren(ctx);
-  //   }
-
-  virtual std::any visitBtype(SysYParser::BtypeContext *ctx) override {
-    os << ctx->getText();
-    return 0;
-  }
-
-  virtual std::any visitDecl(SysYParser::DeclContext *ctx) override {
-    space();
-    if (ctx->CONST())
-      os << ctx->CONST()->getText() << ' ';
-    ctx->btype()->accept(this);
-    os << ' ';
-    interleave(ctx->varDef(), ", ") << ';' << '\n';
-    return 0;
-  }
-
-  virtual std::any visitVarDef(SysYParser::VarDefContext *ctx) override {
-    ctx->lValue()->accept(this);
-    if (ctx->initValue()) {
-      os << ' ' << '=' << ' ';
-      ctx->initValue()->accept(this);
-    }
-    return 0;
-  }
-
-  virtual std::any visitInitValue(SysYParser::InitValueContext *ctx) override {
-    if (not ctx->exp()) {
-      os << '{';
-      auto values = ctx->initValue();
-      if (values.size())
-        interleave(values, ", ");
-      os << '}';
-    }
-    return 0;
-  }
-
-  virtual std::any visitFunc(SysYParser::FuncContext *ctx) override {
-    ctx->funcType()->accept(this);
-    os << ' ' << ctx->ID()->getText() << '(';
-    if (ctx->funcFParams())
-      ctx->funcFParams()->accept(this);
-    os << ')' << ' ';
-    ctx->blockStmt()->accept(this);
-    os << '\n';
-    return 0;
-  }
-
-  virtual std::any visitFuncType(SysYParser::FuncTypeContext *ctx) override {
-    os << ctx->getText();
-    return 0;
-  }
-
-  virtual std::any
-  visitFuncFParams(SysYParser::FuncFParamsContext *ctx) override {
-    interleave(ctx->funcFParam(), ", ");
-    return 0;
-  }
-
-  virtual std::any
-  visitFuncFParam(SysYParser::FuncFParamContext *ctx) override {
-    ctx->btype()->accept(this);
-    os << ' ' << ctx->ID()->getText();
-    if (not ctx->LBRACKET().empty()) {
-      os << '[';
-      auto exp = ctx->exp();
-      if (not exp.empty()) {
-        os << '[';
-        interleave(exp, "][") << ']';
-      }
-    }
-    return 0;
-  }
-
-  virtual std::any visitBlockStmt(SysYParser::BlockStmtContext *ctx) override {
-    os << '{' << '\n';
-    {
-      Indentor indentor(indent);
-      auto items = ctx->blockItem();
-      if (not items.empty())
-        interleave(items, "");
-    }
-    space() << ctx->RBRACE()->getText() << '\n';
-    return 0;
-  }
-
-  //   virtual std::any visitBlockItem(SysYParser::BlockItemContext *ctx)
-  //   override {
-  //     return visitChildren(ctx);
-  //   }
-
-  //   virtual std::any visitStmt(SysYParser::StmtContext *ctx) override {
-  //     return visitChildren(ctx);
-  //   }
-
-  virtual std::any
-  visitAssignStmt(SysYParser::AssignStmtContext *ctx) override {
-    space();
-    ctx->lValue()->accept(this);
-    os << " = ";
-    ctx->exp()->accept(this);
-    os << ';' << '\n';
-    return 0;
-  }
-
-  virtual std::any visitExpStmt(SysYParser::ExpStmtContext *ctx) override {
-    space();
-    ctx->exp()->accept(this);
-    os << ';' << '\n';
-    return 0;
-  }
-
-  void wrapBlock(SysYParser::StmtContext *stmt) {
-    bool isBlock = stmt->blockStmt();
-    if (isBlock) {
-      stmt->accept(this);
-    } else {
-      os << "{\n";
-      {
-        Indentor indentor(indent);
-        stmt->accept(this);
-      }
-      space() << "}\n";
-    }
-  };
-  virtual std::any visitIfStmt(SysYParser::IfStmtContext *ctx) override {
-    space();
-    os << ctx->IF()->getText() << " (";
-    ctx->exp()->accept(this);
-    os << ") ";
-    auto stmt = ctx->stmt();
-    auto ifStmt = stmt[0];
-    wrapBlock(ifStmt);
-    if (stmt.size() == 2) {
-      auto elseStmt = stmt[1];
-      wrapBlock(elseStmt);
-    }
-    return 0;
-  }
-
-  virtual std::any visitWhileStmt(SysYParser::WhileStmtContext *ctx) override {
-    space();
-    os << ctx->WHILE()->getText() << " (";
-    ctx->exp()->accept(this);
-    os << ") ";
-    wrapBlock(ctx->stmt());
-    return 0;
-  }
-
-  virtual std::any visitBreakStmt(SysYParser::BreakStmtContext *ctx) override {
-    space() << ctx->BREAK()->getText() << ';' << '\n';
-    return 0;
-  }
-
-  virtual std::any
-  visitContinueStmt(SysYParser::ContinueStmtContext *ctx) override {
-    space() << ctx->CONTINUE()->getText() << ';' << '\n';
-    return 0;
-  }
-
-  virtual std::any
-  visitReturnStmt(SysYParser::ReturnStmtContext *ctx) override {
-    space() << ctx->RETURN()->getText();
-    if (ctx->exp()) {
-      os << ' ';
-      ctx->exp()->accept(this);
-    }
-    os << ';' << '\n';
-    return 0;
-  }
-
-  //   virtual std::any visitEmptyStmt(SysYParser::EmptyStmtContext *ctx)
-  //   override {
-  //     return visitChildren(ctx);
-  //   }
-
-  virtual std::any
-  visitRelationExp(SysYParser::RelationExpContext *ctx) override {
-    auto lhs = ctx->exp(0);
-    auto rhs = ctx->exp(1);
-    std::string op =
-        ctx->LT() ? "<" : (ctx->LE() ? "<=" : (ctx->GT() ? ">" : ">="));
-    lhs->accept(this);
-    os << ' ' << op << ' ';
-    rhs->accept(this);
-    return 0;
-  }
-
-  virtual std::any
-  visitMultiplicativeExp(SysYParser::MultiplicativeExpContext *ctx) override {
-    auto lhs = ctx->exp(0);
-    auto rhs = ctx->exp(1);
-    std::string op = ctx->MUL() ? "*" : (ctx->DIV() ? "/" : "%");
-    lhs->accept(this);
-    os << ' ' << op << ' ';
-    rhs->accept(this);
-    return 0;
-  }
-
-  //   virtual std::any visitLValueExp(SysYParser::LValueExpContext *ctx)
-  //   override {
-  //     return visitChildren(ctx);
-  //   }
-
-  //   virtual std::any visitNumberExp(SysYParser::NumberExpContext *ctx)
-  //   override {
-  //     return visitChildren(ctx);
-  //   }
-
-  virtual std::any visitAndExp(SysYParser::AndExpContext *ctx) override {
-    ctx->exp(0)->accept(this);
-    os << " && ";
-    ctx->exp(1)->accept(this);
-    return 0;
-  }
-
-  virtual std::any visitUnaryExp(SysYParser::UnaryExpContext *ctx) override {
-    std::string op = ctx->ADD() ? "+" : (ctx->SUB() ? "-" : "!");
-    os << op;
-    ctx->exp()->accept(this);
-    return 0;
-  }
-
-  virtual std::any visitParenExp(SysYParser::ParenExpContext *ctx) override {
-    os << '(';
-    ctx->exp()->accept(this);
-    os << ')';
-    return 0;
-  }
-
-  virtual std::any visitStringExp(SysYParser::StringExpContext *ctx) override {
-    return visitChildren(ctx);
-  }
-
-  virtual std::any visitOrExp(SysYParser::OrExpContext *ctx) override {
-    ctx->exp(0)->accept(this);
-    os << " || ";
-    ctx->exp(1)->accept(this);
-    return 0;
-  }
-
-  //   virtual std::any visitCallExp(SysYParser::CallExpContext *ctx) override {
-  //     return visitChildren(ctx);
-  //   }
-
-  virtual std::any
-  visitAdditiveExp(SysYParser::AdditiveExpContext *ctx) override {
-    auto lhs = ctx->exp(0);
-    auto rhs = ctx->exp(1);
-    std::string op = ctx->ADD() ? "+" : "-";
-    lhs->accept(this);
-    os << ' ' << op << ' ';
-    rhs->accept(this);
-    return 0;
-  }
-
-  virtual std::any visitEqualExp(SysYParser::EqualExpContext *ctx) override {
-    auto lhs = ctx->exp(0);
-    auto rhs = ctx->exp(1);
-    std::string op = ctx->EQ() ? "==" : "!=";
-    lhs->accept(this);
-    os << ' ' << op << ' ';
-    rhs->accept(this);
-    return 0;
-  }
-
-  virtual std::any visitCall(SysYParser::CallContext *ctx) override {
-    os << ctx->ID()->getText() << '(';
-    if (ctx->funcRParams())
-      ctx->funcRParams()->accept(this);
-    os << ')';
-    return 0;
-  }
-
-  virtual std::any visitLValue(SysYParser::LValueContext *ctx) override {
-    os << ctx->ID()->getText();
-    auto exp = ctx->exp();
-    if (not exp.empty()) {
-      os << '[';
-      interleave(exp, "][") << ']';
-    }
-    return 0;
-  }
-
-  virtual std::any visitNumber(SysYParser::NumberContext *ctx) override {
-    os << ctx->getText();
-    return 0;
-  }
-
-  virtual std::any visitString(SysYParser::StringContext *ctx) override {
-    os << ctx->getText();
-    return 0;
-  }
-
-  virtual std::any
-  visitFuncRParams(SysYParser::FuncRParamsContext *ctx) override {
-    interleave(ctx->exp(), ", ");
-    return 0;
-  }
-};
-
-} // namespace sysy

src/include/SysYIRCFGOpt.h

@@ -0,0 +1,101 @@
+#pragma once
+
+#include "IR.h"
+#include "IRBuilder.h"
+#include "Pass.h"
+
+namespace sysy {
+
+// 优化前对SysY IR的预处理，也可以视作部分CFG优化
+// 主要包括删除无用指令、合并基本块、删除空块等
+// 这些操作可以在SysY IR生成时就完成，但为了简化IR生成过程，
+// 这里将其放在SysY IR生成后进行预处理
+// 同时兼容phi节点的处理，可以再mem2reg后再次调用优化
+
+//TODO: 可增加的CFG优化和方法
+// - 检查基本块跳转关系正确性
+// - 简化条件分支（Branch Simplification），如条件恒真/恒假转为直接跳转
+// - 合并连续的跳转指令（Jump Threading）在合并不可达块中似乎已经实现了
+// - 基本块重排序（Block Reordering），提升局部性
+
+// 辅助工具类，包含实际的CFG优化逻辑
+// 这些方法可以被独立的Pass调用
+class SysYCFGOptUtils {
+public:
+  static bool SysYDelInstAfterBr(Function *func); // 删除br后面的指令
+  static bool SysYDelEmptyBlock(Function *func, IRBuilder* pBuilder); // 空块删除
+  static bool SysYDelNoPreBLock(Function *func); // 删除无前驱块（不可达块）
+  static bool SysYBlockMerge(Function *func);    // 合并基本块
+  static bool SysYAddReturn(Function *func, IRBuilder* pBuilder);     // 添加return指令
+  static bool SysYCondBr2Br(Function *func, IRBuilder* pBuilder);  // 条件分支转换为无条件分支
+};
+
+// ======================================================================
+// 独立的CFG优化遍
+// ======================================================================
+
+class SysYDelInstAfterBrPass : public OptimizationPass {
+public:
+  static void *ID; // 唯一ID
+  SysYDelInstAfterBrPass() : OptimizationPass("SysYDelInstAfterBrPass", Granularity::Function) {}
+  bool runOnFunction(Function *F, AnalysisManager& AM) override;
+  void getAnalysisUsage(std::set<void *> &analysisDependencies, std::set<void *> &analysisInvalidations) const override {
+    // 这个优化可能改变CFG结构，使一些CFG相关的分析失效
+    // 可以在这里指定哪些分析会失效，例如支配树、活跃变量等
+    // analysisInvalidations.insert(DominatorTreeAnalysisPass::ID); // 示例
+  }
+  void *getPassID() const override { return &ID; }
+};
+
+class SysYDelEmptyBlockPass : public OptimizationPass {
+private:
+  IRBuilder *pBuilder;
+public:
+  static void *ID;
+  SysYDelEmptyBlockPass(IRBuilder *builder) : OptimizationPass("SysYDelEmptyBlockPass", Granularity::Function), pBuilder(builder) {}
+  bool runOnFunction(Function *F, AnalysisManager& AM) override;
+  void getAnalysisUsage(std::set<void *> &analysisDependencies, std::set<void *> &analysisInvalidations) const override {};
+  void *getPassID() const override { return &ID; }
+};
+
+class SysYDelNoPreBLockPass : public OptimizationPass {
+public:
+  static void *ID;
+  SysYDelNoPreBLockPass() : OptimizationPass("SysYDelNoPreBLockPass", Granularity::Function) {}
+  bool runOnFunction(Function *F, AnalysisManager& AM) override;
+  void getAnalysisUsage(std::set<void *> &analysisDependencies, std::set<void *> &analysisInvalidations) const override {};
+  void *getPassID() const override { return &ID; }
+};
+
+class SysYBlockMergePass : public OptimizationPass {
+public:
+  static void *ID;
+  SysYBlockMergePass() : OptimizationPass("SysYBlockMergePass", Granularity::Function) {}
+  bool runOnFunction(Function *F, AnalysisManager& AM) override;
+  void getAnalysisUsage(std::set<void *> &analysisDependencies, std::set<void *> &analysisInvalidations) const override {};
+  void *getPassID() const override { return &ID; }
+};
+
+class SysYAddReturnPass : public OptimizationPass {
+private:
+  IRBuilder *pBuilder;
+public:
+  static void *ID;
+  SysYAddReturnPass(IRBuilder *builder) : OptimizationPass("SysYAddReturnPass", Granularity::Function), pBuilder(builder) {}
+  bool runOnFunction(Function *F, AnalysisManager& AM) override;
+  void getAnalysisUsage(std::set<void *> &analysisDependencies, std::set<void *> &analysisInvalidations) const override {};
+  void *getPassID() const override { return &ID; }
+};
+
+class SysYCondBr2BrPass : public OptimizationPass {
+private:
+  IRBuilder *pBuilder;
+public:
+  static void *ID;
+  SysYCondBr2BrPass(IRBuilder *builder) : OptimizationPass("SysYCondBr2BrPass", Granularity::Function), pBuilder(builder) {}
+  bool runOnFunction(Function *F, AnalysisManager& AM) override;
+  void getAnalysisUsage(std::set<void *> &analysisDependencies, std::set<void *> &analysisInvalidations) const override {};
+  void *getPassID() const override { return &ID; }
+};
+
+}  // namespace sysy

src/include/SysYIRGenerator.h

@@ -62,12 +62,11 @@ private:
 public:
   SysYIRGenerator() = default;
 
-  bool HasReturnInst;
-
 public:
   Module *get() const { return module.get(); }
   IRBuilder *getBuilder(){ return &builder; }
 public:
+
   std::any visitCompUnit(SysYParser::CompUnitContext *ctx) override;
 
   std::any visitGlobalConstDecl(SysYParser::GlobalConstDeclContext *ctx) override;
@@ -134,6 +133,13 @@ public:
   
   // std::any visitConstExp(SysYParser::ConstExpContext *ctx) override;
 
+public:
+  // 获取GEP指令的地址
+  Value* getGEPAddressInst(Value* basePointer, const std::vector<Value*>& indices);
+  // 构建数组类型
+  Type* buildArrayType(Type* baseType, const std::vector<Value*>& dims);
+
+  unsigned countArrayDimensions(Type* type);
 
 }; // class SysYIRGenerator
 

src/include/SysYIROptPre.h

@@ -1,37 +0,0 @@
-#pragma once
-
-#include "IR.h"
-#include "IRBuilder.h"
-
-namespace sysy {
-
-// 优化前对SysY IR的预处理，也可以视作部分CFG优化
-// 主要包括删除无用指令、合并基本块、删除空块等
-// 这些操作可以在SysY IR生成时就完成，但为了简化IR生成过程，
-// 这里将其放在SysY IR生成后进行预处理
-// 同时兼容phi节点的处理，可以再mem2reg后再次调用优化
-class SysYOptPre {
- private:
-  Module *pModule;
-  IRBuilder *pBuilder;
-
- public:
-  SysYOptPre(Module *pMoudle, IRBuilder *pBuilder) : pModule(pMoudle), pBuilder(pBuilder) {}
-
-  void SysYOptimizateAfterIR(){
-    SysYDelInstAfterBr();
-    SysYBlockMerge();
-    SysYDelNoPreBLock();
-    SysYDelEmptyBlock();
-    SysYAddReturn();
-  }
-  void SysYDelInstAfterBr(); // 删除br后面的指令
-  void SysYDelEmptyBlock(); // 空块删除
-  void SysYDelNoPreBLock(); // 删除无前驱块
-  void SysYBlockMerge();    // 合并基本块(主要针对嵌套if while的exit块，
-                            // 也可以修改IR生成实现回填机制
-  void SysYAddReturn();     // 添加return指令(主要针对Void函数)
-  void usedelete(Instruction *instr); // use删除
-};
-
-}  // namespace sysy

src/include/SysYIROptUtils.h

@@ -0,0 +1,33 @@
+#pragma once
+
+#include "IR.h"
+
+namespace sysy {
+
+// 优化工具类，包含一些通用的优化方法
+// 这些方法可以在不同的优化 pass 中复用
+// 例如：删除use关系,判断是否是全局变量等
+class SysYIROptUtils{
+
+public:
+  // 仅仅删除use关系
+  static void usedelete(Instruction *instr) {
+    for (auto &use : instr->getOperands()) {
+      Value* val = use->getValue();
+      val->removeUse(use);
+    }
+  }
+
+  // 判断是否是全局变量
+  static bool isGlobal(Value *val) {
+    auto gval = dynamic_cast<GlobalValue *>(val);
+    return gval != nullptr;
+  }
+  // 判断是否是数组
+  static bool isArr(Value *val) {
+    auto aval = dynamic_cast<AllocaInst *>(val);
+  return aval != nullptr && aval->getNumDims() != 0;
+  }
+};
+
+}// namespace sysy

src/include/SysYIRPassManager.h

@@ -0,0 +1,58 @@
+// PassManager.h
+#pragma once
+
+#include <vector>
+#include <memory>
+#include <typeindex> // For std::type_index
+#include <unordered_map>
+#include "SysYIRPass.h"
+#include "IR.h" // 假设你的IR.h定义了Module, Function等
+
+namespace sysy {
+
+class PassManager {
+public:
+	PassManager() = default;
+
+	// 添加一个FunctionPass
+	void addPass(std::unique_ptr<FunctionPass> pass) {
+		functionPasses.push_back(std::move(pass));
+	}
+
+	// 添加一个ModulePass
+	void addPass(std::unique_ptr<ModulePass> pass) {
+		modulePasses.push_back(std::move(pass));
+	}
+
+	// 添加一个AnalysisPass
+	template<typename T, typename... Args>
+	T* addAnalysisPass(Args&&... args) {
+		static_assert(std::is_base_of<AnalysisPass, T>::value, "T must derive from AnalysisPass");
+		auto analysis = std::make_unique<T>(std::forward<Args>(args)...);
+		T* rawPtr = analysis.get();
+		analysisPasses[std::type_index(typeid(T))] = std::move(analysis);
+		return rawPtr;
+	}
+
+	// 获取分析结果（用于其他Pass访问）
+	template<typename T>
+	T* getAnalysis() {
+		static_assert(std::is_base_of<AnalysisPass, T>::value, "T must derive from AnalysisPass");
+		auto it = analysisPasses.find(std::type_index(typeid(T)));
+		if (it != analysisPasses.end()) {
+			return static_cast<T*>(it->second.get());
+		}
+		return nullptr; // 或者抛出异常
+	}
+
+	// 运行所有注册的遍
+	void run(Module& M);
+
+private:
+	std::vector<std::unique_ptr<FunctionPass>> functionPasses;
+	std::vector<std::unique_ptr<ModulePass>> modulePasses;
+	std::unordered_map<std::type_index, std::unique_ptr<AnalysisPass>> analysisPasses;
+	// 未来可以添加AnalysisPass的缓存机制
+};
+
+} // namespace sysy

src/sysyc.cpp

@@ -13,13 +13,10 @@ using namespace antlr4;
 
 #include "SysYIRGenerator.h"
 #include "SysYIRPrinter.h"
-#include "SysYIROptPre.h"
+#include "SysYIRCFGOpt.h" // 包含 CFG 优化
 #include "RISCv64Backend.h"
-#include "SysYIRAnalyser.h"
-// #include "DeadCodeElimination.h"
+#include "Pass.h" // 包含新的 Pass 框架
 #include "AddressCalculationExpansion.h"
-// #include "Mem2Reg.h"
-// #include "Reg2Mem.h"
 
 using namespace sysy;
 
@@ -131,19 +128,20 @@ int main(int argc, char **argv) {
   if (argStopAfter == "ird") {
     DEBUG = 1; // 这里可能需要更精细地控制 DEBUG 的开启时机和范围
   }
-  // 默认优化 pass (在所有优化级别都会执行)
-  SysYOptPre optPre(moduleIR, builder);
-  optPre.SysYOptimizateAfterIR(); 
-
-  ControlFlowAnalysis cfa(moduleIR);
-  cfa.init();
-  ActiveVarAnalysis ava;
-  ava.init(moduleIR);
-
+  
   if (DEBUG) {
-    cout << "=== After CFA & AVA (Default) ===\n";
+    cout << "=== Init IR ===\n";
     SysYPrinter(moduleIR).printIR(); // 临时打印器用于调试
   }
+
+  // 创建 Pass 管理器并运行优化管道
+  PassManager passManager(moduleIR, builder); // 创建 Pass 管理器
+  // 好像都不用传递module和builder了，因为 PassManager 初始化了
+  passManager.runOptimizationPipeline(moduleIR, builder, optLevel);
+
+  
+
+
   AddressCalculationExpansion ace(moduleIR, builder);
   if (ace.run()) {
       if (DEBUG) cout << "AddressCalculationExpansion made changes.\n";

test_script/runit-single.sh

@@ -20,6 +20,7 @@ QEMU_RISCV64="qemu-riscv64"
 
 # --- 初始化变量 ---
 EXECUTE_MODE=false
+CLEAN_MODE=false
 SYSYC_TIMEOUT=10      # sysyc 编译超时 (秒)
 GCC_TIMEOUT=10        # gcc 编译超时 (秒)
 EXEC_TIMEOUT=5        # qemu 自动化执行超时 (秒)
@@ -37,6 +38,7 @@ show_help() {
     echo ""
     echo "选项:"
     echo "  -e, --executable         编译为可执行文件并运行测试 (必须)。"
+    echo "  -c, --clean              清理 tmp 临时目录下的所有文件。"
     echo "  -sct N                   设置 sysyc 编译超时为 N 秒 (默认: 10)。"
     echo "  -gct N                   设置 gcc 交叉编译超时为 N 秒 (默认: 10)。"
     echo "  -et N                    设置 qemu 自动化执行超时为 N 秒 (默认: 5)。"
@@ -74,6 +76,10 @@ for arg in "$@"; do
     -e|--executable)
       EXECUTE_MODE=true
       ;;
+    -c|--clean)
+      CLEAN_MODE=true
+      shift
+      ;;
     -sct|-gct|-et|-ml|--max-lines)
       # 选项和其值将在下一个循环中处理
       ;;
@@ -110,6 +116,23 @@ for arg in "$@"; do
   esac
 done
 
+if ${CLEAN_MODE}; then
+  echo "检测到 -c/--clean 选项，正在清空 ${TMP_DIR}..."
+  if [ -d "${TMP_DIR}" ]; then
+    # 使用 * 而不是 . 来确保只删除内容，不删除目录本身
+    # 忽略 rm 可能因目录为空而报告的错误
+    rm -rf "${TMP_DIR}"/* 2>/dev/null
+    echo "清理完成。"
+  else
+    echo "临时目录 ${TMP_DIR} 不存在，无需清理。"
+  fi
+  
+  # 如果只提供了 -c 选项而没有其他 .sy 文件，则在清理后退出
+  if [ ${#SY_FILES[@]} -eq 0 ] && ! ${EXECUTE_MODE}; then
+    exit 0
+  fi
+fi
+
 # --- 主逻辑开始 ---
 if ! ${EXECUTE_MODE}; then
     echo "错误: 请提供 -e 或 --executable 选项来运行测试。"
@@ -138,6 +161,7 @@ for sy_file in "${SY_FILES[@]}"; do
 
     ir_file="${TMP_DIR}/${base_name}_sysyc_riscv64.ll"
     assembly_file="${TMP_DIR}/${base_name}.s"
+    assembly_debug_file="${TMP_DIR}/${base_name}_d.s"
     executable_file="${TMP_DIR}/${base_name}"
     input_file="${source_dir}/${base_name}.in"
     output_reference_file="${source_dir}/${base_name}.out"
@@ -162,6 +186,7 @@ for sy_file in "${SY_FILES[@]}"; do
         echo -e "\e[31m错误: SysY 编译失败或超时。\e[0m"
         is_passed=0
     fi
+    # timeout -s KILL ${SYSYC_TIMEOUT} "${SYSYC}" -s asmd "${sy_file}" > "${assembly_debug_file}" 2>&1
 
     # 步骤 2: GCC 编译
     if [ "$is_passed" -eq 1 ]; then