[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

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