[backend-IRC]修复了后端不适配中端全局变量定义的问题

script/runit-single.sh

@@ -68,7 +68,7 @@ display_file_content() {
     fi
 }
 
-# --- 本次修改点: 整个参数解析逻辑被重写 ---
+# --- 参数解析 ---
 # 使用标准的 while 循环来健壮地处理任意顺序的参数
 while [[ "$#" -gt 0 ]]; do
     case "$1" in
@@ -164,6 +164,16 @@ for sy_file in "${SY_FILES[@]}"; do
     echo "======================================================================"
     echo "正在处理: ${sy_file}"
 
+    # --- 本次修改点: 拷贝源文件到 tmp 目录 ---
+    echo "  拷贝源文件到 ${TMP_DIR}..."
+    cp "${sy_file}" "${TMP_DIR}/$(basename "${sy_file}")"
+    if [ -f "${input_file}" ]; then
+        cp "${input_file}" "${TMP_DIR}/$(basename "${input_file}")"
+    fi
+    if [ -f "${output_reference_file}" ]; then
+        cp "${output_reference_file}" "${TMP_DIR}/$(basename "${output_reference_file}")"
+    fi
+
     # 步骤 1: sysyc 编译
     echo "  使用 sysyc 编译 (超时 ${SYSYC_TIMEOUT}s)..."
     timeout -s KILL ${SYSYC_TIMEOUT} "${SYSYC}" -s ir "${sy_file}" > "${ir_file}"

src/backend/RISCv64/CMakeLists.txt

@@ -8,6 +8,7 @@ add_library(riscv64_backend_lib STATIC
     Handler/CalleeSavedHandler.cpp
     Handler/LegalizeImmediates.cpp
     Handler/PrologueEpilogueInsertion.cpp
+    Handler/EliminateFrameIndices.cpp
     Optimize/Peephole.cpp
     Optimize/PostRA_Scheduler.cpp
     Optimize/PreRA_Scheduler.cpp

src/backend/RISCv64/Handler/CalleeSavedHandler.cpp

@@ -8,11 +8,6 @@ namespace sysy {
 
 char CalleeSavedHandler::ID = 0;
 
-// 辅助函数，用于判断一个物理寄存器是否为浮点寄存器
-static bool is_fp_reg(PhysicalReg reg) {
-    return reg >= PhysicalReg::F0 && reg <= PhysicalReg::F31;
-}
-
 bool CalleeSavedHandler::runOnFunction(Function *F, AnalysisManager& AM) {
     // This pass works on MachineFunction level, not IR level
     return false;
@@ -20,114 +15,37 @@ bool CalleeSavedHandler::runOnFunction(Function *F, AnalysisManager& AM) {
 
 void CalleeSavedHandler::runOnMachineFunction(MachineFunction* mfunc) {
     StackFrameInfo& frame_info = mfunc->getFrameInfo();
-    
-    std::set<PhysicalReg> used_callee_saved;
-
-    // 1. 扫描所有指令，找出被使用的callee-saved寄存器
-    //    这个Pass在RegAlloc之后运行，所以可以访问到物理寄存器
-    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 && !reg_op->isVirtual()) {
-                        PhysicalReg preg = reg_op->getPReg();
-                        
-                        // 检查整数 s1-s11
-                        if (preg >= PhysicalReg::S1 && preg <= PhysicalReg::S11) {
-                            used_callee_saved.insert(preg);
-                        } 
-                        // 检查浮点 fs0-fs11 (f8,f9,f18-f27)
-                        else if ((preg >= PhysicalReg::F8 && preg <= PhysicalReg::F9) || (preg >= PhysicalReg::F18 && preg <= PhysicalReg::F27)) {
-                            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());
-                }
-            }
-        }
-    }
+    const std::set<PhysicalReg>& used_callee_saved = frame_info.used_callee_saved_regs;
 
     if (used_callee_saved.empty()) {
         frame_info.callee_saved_size = 0;
+        frame_info.callee_saved_regs_to_store.clear();
         return;
     }
 
-    // 2. 计算并更新 frame_info
-    frame_info.callee_saved_size = used_callee_saved.size() * 8;
-
-    // 为了布局确定性和恢复顺序一致，对寄存器排序
-    std::vector<PhysicalReg> sorted_regs(used_callee_saved.begin(), used_callee_saved.end());
-    std::sort(sorted_regs.begin(), sorted_regs.end());
-    
-    // 3. 在函数序言中插入保存指令
-    MachineBasicBlock* entry_block = mfunc->getBlocks().front().get();
-    auto& entry_instrs = entry_block->getInstructions();
-    // 插入点在函数入口标签之后，或者就是最开始
-    auto insert_pos = entry_instrs.begin();
-    if (!entry_instrs.empty() && entry_instrs.front()->getOpcode() == RVOpcodes::LABEL) {
-        insert_pos = std::next(insert_pos);
+    // 1. 计算被调用者保存寄存器所需的总空间大小
+    // s0 总是由 PEI Pass 单独处理，这里不计入大小，但要确保它在列表中
+    int size = 0;
+    std::set<PhysicalReg> regs_to_save = used_callee_saved;
+    if (regs_to_save.count(PhysicalReg::S0)) {
+        regs_to_save.erase(PhysicalReg::S0);
     }
-    
-    std::vector<std::unique_ptr<MachineInstr>> save_instrs;
-    // [关键] 从局部变量区域之后开始分配空间
-    int current_offset = - (16 + frame_info.locals_size);
+    size = regs_to_save.size() * 8; // 每个寄存器占8字节 (64-bit)
+    frame_info.callee_saved_size = size;
 
-    for (PhysicalReg reg : sorted_regs) {
-        current_offset -= 8;
-        RVOpcodes save_op = is_fp_reg(reg) ? RVOpcodes::FSD : RVOpcodes::SD;
+    // 2. 创建一个有序的、需要保存的寄存器列表，以便后续 Pass 确定地生成代码
+    // s0 不应包含在此列表中，因为它由 PEI Pass 特殊处理
+    std::vector<PhysicalReg> sorted_regs(regs_to_save.begin(), regs_to_save.end());
+    std::sort(sorted_regs.begin(), sorted_regs.end(), [](PhysicalReg a, PhysicalReg b){ 
+        return static_cast<int>(a) < static_cast<int>(b); 
+    });
+    frame_info.callee_saved_regs_to_store = sorted_regs;
 
-        auto save_instr = std::make_unique<MachineInstr>(save_op);
-        save_instr->addOperand(std::make_unique<RegOperand>(reg));
-        save_instr->addOperand(std::make_unique<MemOperand>(
-            std::make_unique<RegOperand>(PhysicalReg::S0), // 基址为帧指针 s0
-            std::make_unique<ImmOperand>(current_offset)
-        ));
-        save_instrs.push_back(std::move(save_instr));
-    }
-
-    if (!save_instrs.empty()) {
-        entry_instrs.insert(insert_pos,
-                            std::make_move_iterator(save_instrs.begin()),
-                            std::make_move_iterator(save_instrs.end()));
-    }
-
-    // 4. 在函数结尾（ret之前）插入恢复指令
-    for (auto& mbb : mfunc->getBlocks()) {
-        for (auto it = mbb->getInstructions().begin(); it != mbb->getInstructions().end(); ++it) {
-            if ((*it)->getOpcode() == RVOpcodes::RET) {
-                std::vector<std::unique_ptr<MachineInstr>> restore_instrs;
-                // [关键] 使用与保存时完全相同的逻辑来计算偏移量
-                current_offset = - (16 + frame_info.locals_size);
-                
-                for (PhysicalReg reg : sorted_regs) {
-                    current_offset -= 8;
-                    RVOpcodes restore_op = is_fp_reg(reg) ? RVOpcodes::FLD : RVOpcodes::LD;
-
-                    auto restore_instr = std::make_unique<MachineInstr>(restore_op);
-                    restore_instr->addOperand(std::make_unique<RegOperand>(reg));
-                    restore_instr->addOperand(std::make_unique<MemOperand>(
-                        std::make_unique<RegOperand>(PhysicalReg::S0),
-                        std::make_unique<ImmOperand>(current_offset)
-                    ));
-                    restore_instrs.push_back(std::move(restore_instr));
-                }
-                
-                if (!restore_instrs.empty()) {
-                    mbb->getInstructions().insert(it,
-                                                std::make_move_iterator(restore_instrs.begin()),
-                                                std::make_move_iterator(restore_instrs.end()));
-                }
-                goto next_block_label;
-            }
-        }
-        next_block_label:;
-    }
+    // 3. [关键修正] 更新栈帧总大小。
+    // 这是初步计算，PEI Pass 会进行最终的对齐。
+    frame_info.total_size = frame_info.locals_size + 
+                            frame_info.spill_size + 
+                            frame_info.callee_saved_size;
 }
 
-} // namespace sysy
+} // namespace sysy

src/backend/RISCv64/Handler/EliminateFrameIndices.cpp

@@ -0,0 +1,198 @@
+#include "EliminateFrameIndices.h"
+#include "RISCv64ISel.h"
+#include <cassert>
+#include <vector> // [新增] 为插入指令而包含
+
+namespace sysy {
+
+// getTypeSizeInBytes 是一个通用辅助函数，保持不变
+unsigned EliminateFrameIndicesPass::getTypeSizeInBytes(Type* type) {
+    if (!type) {
+        assert(false && "Cannot get size of a null type.");
+        return 0;
+    }
+
+    switch (type->getKind()) {
+        case Type::kInt:
+        case Type::kFloat:
+            return 4;
+        case Type::kPointer:
+            return 8;
+        case Type::kArray: {
+            auto arrayType = type->as<ArrayType>();
+            return arrayType->getNumElements() * getTypeSizeInBytes(arrayType->getElementType());
+        }
+        default:
+            assert(false && "Unsupported type for size calculation.");
+            return 0;
+    }
+}
+
+void EliminateFrameIndicesPass::runOnMachineFunction(MachineFunction* mfunc) {
+    StackFrameInfo& frame_info = mfunc->getFrameInfo();
+    Function* F = mfunc->getFunc();
+    RISCv64ISel* isel = mfunc->getISel();
+    
+    // 1. [已移除] 不再处理栈传递的参数
+    // 原先处理栈参数 (arg_idx >= 8) 的逻辑已被移除。
+    // 这项职责已完全转移到 PrologueEpilogueInsertionPass，以避免逻辑冲突和错误。
+    // [注释更新] -> 上述注释已过时。根据新方案，我们将在这里处理栈传递的参数，
+    // 以便在寄存器分配前就将数据流显式化，修复溢出逻辑的BUG。
+
+    // 2. 只为局部变量(AllocaInst)分配栈空间和计算偏移量
+    // 局部变量从 s0 下方（负偏移量）开始分配，紧接着为 ra 和 s0 预留的16字节之后
+    int local_var_offset = 16;
+    
+    if(F) { // 确保函数指针有效
+        for (auto& bb : F->getBasicBlocks()) {
+            for (auto& inst : bb->getInstructions()) {
+                if (auto alloca = dynamic_cast<AllocaInst*>(inst.get())) {
+                    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字节
+
+                    local_var_offset += size;
+                    unsigned alloca_vreg = isel->getVReg(alloca);
+                    // 局部变量使用相对于s0的负向偏移
+                    frame_info.alloca_offsets[alloca_vreg] = -local_var_offset;
+                }
+            }
+        }
+    }
+    
+    // 记录仅由AllocaInst分配的局部变量的总大小
+    frame_info.locals_size = local_var_offset - 16;
+
+    // 3. [核心修改] 在函数入口为所有栈传递的参数插入load指令
+    // 这个步骤至关重要：它在寄存器分配之前，为这些参数的vreg创建了明确的“定义(def)”指令。
+    // 这解决了在高寄存器压力下，当这些vreg被溢出时，`rewriteProgram`找不到其定义点而崩溃的问题。
+    if (F && isel && !mfunc->getBlocks().empty()) {
+        MachineBasicBlock* entry_block = mfunc->getBlocks().front().get();
+        std::vector<std::unique_ptr<MachineInstr>> arg_load_instrs;
+        int arg_idx = 0;
+        for (Argument* arg : F->getArguments()) {
+            // 根据ABI，前8个整型/指针参数通过寄存器传递，这里只处理超出部分。
+            if (arg_idx >= 8) {
+                // 计算参数在调用者栈帧中的位置，该位置相对于被调用者的帧指针s0是正向偏移。
+                // 第9个参数(arg_idx=8)位于 0(s0)，第10个(arg_idx=9)位于 8(s0)，以此类推。
+                int offset = (arg_idx - 8) * 8; 
+                unsigned arg_vreg = isel->getVReg(arg);
+                Type* arg_type = arg->getType();
+
+                // 根据参数类型选择正确的加载指令
+                RVOpcodes load_op;
+                if (arg_type->isFloat()) {
+                    load_op = RVOpcodes::FLW; // 单精度浮点
+                } else if (arg_type->isPointer()) {
+                    load_op = RVOpcodes::LD;  // 64位指针
+                } else {
+                    load_op = RVOpcodes::LW;  // 32位整数
+                }
+                
+                // 创建加载指令: lw/ld/flw vreg, offset(s0)
+                auto load_instr = std::make_unique<MachineInstr>(load_op);
+                load_instr->addOperand(std::make_unique<RegOperand>(arg_vreg));
+                load_instr->addOperand(std::make_unique<MemOperand>(
+                    std::make_unique<RegOperand>(PhysicalReg::S0), // 基址为帧指针
+                    std::make_unique<ImmOperand>(offset)
+                ));
+                arg_load_instrs.push_back(std::move(load_instr));
+            }
+            arg_idx++;
+        }
+        
+        // 将所有新创建的参数加载指令一次性插入到入口块的起始位置
+        auto& entry_instrs = entry_block->getInstructions();
+        entry_instrs.insert(entry_instrs.begin(),
+                            std::make_move_iterator(arg_load_instrs.begin()),
+                            std::make_move_iterator(arg_load_instrs.end()));
+    }
+
+
+    // 4. 遍历所有机器指令，将访问局部变量的伪指令展开为真实指令
+    // 由于处理参数的逻辑已移除，这里的展开现在只针对局部变量，因此是正确的。
+    // [注释更新] -> 上述注释已过时。此部分逻辑保持不变，它正确地处理了局部变量。
+    for (auto& mbb : mfunc->getBlocks()) {
+        std::vector<std::unique_ptr<MachineInstr>> new_instructions;
+        for (auto& instr_ptr : mbb->getInstructions()) {
+            RVOpcodes opcode = instr_ptr->getOpcode();
+
+            if (opcode == RVOpcodes::FRAME_LOAD_W || opcode == RVOpcodes::FRAME_LOAD_D || opcode == RVOpcodes::FRAME_LOAD_F) {
+                RVOpcodes real_load_op;
+                if (opcode == RVOpcodes::FRAME_LOAD_W) real_load_op = RVOpcodes::LW;
+                else if (opcode == RVOpcodes::FRAME_LOAD_D) real_load_op = RVOpcodes::LD;
+                else real_load_op = RVOpcodes::FLW;
+
+                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(Type::getPointerType(Type::getIntType()));
+
+                // 展开为: 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));
+
+                // 展开为: lw/ld/flw 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(load_instr));
+
+            } else if (opcode == RVOpcodes::FRAME_STORE_W || opcode == RVOpcodes::FRAME_STORE_D || opcode == RVOpcodes::FRAME_STORE_F) {
+                RVOpcodes real_store_op;
+                if (opcode == RVOpcodes::FRAME_STORE_W) real_store_op = RVOpcodes::SW;
+                else if (opcode == RVOpcodes::FRAME_STORE_D) real_store_op = RVOpcodes::SD;
+                else real_store_op = RVOpcodes::FSW;
+
+                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(Type::getPointerType(Type::getIntType()));
+                
+                // 展开为: 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));
+
+                // 展开为: sw/sd/fsw 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(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();
+                int offset = frame_info.alloca_offsets.at(alloca_vreg);
+
+                // 将 `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));
+                addi->addOperand(std::make_unique<ImmOperand>(offset));
+                new_instructions.push_back(std::move(addi));
+
+            } else {
+                new_instructions.push_back(std::move(instr_ptr));
+            }
+        }
+        mbb->getInstructions() = std::move(new_instructions);
+    }
+}
+
+} // namespace sysy

src/backend/RISCv64/Handler/PrologueEpilogueInsertion.cpp

@@ -1,17 +1,22 @@
 #include "PrologueEpilogueInsertion.h"
+#include "RISCv64LLIR.h" // 假设包含了 PhysicalReg, RVOpcodes 等定义
 #include "RISCv64ISel.h"
-#include "RISCv64RegAlloc.h" // 需要访问RegAlloc的结果
 #include <algorithm>
+#include <vector>
+#include <set>
 
 namespace sysy {
 
 char PrologueEpilogueInsertionPass::ID = 0;
 
 void PrologueEpilogueInsertionPass::runOnMachineFunction(MachineFunction* mfunc) {
+    StackFrameInfo& frame_info = mfunc->getFrameInfo();
+    Function* F = mfunc->getFunc();
+    RISCv64ISel* isel = mfunc->getISel();
+    
+    // 1. 清理 KEEPALIVE 伪指令
     for (auto& mbb : mfunc->getBlocks()) {
         auto& instrs = mbb->getInstructions();
-        
-        // 使用标准的 Erase-Remove Idiom 来删除满足条件的元素
         instrs.erase(
             std::remove_if(instrs.begin(), instrs.end(),
                 [](const std::unique_ptr<MachineInstr>& instr) {
@@ -22,39 +27,55 @@ void PrologueEpilogueInsertionPass::runOnMachineFunction(MachineFunction* mfunc)
         );
     }
     
-    StackFrameInfo& frame_info = mfunc->getFrameInfo();
-    Function* F = mfunc->getFunc();
-    RISCv64ISel* isel = mfunc->getISel();
-    
-    // [关键] 获取寄存器分配的结果 (vreg -> preg 的映射)
-    // RegAlloc Pass 必须已经运行过
+    // 2. [新增] 确定需要保存的被调用者保存寄存器 (callee-saved)
+    // 这部分逻辑从 CalleeSavedHandler Pass 移入，以集中管理序言生成
     auto& vreg_to_preg_map = frame_info.vreg_to_preg_map;
+    std::set<PhysicalReg> used_callee_saved_regs_set;
+    const auto& callee_saved_int = getCalleeSavedIntRegs();
+    const auto& callee_saved_fp = getCalleeSavedFpRegs();
 
-    // 完全遵循 AsmPrinter 中的计算逻辑
+    for (const auto& pair : vreg_to_preg_map) {
+        PhysicalReg preg = pair.second;
+        // 检查是否在整数或浮点 callee-saved 集合中
+        // 注意：s0作为帧指针，由序言/尾声逻辑特殊处理，不在此处保存
+        bool is_int_cs = std::find(callee_saved_int.begin(), callee_saved_int.end(), preg) != callee_saved_int.end();
+        bool is_fp_cs = std::find(callee_saved_fp.begin(), callee_saved_fp.end(), preg) != callee_saved_fp.end();
+        if ((is_int_cs && preg != PhysicalReg::S0) || is_fp_cs) {
+            used_callee_saved_regs_set.insert(preg);
+        }
+    }
+    // 为了确定性排序，并存入 frame_info 供尾声使用
+    frame_info.callee_saved_regs_to_store.assign(
+        used_callee_saved_regs_set.begin(), used_callee_saved_regs_set.end()
+    );
+    std::sort(frame_info.callee_saved_regs_to_store.begin(), frame_info.callee_saved_regs_to_store.end());
+    frame_info.callee_saved_size = frame_info.callee_saved_regs_to_store.size() * 8; // 每个寄存器8字节
+
+    // 3. 计算最终的栈帧总大小
     int total_stack_size = frame_info.locals_size + 
                            frame_info.spill_size + 
                            frame_info.callee_saved_size + 
                            16; // 为 ra 和 s0 固定的16字节
     
-    int aligned_stack_size = (total_stack_size + 15) & ~15;
+    int aligned_stack_size = (total_stack_size + 15) & ~15; // 16字节对齐
     frame_info.total_size = aligned_stack_size;
 
-    // 只有在需要分配栈空间时才生成指令
+    // 只有在需要分配栈空间时才生成序言和尾声
     if (aligned_stack_size > 0) {
-        // --- 1. 插入序言 ---
+        // --- 4. 插入完整的序言 ---
         MachineBasicBlock* entry_block = mfunc->getBlocks().front().get();
         auto& entry_instrs = entry_block->getInstructions();
-
         std::vector<std::unique_ptr<MachineInstr>> prologue_instrs;
 
-        // 1. addi sp, sp, -aligned_stack_size
+        // 4.1. 分配栈帧: addi sp, sp, -aligned_stack_size
         auto alloc_stack = std::make_unique<MachineInstr>(RVOpcodes::ADDI);
         alloc_stack->addOperand(std::make_unique<RegOperand>(PhysicalReg::SP));
         alloc_stack->addOperand(std::make_unique<RegOperand>(PhysicalReg::SP));
         alloc_stack->addOperand(std::make_unique<ImmOperand>(-aligned_stack_size));
         prologue_instrs.push_back(std::move(alloc_stack));
 
-        // 2. sd ra, (aligned_stack_size - 8)(sp)
+        // 4.2. 保存 ra 和 s0
+        // sd ra, (aligned_stack_size - 8)(sp)
         auto save_ra = std::make_unique<MachineInstr>(RVOpcodes::SD);
         save_ra->addOperand(std::make_unique<RegOperand>(PhysicalReg::RA));
         save_ra->addOperand(std::make_unique<MemOperand>(
@@ -62,8 +83,7 @@ void PrologueEpilogueInsertionPass::runOnMachineFunction(MachineFunction* mfunc)
             std::make_unique<ImmOperand>(aligned_stack_size - 8)
         ));
         prologue_instrs.push_back(std::move(save_ra));
-
-        // 3. sd s0, (aligned_stack_size - 16)(sp)
+        // sd s0, (aligned_stack_size - 16)(sp)
         auto save_fp = std::make_unique<MachineInstr>(RVOpcodes::SD);
         save_fp->addOperand(std::make_unique<RegOperand>(PhysicalReg::S0));
         save_fp->addOperand(std::make_unique<MemOperand>(
@@ -72,66 +92,60 @@ void PrologueEpilogueInsertionPass::runOnMachineFunction(MachineFunction* mfunc)
         ));
         prologue_instrs.push_back(std::move(save_fp));
         
-        // 4. addi s0, sp, aligned_stack_size
+        // 4.3. 设置新的帧指针 s0: addi s0, sp, aligned_stack_size
         auto set_fp = std::make_unique<MachineInstr>(RVOpcodes::ADDI);
         set_fp->addOperand(std::make_unique<RegOperand>(PhysicalReg::S0));
         set_fp->addOperand(std::make_unique<RegOperand>(PhysicalReg::SP));
         set_fp->addOperand(std::make_unique<ImmOperand>(aligned_stack_size));
         prologue_instrs.push_back(std::move(set_fp));
-
-        // --- 在s0设置完毕后，使用物理寄存器加载栈参数 ---
-        if (F && isel) {
-            int arg_idx = 0;
-            for (Argument* arg : F->getArguments()) {
-                if (arg_idx >= 8) {
-                    unsigned vreg = isel->getVReg(arg);
-                    
-                    if (frame_info.alloca_offsets.count(vreg) && vreg_to_preg_map.count(vreg)) {
-                        int offset = frame_info.alloca_offsets.at(vreg);
-                        PhysicalReg dest_preg = vreg_to_preg_map.at(vreg);
-                        Type* arg_type = arg->getType();
-
-                        if (arg_type->isFloat()) {
-                            auto load_arg = std::make_unique<MachineInstr>(RVOpcodes::FLW);
-                            load_arg->addOperand(std::make_unique<RegOperand>(dest_preg));
-                            load_arg->addOperand(std::make_unique<MemOperand>(
-                                std::make_unique<RegOperand>(PhysicalReg::S0),
-                                std::make_unique<ImmOperand>(offset)
-                            ));
-                            prologue_instrs.push_back(std::move(load_arg));
-                        } else {
-                            RVOpcodes load_op = arg_type->isPointer() ? RVOpcodes::LD : RVOpcodes::LW;
-                            auto load_arg = std::make_unique<MachineInstr>(load_op);
-                            load_arg->addOperand(std::make_unique<RegOperand>(dest_preg));
-                            load_arg->addOperand(std::make_unique<MemOperand>(
-                                std::make_unique<RegOperand>(PhysicalReg::S0),
-                                std::make_unique<ImmOperand>(offset)
-                            ));
-                            prologue_instrs.push_back(std::move(load_arg));
-                        }
-                    }
-                }
-                arg_idx++;
-            }
-        }
         
-        // 确定插入点
-        auto insert_pos = entry_instrs.begin();
-        
-        // 一次性将所有序言指令插入
-        if (!prologue_instrs.empty()) {
-            entry_instrs.insert(insert_pos, 
-                                std::make_move_iterator(prologue_instrs.begin()),
-                                std::make_move_iterator(prologue_instrs.end()));
+        // 4.4. [新增] 保存所有使用到的被调用者保存寄存器
+        // 它们保存在 s0 下方，紧接着 ra/s0 的位置
+        int callee_saved_offset = -16;
+        for (const auto& reg : frame_info.callee_saved_regs_to_store) {
+            callee_saved_offset -= 8;
+            RVOpcodes store_op = (reg >= PhysicalReg::F0 && reg <= PhysicalReg::F31) ? RVOpcodes::FSD : RVOpcodes::SD;
+            auto save_cs_reg = std::make_unique<MachineInstr>(store_op);
+            save_cs_reg->addOperand(std::make_unique<RegOperand>(reg));
+            save_cs_reg->addOperand(std::make_unique<MemOperand>(
+                std::make_unique<RegOperand>(PhysicalReg::S0),
+                std::make_unique<ImmOperand>(callee_saved_offset)
+            ));
+            prologue_instrs.push_back(std::move(save_cs_reg));
         }
 
-        // --- 2. 插入尾声 (此部分逻辑保持不变) ---
+        // 4.5. [核心修改] 加载栈传递参数的逻辑已从此移除
+        // 这项工作已经前移至 `EliminateFrameIndicesPass` 中完成，
+        // 以确保在寄存器分配前就将相关虚拟寄存器定义，从而修复溢出逻辑的bug。
+        
+        // 4.6. 将所有生成的序言指令一次性插入到函数入口
+        entry_instrs.insert(entry_instrs.begin(), 
+                            std::make_move_iterator(prologue_instrs.begin()),
+                            std::make_move_iterator(prologue_instrs.end()));
+
+        // --- 5. 插入完整的尾声 ---
         for (auto& mbb : mfunc->getBlocks()) {
+            // [修正] 使用前向迭代器查找RET指令，以确保在正确的位置（RET之前）插入尾声。
             for (auto it = mbb->getInstructions().begin(); it != mbb->getInstructions().end(); ++it) {
                 if ((*it)->getOpcode() == RVOpcodes::RET) {
                     std::vector<std::unique_ptr<MachineInstr>> epilogue_instrs;
+                    
+                    // 5.1. [新增] 恢复被调用者保存寄存器
+                    callee_saved_offset = -16;
+                    for (const auto& reg : frame_info.callee_saved_regs_to_store) {
+                        callee_saved_offset -= 8;
+                        RVOpcodes load_op = (reg >= PhysicalReg::F0 && reg <= PhysicalReg::F31) ? RVOpcodes::FLD : RVOpcodes::LD;
+                        auto restore_cs_reg = std::make_unique<MachineInstr>(load_op);
+                        restore_cs_reg->addOperand(std::make_unique<RegOperand>(reg));
+                        restore_cs_reg->addOperand(std::make_unique<MemOperand>(
+                            std::make_unique<RegOperand>(PhysicalReg::S0),
+                            std::make_unique<ImmOperand>(callee_saved_offset)
+                        ));
+                        epilogue_instrs.push_back(std::move(restore_cs_reg));
+                    }
 
-                    // 1. ld ra
+                    // 5.2. 恢复 ra 和 s0 (注意基址现在是sp)
+                    // ld ra, (aligned_stack_size - 8)(sp)
                     auto restore_ra = std::make_unique<MachineInstr>(RVOpcodes::LD);
                     restore_ra->addOperand(std::make_unique<RegOperand>(PhysicalReg::RA));
                     restore_ra->addOperand(std::make_unique<MemOperand>(
@@ -139,8 +153,7 @@ void PrologueEpilogueInsertionPass::runOnMachineFunction(MachineFunction* mfunc)
                         std::make_unique<ImmOperand>(aligned_stack_size - 8)
                     ));
                     epilogue_instrs.push_back(std::move(restore_ra));
-
-                    // 2. ld s0
+                    // ld s0, (aligned_stack_size - 16)(sp)
                     auto restore_fp = std::make_unique<MachineInstr>(RVOpcodes::LD);
                     restore_fp->addOperand(std::make_unique<RegOperand>(PhysicalReg::S0));
                     restore_fp->addOperand(std::make_unique<MemOperand>(
@@ -149,18 +162,19 @@ void PrologueEpilogueInsertionPass::runOnMachineFunction(MachineFunction* mfunc)
                     ));
                     epilogue_instrs.push_back(std::move(restore_fp));
 
-                    // 3. addi sp, sp, aligned_stack_size
+                    // 5.3. 释放栈帧: addi sp, sp, aligned_stack_size
                     auto dealloc_stack = std::make_unique<MachineInstr>(RVOpcodes::ADDI);
                     dealloc_stack->addOperand(std::make_unique<RegOperand>(PhysicalReg::SP));
                     dealloc_stack->addOperand(std::make_unique<RegOperand>(PhysicalReg::SP));
                     dealloc_stack->addOperand(std::make_unique<ImmOperand>(aligned_stack_size));
                     epilogue_instrs.push_back(std::move(dealloc_stack));
 
-                    if (!epilogue_instrs.empty()) {
-                        mbb->getInstructions().insert(it, 
-                                                    std::make_move_iterator(epilogue_instrs.begin()),
-                                                    std::make_move_iterator(epilogue_instrs.end()));
-                    }
+                    // 将尾声指令插入到 RET 指令之前
+                    mbb->getInstructions().insert(it, 
+                                                  std::make_move_iterator(epilogue_instrs.begin()),
+                                                  std::make_move_iterator(epilogue_instrs.end()));
+                    
+                    // 一个基本块通常只有一个终止指令，处理完就可以跳到下一个块
                     goto next_block;
                 }
             }

src/backend/RISCv64/RISCv64Backend.cpp

@@ -171,51 +171,222 @@ std::string RISCv64CodeGen::module_gen() {
 }
 
 std::string RISCv64CodeGen::function_gen(Function* func) {
-    // === 完整的后端处理流水线 ===
+    if (DEBUG) {
+        // === 完整的后端处理流水线 ===
 
-    // 阶段 1: 指令选择 (sysy::IR -> LLIR with virtual registers)
-    RISCv64ISel isel;
-    std::unique_ptr<MachineFunction> mfunc = isel.runOnFunction(func);
+        // 阶段 1: 指令选择 (sysy::IR -> LLIR with virtual registers)
+        DEBUG = 0;
+        DEEPDEBUG = 0;
 
-    // 第一次调试打印输出
-    std::stringstream ss1;
-    RISCv64AsmPrinter printer1(mfunc.get());
-    printer1.run(ss1, true);
+        RISCv64ISel isel;
+        std::unique_ptr<MachineFunction> mfunc = isel.runOnFunction(func);
 
-    // 阶段 2: 指令调度 (Instruction Scheduling)
-    PreRA_Scheduler scheduler;
-    scheduler.runOnMachineFunction(mfunc.get());
+        // 第一次调试打印输出
+        std::stringstream ss_after_isel;
+        RISCv64AsmPrinter printer_isel(mfunc.get());
+        printer_isel.run(ss_after_isel, true);
+        // if (DEBUG) {
+        //     std::cout << ss_after_isel.str();
+        // }
+        DEBUG = 0;
+        DEEPDEBUG = 0;
+        DEBUG = 1;
+        DEEPDEBUG = 1;
+        if (DEBUG) {
+            std::cerr << "====== Intermediate Representation after Instruction Selection ======\n" 
+            << ss_after_isel.str();
+        }
+        // DEBUG = 0;
+        // DEEPDEBUG = 0;
+        // [新增] 阶段 2: 消除帧索引 (展开伪指令，计算局部变量偏移)
+        // 这个Pass必须在寄存器分配之前运行
+        EliminateFrameIndicesPass efi_pass;
+        efi_pass.runOnMachineFunction(mfunc.get());
 
-    // 阶段 3: 物理寄存器分配 (Register Allocation)
-    RISCv64RegAlloc reg_alloc(mfunc.get());
-    reg_alloc.run();
+        if (DEBUG) {
+            std::cerr << "====== stack info after eliminate frame indices  ======\n";
+            mfunc->dumpStackFrameInfo(std::cerr);
+            // std::stringstream ss_after_eli;
+            // printer_isel.run(ss_after_eli, true);
+            // std::cerr << "====== LLIR after eliminate frame indices ======\n" 
+            // << ss_after_eli.str();
+        }
 
-    // 阶段 3.1: 处理被调用者保存寄存器
-    CalleeSavedHandler callee_handler;
-    callee_handler.runOnMachineFunction(mfunc.get());
+        // // 阶段 2: 指令调度 (Instruction Scheduling)
+        // PreRA_Scheduler scheduler;
+        // scheduler.runOnMachineFunction(mfunc.get());
 
-    // 阶段 4: 窥孔优化 (Peephole Optimization)
-    PeepholeOptimizer peephole;
-    peephole.runOnMachineFunction(mfunc.get());
+        // DEBUG = 0;
+        // DEEPDEBUG = 0;
+        // DEBUG = 1;
+        // DEEPDEBUG = 1;
+        // 阶段 3: 物理寄存器分配 (Register Allocation)
+        RISCv64RegAlloc reg_alloc(mfunc.get());
+        reg_alloc.run();
 
-    // 阶段 5: 局部指令调度 (Local Scheduling)
-    PostRA_Scheduler local_scheduler;
-    local_scheduler.runOnMachineFunction(mfunc.get());
+        // DEBUG = 0;
+        // DEEPDEBUG = 0;
+        DEBUG = 1;
+        DEEPDEBUG = 1;
+        if (DEBUG) {
+            std::cerr << "====== stack info after reg alloc ======\n";
+            mfunc->dumpStackFrameInfo(std::cerr);
+        }
 
-    // 阶段 3.2: 插入序言和尾声
-    PrologueEpilogueInsertionPass pei_pass;
-    pei_pass.runOnMachineFunction(mfunc.get());
+        // 阶段 3.1: 处理被调用者保存寄存器
+        CalleeSavedHandler callee_handler;
+        callee_handler.runOnMachineFunction(mfunc.get());
 
-    // 阶段 3.3: 清理产生的大立即数
-    LegalizeImmediatesPass legalizer;
-    legalizer.runOnMachineFunction(mfunc.get());
+        if (DEBUG) {
+            std::cerr << "====== stack info after callee handler ======\n";
+            mfunc->dumpStackFrameInfo(std::cerr);
+        }
 
-    // 阶段 6: 代码发射 (Code Emission)
-    std::stringstream ss;
-    RISCv64AsmPrinter printer(mfunc.get());
-    printer.run(ss);
-    if (DEBUG) ss << "\n" << ss1.str(); // 将指令选择阶段的结果也包含在最终输出中
-    return ss.str();
+        // // 阶段 4: 窥孔优化 (Peephole Optimization)
+        // PeepholeOptimizer peephole;
+        // peephole.runOnMachineFunction(mfunc.get());
+
+        // 阶段 5: 局部指令调度 (Local Scheduling)
+        // PostRA_Scheduler local_scheduler;
+        // local_scheduler.runOnMachineFunction(mfunc.get());
+
+        // 阶段 3.2: 插入序言和尾声
+        PrologueEpilogueInsertionPass pei_pass;
+        pei_pass.runOnMachineFunction(mfunc.get());
+
+        DEBUG = 0;
+        DEEPDEBUG = 0;
+
+        // 阶段 3.3: 大立即数合法化
+        LegalizeImmediatesPass legalizer;
+        legalizer.runOnMachineFunction(mfunc.get());
+
+        // 阶段 6: 代码发射 (Code Emission)
+        std::stringstream ss;
+        RISCv64AsmPrinter printer(mfunc.get());
+        printer.run(ss);
+
+        if (DEBUG) {
+            ss << "\n\n; --- Intermediate Representation after Instruction Selection ---\n" 
+            << ss_after_isel.str();
+        }
+        DEBUG = 1;
+        DEEPDEBUG = 1;
+        return ss.str();
+    }
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    else {
+        // === 完整的后端处理流水线 ===
+
+        // 阶段 1: 指令选择 (sysy::IR -> LLIR with virtual registers)
+        DEBUG = 0;
+        DEEPDEBUG = 0;
+
+        RISCv64ISel isel;
+        std::unique_ptr<MachineFunction> mfunc = isel.runOnFunction(func);
+
+        // 第一次调试打印输出
+        std::stringstream ss_after_isel;
+        RISCv64AsmPrinter printer_isel(mfunc.get());
+        printer_isel.run(ss_after_isel, true);
+        // if (DEBUG) {
+        //     std::cout << ss_after_isel.str();
+        // }
+        DEBUG = 0;
+        DEEPDEBUG = 0;
+        // DEBUG = 1;
+        // DEEPDEBUG = 1;
+        if (DEBUG) {
+            std::cerr << "====== Intermediate Representation after Instruction Selection ======\n" 
+            << ss_after_isel.str();
+        }
+        // DEBUG = 0;
+        // DEEPDEBUG = 0;
+        // [新增] 阶段 2: 消除帧索引 (展开伪指令，计算局部变量偏移)
+        // 这个Pass必须在寄存器分配之前运行
+        EliminateFrameIndicesPass efi_pass;
+        efi_pass.runOnMachineFunction(mfunc.get());
+
+        if (DEBUG) {
+            std::cerr << "====== stack info after eliminate frame indices  ======\n";
+            mfunc->dumpStackFrameInfo(std::cerr);
+            std::stringstream ss_after_eli;
+            printer_isel.run(ss_after_eli, true);
+            std::cerr << "====== LLIR after eliminate frame indices ======\n" 
+            << ss_after_eli.str();
+        }
+
+        // // 阶段 2: 指令调度 (Instruction Scheduling)
+        // PreRA_Scheduler scheduler;
+        // scheduler.runOnMachineFunction(mfunc.get());
+
+        DEBUG = 0;
+        DEEPDEBUG = 0;
+        // DEBUG = 1;
+        // DEEPDEBUG = 1;
+        // 阶段 3: 物理寄存器分配 (Register Allocation)
+        RISCv64RegAlloc reg_alloc(mfunc.get());
+        reg_alloc.run();
+
+        DEBUG = 0;
+        DEEPDEBUG = 0;
+        // DEBUG = 1;
+        // DEEPDEBUG = 1;
+        if (DEBUG) {
+            std::cerr << "====== stack info after reg alloc ======\n";
+            mfunc->dumpStackFrameInfo(std::cerr);
+        }
+
+        // 阶段 3.1: 处理被调用者保存寄存器
+        CalleeSavedHandler callee_handler;
+        callee_handler.runOnMachineFunction(mfunc.get());
+
+        if (DEBUG) {
+            std::cerr << "====== stack info after callee handler ======\n";
+            mfunc->dumpStackFrameInfo(std::cerr);
+        }
+
+        // // 阶段 4: 窥孔优化 (Peephole Optimization)
+        // PeepholeOptimizer peephole;
+        // peephole.runOnMachineFunction(mfunc.get());
+
+        // 阶段 5: 局部指令调度 (Local Scheduling)
+        // PostRA_Scheduler local_scheduler;
+        // local_scheduler.runOnMachineFunction(mfunc.get());
+
+        // 阶段 3.2: 插入序言和尾声
+        PrologueEpilogueInsertionPass pei_pass;
+        pei_pass.runOnMachineFunction(mfunc.get());
+
+        DEBUG = 0;
+        DEEPDEBUG = 0;
+
+        // 阶段 3.3: 大立即数合法化
+        LegalizeImmediatesPass legalizer;
+        legalizer.runOnMachineFunction(mfunc.get());
+
+        // 阶段 6: 代码发射 (Code Emission)
+        std::stringstream ss;
+        RISCv64AsmPrinter printer(mfunc.get());
+        printer.run(ss);
+
+        if (DEBUG) {
+            ss << "\n\n; --- Intermediate Representation after Instruction Selection ---\n" 
+            << ss_after_isel.str();
+        }
+        return ss.str();
+    }
 }
 
 } // namespace sysy

src/backend/RISCv64/RISCv64LLIR.cpp

@@ -1,6 +1,122 @@
 #include "RISCv64LLIR.h"
 #include <vector>
+#include <iostream> // 用于 std::ostream 和 std::cerr
+#include <string>   // 用于 std::string
 
 namespace sysy {
 
-}
+// 辅助函数：将 PhysicalReg 枚举转换为可读的字符串
+std::string regToString(PhysicalReg reg) {
+    switch (reg) {
+        case PhysicalReg::ZERO: return "x0";  case PhysicalReg::RA: return "ra";
+        case PhysicalReg::SP: return "sp";    case PhysicalReg::GP: return "gp";
+        case PhysicalReg::TP: return "tp";    case PhysicalReg::T0: return "t0";
+        case PhysicalReg::T1: return "t1";    case PhysicalReg::T2: return "t2";
+        case PhysicalReg::S0: return "s0";    case PhysicalReg::S1: return "s1";
+        case PhysicalReg::A0: return "a0";    case PhysicalReg::A1: return "a1";
+        case PhysicalReg::A2: return "a2";    case PhysicalReg::A3: return "a3";
+        case PhysicalReg::A4: return "a4";    case PhysicalReg::A5: return "a5";
+        case PhysicalReg::A6: return "a6";    case PhysicalReg::A7: return "a7";
+        case PhysicalReg::S2: return "s2";    case PhysicalReg::S3: return "s3";
+        case PhysicalReg::S4: return "s4";    case PhysicalReg::S5: return "s5";
+        case PhysicalReg::S6: return "s6";    case PhysicalReg::S7: return "s7";
+        case PhysicalReg::S8: return "s8";    case PhysicalReg::S9: return "s9";
+        case PhysicalReg::S10: return "s10";  case PhysicalReg::S11: return "s11";
+        case PhysicalReg::T3: return "t3";    case PhysicalReg::T4: return "t4";
+        case PhysicalReg::T5: return "t5";    case PhysicalReg::T6: return "t6";
+        case PhysicalReg::F0: return "f0";    case PhysicalReg::F1: return "f1";
+        case PhysicalReg::F2: return "f2";    case PhysicalReg::F3: return "f3";
+        case PhysicalReg::F4: return "f4";    case PhysicalReg::F5: return "f5";
+        case PhysicalReg::F6: return "f6";    case PhysicalReg::F7: return "f7";
+        case PhysicalReg::F8: return "f8";    case PhysicalReg::F9: return "f9";
+        case PhysicalReg::F10: return "f10";  case PhysicalReg::F11: return "f11";
+        case PhysicalReg::F12: return "f12";  case PhysicalReg::F13: return "f13";
+        case PhysicalReg::F14: return "f14";  case PhysicalReg::F15: return "f15";
+        case PhysicalReg::F16: return "f16";  case PhysicalReg::F17: return "f17";
+        case PhysicalReg::F18: return "f18";  case PhysicalReg::F19: return "f19";
+        case PhysicalReg::F20: return "f20";  case PhysicalReg::F21: return "f21";
+        case PhysicalReg::F22: return "f22";  case PhysicalReg::F23: return "f23";
+        case PhysicalReg::F24: return "f24";  case PhysicalReg::F25: return "f25";
+        case PhysicalReg::F26: return "f26";  case PhysicalReg::F27: return "f27";
+        case PhysicalReg::F28: return "f28";  case PhysicalReg::F29: return "f29";
+        case PhysicalReg::F30: return "f30";  case PhysicalReg::F31: return "f31";
+        default: return "UNKNOWN_REG";
+    }
+}
+
+// [新增] 打印栈帧信息的完整实现
+void MachineFunction::dumpStackFrameInfo(std::ostream& os) const {
+    const StackFrameInfo& info = frame_info;
+
+    os << "--- Stack Frame Info for function '" << getName() << "' ---\n";
+
+    // 打印尺寸信息
+    os << "  Sizes:\n";
+    os << "    Total Size:          " << info.total_size << " bytes\n";
+    os << "    Locals Size:         " << info.locals_size << " bytes\n";
+    os << "    Spill Size:          " << info.spill_size << " bytes\n";
+    os << "    Callee-Saved Size:   " << info.callee_saved_size << " bytes\n";
+    os << "\n";
+
+    // 打印 Alloca 变量的偏移量
+    os << "  Alloca Offsets (vreg -> offset from FP):\n";
+    if (info.alloca_offsets.empty()) {
+        os << "    (None)\n";
+    } else {
+        for (const auto& pair : info.alloca_offsets) {
+            os << "    %vreg" << pair.first << " -> " << pair.second << "\n";
+        }
+    }
+    os << "\n";
+
+    // 打印溢出变量的偏移量
+    os << "  Spill Offsets (vreg -> offset from FP):\n";
+    if (info.spill_offsets.empty()) {
+        os << "    (None)\n";
+    } else {
+        for (const auto& pair : info.spill_offsets) {
+            os << "    %vreg" << pair.first << " -> " << pair.second << "\n";
+        }
+    }
+    os << "\n";
+
+    // 打印使用的被调用者保存寄存器
+    os << "  Used Callee-Saved Registers:\n";
+    if (info.used_callee_saved_regs.empty()) {
+        os << "    (None)\n";
+    } else {
+        os << "    { ";
+        for (const auto& reg : info.used_callee_saved_regs) {
+            os << regToString(reg) << " ";
+        }
+        os << "}\n";
+    }
+    os << "\n";
+
+    // 打印需要保存/恢复的被调用者保存寄存器 (有序)
+    os << "  Callee-Saved Registers to Store/Restore:\n";
+    if (info.callee_saved_regs_to_store.empty()) {
+        os << "    (None)\n";
+    } else {
+        os << "    [ ";
+        for (const auto& reg : info.callee_saved_regs_to_store) {
+            os << regToString(reg) << " ";
+        }
+        os << "]\n";
+    }
+    os << "\n";
+
+    // 打印最终的寄存器分配结果
+    os << "  Final Register Allocation Map (vreg -> preg):\n";
+    if (info.vreg_to_preg_map.empty()) {
+        os << "    (None)\n";
+    } else {
+        for (const auto& pair : info.vreg_to_preg_map) {
+            os << "    %vreg" << pair.first << " -> " << regToString(pair.second) << "\n";
+        }
+    }
+
+    os << "---------------------------------------------------\n";
+}
+
+}

src/include/backend/RISCv64/Handler/EliminateFrameIndices.h

@@ -0,0 +1,20 @@
+#ifndef ELIMINATE_FRAME_INDICES_H
+#define ELIMINATE_FRAME_INDICES_H
+
+#include "RISCv64LLIR.h"
+
+namespace sysy {
+
+class EliminateFrameIndicesPass {
+public:
+    // Pass 的主入口函数
+    void runOnMachineFunction(MachineFunction* mfunc);
+
+private:
+    // 帮助计算类型大小的辅助函数，从原RegAlloc中移出
+    unsigned getTypeSizeInBytes(Type* type);
+};
+
+} // namespace sysy
+
+#endif // ELIMINATE_FRAME_INDICES_H

src/include/backend/RISCv64/RISCv64Backend.h

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

src/include/backend/RISCv64/RISCv64LLIR.h

@@ -3,6 +3,7 @@
 
 #include "IR.h" // 确保包含了您自己的IR头文件
 #include <string>
+#include <iostream>
 #include <vector>
 #include <memory>
 #include <cstdint>
@@ -195,6 +196,11 @@ public:
         preg = new_preg;
         is_virtual = false;
     }
+    
+    void setVRegNum(unsigned new_vreg_num) {
+        vreg_num = new_vreg_num;
+        is_virtual = true; // 确保设置vreg时，操作数状态正确
+    }
 private:
     unsigned vreg_num = 0;
     PhysicalReg preg = PhysicalReg::ZERO;
@@ -280,8 +286,8 @@ struct StackFrameInfo {
     std::map<unsigned, int> alloca_offsets; // <AllocaInst的vreg, 栈偏移>
     std::map<unsigned, int> spill_offsets;  // <溢出vreg, 栈偏移>
     std::set<PhysicalReg> used_callee_saved_regs; // 使用的保存寄存器
-    std::map<unsigned, PhysicalReg> vreg_to_preg_map;
-    std::vector<PhysicalReg> callee_saved_regs; // 用于存储需要保存的被调用者保存寄存器列表
+    std::map<unsigned, PhysicalReg> vreg_to_preg_map; // [新增] RegAlloc最终的分配结果
+    std::vector<PhysicalReg> callee_saved_regs_to_store; // [新增] 已排序的、需要存取的被调用者保存寄存器
 };
 
 // 机器函数
@@ -295,7 +301,7 @@ public:
     StackFrameInfo& getFrameInfo() { return frame_info; }
     const std::vector<std::unique_ptr<MachineBasicBlock>>& getBlocks() const { return blocks; }
     std::vector<std::unique_ptr<MachineBasicBlock>>& getBlocks() { return blocks; }
-
+    void dumpStackFrameInfo(std::ostream& os = std::cerr) const;
     void addBlock(std::unique_ptr<MachineBasicBlock> block) {
         blocks.push_back(std::move(block));
     }

src/include/backend/RISCv64/RISCv64Passes.h

@@ -8,6 +8,7 @@
 #include "CalleeSavedHandler.h"
 #include "LegalizeImmediates.h"
 #include "PrologueEpilogueInsertion.h"
+#include "EliminateFrameIndices.h"
 #include "Pass.h"
 
 namespace sysy {

src/include/backend/RISCv64/RISCv64RegAlloc.h

@@ -3,9 +3,15 @@
 
 #include "RISCv64LLIR.h"
 #include "RISCv64ISel.h" // 包含 RISCv64ISel.h 以访问 ISel 和 Value 类型
+#include <set>
+#include <vector>
+#include <map>
+#include <stack>
 
 extern int DEBUG;
 extern int DEEPDEBUG;
+extern int DEBUGLENGTH; // 用于限制调试输出的长度
+extern int DEEPERDEBUG; // 用于更深层次的调试输出
 
 namespace sysy {
 
@@ -17,58 +23,98 @@ public:
     void run();
 
 private:
-    using LiveSet = std::set<unsigned>; // 活跃虚拟寄存器集合
-    using InterferenceGraph = std::map<unsigned, std::set<unsigned>>;
+    // 类型定义，与Python版本对应
+    using VRegSet = std::set<unsigned>;
+    using InterferenceGraph = std::map<unsigned, VRegSet>;
+    using VRegStack = std::vector<unsigned>; // 使用vector模拟栈，方便遍历
+    using MoveList = std::map<unsigned, std::set<const MachineInstr*>>;
+    using AliasMap = std::map<unsigned, unsigned>;
+    using ColorMap = std::map<unsigned, PhysicalReg>;
+    using VRegMoveSet = std::set<const MachineInstr*>;
 
-    // 栈帧管理
-    void eliminateFrameIndices();
-    
-    // 活跃性分析
+    // --- 核心算法流程 ---
+    void initialize();
+    void build();
+    void makeWorklist();
+    void simplify();
+    void coalesce();
+    void freeze();
+    void selectSpill();
+    void assignColors();
+    void rewriteProgram();
+    bool doAllocation();
+    void applyColoring();
+
+    void dumpState(const std::string &stage);
+
+    void precolorByCallingConvention();
+
+    // --- 辅助函数 ---
+    void getInstrUseDef(const MachineInstr* instr, VRegSet& use, VRegSet& def);
+    void getInstrUseDef_Liveness(const MachineInstr *instr, VRegSet &use, VRegSet &def);
+    void addEdge(unsigned u, unsigned v);
+    VRegSet adjacent(unsigned n);
+    VRegMoveSet nodeMoves(unsigned n);
+    bool moveRelated(unsigned n);
+    void decrementDegree(unsigned m);
+    void enableMoves(const VRegSet& nodes);
+    unsigned getAlias(unsigned n);
+    void addWorklist(unsigned u);
+    bool briggsHeuristic(unsigned u, unsigned v);
+    bool georgeHeuristic(unsigned u, unsigned v);
+    void combine(unsigned u, unsigned v);
+    void freezeMoves(unsigned u);
+    void collectUsedCalleeSavedRegs();
+    bool isFPVReg(unsigned vreg) const;
+    std::string regToString(PhysicalReg reg);
+    std::string regIdToString(unsigned id);
+
+    // --- 活跃性分析 ---
     void analyzeLiveness();
 
-    // 构建干扰图
-    void buildInterferenceGraph();
-
-    // 图着色分配寄存器
-    void colorGraph();
-
-    // 重写函数，替换vreg并插入溢出代码
-    void rewriteFunction();
-    
-    // 辅助函数，获取指令的Use/Def集合
-    void getInstrUseDef(MachineInstr* instr, LiveSet& use, LiveSet& def);
-
-    // 辅助函数，处理调用约定
-    void handleCallingConvention();
-
     MachineFunction* MFunc;
-    
-    // 活跃性分析结果
-    std::map<const MachineInstr*, LiveSet> live_in_map;
-    std::map<const MachineInstr*, LiveSet> live_out_map;
+    RISCv64ISel* ISel;
 
-    // 干扰图
-    InterferenceGraph interference_graph;
-
-    // 图着色结果
-    std::map<unsigned, PhysicalReg> color_map; // vreg -> preg
-    std::set<unsigned> spilled_vregs;         // 被溢出的vreg集合
-
-    // 可用的物理寄存器池
+    // --- 算法数据结构 ---
+    // 寄存器池
     std::vector<PhysicalReg> allocable_int_regs;
     std::vector<PhysicalReg> allocable_fp_regs;
+    int K_int; // 整数寄存器数量
+    int K_fp;  // 浮点寄存器数量
 
-    // 存储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);
+    // 节点集合
+    VRegSet precolored; // 预着色的节点 (物理寄存器)
+    VRegSet initial;    // 初始的、所有待处理的虚拟寄存器节点
+    VRegSet simplifyWorklist;
+    VRegSet freezeWorklist;
+    VRegSet spillWorklist;
+    VRegSet spilledNodes;
+    VRegSet coalescedNodes;
+    VRegSet coloredNodes;
+    VRegStack selectStack;
 
-    // 辅助函数，用于打印集合
-    static void printLiveSet(const LiveSet& s, const std::string& name, std::ostream& os);
+    // Move指令相关
+    std::set<const MachineInstr*> coalescedMoves;
+    std::set<const MachineInstr*> constrainedMoves;
+    std::set<const MachineInstr*> frozenMoves;
+    std::set<const MachineInstr*> worklistMoves;
+    std::set<const MachineInstr*> activeMoves;
+
+    // 数据结构
+    InterferenceGraph adjSet;
+    std::map<unsigned, VRegSet> adjList; // 邻接表
+    std::map<unsigned, int> degree;
+    MoveList moveList;
+    AliasMap alias;
+    ColorMap color_map;
+
+    // 活跃性分析结果
+    std::map<const MachineInstr*, VRegSet> live_in_map;
+    std::map<const MachineInstr*, VRegSet> live_out_map;
     
+    // VReg -> Value* 和 VReg -> Type* 的映射
+    const std::map<unsigned, Value*>& vreg_to_value_map;
+    const std::map<unsigned, Type*>& vreg_type_map;
 };
 
 } // namespace sysy

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

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

src/midend/Pass/Analysis/Dom.cpp

@@ -1,30 +1,21 @@
 #include "Dom.h"
-#include <algorithm> // for std::set_intersection, std::reverse
+#include <algorithm> // for std::set_intersection, std::set_difference, std::set_union
 #include <iostream>  // for debug output
 #include <limits>    // for std::numeric_limits
 #include <queue>
-#include <functional> // for std::function
-#include <map>
-#include <vector>
-#include <set>
 
 namespace sysy {
 
-// ==============================================================
-// DominatorTreeAnalysisPass 的静态ID
-// ==============================================================
+// 初始化 支配树静态 ID
 void *DominatorTreeAnalysisPass::ID = (void *)&DominatorTreeAnalysisPass::ID;
-
 // ==============================================================
 // DominatorTree 结果类的实现
 // ==============================================================
 
-// 构造函数：初始化关联函数，但不进行计算
 DominatorTree::DominatorTree(Function *F) : AssociatedFunction(F) {
-  // 构造时不需要计算，在分析遍运行里计算并填充
+  // 构造时可以不计算，在分析遍运行里计算并填充
 }
 
-// Getter 方法 (保持不变)
 const std::set<BasicBlock *> *DominatorTree::getDominators(BasicBlock *BB) const {
   auto it = Dominators.find(BB);
   if (it != Dominators.end()) {
@@ -57,7 +48,7 @@ const std::set<BasicBlock *> *DominatorTree::getDominatorTreeChildren(BasicBlock
   return nullptr;
 }
 
-// 辅助函数：打印 BasicBlock 集合 (保持不变)
+// 辅助函数：打印 BasicBlock 集合
 void printBBSet(const std::string &prefix, const std::set<BasicBlock *> &s) {
   if (!DEBUG)
     return;
@@ -72,52 +63,24 @@ void printBBSet(const std::string &prefix, const std::set<BasicBlock *> &s) {
   std::cout << "}" << std::endl;
 }
 
-// 辅助函数：计算逆后序遍历 (RPO) - 保持不变
-std::vector<BasicBlock*> DominatorTree::computeReversePostOrder(Function* F) {
-    std::vector<BasicBlock*> postOrder;
-    std::set<BasicBlock*> visited;
-    
-    std::function<void(BasicBlock*)> dfs_rpo =
-        [&](BasicBlock* bb) {
-        visited.insert(bb);
-        for (BasicBlock* succ : bb->getSuccessors()) {
-            if (visited.find(succ) == visited.end()) {
-                dfs_rpo(succ);
-            }
-        }
-        postOrder.push_back(bb);
-    };
-
-    dfs_rpo(F->getEntryBlock());
-    std::reverse(postOrder.begin(), postOrder.end());
-    
-    if (DEBUG) {
-        std::cout << "--- Computed RPO: ";
-        for (BasicBlock* bb : postOrder) {
-            std::cout << bb->getName() << " ";
-        }
-        std::cout << "---" << std::endl;
-    }
-    return postOrder;
-}
-
-// computeDominators 方法 (保持不变，因为它它是独立于IDom算法的)
 void DominatorTree::computeDominators(Function *F) {
   if (DEBUG)
     std::cout << "--- Computing Dominators ---" << std::endl;
 
   BasicBlock *entryBlock = F->getEntryBlock();
-  std::vector<BasicBlock*> bbs_rpo = computeReversePostOrder(F);
+  std::vector<BasicBlock *> bbs_in_order; // 用于确定遍历顺序，如果需要的话
 
-  for (BasicBlock *bb : bbs_rpo) {
+  // 初始化：入口块只被自己支配，其他块被所有块支配
+  for (const auto &bb_ptr : F->getBasicBlocks()) {
+    BasicBlock *bb = bb_ptr.get();
+    bbs_in_order.push_back(bb); // 收集所有块
     if (bb == entryBlock) {
-      Dominators[bb].clear();
       Dominators[bb].insert(bb);
-      if (DEBUG) std::cout << "Init Dominators[" << bb->getName() << "]: {" << bb->getName() << "}" << std::endl;
+      if (DEBUG)
+        std::cout << "Init Dominators[" << bb->getName() << "]: {" << bb->getName() << "}" << std::endl;
     } else {
-      Dominators[bb].clear();
-      for (BasicBlock *all_bb : bbs_rpo) {
-        Dominators[bb].insert(all_bb);
+      for (const auto &all_bb_ptr : F->getBasicBlocks()) {
+        Dominators[bb].insert(all_bb_ptr.get());
       }
       if (DEBUG) {
         std::cout << "Init Dominators[" << bb->getName() << "]: ";
@@ -131,29 +94,35 @@ void DominatorTree::computeDominators(Function *F) {
   while (changed) {
     changed = false;
     iteration++;
-    if (DEBUG) std::cout << "Iteration " << iteration << std::endl;
+    if (DEBUG)
+      std::cout << "Iteration " << iteration << std::endl;
 
-    for (BasicBlock *bb : bbs_rpo) {
-      if (bb == entryBlock) continue;
+    // 确保遍历顺序一致性，例如可以按照DFS或BFS顺序，或者简单的迭代器顺序
+    // 如果Function::getBasicBlocks()返回的迭代器顺序稳定，则无需bbs_in_order
+    for (const auto &bb_ptr : F->getBasicBlocks()) { // 假设这个迭代器顺序稳定
+      BasicBlock *bb = bb_ptr.get();
+      if (bb == entryBlock)
+        continue;
 
+      // 计算所有前驱的支配者集合的交集
       std::set<BasicBlock *> newDom;
       bool firstPredProcessed = false;
 
       for (BasicBlock *pred : bb->getPredecessors()) {
-        if(DEBUG){
-          std::cout << "  Processing predecessor: " << pred->getName() << std::endl;
-        }
+        // 确保前驱的支配者集合已经计算过
+        if (Dominators.count(pred)) {
           if (!firstPredProcessed) {
-              newDom = Dominators[pred];
-              firstPredProcessed = true;
+            newDom = Dominators[pred];
+            firstPredProcessed = true;
           } else {
-              std::set<BasicBlock *> intersection;
-              std::set_intersection(newDom.begin(), newDom.end(), Dominators[pred].begin(), Dominators[pred].end(),
-                                     std::inserter(intersection, intersection.begin()));
-              newDom = intersection;
+            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);
+      newDom.insert(bb); // BB 永远支配自己
 
       if (newDom != Dominators[bb]) {
         if (DEBUG) {
@@ -171,242 +140,78 @@ void DominatorTree::computeDominators(Function *F) {
     std::cout << "--- Dominators Computation Finished ---" << std::endl;
 }
 
-// ==============================================================
-// Lengauer-Tarjan 算法辅助数据结构和函数 (私有成员)
-// ==============================================================
-
-// DFS 遍历，填充 dfnum_map, vertex_vec, parent_map
-// 对应用户代码的 dfs 函数
-void DominatorTree::dfs_lt_helper(BasicBlock* u) {
-    dfnum_map[u] = df_counter;
-    if (df_counter >= vertex_vec.size()) { // 动态调整大小
-        vertex_vec.resize(df_counter + 1);
-    }
-    vertex_vec[df_counter] = u;
-    if (DEBUG) std::cout << "  DFS: Visiting " << u->getName() << ", dfnum = " << df_counter << std::endl;
-    df_counter++;
-
-    for (BasicBlock* v : u->getSuccessors()) {
-        if (dfnum_map.find(v) == dfnum_map.end()) { // 如果 v 未访问过
-            parent_map[v] = u;
-            if (DEBUG) std::cout << "    DFS: Setting parent[" << v->getName() << "] = " << u->getName() << std::endl;
-            dfs_lt_helper(v);
-        }
-    }
-}
-
-// 并查集：找到集合的代表，并进行路径压缩
-// 同时更新 label，确保 label[i] 总是指向其祖先链中 sdom_map 最小的节点
-// 对应用户代码的 find 函数，也包含了 eval 的逻辑
-BasicBlock* DominatorTree::evalAndCompress_lt_helper(BasicBlock* i) {
-    if (DEBUG) std::cout << "    Eval: Processing " << i->getName() << std::endl;
-    // 如果 i 是根 (ancestor_map[i] == nullptr)
-    if (ancestor_map.find(i) == ancestor_map.end() || ancestor_map[i] == nullptr) {
-        if (DEBUG) std::cout << "      Eval: " << i->getName() << " is root, returning itself." << std::endl;
-        return i; // 根节点自身就是路径上sdom最小的，因为它没有祖先
-    }
-    
-    // 如果 i 的祖先不是根，则递归查找并进行路径压缩
-    BasicBlock* root_ancestor = evalAndCompress_lt_helper(ancestor_map[i]);
-    
-    // 路径压缩时，根据 sdom_map 比较并更新 label_map
-    // 确保 label_map[i] 存储的是 i 到 root_ancestor 路径上 sdom_map 最小的节点
-    // 注意：这里的 ancestor_map[i] 已经被递归调用压缩过一次了，所以是root_ancestor的旧路径
-    // 应该比较的是 label_map[ancestor_map[i]] 和 label_map[i]
-    if (sdom_map.count(label_map[ancestor_map[i]]) && // 确保 label_map[ancestor_map[i]] 存在 sdom
-        sdom_map.count(label_map[i]) &&                // 确保 label_map[i] 存在 sdom
-        dfnum_map[sdom_map[label_map[ancestor_map[i]]]] < dfnum_map[sdom_map[label_map[i]]]) {
-        if (DEBUG) std::cout << "      Eval: Updating label for " << i->getName() << " from " 
-                              << label_map[i]->getName() << " to " << label_map[ancestor_map[i]]->getName() << std::endl;
-        label_map[i] = label_map[ancestor_map[i]];
-    }
-    
-    ancestor_map[i] = root_ancestor; // 执行路径压缩：将 i 直接指向其所属集合的根
-    if (DEBUG) std::cout << "      Eval: Path compression for " << i->getName() << ", new ancestor = " 
-                          << (root_ancestor ? root_ancestor->getName() : "nullptr") << std::endl;
-    
-    return label_map[i]; // <-- **将这里改为返回 label_map[i]**
-}
-
-// Link 函数：将 v 加入 u 的 DFS 树子树中 (实际上是并查集操作)
-// 对应用户代码的 fa[u] = fth[u];
-void DominatorTree::link_lt_helper(BasicBlock* u_parent, BasicBlock* v_child) {
-    ancestor_map[v_child] = u_parent; // 设置并查集父节点
-    label_map[v_child] = v_child;     // 初始化 label 为自身
-    if (DEBUG) std::cout << "  Link: " << v_child->getName() << " linked to " << u_parent->getName() << std::endl;
-}
-
-// ==============================================================
-// Lengauer-Tarjan 算法实现 computeIDoms
-// ==============================================================
 void DominatorTree::computeIDoms(Function *F) {
-    if (DEBUG) std::cout << "--- Computing Immediate Dominators (IDoms) using Lengauer-Tarjan ---" << std::endl;
+  if (DEBUG)
+    std::cout << "--- Computing Immediate Dominators (IDoms) ---" << std::endl;
 
-    BasicBlock *entryBlock = F->getEntryBlock();
+  BasicBlock *entryBlock = F->getEntryBlock();
+  IDoms[entryBlock] = nullptr; // 入口块没有即时支配者
 
-    // 1. 初始化所有 LT 相关的数据结构
-    dfnum_map.clear();
-    vertex_vec.clear();
-    parent_map.clear();
-    sdom_map.clear();
-    idom_map.clear();
-    bucket_map.clear();
-    ancestor_map.clear();
-    label_map.clear();
-    df_counter = 0; // DFS 计数器从 0 开始
+  // 遍历所有非入口块
+  for (const auto &bb_ptr : F->getBasicBlocks()) {
+    BasicBlock *bb = bb_ptr.get();
+    if (bb == entryBlock)
+      continue;
 
-    // 预分配 vertex_vec 的大小，避免频繁resize
-    vertex_vec.resize(F->getBasicBlocks().size() + 1); 
-    // 在 DFS 遍历之前，先为所有基本块初始化 sdom 和 label
-    // 这是 Lengauer-Tarjan 算法的要求，确保所有节点在 Phase 2 开始前都在 map 中
-    for (auto &bb_ptr : F->getBasicBlocks()) {
-        BasicBlock* bb = bb_ptr.get();
-        sdom_map[bb] = bb; // sdom(bb) 初始化为 bb 自身
-        label_map[bb] = bb; // label(bb) 初始化为 bb 自身 (用于 Union-Find 的路径压缩)
-    }
-    // 确保入口块也被正确初始化（如果它不在 F->getBasicBlocks() 的正常迭代中）
-    sdom_map[entryBlock] = entryBlock;
-    label_map[entryBlock] = entryBlock;
-    // Phase 1: DFS 遍历并预处理
-    // 对应用户代码的 dfs(st)
-    dfs_lt_helper(entryBlock);
-    idom_map[entryBlock] = nullptr; // 入口块没有即时支配者
-    if (DEBUG) std::cout << "  IDom[" << entryBlock->getName() << "] = nullptr" << std::endl;
-
-    if (DEBUG) std::cout << "  Sdom[" << entryBlock->getName() << "] = " << entryBlock->getName() << std::endl;
-    
-    // 初始化并查集的祖先和 label
-    for (auto const& [bb_key, dfn_val] : dfnum_map) {
-        ancestor_map[bb_key] = nullptr; // 初始为独立集合的根
-        label_map[bb_key] = bb_key;   // 初始 label 为自身
+    BasicBlock *currentIDom = nullptr;
+    const std::set<BasicBlock *> *domsOfBB = getDominators(bb);
+    if (!domsOfBB) {
+      if (DEBUG)
+        std::cerr << "Warning: Dominators for " << bb->getName() << " not found!" << std::endl;
+      continue;
     }
 
+    // 遍历bb的所有严格支配者 D (即 bb 的支配者中除了 bb 自身)
+    for (BasicBlock *D_candidate : *domsOfBB) {
+      if (D_candidate == bb)
+        continue; // 跳过bb自身
+
+      bool D_candidate_is_IDom = true;
+      // 检查是否存在另一个块 X，使得 D_candidate 严格支配 X 且 X 严格支配 bb
+      // 或者更直接的，检查 D_candidate 是否被 bb 的所有其他严格支配者所支配
+      for (BasicBlock *X_other_dom : *domsOfBB) {
+        if (X_other_dom == bb || X_other_dom == D_candidate)
+          continue; // 跳过bb自身和D_candidate
+
+        // 如果 X_other_dom 严格支配 bb (它在 domsOfBB 中且不是bb自身)
+        // 并且 X_other_dom 不被 D_candidate 支配，那么 D_candidate 就不是 IDom
+        const std::set<BasicBlock *> *domsOfX_other_dom = getDominators(X_other_dom);
+        if (domsOfX_other_dom && domsOfX_other_dom->count(D_candidate)) { // X_other_dom 支配 D_candidate
+          // D_candidate 被另一个支配者 X_other_dom 支配
+          // 这说明 D_candidate 位于 X_other_dom 的“下方”，X_other_dom 更接近 bb
+          // 因此 D_candidate 不是 IDom
+          D_candidate_is_IDom = false;
+          break;
+        }
+      }
+      if (D_candidate_is_IDom) {
+        currentIDom = D_candidate;
+        break; // 找到即时支配者，可以退出循环，因为它是唯一的
+      }
+    }
+    IDoms[bb] = currentIDom;
     if (DEBUG) {
-        std::cout << "  --- DFS Phase Complete ---" << std::endl;
-        std::cout << "  dfnum_map:" << std::endl;
-        for (auto const& [bb, dfn] : dfnum_map) {
-            std::cout << "    " << bb->getName() << " -> " << dfn << std::endl;
-        }
-        std::cout << "  vertex_vec (by dfnum):" << std::endl;
-        for (size_t k = 0; k < df_counter; ++k) {
-            if (vertex_vec[k]) std::cout << "    [" << k << "] -> " << vertex_vec[k]->getName() << std::endl;
-        }
-        std::cout << "  parent_map:" << std::endl;
-        for (auto const& [child, parent] : parent_map) {
-            std::cout << "    " << child->getName() << " -> " << (parent ? parent->getName() : "nullptr") << std::endl;
-        }
-        std::cout << "  ------------------------" << std::endl;
+      std::cout << "  IDom[" << bb->getName() << "] = " << (currentIDom ? currentIDom->getName() : "nullptr")
+                << std::endl;
     }
-
-
-    // Phase 2: 计算半支配者 (sdom)
-    // 对应用户代码的 for (int i = dfc; i >= 2; --i) 循环的上半部分
-    // 按照 DFS 编号递减的顺序遍历所有节点 (除了 entryBlock，它的 DFS 编号是 0)
-    if (DEBUG) std::cout << "--- Phase 2: Computing Semi-Dominators (sdom) ---" << std::endl;
-    for (int i = df_counter - 1; i >= 1; --i) { // 从 DFS 编号最大的节点开始，到 1
-        BasicBlock* w = vertex_vec[i]; // 当前处理的节点
-        if (DEBUG) std::cout << "  Processing node w: " << w->getName() << " (dfnum=" << i << ")" << std::endl;
-
-
-        // 对于 w 的每个前驱 v
-        for (BasicBlock* v : w->getPredecessors()) {
-            if (DEBUG) std::cout << "    Considering predecessor v: " << v->getName() << std::endl;
-            // 如果前驱 v 未被 DFS 访问过 (即不在 dfnum_map 中)，则跳过
-            if (dfnum_map.find(v) == dfnum_map.end()) {
-                if (DEBUG) std::cout << "      Predecessor " << v->getName() << " not in DFS tree, skipping." << std::endl;
-                continue; 
-            }
-
-            // 调用 evalAndCompress 来找到 v 在其 DFS 树祖先链上具有最小 sdom 的节点
-            BasicBlock* u_with_min_sdom_on_path = evalAndCompress_lt_helper(v);
-            if (DEBUG) std::cout << "      Eval(" << v->getName() << ") returned " 
-                                  << u_with_min_sdom_on_path->getName() << std::endl;
-            if (DEBUG && sdom_map.count(u_with_min_sdom_on_path) && sdom_map.count(w)) {
-                std::cout << "      Comparing sdom: dfnum[" << sdom_map[u_with_min_sdom_on_path]->getName() << "] (" << dfnum_map[sdom_map[u_with_min_sdom_on_path]] 
-                          << ") vs dfnum[" << sdom_map[w]->getName() << "] (" << dfnum_map[sdom_map[w]] << ")" << std::endl;
-            }
-            // 比较 sdom(u) 和 sdom(w)
-            if (sdom_map.count(u_with_min_sdom_on_path) && sdom_map.count(w) &&
-                dfnum_map[sdom_map[u_with_min_sdom_on_path]] < dfnum_map[sdom_map[w]]) {
-                if (DEBUG) std::cout << "      Updating sdom[" << w->getName() << "] from " 
-                                      << sdom_map[w]->getName() << " to " 
-                                      << sdom_map[u_with_min_sdom_on_path]->getName() << std::endl;
-                sdom_map[w] = sdom_map[u_with_min_sdom_on_path]; // 更新 sdom(w)
-                if (DEBUG) std::cout << "      Sdom update applied. New sdom[" << w->getName() << "] = " << sdom_map[w]->getName() << std::endl;
-            }
-        }
-        
-        // 将 w 加入 sdom(w) 对应的桶中
-        bucket_map[sdom_map[w]].push_back(w);
-        if (DEBUG) std::cout << "    Adding " << w->getName() << " to bucket of sdom(" << w->getName() << "): " 
-                              << sdom_map[w]->getName() << std::endl;
-
-        // 将 w 的父节点加入并查集 (link 操作)
-        if (parent_map.count(w) && parent_map[w] != nullptr) {
-            link_lt_helper(parent_map[w], w);
-        }
-        
-        // Phase 3-part 1: 处理 parent[w] 的桶中所有节点，确定部分 idom
-        if (parent_map.count(w) && parent_map[w] != nullptr) {
-            BasicBlock* p = parent_map[w]; // p 是 w 的父节点
-            if (DEBUG) std::cout << "    Processing bucket for parent " << p->getName() << std::endl;
-
-            // 注意：这里需要复制桶的内容，因为原始桶在循环中会被clear
-            std::vector<BasicBlock*> nodes_in_p_bucket_copy = bucket_map[p];
-            for (BasicBlock* y : nodes_in_p_bucket_copy) {
-                if (DEBUG) std::cout << "      Processing node y from bucket: " << y->getName() << std::endl;
-                // 找到 y 在其 DFS 树祖先链上具有最小 sdom 的节点
-                BasicBlock* u = evalAndCompress_lt_helper(y);
-                if (DEBUG) std::cout << "        Eval(" << y->getName() << ") returned " << u->getName() << std::endl;
-                
-                // 确定 idom(y)
-                // if sdom(eval(y)) == sdom(parent(w)), then idom(y) = parent(w)
-                // else idom(y) = eval(y)
-                if (sdom_map.count(u) && sdom_map.count(p) &&
-                    dfnum_map[sdom_map[u]] < dfnum_map[sdom_map[p]]) {
-                    idom_map[y] = u; // 确定的 idom
-                    if (DEBUG) std::cout << "        IDom[" << y->getName() << "] set to " << u->getName() << std::endl;
-                } else {
-                    idom_map[y] = p; // p 是 y 的 idom
-                    if (DEBUG) std::cout << "        IDom[" << y->getName() << "] set to " << p->getName() << std::endl;
-                }
-            }
-            bucket_map[p].clear(); // 清空桶，防止重复处理
-            if (DEBUG) std::cout << "    Cleared bucket for parent " << p->getName() << std::endl;
-        }
-    }
-
-    // Phase 3-part 2: 最终确定 idom (处理那些 idom != sdom 的节点)
-    if (DEBUG) std::cout << "--- Phase 3: Finalizing Immediate Dominators (idom) ---" << std::endl;
-    for (int i = 1; i < df_counter; ++i) { // 从 DFS 编号最小的节点 (除了 entryBlock) 开始
-        BasicBlock* w = vertex_vec[i];
-        if (DEBUG) std::cout << "  Finalizing node w: " << w->getName() << std::endl;
-        if (idom_map.count(w) && sdom_map.count(w) && idom_map[w] != sdom_map[w]) {
-            // idom[w] 的 idom 是其真正的 idom
-            if (DEBUG) std::cout << "    idom[" << w->getName() << "] (" << idom_map[w]->getName() 
-                                  << ") != sdom[" << w->getName() << "] (" << sdom_map[w]->getName() << ")" << std::endl;
-            if (idom_map.count(idom_map[w])) {
-                idom_map[w] = idom_map[idom_map[w]];
-                if (DEBUG) std::cout << "    Updating idom[" << w->getName() << "] to idom(idom(w)): " 
-                                      << idom_map[w]->getName() << std::endl;
-            } else {
-                 if (DEBUG) std::cout << "    Warning: idom(idom(" << w->getName() << ")) not found, leaving idom[" << w->getName() << "] as is." << std::endl;
-            }
-        }
-        if (DEBUG) {
-            std::cout << "  Final IDom[" << w->getName() << "] = " << (idom_map[w] ? idom_map[w]->getName() : "nullptr") << std::endl;
-        }
-    }
-
-    // 将计算结果从 idom_map 存储到 DominatorTree 的成员变量 IDoms 中
-    IDoms = idom_map; 
-
-    if (DEBUG) std::cout << "--- Immediate Dominators Computation Finished ---" << std::endl;
+  }
+  if (DEBUG)
+    std::cout << "--- Immediate Dominators Computation Finished ---" << std::endl;
 }
 
-// ==============================================================
-// computeDominanceFrontiers 和 computeDominatorTreeChildren (保持不变)
-// ==============================================================
+/*
+for each node n in a postorder traversal of the dominator tree:
+  df[n] = empty set
+  // compute DF_local(n)
+  for each child y of n in the CFG:
+    if idom[y] != n:
+      df[n] = df[n] U {y}
+  // compute DF_up(n)
+  for each child c of n in the dominator tree:
+    for each element w in df[c]:
+      if idom[w] != n:
+        df[n] = df[n] U {w}
+*/
 
 void DominatorTree::computeDominanceFrontiers(Function *F) {
   if (DEBUG)
@@ -416,17 +221,21 @@ void DominatorTree::computeDominanceFrontiers(Function *F) {
     BasicBlock *X = bb_ptr_X.get();
     DominanceFrontiers[X].clear();
 
+    // 遍历所有可能的 Z (X支配Z，或者Z就是X)
     for (const auto &bb_ptr_Z : F->getBasicBlocks()) {
       BasicBlock *Z = bb_ptr_Z.get();
       const std::set<BasicBlock *> *domsOfZ = getDominators(Z);
 
-      if (!domsOfZ || domsOfZ->find(X) == domsOfZ->end()) { // Z 不被 X 支配
+      // 如果 X 不支配 Z，则 Z 与 DF(X) 无关
+      if (!domsOfZ || domsOfZ->find(X) == domsOfZ->end()) {
         continue;
       }
 
+      // 遍历 Z 的所有后继 Y
       for (BasicBlock *Y : Z->getSuccessors()) {
+        // 如果 Y 不被 X 严格支配，则 Y 在 DF(X) 中
+        // Y 不被 X 严格支配意味着 (Y不被X支配) 或 (Y就是X)
         const std::set<BasicBlock *> *domsOfY = getDominators(Y);
-        // 如果 Y == X，或者 Y 不被 X 严格支配 (即 Y 不被 X 支配)
         if (Y == X || (domsOfY && domsOfY->find(X) == domsOfY->end())) {
           DominanceFrontiers[X].insert(Y);
         }
@@ -465,21 +274,23 @@ void DominatorTree::computeDominatorTreeChildren(Function *F) {
 }
 
 // ==============================================================
-// DominatorTreeAnalysisPass 的实现 (保持不变)
+// DominatorTreeAnalysisPass 的实现
 // ==============================================================
 
 bool DominatorTreeAnalysisPass::runOnFunction(Function *F, AnalysisManager &AM) {
   // 每次运行时清空旧数据，确保重新计算
   CurrentDominatorTree = std::make_unique<DominatorTree>(F);
+  // 不需要手动清空map，unique_ptr会创建新的DominatorTree对象，其map是空的
 
   CurrentDominatorTree->computeDominators(F);
-  CurrentDominatorTree->computeIDoms(F); // 修正后的LT算法
+  CurrentDominatorTree->computeIDoms(F); // 修正后的IDoms算法
   CurrentDominatorTree->computeDominanceFrontiers(F);
   CurrentDominatorTree->computeDominatorTreeChildren(F);
-  return false;
+  return false; // 分析遍通常返回 false，表示不修改 IR
 }
 
 std::unique_ptr<AnalysisResultBase> DominatorTreeAnalysisPass::getResult() {
+  // 返回计算好的 DominatorTree 实例，所有权转移给 AnalysisManager
   return std::move(CurrentDominatorTree);
 }
 

src/midend/Pass/Pass.cpp

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

src/midend/SysYIRGenerator.cpp

@@ -586,18 +586,7 @@ std::any SysYIRGenerator::visitConstDecl(SysYParser::ConstDeclContext *ctx) {
 
     // 显式地为局部常量在栈上分配空间
     // alloca 的类型将是指针指向常量类型，例如 `int*` 或 `int[2][3]*`
-    // 将 alloca 全部集中到entry函数中
-    // 记录当前位置
-    BasicBlock *curBB = builder.getBasicBlock();
-    auto curPos =builder.getPosition();
-    Function *currentFunction = builder.getBasicBlock()->getParent();
-    BasicBlock *entryBB = currentFunction->getEntryBlock();
-    // 在terminator前插入
-    auto entryPos = entryBB->terminator();
-    builder.setPosition(entryBB, entryPos);
     AllocaInst *alloca = builder.createAllocaInst(Type::getPointerType(variableType), name);
-    // 恢复当前位置
-    builder.setPosition(curBB, curPos);
 
     ArrayValueTree *root = std::any_cast<ArrayValueTree *>(constDef->constInitVal()->accept(this));
     ValueCounter values;
@@ -754,20 +743,8 @@ std::any SysYIRGenerator::visitVarDecl(SysYParser::VarDeclContext *ctx) {
 
     // 对于数组，alloca 的类型将是指针指向数组类型，例如 `int[2][3]*`
     // 对于标量，alloca 的类型将是指针指向标量类型，例如 `int*`
-
-    BasicBlock *curBB = builder.getBasicBlock();
-    auto curPos =builder.getPosition();
-    Function *currentFunction = builder.getBasicBlock()->getParent();
-    BasicBlock *entryBB = currentFunction->getEntryBlock();
-    // 在terminator前插入
-    auto entryPos = entryBB->terminator();
-    builder.setPosition(entryBB, entryPos);
-    AllocaInst *alloca = builder.createAllocaInst(Type::getPointerType(variableType), name);
-    // 恢复当前位置
-    builder.setPosition(curBB, curPos);
-
-    // AllocaInst* alloca =
-    //     builder.createAllocaInst(Type::getPointerType(variableType), name);
+    AllocaInst* alloca =
+        builder.createAllocaInst(Type::getPointerType(variableType), name);
 
     if (varDef->initVal() != nullptr) {
       ValueCounter values;
@@ -1060,7 +1037,6 @@ std::any SysYIRGenerator::visitFuncDef(SysYParser::FuncDefContext *ctx){
   
   // 从 entryBB 无条件跳转到 funcBodyEntry
   builder.createUncondBrInst(funcBodyEntry);
-  BasicBlock::conectBlocks(entry, funcBodyEntry); // 连接 entryBB 和 funcBodyEntry
   builder.setPosition(funcBodyEntry,funcBodyEntry->end()); // 将插入点设置到 funcBodyEntry
 
   for (auto item : ctx->blockStmt()->blockItem()) {

src/sysyc.cpp

@@ -21,6 +21,8 @@ using namespace sysy;
 
 int DEBUG = 0;
 int DEEPDEBUG = 0;
+int DEEPERDEBUG = 0;
+int DEBUGLENGTH = 50;
 
 static string argStopAfter;
 static string argInputFile;