From 03e88eee7005a626db69d8cc4a6f424c069a39be Mon Sep 17 00:00:00 2001 From: Lixuanwang Date: Thu, 31 Jul 2025 23:02:53 +0800 Subject: [PATCH 01/55] =?UTF-8?q?[backend-IRC]=E5=88=9D=E6=AD=A5=E6=9E=84?= =?UTF-8?q?=E5=BB=BA=E6=96=B0=E7=9A=84=E5=AF=84=E5=AD=98=E5=99=A8=E5=88=86?= =?UTF-8?q?=E9=85=8D=E5=99=A8?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- script/runit-single.sh | 12 +- src/backend/RISCv64/CMakeLists.txt | 1 + .../RISCv64/Handler/CalleeSavedHandler.cpp | 82 +- .../RISCv64/Handler/EliminateFrameIndices.cpp | 157 ++ .../Handler/PrologueEpilogueInsertion.cpp | 121 +- src/backend/RISCv64/RISCv64Backend.cpp | 34 +- src/backend/RISCv64/RISCv64RegAlloc.cpp | 1975 ++++++++++------- .../RISCv64/Handler/EliminateFrameIndices.h | 20 + src/include/backend/RISCv64/RISCv64LLIR.h | 9 +- src/include/backend/RISCv64/RISCv64Passes.h | 1 + src/include/backend/RISCv64/RISCv64RegAlloc.h | 130 +- 11 files changed, 1514 insertions(+), 1028 deletions(-) create mode 100644 src/backend/RISCv64/Handler/EliminateFrameIndices.cpp create mode 100644 src/include/backend/RISCv64/Handler/EliminateFrameIndices.h diff --git a/script/runit-single.sh b/script/runit-single.sh index 8b7804f..ed32181 100644 --- a/script/runit-single.sh +++ b/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}" diff --git a/src/backend/RISCv64/CMakeLists.txt b/src/backend/RISCv64/CMakeLists.txt index eb9f37f..6e397cc 100644 --- a/src/backend/RISCv64/CMakeLists.txt +++ b/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 diff --git a/src/backend/RISCv64/Handler/CalleeSavedHandler.cpp b/src/backend/RISCv64/Handler/CalleeSavedHandler.cpp index cdbccc1..b4cbc83 100644 --- a/src/backend/RISCv64/Handler/CalleeSavedHandler.cpp +++ b/src/backend/RISCv64/Handler/CalleeSavedHandler.cpp @@ -8,7 +8,6 @@ namespace sysy { char CalleeSavedHandler::ID = 0; -// 辅助函数，用于判断一个物理寄存器是否为浮点寄存器 static bool is_fp_reg(PhysicalReg reg) { return reg >= PhysicalReg::F0 && reg <= PhysicalReg::F31; } @@ -20,100 +19,72 @@ bool CalleeSavedHandler::runOnFunction(Function *F, AnalysisManager& AM) { void CalleeSavedHandler::runOnMachineFunction(MachineFunction* mfunc) { StackFrameInfo& frame_info = mfunc->getFrameInfo(); - - std::set 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(op.get())); - } else if (op->getKind() == MachineOperand::KIND_MEM) { - check_and_insert_reg(static_cast(op.get())->getBase()); - } - } - } - } + const std::set& used_callee_saved = frame_info.used_callee_saved_regs; if (used_callee_saved.empty()) { frame_info.callee_saved_size = 0; return; } - // 2. 计算并更新 frame_info - frame_info.callee_saved_size = used_callee_saved.size() * 8; - - // 为了布局确定性和恢复顺序一致，对寄存器排序 + // 1. 计算大小并排序，以便确定地生成代码 + frame_info.callee_saved_size = used_callee_saved.size() * 8; // 每个寄存器占8字节 std::vector sorted_regs(used_callee_saved.begin(), used_callee_saved.end()); - std::sort(sorted_regs.begin(), sorted_regs.end()); - - // 3. 在函数序言中插入保存指令 + std::sort(sorted_regs.begin(), sorted_regs.end(), [](PhysicalReg a, PhysicalReg b){ return static_cast(a) < static_cast(b); }); + frame_info.callee_saved_regs_to_store = sorted_regs; // 保存排序后的列表 + + // 2. 在函数序言中插入保存指令 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); - } - + // 确保插入在任何栈分配指令之后，但在其他代码之前。 + // PrologueEpilogueInsertionPass 会处理最终顺序，这里我们先插入。 + std::vector> save_instrs; - // [关键] 从局部变量区域之后开始分配空间 - int current_offset = - (16 + frame_info.locals_size); + int current_offset = -16; // 栈布局: [ra, s0] 在最顶层，然后是callee-saved for (PhysicalReg reg : sorted_regs) { + // s0/fp 已经在序言中由 PrologueEpilogueInsertionPass 特殊处理，这里跳过 + if (reg == PhysicalReg::S0) continue; + current_offset -= 8; RVOpcodes save_op = is_fp_reg(reg) ? RVOpcodes::FSD : RVOpcodes::SD; auto save_instr = std::make_unique(save_op); save_instr->addOperand(std::make_unique(reg)); save_instr->addOperand(std::make_unique( - std::make_unique(PhysicalReg::S0), // 基址为帧指针 s0 - std::make_unique(current_offset) + std::make_unique(PhysicalReg::SP), // 基址为 SP + std::make_unique(0) // 偏移量将在PEI中修正 )); save_instrs.push_back(std::move(save_instr)); } if (!save_instrs.empty()) { + // 在序言的开头插入保存指令（PEI会后续调整它们的偏移） entry_instrs.insert(insert_pos, std::make_move_iterator(save_instrs.begin()), std::make_move_iterator(save_instrs.end())); } - // 4. 在函数结尾（ret之前）插入恢复指令 + // 3. 在函数结尾（ret之前）插入恢复指令 for (auto& mbb : mfunc->getBlocks()) { for (auto it = mbb->getInstructions().begin(); it != mbb->getInstructions().end(); ++it) { if ((*it)->getOpcode() == RVOpcodes::RET) { std::vector> restore_instrs; - // [关键] 使用与保存时完全相同的逻辑来计算偏移量 - current_offset = - (16 + frame_info.locals_size); + current_offset = -16; - for (PhysicalReg reg : sorted_regs) { + // 以相反的顺序恢复寄存器 + for (auto reg_it = sorted_regs.rbegin(); reg_it != sorted_regs.rend(); ++reg_it) { + PhysicalReg reg = *reg_it; + if (reg == PhysicalReg::S0) continue; + current_offset -= 8; RVOpcodes restore_op = is_fp_reg(reg) ? RVOpcodes::FLD : RVOpcodes::LD; auto restore_instr = std::make_unique(restore_op); restore_instr->addOperand(std::make_unique(reg)); restore_instr->addOperand(std::make_unique( - std::make_unique(PhysicalReg::S0), - std::make_unique(current_offset) + std::make_unique(PhysicalReg::SP), + std::make_unique(0) // 偏移量同样由PEI修正 )); restore_instrs.push_back(std::move(restore_instr)); } @@ -129,5 +100,4 @@ void CalleeSavedHandler::runOnMachineFunction(MachineFunction* mfunc) { next_block_label:; } } - } // namespace sysy \ No newline at end of file diff --git a/src/backend/RISCv64/Handler/EliminateFrameIndices.cpp b/src/backend/RISCv64/Handler/EliminateFrameIndices.cpp new file mode 100644 index 0000000..f2aa6fa --- /dev/null +++ b/src/backend/RISCv64/Handler/EliminateFrameIndices.cpp @@ -0,0 +1,157 @@ +#include "EliminateFrameIndices.h" +#include "RISCv64ISel.h" +#include + +namespace sysy { + +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(); + 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. 为栈传递的参数计算偏移量 + if (F) { + int arg_idx = 0; + for (Argument* arg : F->getArguments()) { + // 只关心第8个索引及之后的参数 (即第9个参数开始) + if (arg_idx >= 8) { + // 第一个栈参数(idx=8)在0(s0), 第二个(idx=9)在8(s0) + int offset = (arg_idx - 8) * 8; + unsigned vreg = isel->getVReg(arg); + frame_info.alloca_offsets[vreg] = offset; + } + arg_idx++; + } + } + + // 2. 为局部变量分配空间，起始点在 [ra, s0] (16字节) 之后 + int local_var_offset = 16; + + // 处理局部变量 (AllocaInst) + if(F) { // 确保函数指针有效 + for (auto& bb : F->getBasicBlocks()) { + for (auto& inst : bb->getInstructions()) { + if (auto alloca = dynamic_cast(inst.get())) { + Type* allocated_type = alloca->getType()->as()->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. 遍历所有机器指令，将伪指令展开为真实指令 + for (auto& mbb : mfunc->getBlocks()) { + std::vector> 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(operands[0].get())->getVRegNum(); + unsigned alloca_vreg = static_cast(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(RVOpcodes::ADDI); + addi->addOperand(std::make_unique(addr_vreg)); + addi->addOperand(std::make_unique(PhysicalReg::S0)); + addi->addOperand(std::make_unique(offset)); + new_instructions.push_back(std::move(addi)); + + // 展开为: lw/ld/flw dest_vreg, 0(addr_vreg) + auto load_instr = std::make_unique(real_load_op); + load_instr->addOperand(std::make_unique(dest_vreg)); + load_instr->addOperand(std::make_unique( + std::make_unique(addr_vreg), + std::make_unique(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(operands[0].get())->getVRegNum(); + unsigned alloca_vreg = static_cast(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(RVOpcodes::ADDI); + addi->addOperand(std::make_unique(addr_vreg)); + addi->addOperand(std::make_unique(PhysicalReg::S0)); + addi->addOperand(std::make_unique(offset)); + new_instructions.push_back(std::move(addi)); + + // 展开为: sw/sd/fsw src_vreg, 0(addr_vreg) + auto store_instr = std::make_unique(real_store_op); + store_instr->addOperand(std::make_unique(src_vreg)); + store_instr->addOperand(std::make_unique( + std::make_unique(addr_vreg), + std::make_unique(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(operands[0].get())->getVRegNum(); + unsigned alloca_vreg = static_cast(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(RVOpcodes::ADDI); + addi->addOperand(std::make_unique(dest_vreg)); + addi->addOperand(std::make_unique(PhysicalReg::S0)); + addi->addOperand(std::make_unique(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 \ No newline at end of file diff --git a/src/backend/RISCv64/Handler/PrologueEpilogueInsertion.cpp b/src/backend/RISCv64/Handler/PrologueEpilogueInsertion.cpp index 30fa6bd..05532b7 100644 --- a/src/backend/RISCv64/Handler/PrologueEpilogueInsertion.cpp +++ b/src/backend/RISCv64/Handler/PrologueEpilogueInsertion.cpp @@ -1,6 +1,5 @@ #include "PrologueEpilogueInsertion.h" #include "RISCv64ISel.h" -#include "RISCv64RegAlloc.h" // 需要访问RegAlloc的结果 #include namespace sysy { @@ -8,10 +7,11 @@ namespace sysy { char PrologueEpilogueInsertionPass::ID = 0; void PrologueEpilogueInsertionPass::runOnMachineFunction(MachineFunction* mfunc) { + StackFrameInfo& frame_info = mfunc->getFrameInfo(); + + // 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& instr) { @@ -22,39 +22,28 @@ void PrologueEpilogueInsertionPass::runOnMachineFunction(MachineFunction* mfunc) ); } - StackFrameInfo& frame_info = mfunc->getFrameInfo(); - Function* F = mfunc->getFunc(); - RISCv64ISel* isel = mfunc->getISel(); - - // [关键] 获取寄存器分配的结果 (vreg -> preg 的映射) - // RegAlloc Pass 必须已经运行过 - auto& vreg_to_preg_map = frame_info.vreg_to_preg_map; - - // 完全遵循 AsmPrinter 中的计算逻辑 - 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; + // 2. 计算最终的栈帧总大小 + // 总大小 = [ra, s0] + [被调用者保存寄存器] + [局部变量] + [溢出槽] + [调用其他函数的参数区] + // 假设调用参数区大小为0，因为它是在call指令周围动态分配和释放的 + int total_stack_size = 16 + frame_info.callee_saved_size + frame_info.locals_size + frame_info.spill_size; + int aligned_stack_size = (total_stack_size + 15) & ~15; // 16字节对齐 frame_info.total_size = aligned_stack_size; - // 只有在需要分配栈空间时才生成指令 + // 只有在需要分配栈空间时才生成序言/尾声 if (aligned_stack_size > 0) { - // --- 1. 插入序言 --- + // --- 3. 插入序言 --- MachineBasicBlock* entry_block = mfunc->getBlocks().front().get(); auto& entry_instrs = entry_block->getInstructions(); - std::vector> prologue_instrs; - // 1. addi sp, sp, -aligned_stack_size + // a. addi sp, sp, -aligned_stack_size auto alloc_stack = std::make_unique(RVOpcodes::ADDI); alloc_stack->addOperand(std::make_unique(PhysicalReg::SP)); alloc_stack->addOperand(std::make_unique(PhysicalReg::SP)); alloc_stack->addOperand(std::make_unique(-aligned_stack_size)); prologue_instrs.push_back(std::move(alloc_stack)); - // 2. sd ra, (aligned_stack_size - 8)(sp) + // b. sd ra, (aligned_stack_size - 8)(sp) auto save_ra = std::make_unique(RVOpcodes::SD); save_ra->addOperand(std::make_unique(PhysicalReg::RA)); save_ra->addOperand(std::make_unique( @@ -63,7 +52,7 @@ void PrologueEpilogueInsertionPass::runOnMachineFunction(MachineFunction* mfunc) )); prologue_instrs.push_back(std::move(save_ra)); - // 3. sd s0, (aligned_stack_size - 16)(sp) + // c. sd s0, (aligned_stack_size - 16)(sp) auto save_fp = std::make_unique(RVOpcodes::SD); save_fp->addOperand(std::make_unique(PhysicalReg::S0)); save_fp->addOperand(std::make_unique( @@ -72,66 +61,25 @@ void PrologueEpilogueInsertionPass::runOnMachineFunction(MachineFunction* mfunc) )); prologue_instrs.push_back(std::move(save_fp)); - // 4. addi s0, sp, aligned_stack_size + // d. addi s0, sp, aligned_stack_size auto set_fp = std::make_unique(RVOpcodes::ADDI); set_fp->addOperand(std::make_unique(PhysicalReg::S0)); set_fp->addOperand(std::make_unique(PhysicalReg::SP)); set_fp->addOperand(std::make_unique(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(); + // 将序言指令插入到函数入口 + entry_instrs.insert(entry_instrs.begin(), + std::make_move_iterator(prologue_instrs.begin()), + std::make_move_iterator(prologue_instrs.end())); - if (arg_type->isFloat()) { - auto load_arg = std::make_unique(RVOpcodes::FLW); - load_arg->addOperand(std::make_unique(dest_preg)); - load_arg->addOperand(std::make_unique( - std::make_unique(PhysicalReg::S0), - std::make_unique(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(load_op); - load_arg->addOperand(std::make_unique(dest_preg)); - load_arg->addOperand(std::make_unique( - std::make_unique(PhysicalReg::S0), - std::make_unique(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())); - } - - // --- 2. 插入尾声 (此部分逻辑保持不变) --- + // --- 4. 插入尾声 --- for (auto& mbb : mfunc->getBlocks()) { for (auto it = mbb->getInstructions().begin(); it != mbb->getInstructions().end(); ++it) { if ((*it)->getOpcode() == RVOpcodes::RET) { std::vector> epilogue_instrs; - // 1. ld ra + // a. ld ra auto restore_ra = std::make_unique(RVOpcodes::LD); restore_ra->addOperand(std::make_unique(PhysicalReg::RA)); restore_ra->addOperand(std::make_unique( @@ -140,7 +88,7 @@ void PrologueEpilogueInsertionPass::runOnMachineFunction(MachineFunction* mfunc) )); epilogue_instrs.push_back(std::move(restore_ra)); - // 2. ld s0 + // b. ld s0 auto restore_fp = std::make_unique(RVOpcodes::LD); restore_fp->addOperand(std::make_unique(PhysicalReg::S0)); restore_fp->addOperand(std::make_unique( @@ -149,24 +97,39 @@ void PrologueEpilogueInsertionPass::runOnMachineFunction(MachineFunction* mfunc) )); epilogue_instrs.push_back(std::move(restore_fp)); - // 3. addi sp, sp, aligned_stack_size + // c. addi sp, sp, aligned_stack_size auto dealloc_stack = std::make_unique(RVOpcodes::ADDI); dealloc_stack->addOperand(std::make_unique(PhysicalReg::SP)); dealloc_stack->addOperand(std::make_unique(PhysicalReg::SP)); dealloc_stack->addOperand(std::make_unique(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())); - } + mbb->getInstructions().insert(it, + std::make_move_iterator(epilogue_instrs.begin()), + std::make_move_iterator(epilogue_instrs.end())); + it++; // 跳过刚插入的指令和原有的RET goto next_block; } } next_block:; } } + + // --- 5. [新增] 修正所有基于S0的内存访问偏移量 --- + // CalleeSaved, Alloca, Spill 的偏移量都是相对于S0的负向偏移 + for (auto& mbb : mfunc->getBlocks()) { + for (auto& instr : mbb->getInstructions()) { + if (instr->getOperands().empty() || instr->getOperands().back()->getKind() != MachineOperand::KIND_MEM) { + continue; + } + auto mem_op = static_cast(instr->getOperands().back().get()); + if (mem_op->getBase()->isVirtual() || mem_op->getBase()->getPReg() != PhysicalReg::S0) { + continue; + } + // 此时所有基于S0的偏移量都是负数，无需再次调整 + // 之前的RegAlloc/CalleeSavedHandler已经计算好了正确的相对于S0的偏移 + } + } } } // namespace sysy \ No newline at end of file diff --git a/src/backend/RISCv64/RISCv64Backend.cpp b/src/backend/RISCv64/RISCv64Backend.cpp index 2797eb7..3841eec 100644 --- a/src/backend/RISCv64/RISCv64Backend.cpp +++ b/src/backend/RISCv64/RISCv64Backend.cpp @@ -115,13 +115,21 @@ std::string RISCv64CodeGen::function_gen(Function* func) { std::unique_ptr mfunc = isel.runOnFunction(func); // 第一次调试打印输出 - std::stringstream ss1; - RISCv64AsmPrinter printer1(mfunc.get()); - printer1.run(ss1, true); + std::stringstream ss_after_isel; + if (DEBUG) { + RISCv64AsmPrinter printer_isel(mfunc.get()); + printer_isel.run(ss_after_isel, true); + std::cout << ss_after_isel.str(); + } - // 阶段 2: 指令调度 (Instruction Scheduling) - PreRA_Scheduler scheduler; - scheduler.runOnMachineFunction(mfunc.get()); + // [新增] 阶段 2: 消除帧索引 (展开伪指令，计算局部变量偏移) + // 这个Pass必须在寄存器分配之前运行 + EliminateFrameIndicesPass efi_pass; + efi_pass.runOnMachineFunction(mfunc.get()); + + // // 阶段 2: 指令调度 (Instruction Scheduling) + // PreRA_Scheduler scheduler; + // scheduler.runOnMachineFunction(mfunc.get()); // 阶段 3: 物理寄存器分配 (Register Allocation) RISCv64RegAlloc reg_alloc(mfunc.get()); @@ -131,9 +139,9 @@ std::string RISCv64CodeGen::function_gen(Function* func) { CalleeSavedHandler callee_handler; callee_handler.runOnMachineFunction(mfunc.get()); - // 阶段 4: 窥孔优化 (Peephole Optimization) - PeepholeOptimizer peephole; - peephole.runOnMachineFunction(mfunc.get()); + // // 阶段 4: 窥孔优化 (Peephole Optimization) + // PeepholeOptimizer peephole; + // peephole.runOnMachineFunction(mfunc.get()); // 阶段 5: 局部指令调度 (Local Scheduling) PostRA_Scheduler local_scheduler; @@ -143,7 +151,7 @@ std::string RISCv64CodeGen::function_gen(Function* func) { PrologueEpilogueInsertionPass pei_pass; pei_pass.runOnMachineFunction(mfunc.get()); - // 阶段 3.3: 清理产生的大立即数 + // 阶段 3.3: 大立即数合法化 LegalizeImmediatesPass legalizer; legalizer.runOnMachineFunction(mfunc.get()); @@ -151,7 +159,11 @@ std::string RISCv64CodeGen::function_gen(Function* func) { std::stringstream ss; RISCv64AsmPrinter printer(mfunc.get()); printer.run(ss); - if (DEBUG) ss << "\n" << ss1.str(); // 将指令选择阶段的结果也包含在最终输出中 + + if (DEBUG) { + ss << "\n\n; --- Intermediate Representation after Instruction Selection ---\n" + << ss_after_isel.str(); + } return ss.str(); } diff --git a/src/backend/RISCv64/RISCv64RegAlloc.cpp b/src/backend/RISCv64/RISCv64RegAlloc.cpp index cf73191..64ff4ef 100644 --- a/src/backend/RISCv64/RISCv64RegAlloc.cpp +++ b/src/backend/RISCv64/RISCv64RegAlloc.cpp @@ -1,128 +1,122 @@ +// in file: RISCv64RegAlloc.cpp + #include "RISCv64RegAlloc.h" -#include "RISCv64ISel.h" -#include "RISCv64AsmPrinter.h" // For DEBUG output -#include "LegalizeImmediates.h" +#include "RISCv64AsmPrinter.h" #include -#include -#include // For DEBUG output -#include // For assert +#include +#include +#include namespace sysy { -RISCv64RegAlloc::RISCv64RegAlloc(MachineFunction* mfunc) : MFunc(mfunc) { +// 构造函数：初始化寄存器池和数据结构 +RISCv64RegAlloc::RISCv64RegAlloc(MachineFunction* mfunc) + : MFunc(mfunc), + ISel(mfunc->getISel()), + vreg_to_value_map(ISel->getVRegValueMap()), + vreg_type_map(ISel->getVRegTypeMap()) { // 1. 初始化可分配的整数寄存器池 allocable_int_regs = { - PhysicalReg::T0, PhysicalReg::T1, PhysicalReg::T2, PhysicalReg::T3, - PhysicalReg::T4, /*PhysicalReg::T5,*/ PhysicalReg::T6, // T5是大立即数传送寄存器 - PhysicalReg::A0, PhysicalReg::A1, PhysicalReg::A2, PhysicalReg::A3, - PhysicalReg::A4, PhysicalReg::A5, PhysicalReg::A6, PhysicalReg::A7, - PhysicalReg::S0, PhysicalReg::S1, PhysicalReg::S2, PhysicalReg::S3, - PhysicalReg::S4, PhysicalReg::S5, PhysicalReg::S6, PhysicalReg::S7, + PhysicalReg::T0, PhysicalReg::T1, PhysicalReg::T2, PhysicalReg::T3, PhysicalReg::T4, /* T5保留 */ PhysicalReg::T6, + PhysicalReg::A0, PhysicalReg::A1, PhysicalReg::A2, PhysicalReg::A3, PhysicalReg::A4, PhysicalReg::A5, PhysicalReg::A6, PhysicalReg::A7, + PhysicalReg::S1, PhysicalReg::S2, PhysicalReg::S3, PhysicalReg::S4, PhysicalReg::S5, PhysicalReg::S6, PhysicalReg::S7, PhysicalReg::S8, PhysicalReg::S9, PhysicalReg::S10, PhysicalReg::S11, + // S0 是帧指针，不参与分配 }; + K_int = allocable_int_regs.size(); // 2. 初始化可分配的浮点寄存器池 allocable_fp_regs = { - // 浮点临时寄存器 ft0-ft11 - PhysicalReg::F0, PhysicalReg::F1, PhysicalReg::F2, PhysicalReg::F3, - PhysicalReg::F4, PhysicalReg::F5, PhysicalReg::F6, PhysicalReg::F7, + PhysicalReg::F0, PhysicalReg::F1, PhysicalReg::F2, PhysicalReg::F3, PhysicalReg::F4, PhysicalReg::F5, PhysicalReg::F6, PhysicalReg::F7, + PhysicalReg::F10, PhysicalReg::F11, PhysicalReg::F12, PhysicalReg::F13, PhysicalReg::F14, PhysicalReg::F15, PhysicalReg::F16, PhysicalReg::F17, + PhysicalReg::F8, PhysicalReg::F9, PhysicalReg::F18, PhysicalReg::F19, PhysicalReg::F20, PhysicalReg::F21, PhysicalReg::F22, + PhysicalReg::F23, PhysicalReg::F24, PhysicalReg::F25, PhysicalReg::F26, PhysicalReg::F27, PhysicalReg::F28, PhysicalReg::F29, PhysicalReg::F30, PhysicalReg::F31, - // 浮点参数/返回值寄存器 fa0-fa7 - PhysicalReg::F10, PhysicalReg::F11, PhysicalReg::F12, PhysicalReg::F13, - PhysicalReg::F14, PhysicalReg::F15, PhysicalReg::F16, PhysicalReg::F17, - // 浮点保存寄存器 fs0-fs11 - PhysicalReg::F8, PhysicalReg::F9, - PhysicalReg::F18, PhysicalReg::F19, PhysicalReg::F20, PhysicalReg::F21, - PhysicalReg::F22, PhysicalReg::F23, PhysicalReg::F24, PhysicalReg::F25, - PhysicalReg::F26, PhysicalReg::F27 }; - - // 3. 映射所有物理寄存器（包括整数、浮点和特殊寄存器）到特殊的虚拟寄存器ID - // 这是为了让活跃性分析和干扰图构建能够统一处理所有类型的寄存器 - for (int i = 0; i < static_cast(PhysicalReg::PHYS_REG_START_ID); ++i) { - auto preg = static_cast(i); - preg_to_vreg_id_map[preg] = static_cast(PhysicalReg::PHYS_REG_START_ID) + i; - } + K_fp = allocable_fp_regs.size(); + + // 3. 预着色所有物理寄存器 + const unsigned offset = static_cast(PhysicalReg::PHYS_REG_START_ID); + for (const auto& reg : allocable_int_regs) precolored.insert(offset + static_cast(reg)); + for (const auto& reg : allocable_fp_regs) precolored.insert(offset + static_cast(reg)); + precolored.insert(offset + static_cast(PhysicalReg::S0)); + precolored.insert(offset + static_cast(PhysicalReg::RA)); + precolored.insert(offset + static_cast(PhysicalReg::SP)); + precolored.insert(offset + static_cast(PhysicalReg::ZERO)); } -// 寄存器分配的主入口点 +// 主入口: 迭代运行分配算法直到无溢出 void RISCv64RegAlloc::run() { - // --- 在所有流程开始前，构建完整的vreg到Value的反向映射 --- - const auto& vreg_map_from_isel = MFunc->getISel()->getVRegMap(); - for (const auto& pair : vreg_map_from_isel) { - Value* val = pair.first; - unsigned vreg = pair.second; - vreg_to_value_map[vreg] = val; + if (DEBUG) std::cerr << "===== LLIR Before Running Graph Coloring Register Allocation " << MFunc->getName() << " =====\n"; + std::stringstream ss_before_reg_alloc; + if (DEBUG) { + RISCv64AsmPrinter printer_reg_alloc(MFunc); + printer_reg_alloc.run(ss_before_reg_alloc, true); + std::cout << ss_before_reg_alloc.str(); } - // 阶段 1: 处理函数调用约定（参数寄存器预着色） - handleCallingConvention(); - // 阶段 2: 消除帧索引（为局部变量和栈参数分配栈偏移） - eliminateFrameIndices(); - // 调试输出当前的LLIR状态 - { // 使用大括号创建一个局部作用域，避免printer变量泄露 - if (DEBUG) { - std::cerr << "\n===== LLIR after eliminateFrameIndices for function: " - << MFunc->getName() << " =====\n"; - // 1. 创建一个 AsmPrinter 实例，传入当前的 MachineFunction - RISCv64AsmPrinter printer(MFunc); - // 2. 调用 run 方法，将结果打印到标准错误流 (std::cerr) - // 3. 必须将 debug 参数设为 true！ - // 因为此时指令中仍然包含虚拟寄存器 (%vreg)， - // debug模式下的 AsmPrinter 才能正确处理它们而不会报错。 - printer.run(std::cerr, true); - std::cerr << "===== End of LLIR =====\n\n"; + if (DEBUG) std::cerr << "===== Running Graph Coloring Register Allocation for function: " << MFunc->getName() << " =====\n"; + + while (true) { + if (doAllocation()) { + break; + } else { + rewriteProgram(); + if (DEBUG) std::cerr << "--- Spilling detected, re-running allocation ---\n"; } } - // 阶段 3: 活跃性分析 - analyzeLiveness(); - // 阶段 4: 构建干扰图（包含CALL指令对调用者保存寄存器的影响） - buildInterferenceGraph(); - // 阶段 5: 图着色算法分配物理寄存器 - colorGraph(); - // 阶段 6: 重写函数（插入溢出/填充代码，替换虚拟寄存器为物理寄存器） - rewriteFunction(); + applyColoring(); - // 将最终的寄存器分配结果保存到MachineFunction的帧信息中，供后续Pass使用 MFunc->getFrameInfo().vreg_to_preg_map = this->color_map; + collectUsedCalleeSavedRegs(); + if (DEBUG) std::cerr << "===== Finished Graph Coloring Register Allocation =====\n\n"; } -/** - * @brief 处理调用约定，预先为函数参数和调用返回值分配物理寄存器。 - * 这个函数现在负责处理调用约定的两个方面： - * 1. 作为被调用者(callee)，如何接收传入的参数。 - * 2. 作为调用者(caller)，如何接收调用的其他函数的返回值。 - */ -void RISCv64RegAlloc::handleCallingConvention() { - Function* F = MFunc->getFunc(); - RISCv64ISel* isel = MFunc->getISel(); - - // --- 部分1：处理函数传入参数的预着色 --- - if (F) { - auto& args = F->getArguments(); - - // [修改] 为整数参数和浮点参数分别维护索引 - int int_arg_idx = 0; - int float_arg_idx = 0; +// 单次分配的核心流程 +bool RISCv64RegAlloc::doAllocation() { + initialize(); + precolorByCallingConvention(); + analyzeLiveness(); + build(); + makeWorklist(); - for (Argument* arg : args) { - // [修改] 根据参数类型决定使用哪个寄存器池和索引 - if (arg->getType()->isFloat()) { - // --- 处理浮点参数 --- - if (float_arg_idx >= 8) continue; // fa0-fa7 - - unsigned vreg = isel->getVReg(arg); - // 浮点参数使用 fa10-fa17 (在RISC-V ABI中对应F10-F17) + while (!simplifyWorklist.empty() || !worklistMoves.empty() || !freezeWorklist.empty() || !spillWorklist.empty()) { + if (DEEPDEBUG) dumpState("Loop Start"); + if (!simplifyWorklist.empty()) simplify(); + else if (!worklistMoves.empty()) coalesce(); + else if (!freezeWorklist.empty()) freeze(); + else if (!spillWorklist.empty()) selectSpill(); + } + + if (DEEPDEBUG) dumpState("Before AssignColors"); + assignColors(); + return spilledNodes.empty(); +} + +void RISCv64RegAlloc::precolorByCallingConvention() { + // [新增] 在处理前，先清空颜色相关的状态，确保重试时不会出错 + color_map.clear(); + coloredNodes.clear(); + + Function* F = MFunc->getFunc(); + if (!F) return; + + // --- 部分1：处理函数传入参数的预着色 --- + int int_arg_idx = 0; + int float_arg_idx = 0; + + for (Argument* arg : F->getArguments()) { + unsigned vreg = ISel->getVReg(arg); + + if (arg->getType()->isFloat()) { + if (float_arg_idx < 8) { // fa0-fa7 auto preg = static_cast(static_cast(PhysicalReg::F10) + float_arg_idx); color_map[vreg] = preg; float_arg_idx++; - - } else { - // --- 处理整数/指针参数 (原有逻辑) --- - if (int_arg_idx >= 8) continue; // a0-a7 - - unsigned vreg = isel->getVReg(arg); + } + } else { // 整数或指针 + if (int_arg_idx < 8) { // a0-a7 auto preg = static_cast(static_cast(PhysicalReg::A0) + int_arg_idx); color_map[vreg] = preg; int_arg_idx++; @@ -134,877 +128,1184 @@ void RISCv64RegAlloc::handleCallingConvention() { for (auto& mbb : MFunc->getBlocks()) { for (auto& instr : mbb->getInstructions()) { if (instr->getOpcode() == RVOpcodes::CALL) { - // 根据协议，如果CALL有返回值，其目标vreg是第一个操作数 if (!instr->getOperands().empty() && instr->getOperands().front()->getKind() == MachineOperand::KIND_REG) { auto reg_op = static_cast(instr->getOperands().front().get()); if (reg_op->isVirtual()) { unsigned ret_vreg = reg_op->getVRegNum(); - - // [修改] 检查返回值的类型，预着色到 a0 或 fa0 - assert(MFunc->getISel()->getVRegValueMap().count(ret_vreg) && "Return vreg not found in value map!"); - Value* ret_val = MFunc->getISel()->getVRegValueMap().at(ret_vreg); + assert(vreg_to_value_map.count(ret_vreg) && "Return vreg not found!"); + Value* ret_val = vreg_to_value_map.at(ret_vreg); if (ret_val->getType()->isFloat()) { - // 浮点返回值预着色到 fa0 (F10) - color_map[ret_vreg] = PhysicalReg::F10; + color_map[ret_vreg] = PhysicalReg::F10; // fa0 } else { - // 整数/指针返回值预着色到 a0 - color_map[ret_vreg] = PhysicalReg::A0; + color_map[ret_vreg] = PhysicalReg::A0; // a0 } } } } } } -} - -/** - * @brief 消除帧索引，为局部变量和栈参数分配栈偏移量，并展开伪指令。 - */ -void RISCv64RegAlloc::eliminateFrameIndices() { - StackFrameInfo& frame_info = MFunc->getFrameInfo(); - Function* F = MFunc->getFunc(); - RISCv64ISel* isel = MFunc->getISel(); - // 在处理局部变量前，首先为栈参数计算偏移量。 - if (F) { - int arg_idx = 0; - for (Argument* arg : F->getArguments()) { - // 我们只关心第8个索引及之后的参数（即第9个参数开始） - if (arg_idx >= 8) { - // 计算偏移量：第一个栈参数(idx=8)在0(s0)，第二个(idx=9)在8(s0)，以此类推。 - int offset = (arg_idx - 8) * 8; - unsigned vreg = isel->getVReg(arg); - - // 将这个vreg和它的栈偏移存入map。 - // 我们可以复用alloca_offsets，因为它们都代表“vreg到栈偏移”的映射。 - frame_info.alloca_offsets[vreg] = offset; - } - arg_idx++; - } + // 将所有预着色的vreg视为已着色节点 + for(const auto& pair : color_map) { + coloredNodes.insert(pair.first); } - - // [关键修改] 为局部变量分配空间时，起始点必须考虑为ra, s0以及所有callee-saved寄存器预留的空间。 - // 布局顺序为: [s0/ra, 16字节] -> [callee-saved, callee_saved_size字节] -> [局部变量...] - int local_var_offset = 16 + frame_info.callee_saved_size; - int locals_start_offset = local_var_offset; // 记录局部变量区域的起始点，用于计算总大小 - - // 处理局部变量 (AllocaInst) - for (auto& bb : F->getBasicBlocks()) { - for (auto& inst : bb->getInstructions()) { - if (auto alloca = dynamic_cast(inst.get())) { - Type* allocated_type = alloca->getType()->as()->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; - } - } - } - - // [修复] 正确计算并设置locals_size - // 它只应该包含由AllocaInst分配的局部变量的总大小。 - frame_info.locals_size = local_var_offset - locals_start_offset; - - // 遍历所有机器指令，将伪指令展开为真实指令 - for (auto& mbb : MFunc->getBlocks()) { - std::vector> new_instructions; - for (auto& instr_ptr : mbb->getInstructions()) { - RVOpcodes opcode = instr_ptr->getOpcode(); - - // --- MODIFICATION START: 处理区分宽度的伪指令 --- - if (opcode == RVOpcodes::FRAME_LOAD_W || opcode == RVOpcodes::FRAME_LOAD_D) { - // 确定要生成的真实加载指令是 lw 还是 ld - RVOpcodes real_load_op = (opcode == RVOpcodes::FRAME_LOAD_W) ? RVOpcodes::LW : RVOpcodes::LD; - - auto& operands = instr_ptr->getOperands(); - unsigned dest_vreg = static_cast(operands[0].get())->getVRegNum(); - unsigned alloca_vreg = static_cast(operands[1].get())->getVRegNum(); - int offset = frame_info.alloca_offsets.at(alloca_vreg); - auto addr_vreg = isel->getNewVReg(); - - // 展开为: addi addr_vreg, s0, offset - auto addi = std::make_unique(RVOpcodes::ADDI); - addi->addOperand(std::make_unique(addr_vreg)); - addi->addOperand(std::make_unique(PhysicalReg::S0)); - addi->addOperand(std::make_unique(offset)); - new_instructions.push_back(std::move(addi)); - - // 展开为: lw/ld dest_vreg, 0(addr_vreg) - auto load_instr = std::make_unique(real_load_op); - load_instr->addOperand(std::make_unique(dest_vreg)); - load_instr->addOperand(std::make_unique( - std::make_unique(addr_vreg), - std::make_unique(0))); - new_instructions.push_back(std::move(load_instr)); - - } else if (opcode == RVOpcodes::FRAME_LOAD_F) { - // 展开浮点加载伪指令 - RVOpcodes real_load_op = RVOpcodes::FLW; // 对应的真实指令是 flw - - auto& operands = instr_ptr->getOperands(); - unsigned dest_vreg = static_cast(operands[0].get())->getVRegNum(); - unsigned alloca_vreg = static_cast(operands[1].get())->getVRegNum(); - int offset = frame_info.alloca_offsets.at(alloca_vreg); - auto addr_vreg = isel->getNewVReg(); - - // 展开为: addi addr_vreg, s0, offset - auto addi = std::make_unique(RVOpcodes::ADDI); - addi->addOperand(std::make_unique(addr_vreg)); - addi->addOperand(std::make_unique(PhysicalReg::S0)); - addi->addOperand(std::make_unique(offset)); - new_instructions.push_back(std::move(addi)); - - // 展开为: flw dest_vreg, 0(addr_vreg) - auto load_instr = std::make_unique(real_load_op); - load_instr->addOperand(std::make_unique(dest_vreg)); - load_instr->addOperand(std::make_unique( - std::make_unique(addr_vreg), - std::make_unique(0))); - new_instructions.push_back(std::move(load_instr)); - } else if (opcode == RVOpcodes::FRAME_STORE_W || opcode == RVOpcodes::FRAME_STORE_D) { - // 确定要生成的真实存储指令是 sw 还是 sd - RVOpcodes real_store_op = (opcode == RVOpcodes::FRAME_STORE_W) ? RVOpcodes::SW : RVOpcodes::SD; - - auto& operands = instr_ptr->getOperands(); - unsigned src_vreg = static_cast(operands[0].get())->getVRegNum(); - unsigned alloca_vreg = static_cast(operands[1].get())->getVRegNum(); - int offset = frame_info.alloca_offsets.at(alloca_vreg); - auto addr_vreg = isel->getNewVReg(); - - // 展开为: addi addr_vreg, s0, offset - auto addi = std::make_unique(RVOpcodes::ADDI); - addi->addOperand(std::make_unique(addr_vreg)); - addi->addOperand(std::make_unique(PhysicalReg::S0)); - addi->addOperand(std::make_unique(offset)); - new_instructions.push_back(std::move(addi)); - - // 展开为: sw/sd src_vreg, 0(addr_vreg) - auto store_instr = std::make_unique(real_store_op); - store_instr->addOperand(std::make_unique(src_vreg)); - store_instr->addOperand(std::make_unique( - std::make_unique(addr_vreg), - std::make_unique(0))); - new_instructions.push_back(std::move(store_instr)); - - } else if (opcode == RVOpcodes::FRAME_STORE_F) { - // 展开浮点存储伪指令 - RVOpcodes real_store_op = RVOpcodes::FSW; // 对应的真实指令是 fsw - - auto& operands = instr_ptr->getOperands(); - unsigned src_vreg = static_cast(operands[0].get())->getVRegNum(); - unsigned alloca_vreg = static_cast(operands[1].get())->getVRegNum(); - int offset = frame_info.alloca_offsets.at(alloca_vreg); - auto addr_vreg = isel->getNewVReg(); - - // 展开为: addi addr_vreg, s0, offset - auto addi = std::make_unique(RVOpcodes::ADDI); - addi->addOperand(std::make_unique(addr_vreg)); - addi->addOperand(std::make_unique(PhysicalReg::S0)); - addi->addOperand(std::make_unique(offset)); - new_instructions.push_back(std::move(addi)); - - // 展开为: fsw src_vreg, 0(addr_vreg) - auto store_instr = std::make_unique(real_store_op); - store_instr->addOperand(std::make_unique(src_vreg)); - store_instr->addOperand(std::make_unique( - std::make_unique(addr_vreg), - std::make_unique(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(operands[0].get())->getVRegNum(); - unsigned alloca_vreg = static_cast(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(RVOpcodes::ADDI); - addi->addOperand(std::make_unique(dest_vreg)); - addi->addOperand(std::make_unique(PhysicalReg::S0)); - addi->addOperand(std::make_unique(offset)); - new_instructions.push_back(std::move(addi)); - } else { - new_instructions.push_back(std::move(instr_ptr)); - } - // --- MODIFICATION END --- - } - mbb->getInstructions() = std::move(new_instructions); + if (DEEPDEBUG) { + std::cerr << "Precolored registers: { "; + // 修改部分：将物理寄存器ID转换为其字符串名称 + for (unsigned v : precolored) std::cerr << regIdToString(v) << " "; + std::cerr << "}\nColored nodes: { "; + for (unsigned v : coloredNodes) std::cerr << "%vreg" << v << " "; + std::cerr << "}\n"; } } -/** - * @brief 计算给定 MachineInstr 的 Use (读取) 和 Def (写入) 寄存器集合。 - * 这是活跃性分析的基础。 - * @param instr 要分析的机器指令。 - * @param use 存储 Use 寄存器（虚拟寄存器 ID）的集合。 - * @param def 存储 Def 寄存器（虚拟寄存器 ID）的集合。 - */ -void RISCv64RegAlloc::getInstrUseDef(MachineInstr* instr, LiveSet& use, LiveSet& def) { - bool first_reg_is_def = true; // 默认情况下，指令的第一个寄存器操作数是定义 (def) - auto opcode = instr->getOpcode(); +// 初始化/重置所有数据结构 +void RISCv64RegAlloc::initialize() { + initial.clear(); + simplifyWorklist.clear(); + freezeWorklist.clear(); + spillWorklist.clear(); + spilledNodes.clear(); + coalescedNodes.clear(); + coloredNodes.clear(); // [修正] 恢复对这两个集合的清除 + selectStack.clear(); - if (opcode == RVOpcodes::PSEUDO_KEEPALIVE) { - for (auto& op : instr->getOperands()) { - if (op->getKind() == MachineOperand::KIND_REG) { - auto reg_op = static_cast(op.get()); - if (reg_op->isVirtual()) { - use.insert(reg_op->getVRegNum()); // 它的所有操作数都是 "use" - } - } - } - return; // 处理完毕 - } + coalescedMoves.clear(); + constrainedMoves.clear(); + frozenMoves.clear(); + worklistMoves.clear(); + activeMoves.clear(); - // 1. 特殊指令的 `is_def` 标志调整 - // 这些指令的第一个寄存器操作数是源操作数 (use)，而不是目标操作数 (def)。 - if (opcode == RVOpcodes::SW || opcode == RVOpcodes::SD || opcode == RVOpcodes::FSW || - opcode == RVOpcodes::BEQ || opcode == RVOpcodes::BNE || - opcode == RVOpcodes::BLT || opcode == RVOpcodes::BGE || - opcode == RVOpcodes::BLTU || opcode == RVOpcodes::BGEU || - opcode == RVOpcodes::RET || opcode == RVOpcodes::J) { - first_reg_is_def = false; - } - - // JAL 和 JALR 指令定义 ra (x1) - if (opcode == RVOpcodes::JAL || opcode == RVOpcodes::JALR) { - // 使用 ra 对应的特殊虚拟寄存器ID - def.insert(preg_to_vreg_id_map.at(PhysicalReg::RA)); - first_reg_is_def = false; // JAL/JALR 的第一个操作数是 ra，已经处理为 def - } - - // 2. CALL 指令的特殊处理 - if (opcode == RVOpcodes::CALL) { - // 根据 s1 分支 ISel 定义的协议来解析操作数列表 - bool first_reg_operand_is_def = true; - for (auto& op : instr->getOperands()) { - if (op->getKind() == MachineOperand::KIND_REG) { - auto reg_op = static_cast(op.get()); - if (reg_op->isVirtual()) { - // 协议：第一个寄存器操作数是返回值 (def) - if (first_reg_operand_is_def) { - def.insert(reg_op->getVRegNum()); - first_reg_operand_is_def = false; - } else { - // 后续所有寄存器操作数都是参数 (use) - use.insert(reg_op->getVRegNum()); - } - } else { // [修复] CALL指令也可能定义物理寄存器（如a0） - if (first_reg_operand_is_def) { - auto it = preg_to_vreg_id_map.find(reg_op->getPReg()); - if (it != preg_to_vreg_id_map.end()) { - def.insert(it->second); - } - first_reg_operand_is_def = false; - } else { - auto it = preg_to_vreg_id_map.find(reg_op->getPReg()); - if (it != preg_to_vreg_id_map.end()) { - use.insert(it->second); - } - } - } - } - } - return; // CALL 指令处理完毕 - } - - // 2.1 浮点比较指令添加特殊规则 - // 它们的源操作数是浮点寄存器，但目标操作数是整数寄存器 - if (opcode == RVOpcodes::FEQ_S || opcode == RVOpcodes::FLT_S || opcode == RVOpcodes::FLE_S) { - auto& operands = instr->getOperands(); - // Def: 第一个操作数 (整数vreg) - if (operands[0]->getKind() == MachineOperand::KIND_REG) { - auto reg_op = static_cast(operands[0].get()); - if(reg_op->isVirtual()) def.insert(reg_op->getVRegNum()); - } - // Use: 第二、三个操作数 (浮点vreg) - if (operands[1]->getKind() == MachineOperand::KIND_REG) { - auto reg_op = static_cast(operands[1].get()); - if(reg_op->isVirtual()) use.insert(reg_op->getVRegNum()); - } - if (operands[2]->getKind() == MachineOperand::KIND_REG) { - auto reg_op = static_cast(operands[2].get()); - if(reg_op->isVirtual()) use.insert(reg_op->getVRegNum()); - } - return; // 处理完毕 - } - - // 3. 对其他所有指令的通用处理逻辑 [已重构和修复] - for (const auto& op : instr->getOperands()) { - if (op->getKind() == MachineOperand::KIND_REG) { - auto reg_op = static_cast(op.get()); - - if (first_reg_is_def) { - // --- 处理定义（Def） --- - if (reg_op->isVirtual()) { - def.insert(reg_op->getVRegNum()); - } else { // 物理寄存器也可以是 Def - auto it = preg_to_vreg_id_map.find(reg_op->getPReg()); - if (it != preg_to_vreg_id_map.end()) { - def.insert(it->second); - } - } - first_reg_is_def = false; // **关键**：处理完第一个寄存器后，立即更新标志 - } else { - // --- 处理使用（Use） --- - if (reg_op->isVirtual()) { - use.insert(reg_op->getVRegNum()); - } else { // 物理寄存器也可以是 Use - auto it = preg_to_vreg_id_map.find(reg_op->getPReg()); - if (it != preg_to_vreg_id_map.end()) { - use.insert(it->second); - } - } - } - } else if (op->getKind() == MachineOperand::KIND_MEM) { - // 内存操作数的处理逻辑看起来是正确的 - auto mem_op = static_cast(op.get()); - auto base_reg = mem_op->getBase(); - if (base_reg->isVirtual()) { - use.insert(base_reg->getVRegNum()); - } else { - PhysicalReg preg = base_reg->getPReg(); - auto it = preg_to_vreg_id_map.find(preg); - if (it != preg_to_vreg_id_map.end()) { - use.insert(it->second); - } - } - - // 对于存储内存指令 (SW, SD)，要存储的值（第一个操作数）也是 `use` - if ((opcode == RVOpcodes::SW || opcode == RVOpcodes::SD || opcode == RVOpcodes::FSW) && - !instr->getOperands().empty() && - instr->getOperands().front()->getKind() == MachineOperand::KIND_REG) { - auto src_reg_op = static_cast(instr->getOperands().front().get()); - if (src_reg_op->isVirtual()) { - use.insert(src_reg_op->getVRegNum()); - } else { - auto it = preg_to_vreg_id_map.find(src_reg_op->getPReg()); - if (it != preg_to_vreg_id_map.end()) { - use.insert(it->second); - } - } - } - } - } -} - -/** - * @brief 计算一个类型在内存中占用的字节数。 - * @param type 需要计算大小的IR类型。 - * @return 该类型占用的字节数。 - */ -unsigned RISCv64RegAlloc::getTypeSizeInBytes(Type* type) { - if (!type) { - assert(false && "Cannot get size of a null type."); - return 0; - } - - switch (type->getKind()) { - // 对于SysY语言，基本类型int和float都占用4字节 - case Type::kInt: - case Type::kFloat: - return 4; - - // 指针类型在RISC-V 64位架构下占用8字节 - // 虽然SysY没有'int*'语法，但数组变量在IR层面本身就是指针类型 - case Type::kPointer: - return 8; - - // 数组类型的总大小 = 元素数量 * 单个元素的大小 - case Type::kArray: { - auto arrayType = type->as(); - // 递归调用以计算元素大小 - return arrayType->getNumElements() * getTypeSizeInBytes(arrayType->getElementType()); - } - - // 其他类型，如Void, Label等不占用栈空间，或者不应该出现在这里 - default: - // 如果遇到未处理的类型，触发断言，方便调试 - assert(false && "Unsupported type for size calculation."); - return 0; - } + adjList.clear(); + degree.clear(); + moveList.clear(); + alias.clear(); + color_map.clear(); // [修正] 恢复对 color_map 的清除 } +// 活跃性分析（此部分为标准数据流分析，与现有版本类似但更精细） void RISCv64RegAlloc::analyzeLiveness() { - // === 阶段 1: 预计算每个基本块的 use 和 def 集合 === - // 这样可以避免在主循环中重复计算 - std::map block_uses; - std::map block_defs; - for (auto& mbb_ptr : MFunc->getBlocks()) { - MachineBasicBlock* mbb = mbb_ptr.get(); - LiveSet uses, defs; - for (auto& instr_ptr : mbb->getInstructions()) { - LiveSet instr_use, instr_def; - getInstrUseDef(instr_ptr.get(), instr_use, instr_def); - // use[B] = use[B] U (instr_use - def[B]) + live_in_map.clear(); + live_out_map.clear(); + + std::map block_uses; + std::map block_defs; + + for (const auto& mbb_ptr : MFunc->getBlocks()) { + const MachineBasicBlock* mbb = mbb_ptr.get(); + VRegSet uses, defs; + for (const auto& instr_ptr : mbb->getInstructions()) { + VRegSet instr_use, instr_def; + // 使用新的、能看到物理寄存器的版本 + getInstrUseDef_Liveness(instr_ptr.get(), instr_use, instr_def); for (unsigned u : instr_use) { - if (defs.find(u) == defs.end()) { - uses.insert(u); - } + if (defs.find(u) == defs.end()) uses.insert(u); } - // def[B] = def[B] U instr_def defs.insert(instr_def.begin(), instr_def.end()); } block_uses[mbb] = uses; block_defs[mbb] = defs; } - // === 阶段 2: 在“块”粒度上进行迭代数据流分析，直到收敛 === - std::map block_live_in; - std::map block_live_out; bool changed = true; + std::map live_in, live_out; while (changed) { changed = false; - // 以逆后序遍历基本块，可以加速收敛，但简单的逆序对于大多数情况也有效 for (auto it = MFunc->getBlocks().rbegin(); it != MFunc->getBlocks().rend(); ++it) { - auto& mbb = *it; - - // 2.1 计算 live_out[B] = U_{S in succ(B)} live_in[S] - LiveSet new_live_out; + const auto& mbb_ptr = *it; + const MachineBasicBlock* mbb = mbb_ptr.get(); + VRegSet new_out; for (auto succ : mbb->successors) { - new_live_out.insert(block_live_in[succ].begin(), block_live_in[succ].end()); + new_out.insert(live_in[succ].begin(), live_in[succ].end()); } - - // 2.2 计算 live_in[B] = use[B] U (live_out[B] - def[B]) - LiveSet live_out_minus_def = new_live_out; - for (unsigned d : block_defs[mbb.get()]) { - live_out_minus_def.erase(d); - } - LiveSet new_live_in = block_uses[mbb.get()]; - new_live_in.insert(live_out_minus_def.begin(), live_out_minus_def.end()); - - // 2.3 检查 live_in 和 live_out 是否变化，以判断是否达到不动点 - if (block_live_out[mbb.get()] != new_live_out) { + VRegSet new_in = block_uses[mbb]; + VRegSet out_minus_def = new_out; + for (unsigned d : block_defs[mbb]) out_minus_def.erase(d); + new_in.insert(out_minus_def.begin(), out_minus_def.end()); + if (live_out[mbb] != new_out || live_in[mbb] != new_in) { changed = true; - block_live_out[mbb.get()] = new_live_out; - } - if (block_live_in[mbb.get()] != new_live_in) { - changed = true; - block_live_in[mbb.get()] = new_live_in; + live_out[mbb] = new_out; + live_in[mbb] = new_in; } } } - // === 阶段 3: 进行一次指令粒度的遍历，填充最终的 live_in_map 和 live_out_map === - // 此时块级别的活跃信息已经稳定，我们只需遍历一次即可 - for (auto& mbb_ptr : MFunc->getBlocks()) { - MachineBasicBlock* mbb = mbb_ptr.get(); - LiveSet live_out = block_live_out[mbb]; // 从已收敛的块级 live_out 开始 - + for (const auto& mbb_ptr : MFunc->getBlocks()) { + const MachineBasicBlock* mbb = mbb_ptr.get(); + VRegSet current_live = live_out[mbb]; for (auto instr_it = mbb->getInstructions().rbegin(); instr_it != mbb->getInstructions().rend(); ++instr_it) { - MachineInstr* instr = instr_it->get(); - live_out_map[instr] = live_out; - - LiveSet use, def; - getInstrUseDef(instr, use, def); - - LiveSet live_in = use; - LiveSet diff = live_out; - for (auto vreg : def) { - diff.erase(vreg); - } - live_in.insert(diff.begin(), diff.end()); - live_in_map[instr] = live_in; - - // 更新 live_out，为块内的上一条指令做准备 - live_out = live_in; + const MachineInstr* instr = instr_it->get(); + live_out_map[instr] = current_live; + VRegSet use, def; + // 使用新的、能看到物理寄存器的版本 + getInstrUseDef_Liveness(instr, use, def); + for(auto d : def) current_live.erase(d); + for(auto u : use) current_live.insert(u); + live_in_map[instr] = current_live; } } } -// 辅助函数，用于清晰地打印寄存器集合。可以放在 .cpp 文件的顶部。 -void RISCv64RegAlloc::printLiveSet(const LiveSet& s, const std::string& name, std::ostream& os) { - os << " " << name << ": { "; - for (unsigned vreg : s) { - // 为了可读性，将物理寄存器对应的特殊ID进行转换 - if (vreg >= static_cast(sysy::PhysicalReg::PHYS_REG_START_ID)) { - os << "preg(" << (vreg - static_cast(sysy::PhysicalReg::PHYS_REG_START_ID)) << ") "; - } else { - os << "%vreg" << vreg << " "; - } - } - os << "}\n"; -} +// [最终修正] 包含了所有正确逻辑和您已有调试代码的完整版本 +void RISCv64RegAlloc::build() { + initial.clear(); + RISCv64AsmPrinter printer_inside_build(MFunc); + printer_inside_build.setStream(std::cerr); -void RISCv64RegAlloc::buildInterferenceGraph() { - std::set all_vregs; - // 收集所有虚拟寄存器和物理寄存器在干扰图中的节点ID - for (auto& mbb : MFunc->getBlocks()) { - for(auto& instr : mbb->getInstructions()) { - LiveSet use, def; - getInstrUseDef(instr.get(), use, def); - for(auto u : use) all_vregs.insert(u); - for(auto d : def) all_vregs.insert(d); - } - } - // 添加所有物理寄存器对应的特殊虚拟寄存器ID到all_vregs，作为干扰图节点 - for (auto preg : allocable_int_regs) { - all_vregs.insert(preg_to_vreg_id_map.at(preg)); - } + for (const auto& mbb_ptr : MFunc->getBlocks()) { + for (const auto& instr_ptr : mbb_ptr->getInstructions()) { + const MachineInstr* instr = instr_ptr.get(); + VRegSet use, def; + getInstrUseDef_Liveness(instr, use, def); - // 初始化干扰图邻接表 - for (auto vreg : all_vregs) { interference_graph[vreg] = {}; } - - // 创建一个临时的AsmPrinter用于打印指令，方便调试 - RISCv64AsmPrinter temp_printer(MFunc); - temp_printer.setStream(std::cerr); - - for (auto& mbb : MFunc->getBlocks()) { - if (DEEPDEBUG) std::cerr << "--- Building Graph for Basic Block: " << mbb->getName() << " ---\n"; - for (auto& instr_ptr : mbb->getInstructions()) { - MachineInstr* instr = instr_ptr.get(); + // 调试输出 use 和 def if (DEEPDEBUG) { - // 打印当前正在处理的指令 - std::cerr << " Instr: "; - temp_printer.printInstruction(instr, true); // 使用 true 来打印虚拟寄存器 + std::cerr << "Instr:"; + printer_inside_build.printInstruction(instr_ptr.get(), true); + // 修改 lambda 以捕获 this 指针，从而可以调用成员函数 + auto print_set = [this](const VRegSet& s, const std::string& name) { + std::cerr << " " << name << ": { "; + for(unsigned v : s) std::cerr << regIdToString(v) << " "; // 使用新函数 + std::cerr << "}\n"; + }; + print_set(def, "Def "); + print_set(use, "Use "); + } + + for (unsigned v : use) { + if (!coloredNodes.count(v)) { + initial.insert(v); + } else if (DEEPDEBUG) { + std::cerr << "Skipping %vreg" << v << " because it is in coloredNodes.\n"; + } + } + for (unsigned v : def) { + if (!coloredNodes.count(v)) { + initial.insert(v); + } else if (DEEPDEBUG) { + std::cerr << "Skipping %vreg" << v << " because it is in coloredNodes.\n"; + } + } + } + } + + if (DEEPDEBUG) { + std::cerr << "Initial set after build: { "; + for (unsigned v : initial) std::cerr << "%vreg" << v << " "; + std::cerr << "}\n"; + } + + for(unsigned vreg : initial) { + adjList[vreg] = {}; + degree[vreg] = 0; + moveList[vreg] = {}; + // alias[vreg] = vreg; + } + + for (const auto& mbb_ptr : MFunc->getBlocks()) { + if (DEEPDEBUG) std::cerr << "\n--- Building Graph for Basic Block: " << mbb_ptr->getName() << " ---\n"; + for (const auto& instr_ptr : mbb_ptr->getInstructions()) { + const MachineInstr* instr = instr_ptr.get(); + VRegSet use, def; + getInstrUseDef_Liveness(instr, use, def); + const VRegSet& live_out = live_out_map.at(instr); + + if (DEEPDEBUG) { + // 使用临时的 AsmPrinter 打印当前指令，便于观察 + RISCv64AsmPrinter temp_printer(MFunc); + temp_printer.setStream(std::cerr); + std::cerr << "Instr: "; + temp_printer.printInstruction(const_cast(instr), true); + + auto print_set = [this](const VRegSet& s, const std::string& name) { + std::cerr << " " << name << ": { "; + for(unsigned v : s) std::cerr << regIdToString(v) << " "; // 使用新函数 + std::cerr << "}\n"; + }; + print_set(def, "Def "); + print_set(use, "Use "); + print_set(live_out, "Live_Out"); + std::cerr << " ----------------\n"; } - LiveSet def, use; - getInstrUseDef(instr, use, def); - const LiveSet& live_out = live_out_map.at(instr); + bool is_move = instr->getOpcode() == RVOpcodes::MV; - // [新增调试逻辑] 打印所有相关的寄存器集合 - if (DEEPDEBUG) { - printLiveSet(use, "Use ", std::cerr); - printLiveSet(def, "Def ", std::cerr); - printLiveSet(live_out, "Live_Out", std::cerr); // 这是我们最关心的信息 + if (is_move) { + worklistMoves.insert(instr); + VRegSet move_vregs; + for(const auto& op : instr->getOperands()) { + if (op->getKind() == MachineOperand::KIND_REG) { + auto reg_op = static_cast(op.get()); + if(reg_op->isVirtual()) move_vregs.insert(reg_op->getVRegNum()); + } + } + for (unsigned vreg : move_vregs) { + moveList[vreg].insert(instr); + } } - // 标准干扰图构建：def 与 live_out 中的其他变量干扰 + // --- 规则 1: Def 与 Live_Out 变量干扰 --- + VRegSet live = live_out; + if (is_move) { + for (unsigned u : use) { + live.erase(u); + } + } for (unsigned d : def) { - for (unsigned l : live_out) { - if (d != l) { - // [新增调试逻辑] 打印添加的干扰边及其原因 - if (DEEPDEBUG && interference_graph[d].find(l) == interference_graph[d].end()) { - std::cerr << " Edge (Def-LiveOut): %vreg" << d << " <-> %vreg" << l << "\n"; - } - interference_graph[d].insert(l); - interference_graph[l].insert(d); - } + for (unsigned l : live) { + addEdge(d, l); } } - - // 所有在某一点上同时活跃的寄存器（即live_out集合中的所有成员）， - // 它们之间必须两两互相干扰。 - // 这会根据我们修正后的 liveness 信息，在所有参数vreg之间构建一个完全图（clique）。 - std::vector live_out_vec(live_out.begin(), live_out.end()); - for (size_t i = 0; i < live_out_vec.size(); ++i) { - for (size_t j = i + 1; j < live_out_vec.size(); ++j) { - unsigned u = live_out_vec[i]; - unsigned v = live_out_vec[j]; - if (DEEPDEBUG && interference_graph[u].find(v) == interference_graph[u].end()) { - std::cerr << " Edge (Live-Live): %vreg" << u << " <-> %vreg" << v << "\n"; - } - interference_graph[u].insert(v); - interference_graph[v].insert(u); - } - } - - // 在非move指令中，def 与 use 互相干扰 - if (instr->getOpcode() != RVOpcodes::MV) { + + // --- [新增的关键逻辑] 规则 2: 对于非move指令，强制def和use互相干扰 --- + // 这可以防止指令内部的源寄存器被目标寄存器错误地覆盖 + if (!is_move) { for (unsigned d : def) { for (unsigned u : use) { - if (d != u) { - // [新增调试逻辑] 打印添加的干扰边及其原因 - if (DEEPDEBUG && interference_graph[d].find(u) == interference_graph[d].end()) { - std::cerr << " Edge (Def-Use) : %vreg" << d << " <-> %vreg" << u << "\n"; - } - interference_graph[d].insert(u); - interference_graph[u].insert(d); - } + addEdge(d, u); } } } - // *** 处理 CALL 指令的隐式 def *** - if (instr->getOpcode() == RVOpcodes::CALL) { - // 你的原始CALL调试信息 - if (DEEPDEBUG) { - std::string live_out_str; - for (unsigned vreg : live_out) { - live_out_str += "%vreg" + std::to_string(vreg) + " "; - } - std::cerr << "[DEEPDEBUG] buildInterferenceGraph: CALL instruction found. Live out set is: {" - << live_out_str << "}" << std::endl; - } - // CALL 指令会定义（杀死）所有调用者保存的寄存器。 - // 因此，所有调用者保存的物理寄存器都与 CALL 指令的 live_out 中的所有变量冲突。 - - // 辅助函数，用于判断一个vreg是整数类型还是浮点类型 - auto is_fp_vreg = [&](unsigned vreg) { - if (vreg_to_value_map.count(vreg)) { - return vreg_to_value_map.at(vreg)->getType()->isFloat(); - } - // 对于ISel创建的、没有直接IR Value对应的临时vreg， - // 默认其为整数类型。这是一个合理的兜底策略。 - return false; - }; - - // --- 处理整数寄存器干扰 --- - const std::vector& caller_saved_int_regs = getCallerSavedIntRegs(); - for (PhysicalReg cs_reg : caller_saved_int_regs) { - // 确保物理寄存器在映射表中，我们已在构造函数中保证了这一点 - unsigned cs_vreg_id = preg_to_vreg_id_map.at(cs_reg); - - for (unsigned live_vreg_out : live_out) { - // 只为整数vreg添加与整数preg的干扰 - if (!is_fp_vreg(live_vreg_out)) { - if (cs_vreg_id != live_vreg_out) { - if (DEEPDEBUG && interference_graph[cs_vreg_id].find(live_vreg_out) == interference_graph[cs_vreg_id].end()) { - std::cerr << " Edge (CALL, Int): preg(" << static_cast(cs_reg) << ") <-> %vreg" << live_vreg_out << "\n"; - } - interference_graph[cs_vreg_id].insert(live_vreg_out); - interference_graph[live_vreg_out].insert(cs_vreg_id); - } - } - } - } - - // --- 处理浮点寄存器干扰 --- - const std::vector& caller_saved_fp_regs = getCallerSavedFpRegs(); - for (PhysicalReg cs_reg : caller_saved_fp_regs) { - unsigned cs_vreg_id = preg_to_vreg_id_map.at(cs_reg); - - for (unsigned live_vreg_out : live_out) { - // 只为浮点vreg添加与浮点preg的干扰 - if (is_fp_vreg(live_vreg_out)) { - if (cs_vreg_id != live_vreg_out) { - // 添加与整数版本一致的调试代码 - if (DEEPDEBUG && interference_graph[cs_vreg_id].find(live_vreg_out) == interference_graph[cs_vreg_id].end()) { - std::cerr << " Edge (CALL, FP): preg(" << static_cast(cs_reg) << ") <-> %vreg" << live_vreg_out << "\n"; - } - interference_graph[cs_vreg_id].insert(live_vreg_out); - interference_graph[live_vreg_out].insert(cs_vreg_id); - } - } - } + // --- 规则 3: Live_Out 集合内部形成完全图 --- + for (unsigned l1 : live_out) { + for (unsigned l2 : live_out) { + addEdge(l1, l2); } } - if (DEEPDEBUG) std::cerr << " ----------------\n"; } } } -void RISCv64RegAlloc::colorGraph() { - std::vector sorted_vregs; - for (auto const& [vreg, neighbors] : interference_graph) { - // 只为未预着色的虚拟寄存器排序和着色 - if (color_map.find(vreg) == color_map.end() && vreg < static_cast(PhysicalReg::PHYS_REG_START_ID)) { - sorted_vregs.push_back(vreg); +// 将节点放入初始工作列表 +void RISCv64RegAlloc::makeWorklist() { + for (unsigned n : initial) { + int K = isFPVReg(n) ? K_fp : K_int; + if (degree.count(n) == 0) { + std::cerr << "Error: degree not initialized for %vreg" << n << "\n"; + continue; + } + if (DEEPDEBUG) { + std::cerr << "Assigning %vreg" << n << " (degree=" << degree.at(n) + << ", moveRelated=" << moveRelated(n) << ")\n"; + } + if (degree.at(n) >= K) { + spillWorklist.insert(n); + } else if (moveRelated(n)) { + freezeWorklist.insert(n); + } else { + simplifyWorklist.insert(n); } } + if (DEEPDEBUG) std::cerr << "--------------------------------\n"; + initial.clear(); +} - // 排序 - std::sort(sorted_vregs.begin(), sorted_vregs.end(), [&](unsigned a, unsigned b) { - return interference_graph[a].size() > interference_graph[b].size(); - }); +// 简化阶段 +void RISCv64RegAlloc::simplify() { + unsigned n = *simplifyWorklist.begin(); + simplifyWorklist.erase(simplifyWorklist.begin()); + if (DEEPDEBUG) std::cerr << "[Simplify] Popped %vreg" << n << ", pushing to stack.\n"; + selectStack.push_back(n); + for (unsigned m : adjacent(n)) { + decrementDegree(m); + } +} - // [调试] 辅助函数，用于判断一个vreg是整数还是浮点类型，并打印详细诊断信息 - auto is_fp_vreg = [&](unsigned vreg) { +// 合并阶段 +void RISCv64RegAlloc::coalesce() { + const MachineInstr* move = *worklistMoves.begin(); + worklistMoves.erase(worklistMoves.begin()); + VRegSet use, def; + getInstrUseDef_Liveness(move, use, def); + unsigned x = getAlias(*def.begin()); + unsigned y = getAlias(*use.begin()); + unsigned u, v; + if (precolored.count(y)) { u = y; v = x; } else { u = x; v = y; } + + if (DEEPDEBUG) std::cerr << "[Coalesce] Processing move between " << regIdToString(x) + << " and " << regIdToString(y) << " (aliases " << regIdToString(u) + << ", " << regIdToString(v) << ").\n"; + + if (u == v) { + if (DEEPDEBUG) std::cerr << " -> Trivial coalesce (u == v).\n"; + coalescedMoves.insert(move); + addWorklist(u); + return; // 处理完毕，提前返回 + } + + if (isFPVReg(u) != isFPVReg(v)) { + if (DEEPDEBUG) std::cerr << " -> Constrained (type mismatch: " << regIdToString(u) << " is " + << (isFPVReg(u) ? "float" : "int") << ", " << regIdToString(v) << " is " + << (isFPVReg(v) ? "float" : "int") << ").\n"; + constrainedMoves.insert(move); + addWorklist(u); + addWorklist(v); + return; // 立即返回，不再进行后续检查 + } + + // --- 新的、拆分后的启发式检查逻辑 --- + + bool pre_interfere = adjList.at(v).count(u); + + if (pre_interfere) { + if (DEEPDEBUG) std::cerr << " -> Constrained (nodes already interfere).\n"; + constrainedMoves.insert(move); + addWorklist(u); + addWorklist(v); + return; + } + + bool is_u_precolored = precolored.count(u); + bool can_coalesce = false; + + if (is_u_precolored) { + // --- 场景1：u是物理寄存器，使用 George 启发式 --- + if (DEEPDEBUG) std::cerr << " -> Trying George Heuristic (u is precolored)...\n"; + + // ==================== [展开的 std::all_of 逻辑] ==================== + + // 步骤 1: 独立调用 adjacent(v) 获取邻居集合 + VRegSet neighbors_of_v = adjacent(v); if (DEEPDEBUG) { - std::cout << " [Debug is_fp_vreg] Checking vreg" << vreg << ": "; + std::cerr << " - Neighbors of " << regIdToString(v) << " to check are (" << neighbors_of_v.size() << "): { "; + for (unsigned id : neighbors_of_v) std::cerr << regIdToString(id) << " "; + std::cerr << "}\n"; } - if (vreg_to_value_map.count(vreg)) { - Value* val = vreg_to_value_map.at(vreg); - bool is_float = val->getType()->isFloat(); + + // 步骤 2: 使用显式的 for 循环来代替 std::all_of + bool george_ok = true; // 默认假设成功，任何一个邻居失败都会将此设为 false + for (unsigned t : neighbors_of_v) { if (DEEPDEBUG) { - std::cout << "Found in map. Value is '" << val->getName() - << "', Type is " << (is_float ? "FLOAT" : "INT") - << ". Returning " << (is_float ? "true" : "false") << ".\n"; + std::cerr << " - Checking neighbor " << regIdToString(t) << ":\n"; + } + + // 步骤 3: 独立调用启发式函数 + bool heuristic_result = georgeHeuristic(t, u); + + if (DEEPDEBUG) { + std::cerr << " - georgeHeuristic(" << regIdToString(t) << ", " << regIdToString(u) << ") -> " << (heuristic_result ? "OK" : "FAIL") << "\n"; + } + + if (!heuristic_result) { + george_ok = false; // 只要有一个邻居不满足条件，整个检查就失败 + break; // 并且可以立即停止检查其他邻居 } - return is_float; } if (DEEPDEBUG) { - std::cout << "NOT found in vreg_to_value_map. Defaulting to INT. Returning false.\n"; + std::cerr << " -> George Heuristic final result: " << (george_ok ? "OK" : "FAIL") << "\n"; } - // 对于ISel创建的、没有直接IR Value对应的临时vreg，默认其为整数类型。 - return false; - }; + // ================================================================= - // 着色 - for (unsigned vreg : sorted_vregs) { - std::set used_colors; - for (unsigned neighbor_id : interference_graph.at(vreg)) { - // 收集邻居颜色的逻辑保持不变 - if (color_map.count(neighbor_id)) { - used_colors.insert(color_map.at(neighbor_id)); - } - else if (neighbor_id >= static_cast(PhysicalReg::PHYS_REG_START_ID)) { - PhysicalReg neighbor_preg = static_cast(neighbor_id - static_cast(PhysicalReg::PHYS_REG_START_ID)); - used_colors.insert(neighbor_preg); - } + if (george_ok) { + can_coalesce = true; } + + } else { + // --- 场景2：u和v都是虚拟寄存器，使用 Briggs 启发式 --- + if (DEEPDEBUG) std::cerr << " -> Trying Briggs Heuristic (u and v are virtual)...\n"; - bool is_float = is_fp_vreg(vreg); - const auto& allocable_regs = is_float ? allocable_fp_regs : allocable_int_regs; - - // [调试] 打印着色决策过程 - if (DEBUG) { - std::cout << "[DEBUG] Coloring %vreg" << vreg - << ": Type is " << (is_float ? "FLOAT" : "INT") - << ", choosing from " << (is_float ? "Float" : "Integer") << " pool.\n"; + bool briggs_ok = briggsHeuristic(u, v); + if (DEEPDEBUG) std::cerr << " - briggsHeuristic(" << regIdToString(u) << ", " << regIdToString(v) << ") -> " << (briggs_ok ? "OK" : "FAIL") << "\n"; + + if (briggs_ok) { + can_coalesce = true; } - - bool colored = false; - for (PhysicalReg preg : allocable_regs) { - if (used_colors.find(preg) == used_colors.end()) { - color_map[vreg] = preg; - colored = true; - if (DEBUG) { - RISCv64AsmPrinter p(MFunc); // For regToString - std::cout << " -> Assigned to physical register: " << p.regToString(preg) << "\n"; + } + + // --- 根据启发式结果进行最终决策 --- + + if (can_coalesce) { + if (DEEPDEBUG) std::cerr << " -> Heuristic OK. Combining " << regIdToString(v) << " into " << regIdToString(u) << ".\n"; + coalescedMoves.insert(move); + combine(u, v); + addWorklist(u); + } else { + if (DEEPDEBUG) std::cerr << " -> Heuristic failed. Adding to active moves.\n"; + activeMoves.insert(move); + } +} + +// 冻结阶段 +void RISCv64RegAlloc::freeze() { + unsigned u = *freezeWorklist.begin(); + freezeWorklist.erase(freezeWorklist.begin()); + if (DEEPDEBUG) std::cerr << "[Freeze] Freezing %vreg" << u << " and moving to simplify list.\n"; + simplifyWorklist.insert(u); + freezeMoves(u); +} + +// 选择溢出节点 +void RISCv64RegAlloc::selectSpill() { + auto it = std::max_element(spillWorklist.begin(), spillWorklist.end(), + [&](unsigned a, unsigned b){ return degree.at(a) < degree.at(b); }); + unsigned m = *it; + spillWorklist.erase(it); + if (DEEPDEBUG) std::cerr << "[Spill] Selecting %vreg" << m << " to spill.\n"; + simplifyWorklist.insert(m); + freezeMoves(m); +} + +void RISCv64RegAlloc::assignColors() { + if (DEEPDEBUG) std::cerr << "[AssignColors] Starting...\n"; + while (!selectStack.empty()) { + unsigned n = selectStack.back(); + selectStack.pop_back(); + bool is_fp = isFPVReg(n); + const auto& available_regs = is_fp ? allocable_fp_regs : allocable_int_regs; + std::set ok_colors(available_regs.begin(), available_regs.end()); + + // 遍历 n 的所有邻居 w + for (unsigned w : adjList.at(n)) { + unsigned w_alias = getAlias(w); + + // [关键修正] 邻居 w 可能是一个已着色的虚拟寄存器， + // 或者它本身就是一个物理寄存器。两种情况都要处理！ + bool is_colored_vreg = coloredNodes.count(w_alias); + bool is_physical_reg = precolored.count(w_alias); + const unsigned offset = static_cast(PhysicalReg::PHYS_REG_START_ID); + + if (is_colored_vreg || is_physical_reg) { + PhysicalReg neighbor_color; + if (is_colored_vreg) { + // 如果是已着色的vreg，从 color_map 获取它的颜色 + neighbor_color = color_map.at(w_alias); + } else { + // 如果是物理寄存器，它的ID就是它的颜色 + neighbor_color = static_cast(w_alias - offset); } - break; + ok_colors.erase(neighbor_color); } } - if (!colored) { - spilled_vregs.insert(vreg); - if (DEBUG) { - std::cout << " -> FAILED to color. Spilling.\n"; - } + + if (ok_colors.empty()) { + if (DEEPDEBUG) std::cerr << " -> No color for %vreg" << n << ". Spilling.\n"; + spilledNodes.insert(n); + } else { + PhysicalReg c = *ok_colors.begin(); + coloredNodes.insert(n); + color_map[n] = c; + if (DEEPDEBUG) std::cerr << " -> Colored %vreg" << n << " with " << regToString(c) << " (ID: " << static_cast(c) << ").\n"; + } + } + + // 为合并的节点上色（这部分逻辑是正确的） + for (unsigned n : coalescedNodes) { + unsigned root_alias = getAlias(n); + if (color_map.count(root_alias)) { + color_map[n] = color_map.at(root_alias); + if (DEEPDEBUG) std::cerr << " -> Coalesced " << regIdToString(n) << " gets color of alias " << regIdToString(root_alias) << ".\n"; + } else { + if (DEEPDEBUG) std::cerr << " -> No color for alias of %vreg" << n << ". Spilling.\n"; + spilledNodes.insert(n); } } } -void RISCv64RegAlloc::rewriteFunction() { +// 重写程序，插入溢出代码 +void RISCv64RegAlloc::rewriteProgram() { + // 1. 为溢出的旧vreg在栈上分配空间 (这部分逻辑不变) StackFrameInfo& frame_info = MFunc->getFrameInfo(); - int current_offset = frame_info.locals_size; + // locals_size, callee_saved_size等已经由之前的步骤或上一次运行计算好 + // 我们在此基础上累加溢出区大小 + int spill_base_offset = frame_info.locals_size + frame_info.callee_saved_size; - // --- 动态计算溢出槽大小 --- - // 根据溢出虚拟寄存器的真实类型，为其在栈上分配正确大小的空间。 - for (unsigned vreg : spilled_vregs) { - // 从反向映射中查找 vreg 对应的 IR Value - assert(vreg_to_value_map.count(vreg) && "Spilled vreg not found in map!"); - Value* val = vreg_to_value_map.at(vreg); - - // 使用辅助函数获取类型大小 - int size = getTypeSizeInBytes(val->getType()); - - // 保持栈8字节对齐 - current_offset += size; - current_offset = (current_offset + 7) & ~7; + for (unsigned vreg : spilledNodes) { + if (frame_info.spill_offsets.count(vreg)) continue; // 如果已经分配过则跳过 - frame_info.spill_offsets[vreg] = -current_offset; + int size = 4; // 默认4字节 + if (isFPVReg(vreg)) { + size = 4; // float + } else if (vreg_type_map.count(vreg) && vreg_type_map.at(vreg)->isPointer()) { + size = 8; // pointer + } + + spill_base_offset += size; + spill_base_offset = (spill_base_offset + 7) & ~7; // 8字节对齐 + frame_info.spill_offsets[vreg] = spill_base_offset; } - frame_info.spill_size = current_offset - frame_info.locals_size; - - // 定义专用的溢出寄存器 - const PhysicalReg INT_SPILL_REG = PhysicalReg::T6; // t6 - const PhysicalReg FP_SPILL_REG = PhysicalReg::F7; // ft7 + frame_info.spill_size = spill_base_offset - (frame_info.locals_size + frame_info.callee_saved_size); + // 2. 遍历所有指令，为溢出vreg的use/def插入load/store，并使用新的临时虚拟寄存器 for (auto& mbb : MFunc->getBlocks()) { std::vector> new_instructions; + for (auto& instr_ptr : mbb->getInstructions()) { - LiveSet use, def; - getInstrUseDef(instr_ptr.get(), use, def); + // 对每条指令，记录其使用的旧vreg到新临时vreg的映射 + std::map vreg_remap; - // --- 为溢出的 'use' 操作数插入正确的加载指令 --- - for (unsigned vreg : use) { - if (spilled_vregs.count(vreg)) { - // 同样地，根据 vreg 的类型决定使用 lw 还是 ld - assert(vreg_to_value_map.count(vreg)); - Value* val = vreg_to_value_map.at(vreg); - - // 根据vreg类型决定加载指令(lw/ld/flw)和目标物理寄存器(t6/ft7) - RVOpcodes load_op; - PhysicalReg target_preg; - if (val->getType()->isFloat()) { - load_op = RVOpcodes::FLW; - target_preg = FP_SPILL_REG; - } else if (val->getType()->isPointer()) { - load_op = RVOpcodes::LD; - target_preg = INT_SPILL_REG; - } else { - load_op = RVOpcodes::LW; - target_preg = INT_SPILL_REG; + // a. 为每个溢出的 use 操作数，在原指令前插入 load 指令 + VRegSet use, def; + getInstrUseDef_Liveness(instr_ptr.get(), use, def); // 假设此函数能正确处理operands + + for(auto& op : instr_ptr->getOperands()) { + if (op->getKind() == MachineOperand::KIND_REG) { + auto reg_op = static_cast(op.get()); + if (reg_op->isVirtual() && spilledNodes.count(reg_op->getVRegNum()) && use.count(reg_op->getVRegNum())) { + unsigned old_vreg = reg_op->getVRegNum(); + // 仅当还未为此vreg创建临时替身时才创建 + if (vreg_remap.find(old_vreg) == vreg_remap.end()) { + Type* type = vreg_type_map.count(old_vreg) ? vreg_type_map.at(old_vreg) : Type::getIntType(); + unsigned new_temp_vreg = ISel->getNewVReg(type); + vreg_remap[old_vreg] = new_temp_vreg; + + RVOpcodes load_op; + if (isFPVReg(old_vreg)) load_op = RVOpcodes::FLW; + else if (type->isPointer()) load_op = RVOpcodes::LD; + else load_op = RVOpcodes::LW; + + auto load = std::make_unique(load_op); + load->addOperand(std::make_unique(new_temp_vreg)); + load->addOperand(std::make_unique( + std::make_unique(PhysicalReg::S0), + std::make_unique(-frame_info.spill_offsets.at(old_vreg)) // 偏移是相对于S0的负值 + )); + new_instructions.push_back(std::move(load)); + } } + } else if (op->getKind() == MachineOperand::KIND_MEM) { + auto reg_op = static_cast(op.get())->getBase(); + if (reg_op->isVirtual() && spilledNodes.count(reg_op->getVRegNum())) { + unsigned old_vreg = reg_op->getVRegNum(); + if (vreg_remap.find(old_vreg) == vreg_remap.end()) { + Type* type = vreg_type_map.count(old_vreg) ? vreg_type_map.at(old_vreg) : Type::getIntType(); + unsigned new_temp_vreg = ISel->getNewVReg(type); + vreg_remap[old_vreg] = new_temp_vreg; - int offset = frame_info.spill_offsets.at(vreg); - auto load = std::make_unique(load_op); - load->addOperand(std::make_unique(target_preg)); // 加载到专用溢出寄存器 - load->addOperand(std::make_unique( - std::make_unique(PhysicalReg::S0), - std::make_unique(offset) - )); - new_instructions.push_back(std::move(load)); + RVOpcodes load_op = (type->isPointer()) ? RVOpcodes::LD : RVOpcodes::LW; + auto load = std::make_unique(load_op); + load->addOperand(std::make_unique(new_temp_vreg)); + load->addOperand(std::make_unique( + std::make_unique(PhysicalReg::S0), + std::make_unique(-frame_info.spill_offsets.at(old_vreg)) + )); + new_instructions.push_back(std::move(load)); + } + } + } + } + + // b. 替换原指令中的操作数，并将其加入新指令列表 + for(auto& op : instr_ptr->getOperands()) { + if (op->getKind() == MachineOperand::KIND_REG) { + auto reg_op = static_cast(op.get()); + if (reg_op->isVirtual() && vreg_remap.count(reg_op->getVRegNum())) { + reg_op->setVRegNum(vreg_remap.at(reg_op->getVRegNum())); + } + } else if (op->getKind() == MachineOperand::KIND_MEM) { + auto reg_op = static_cast(op.get())->getBase(); + if (reg_op->isVirtual() && vreg_remap.count(reg_op->getVRegNum())) { + reg_op->setVRegNum(vreg_remap.at(reg_op->getVRegNum())); + } } } - new_instructions.push_back(std::move(instr_ptr)); - // --- 为溢出的 'def' 操作数插入正确的存储指令 --- - for (unsigned vreg : def) { - if (spilled_vregs.count(vreg)) { - assert(vreg_to_value_map.count(vreg)); - Value* val = vreg_to_value_map.at(vreg); - - // 根据vreg类型决定存储指令(sw/sd/fsw)和源物理寄存器(t6/ft7) - RVOpcodes store_op; - PhysicalReg src_preg; - if (val->getType()->isFloat()) { - store_op = RVOpcodes::FSW; - src_preg = FP_SPILL_REG; - } else if (val->getType()->isPointer()) { - store_op = RVOpcodes::SD; - src_preg = INT_SPILL_REG; - } else { - store_op = RVOpcodes::SW; - src_preg = INT_SPILL_REG; - } + // c. 为每个溢出的 def 操作数，在原指令后插入 store 指令 + vreg_remap.clear(); // 清空映射，为def创建新的临时vreg + for(auto& op : new_instructions.back()->getOperands()) { + if (op->getKind() == MachineOperand::KIND_REG) { + auto reg_op = static_cast(op.get()); + if (reg_op->isVirtual() && spilledNodes.count(reg_op->getVRegNum()) && def.count(reg_op->getVRegNum())) { + unsigned old_vreg = reg_op->getVRegNum(); + if (vreg_remap.find(old_vreg) == vreg_remap.end()) { + Type* type = vreg_type_map.count(old_vreg) ? vreg_type_map.at(old_vreg) : Type::getIntType(); + unsigned new_temp_vreg = ISel->getNewVReg(type); + vreg_remap[old_vreg] = new_temp_vreg; // 记录从old到new的映射 + + // 再次修改指令，将def的vreg也换成新的临时vreg + reg_op->setVRegNum(new_temp_vreg); - int offset = frame_info.spill_offsets.at(vreg); - auto store = std::make_unique(store_op); - store->addOperand(std::make_unique(src_preg)); // 从专用溢出寄存器存储 - store->addOperand(std::make_unique( - std::make_unique(PhysicalReg::S0), - std::make_unique(offset) - )); - new_instructions.push_back(std::move(store)); - } + RVOpcodes store_op; + if (isFPVReg(old_vreg)) store_op = RVOpcodes::FSW; + else if (type->isPointer()) store_op = RVOpcodes::SD; + else store_op = RVOpcodes::SW; + + auto store = std::make_unique(store_op); + store->addOperand(std::make_unique(new_temp_vreg)); // 从新的临时vreg中存值 + store->addOperand(std::make_unique( + std::make_unique(PhysicalReg::S0), + std::make_unique(-frame_info.spill_offsets.at(old_vreg)) + )); + // 在原指令之后插入store + new_instructions.push_back(std::move(store)); + } + } + } } } mbb->getInstructions() = std::move(new_instructions); } - // 最后的虚拟寄存器到物理寄存器的替换过程保持不变 + // 清空溢出节点集合，为下一次迭代分配做准备 + spilledNodes.clear(); +} + +/** + * @brief [最终修正] 获取一条指令完整的【虚拟】使用/定义寄存器集合 + * 这个函数将服务于图的构建（收集initial节点等）。 + */ +void RISCv64RegAlloc::getInstrUseDef(const MachineInstr* instr, VRegSet& use, VRegSet& def) { + auto opcode = instr->getOpcode(); + const auto& operands = instr->getOperands(); + + static const std::map, std::vector>> op_info = { + {RVOpcodes::ADD, {{0}, {1, 2}}}, {RVOpcodes::SUB, {{0}, {1, 2}}}, {RVOpcodes::MUL, {{0}, {1, 2}}}, + {RVOpcodes::DIV, {{0}, {1, 2}}}, {RVOpcodes::REM, {{0}, {1, 2}}}, {RVOpcodes::ADDW, {{0}, {1, 2}}}, + {RVOpcodes::SUBW, {{0}, {1, 2}}}, {RVOpcodes::MULW, {{0}, {1, 2}}}, {RVOpcodes::DIVW, {{0}, {1, 2}}}, + {RVOpcodes::REMW, {{0}, {1, 2}}}, {RVOpcodes::SLT, {{0}, {1, 2}}}, {RVOpcodes::SLTU, {{0}, {1, 2}}}, + {RVOpcodes::ADDI, {{0}, {1}}}, {RVOpcodes::ADDIW, {{0}, {1}}}, {RVOpcodes::XORI, {{0}, {1}}}, + {RVOpcodes::SLTI, {{0}, {1}}}, {RVOpcodes::SLTIU, {{0}, {1}}}, {RVOpcodes::LB, {{0}, {}}}, + {RVOpcodes::LH, {{0}, {}}}, {RVOpcodes::LW, {{0}, {}}}, {RVOpcodes::LD, {{0}, {}}}, + {RVOpcodes::LBU, {{0}, {}}}, {RVOpcodes::LHU, {{0}, {}}}, {RVOpcodes::LWU, {{0}, {}}}, + {RVOpcodes::FLW, {{0}, {}}}, {RVOpcodes::FLD, {{0}, {}}}, {RVOpcodes::SB, {{}, {0, 1}}}, + {RVOpcodes::SH, {{}, {0, 1}}}, {RVOpcodes::SW, {{}, {0, 1}}}, {RVOpcodes::SD, {{}, {0, 1}}}, + {RVOpcodes::FSW, {{}, {0, 1}}}, {RVOpcodes::FSD, {{}, {0, 1}}}, {RVOpcodes::BEQ, {{}, {0, 1}}}, + {RVOpcodes::BNE, {{}, {0, 1}}}, {RVOpcodes::BLT, {{}, {0, 1}}}, {RVOpcodes::BGE, {{}, {0, 1}}}, + {RVOpcodes::JALR, {{0}, {1}}}, {RVOpcodes::LI, {{0}, {}}}, {RVOpcodes::LA, {{0}, {}}}, + {RVOpcodes::MV, {{0}, {1}}}, {RVOpcodes::SEQZ, {{0}, {1}}}, {RVOpcodes::SNEZ, {{0}, {1}}}, + {RVOpcodes::RET, {{}, {}}}, {RVOpcodes::FADD_S, {{0}, {1, 2}}}, {RVOpcodes::FSUB_S, {{0}, {1, 2}}}, + {RVOpcodes::FMUL_S, {{0}, {1, 2}}}, {RVOpcodes::FDIV_S, {{0}, {1, 2}}}, {RVOpcodes::FEQ_S, {{0}, {1, 2}}}, + {RVOpcodes::FLT_S, {{0}, {1, 2}}}, {RVOpcodes::FLE_S, {{0}, {1, 2}}}, {RVOpcodes::FCVT_S_W, {{0}, {1}}}, + {RVOpcodes::FCVT_W_S, {{0}, {1}}}, {RVOpcodes::FMV_S, {{0}, {1}}}, {RVOpcodes::FMV_W_X, {{0}, {1}}}, + {RVOpcodes::FMV_X_W, {{0}, {1}}}, {RVOpcodes::FNEG_S, {{0}, {1}}} + }; + + auto get_vreg_id_if_virtual = [&](const MachineOperand* op, VRegSet& s) { + if (op->getKind() == MachineOperand::KIND_REG) { + auto reg_op = static_cast(op); + if (reg_op->isVirtual()) s.insert(reg_op->getVRegNum()); + } else if (op->getKind() == MachineOperand::KIND_MEM) { + auto mem_op = static_cast(op); + auto reg_op = mem_op->getBase(); + if (reg_op->isVirtual()) s.insert(reg_op->getVRegNum()); + } + }; + + if (op_info.count(opcode)) { + const auto& info = op_info.at(opcode); + for (int idx : info.first) if (idx < operands.size()) get_vreg_id_if_virtual(operands[idx].get(), def); + for (int idx : info.second) if (idx < operands.size()) get_vreg_id_if_virtual(operands[idx].get(), use); + for (const auto& op : operands) if (op->getKind() == MachineOperand::KIND_MEM) get_vreg_id_if_virtual(op.get(), use); + } else if (opcode == RVOpcodes::CALL) { + if (!operands.empty() && operands[0]->getKind() == MachineOperand::KIND_REG) get_vreg_id_if_virtual(operands[0].get(), def); + for (size_t i = 1; i < operands.size(); ++i) if (operands[i]->getKind() == MachineOperand::KIND_REG) get_vreg_id_if_virtual(operands[i].get(), use); + } +} + +/** + * @brief [新增] 获取一条指令完整的、包含物理寄存器的Use/Def集合 + * 这个新函数将专门服务于活跃性分析。 + */ +void RISCv64RegAlloc::getInstrUseDef_Liveness(const MachineInstr* instr, VRegSet& use, VRegSet& def) { + auto opcode = instr->getOpcode(); + const auto& operands = instr->getOperands(); + + static const std::map, std::vector>> op_info = { + {RVOpcodes::ADD, {{0}, {1, 2}}}, {RVOpcodes::SUB, {{0}, {1, 2}}}, {RVOpcodes::MUL, {{0}, {1, 2}}}, + {RVOpcodes::DIV, {{0}, {1, 2}}}, {RVOpcodes::REM, {{0}, {1, 2}}}, {RVOpcodes::ADDW, {{0}, {1, 2}}}, + {RVOpcodes::SUBW, {{0}, {1, 2}}}, {RVOpcodes::MULW, {{0}, {1, 2}}}, {RVOpcodes::DIVW, {{0}, {1, 2}}}, + {RVOpcodes::REMW, {{0}, {1, 2}}}, {RVOpcodes::SLT, {{0}, {1, 2}}}, {RVOpcodes::SLTU, {{0}, {1, 2}}}, + {RVOpcodes::ADDI, {{0}, {1}}}, {RVOpcodes::ADDIW, {{0}, {1}}}, {RVOpcodes::XORI, {{0}, {1}}}, + {RVOpcodes::SLTI, {{0}, {1}}}, {RVOpcodes::SLTIU, {{0}, {1}}}, {RVOpcodes::LB, {{0}, {}}}, + {RVOpcodes::LH, {{0}, {}}}, {RVOpcodes::LW, {{0}, {}}}, {RVOpcodes::LD, {{0}, {}}}, + {RVOpcodes::LBU, {{0}, {}}}, {RVOpcodes::LHU, {{0}, {}}}, {RVOpcodes::LWU, {{0}, {}}}, + {RVOpcodes::FLW, {{0}, {}}}, {RVOpcodes::FLD, {{0}, {}}}, {RVOpcodes::SB, {{}, {0, 1}}}, + {RVOpcodes::SH, {{}, {0, 1}}}, {RVOpcodes::SW, {{}, {0, 1}}}, {RVOpcodes::SD, {{}, {0, 1}}}, + {RVOpcodes::FSW, {{}, {0, 1}}}, {RVOpcodes::FSD, {{}, {0, 1}}}, {RVOpcodes::BEQ, {{}, {0, 1}}}, + {RVOpcodes::BNE, {{}, {0, 1}}}, {RVOpcodes::BLT, {{}, {0, 1}}}, {RVOpcodes::BGE, {{}, {0, 1}}}, + {RVOpcodes::JALR, {{0}, {1}}}, {RVOpcodes::LI, {{0}, {}}}, {RVOpcodes::LA, {{0}, {}}}, + {RVOpcodes::MV, {{0}, {1}}}, {RVOpcodes::SEQZ, {{0}, {1}}}, {RVOpcodes::SNEZ, {{0}, {1}}}, + {RVOpcodes::RET, {{}, {static_cast(PhysicalReg::A0), static_cast(PhysicalReg::F10)}}}, + {RVOpcodes::FADD_S, {{0}, {1, 2}}}, {RVOpcodes::FSUB_S, {{0}, {1, 2}}}, {RVOpcodes::FMUL_S, {{0}, {1, 2}}}, + {RVOpcodes::FDIV_S, {{0}, {1, 2}}}, {RVOpcodes::FEQ_S, {{0}, {1, 2}}}, {RVOpcodes::FLT_S, {{0}, {1, 2}}}, + {RVOpcodes::FLE_S, {{0}, {1, 2}}}, {RVOpcodes::FCVT_S_W, {{0}, {1}}}, {RVOpcodes::FCVT_W_S, {{0}, {1}}}, + {RVOpcodes::FMV_S, {{0}, {1}}}, {RVOpcodes::FMV_W_X, {{0}, {1}}}, {RVOpcodes::FMV_X_W, {{0}, {1}}}, + {RVOpcodes::FNEG_S, {{0}, {1}}} + }; + + const unsigned offset = static_cast(PhysicalReg::PHYS_REG_START_ID); + auto get_any_reg_id = [&](const MachineOperand* op) -> unsigned { + if (op->getKind() == MachineOperand::KIND_REG) { + auto reg_op = static_cast(op); + return reg_op->isVirtual() ? reg_op->getVRegNum() : (offset + static_cast(reg_op->getPReg())); + } else if (op->getKind() == MachineOperand::KIND_MEM) { + auto mem_op = static_cast(op); + auto reg_op = mem_op->getBase(); + return reg_op->isVirtual() ? reg_op->getVRegNum() : (offset + static_cast(reg_op->getPReg())); + } + return (unsigned)-1; + }; + + if (op_info.count(opcode)) { + const auto& info = op_info.at(opcode); + for (int idx : info.first) if (idx < operands.size()) def.insert(get_any_reg_id(operands[idx].get())); + for (int idx : info.second) if (idx < operands.size()) use.insert(get_any_reg_id(operands[idx].get())); + for (const auto& op : operands) if (op->getKind() == MachineOperand::KIND_MEM) use.insert(get_any_reg_id(op.get())); + } else if (opcode == RVOpcodes::CALL) { + if (!operands.empty() && operands[0]->getKind() == MachineOperand::KIND_REG) def.insert(get_any_reg_id(operands[0].get())); + for (size_t i = 1; i < operands.size(); ++i) if (operands[i]->getKind() == MachineOperand::KIND_REG) use.insert(get_any_reg_id(operands[i].get())); + for (auto preg : getCallerSavedIntRegs()) def.insert(static_cast(preg)); + for (auto preg : getCallerSavedFpRegs()) def.insert(static_cast(preg)); + def.insert(static_cast(PhysicalReg::RA)); + } +} + +void RISCv64RegAlloc::addEdge(unsigned u, unsigned v) { + if (u == v) return; + + // 关键修正：只为虚拟寄存器（非预着色）更新邻接表和度数 + // 如果 u 是虚拟寄存器 + if (!precolored.count(u)) { + // 并且 u 和 v 之间还没有边 + if (adjList.at(u).find(v) == adjList.at(u).end()) { + adjList.at(u).insert(v); + degree.at(u)++; + } + } + + // 对称地，如果 v 是虚拟寄存器 + if (!precolored.count(v)) { + // 并且 v 和 u 之间还没有边 + if (adjList.at(v).find(u) == adjList.at(v).end()) { + adjList.at(v).insert(u); + degree.at(v)++; + } + } +} + +RISCv64RegAlloc::VRegSet RISCv64RegAlloc::adjacent(unsigned n) { + // 仅在 DEEPDEBUG 模式下启用详细日志 + if (DEEPDEBUG) { + // 使用 regIdToString 打印节点 n，无论是物理还是虚拟 + std::cerr << "\n[adjacent] >>>>> Executing for node " << regIdToString(n) << " <<<<<\n"; + } + + // 1. 如果节点 n 是物理寄存器，它没有邻接表，直接返回空集 + if (precolored.count(n)) { + if (DEEPDEBUG) { + std::cerr << "[adjacent] Node " << regIdToString(n) << " is precolored. Returning {}.\n"; + } + return {}; + } + + // 安全检查：确保 n 在 adjList 中存在，防止 map::at 崩溃 + if (adjList.count(n) == 0) { + if (DEEPDEBUG) { + std::cerr << "[adjacent] WARNING: Node " << regIdToString(n) << " not found in adjList. Returning {}.\n"; + } + return {}; + } + + // 2. 获取 n 在冲突图中的所有邻居 + VRegSet result = adjList.at(n); + + if (DEEPDEBUG) { + // 定义一个局部的 lambda 方便打印集合 + auto print_set = [this](const VRegSet& s, const std::string& name) { + std::cerr << "[adjacent] " << name << " (" << s.size() << "): { "; + for (unsigned id : s) std::cerr << regIdToString(id) << " "; + std::cerr << "}\n"; + }; + print_set(result, "Initial full neighbors"); + } + + // 3. 过滤掉那些已经在 selectStack 或 coalescedNodes 中的邻居 + // 这些节点被认为是“已移除”的，不参与当前的启发式判断 + + // 3a. 从 selectStack 中移除 + VRegSet removed_from_stack; // 仅用于调试打印 + for (auto it = selectStack.rbegin(); it != selectStack.rend(); ++it) { + if (result.count(*it)) { + if (DEEPDEBUG) removed_from_stack.insert(*it); + result.erase(*it); + } + } + if (DEEPDEBUG && !removed_from_stack.empty()) { + std::cerr << "[adjacent] - Removed from selectStack: { "; + for(unsigned id : removed_from_stack) std::cerr << regIdToString(id) << " "; + std::cerr << "}\n"; + } + + // 3b. 从 coalescedNodes 中移除 + VRegSet removed_from_coalesced; // 仅用于调试打印 + for (unsigned cn : coalescedNodes) { + if (result.count(cn)) { + if (DEEPDEBUG) removed_from_coalesced.insert(cn); + result.erase(cn); + } + } + if (DEEPDEBUG && !removed_from_coalesced.empty()) { + std::cerr << "[adjacent] - Removed from coalescedNodes: { "; + for(unsigned id : removed_from_coalesced) std::cerr << regIdToString(id) << " "; + std::cerr << "}\n"; + } + + // 4. 返回最终的、过滤后的“有效”邻居集合 + if (DEEPDEBUG) { + std::cerr << "[adjacent] >>>>> Returning final adjacent set (" << result.size() << "): { "; + for (unsigned id : result) std::cerr << regIdToString(id) << " "; + std::cerr << "}\n\n"; + } + + return result; +} + +RISCv64RegAlloc::VRegMoveSet RISCv64RegAlloc::nodeMoves(unsigned n) { + if (precolored.count(n) || !moveList.count(n)) { + return {}; + } + + VRegMoveSet result; + const VRegMoveSet& moves = moveList.at(n); + for (const auto& move : moves) { + if (activeMoves.count(move) || worklistMoves.count(move)) { + result.insert(move); + } + } + return result; +} + +bool RISCv64RegAlloc::moveRelated(unsigned n) { + return !nodeMoves(n).empty(); +} + +void RISCv64RegAlloc::decrementDegree(unsigned m) { + if (precolored.count(m)) { + return; + } + + int K = isFPVReg(m) ? K_fp : K_int; + int d = degree.at(m); + degree.at(m)--; + if (d == K) { + VRegSet nodes_to_enable = adjacent(m); + nodes_to_enable.insert(m); + enableMoves(nodes_to_enable); + spillWorklist.erase(m); + if (moveRelated(m)) { + freezeWorklist.insert(m); + } else { + simplifyWorklist.insert(m); + } + } +} + +void RISCv64RegAlloc::enableMoves(const VRegSet& nodes) { + for (unsigned n : nodes) { + VRegMoveSet moves = nodeMoves(n); + for (const auto& move : moves) { + if (activeMoves.count(move)) { + activeMoves.erase(move); + worklistMoves.insert(move); + } + } + } +} + +unsigned RISCv64RegAlloc::getAlias(unsigned n) { + if (precolored.count(n)) { + return n; + } + if (alias.count(n)) { + // 路径压缩 + alias.at(n) = getAlias(alias.at(n)); + return alias.at(n); + } + return n; +} + +void RISCv64RegAlloc::addWorklist(unsigned u) { + if (precolored.count(u)) return; + + int K = isFPVReg(u) ? K_fp : K_int; + if (!moveRelated(u) && degree.at(u) < K) { + freezeWorklist.erase(u); + simplifyWorklist.insert(u); + } +} + +// Briggs启发式 +bool RISCv64RegAlloc::briggsHeuristic(unsigned u, unsigned v) { + if (DEEPDEBUG) { + std::cerr << "\n[Briggs] >>>>> Checking coalesce between " << regIdToString(u) << " and " << regIdToString(v) << " <<<<<\n"; + } + + // 步骤 1: 分别获取 u 和 v 的邻居 + VRegSet u_adj = adjacent(u); + VRegSet v_adj = adjacent(v); + + // 步骤 2: 合并两个邻居集合 + VRegSet all_adj = u_adj; + all_adj.insert(v_adj.begin(), v_adj.end()); + + if (DEEPDEBUG) { + auto print_set = [this](const VRegSet& s, const std::string& name) { + std::cerr << "[Briggs] " << name << " (" << s.size() << "): { "; + for (unsigned id : s) std::cerr << regIdToString(id) << " "; + std::cerr << "}\n"; + }; + print_set(u_adj, "Neighbors of u"); + print_set(v_adj, "Neighbors of v"); + print_set(all_adj, "Combined neighbors"); + } + + // 步骤 3: 遍历合并后的邻居集合，计算度数 >= K 的节点数量 + int k = 0; + if (DEEPDEBUG) std::cerr << "[Briggs] Checking significance of combined neighbors:\n"; + for (unsigned n : all_adj) { + // 关键修正：只考虑那些在工作集中的邻居节点 n + if (degree.count(n) > 0) { + int K = isFPVReg(n) ? K_fp : K_int; + if (degree.at(n) >= K) { + k++; + if (DEEPDEBUG) { + std::cerr << "[Briggs] - Node " << regIdToString(n) << " is significant (degree " << degree.at(n) << " >= " << K << "). Count k is now " << k << ".\n"; + } + } + } + } + + // 步骤 4: 比较 "重要" 邻居的数量是否小于 K + int K_u = isFPVReg(u) ? K_fp : K_int; + bool result = (k < K_u); + + if (DEEPDEBUG) { + std::cerr << "[Briggs] Final count of significant neighbors (k) = " << k << ".\n"; + std::cerr << "[Briggs] K value for node " << regIdToString(u) << " is " << K_u << ".\n"; + std::cerr << "[Briggs] >>>>> Result (k < K): " << (result ? "OK (can coalesce)" : "FAIL (cannot coalesce)") << "\n\n"; + } + + return result; +} + +// George启发式 +bool RISCv64RegAlloc::georgeHeuristic(unsigned t, unsigned u) { + // 关键修正：如果 t 不是一个待分配的虚拟寄存器（即它是物理寄存器）， + // 那么它已经被预着色，总是满足 George 启发式条件。 + // 我们通过检查 degree.count(t) 来判断 t 是否在我们的虚拟寄存器工作集中。 + if (degree.count(t) == 0) { + return true; + } + + int K = isFPVReg(t) ? K_fp : K_int; + // adjList.at(t) 现在是安全的，因为 degree.count(t) > 0 保证了 adjList.count(t) > 0 + return degree.at(t) < K || precolored.count(u) || adjList.at(t).count(u); +} + +void RISCv64RegAlloc::combine(unsigned u, unsigned v) { + freezeWorklist.erase(v); + spillWorklist.erase(v); + coalescedNodes.insert(v); + alias[v] = u; + if (moveList.count(u) && moveList.count(v)) { + moveList.at(u).insert(moveList.at(v).begin(), moveList.at(v).end()); + } else if (moveList.count(v)) { + moveList[u] = moveList.at(v); + } + enableMoves({v}); + for (unsigned t : adjacent(v)) { + addEdge(t, u); + decrementDegree(t); + } + int K = isFPVReg(u) ? K_fp : K_int; + if (degree.at(u) >= K && freezeWorklist.count(u)) { + freezeWorklist.erase(u); + spillWorklist.insert(u); + } +} + +void RISCv64RegAlloc::freezeMoves(unsigned u) { + if (precolored.count(u)) return; + + VRegMoveSet moves = nodeMoves(u); + for (const auto& move : moves) { + VRegSet use, def; + getInstrUseDef_Liveness(move, use, def); + unsigned x = *def.begin(); + unsigned y = *use.begin(); + unsigned v_alias; + + if (getAlias(y) == getAlias(u)) { + v_alias = getAlias(x); + } else { + v_alias = getAlias(y); + } + + activeMoves.erase(move); + frozenMoves.insert(move); + + if (!precolored.count(v_alias) && nodeMoves(v_alias).empty() && degree.at(v_alias) < (isFPVReg(v_alias) ? K_fp : K_int)) { + freezeWorklist.erase(v_alias); + simplifyWorklist.insert(v_alias); + } + } +} + +// 检查vreg是否为浮点类型 +bool RISCv64RegAlloc::isFPVReg(unsigned vreg) const { + // 1. 检查是否为虚拟寄存器 + if (vreg_type_map.count(vreg)) { + return vreg_type_map.at(vreg)->isFloat(); + } + + // 2. 检查是否为物理寄存器 (ID >= 100000) + const unsigned offset = static_cast(PhysicalReg::PHYS_REG_START_ID); + if (vreg >= offset) { + // 先减去偏移，还原成原始的、小的枚举值 + unsigned raw_preg_id = vreg - offset; + + // 再用原始枚举值判断是否在浮点寄存器范围内 + if (raw_preg_id >= static_cast(PhysicalReg::F0) && raw_preg_id <= static_cast(PhysicalReg::F31)) { + return true; + } + } + + // 3. 其他所有情况（如未知的vreg，或整数物理寄存器）都默认为整数 + return false; +} + +// 收集被使用的被调用者保存寄存器 +void RISCv64RegAlloc::collectUsedCalleeSavedRegs() { + StackFrameInfo& frame_info = MFunc->getFrameInfo(); + frame_info.used_callee_saved_regs.clear(); + + const auto& callee_saved_int = getCalleeSavedIntRegs(); + const auto& callee_saved_fp = getCalleeSavedFpRegs(); + std::set callee_saved_set(callee_saved_int.begin(), callee_saved_int.end()); + callee_saved_set.insert(callee_saved_fp.begin(), callee_saved_fp.end()); + // s0总是被使用作为帧指针 + callee_saved_set.insert(PhysicalReg::S0); + + + for(const auto& pair : color_map) { + PhysicalReg preg = pair.second; + if(callee_saved_set.count(preg)) { + frame_info.used_callee_saved_regs.insert(preg); + } + } +} + +/** + * @brief 将最终的寄存器分配结果应用到所有机器指令上。 + * 遍历所有操作数，将虚拟寄存器替换为分配到的物理寄存器。 + */ +void RISCv64RegAlloc::applyColoring() { for (auto& mbb : MFunc->getBlocks()) { for (auto& instr_ptr : mbb->getInstructions()) { for (auto& op_ptr : instr_ptr->getOperands()) { - // 定义一个处理寄存器操作数的 lambda 函数 - auto process_reg_op = [&](RegOperand* reg_op) { + if (op_ptr->getKind() == MachineOperand::KIND_REG) { + auto reg_op = static_cast(op_ptr.get()); + if (reg_op->isVirtual()) { + unsigned vreg = reg_op->getVRegNum(); + if (color_map.count(vreg)) { + // 使用 setPReg 将虚拟寄存器转换为物理寄存器 + reg_op->setPReg(color_map.at(vreg)); + } else { + // 如果一个vreg在成功分配后仍然没有颜色，这是一个错误 + std::cerr << "FATAL: Virtual register %vreg" << vreg << " has no color after allocation!\n"; + assert(false && "Virtual register has no color after allocation!"); + reg_op->setPReg(PhysicalReg::T6); + } + } + } else if (op_ptr->getKind() == MachineOperand::KIND_MEM) { + auto mem_op = static_cast(op_ptr.get()); + auto reg_op = mem_op->getBase(); if (reg_op->isVirtual()) { unsigned vreg = reg_op->getVRegNum(); if (color_map.count(vreg)) { reg_op->setPReg(color_map.at(vreg)); - } else if (spilled_vregs.count(vreg)) { - // 根据vreg类型，替换为对应的专用溢出寄存器 - assert(vreg_to_value_map.count(vreg)); - Value* val = vreg_to_value_map.at(vreg); - if (val->getType()->isFloat()) { - reg_op->setPReg(FP_SPILL_REG); - } else { - reg_op->setPReg(INT_SPILL_REG); - } + } else { + assert(false && "Virtual register in memory operand has no color!"); + reg_op->setPReg(PhysicalReg::T6); } } - }; - - if(op_ptr->getKind() == MachineOperand::KIND_REG) { - process_reg_op(static_cast(op_ptr.get())); - } else if (op_ptr->getKind() == MachineOperand::KIND_MEM) { - process_reg_op(static_cast(op_ptr.get())->getBase()); } } } } } +void RISCv64RegAlloc::dumpState(const std::string& stage) { + if (!DEEPDEBUG) return; + std::cerr << "\n=============== STATE DUMP (" << stage << ") ===============\n"; + auto print_vreg_set = [&](const VRegSet& s, const std::string& name){ + std::cerr << name << " (" << s.size() << "): { "; + for(unsigned v : s) std::cerr << "%vreg" << v << " "; + std::cerr << "}\n"; + }; + print_vreg_set(simplifyWorklist, "SimplifyWorklist"); + print_vreg_set(freezeWorklist, "FreezeWorklist"); + print_vreg_set(spillWorklist, "SpillWorklist"); + print_vreg_set(coalescedNodes, "CoalescedNodes"); + print_vreg_set(spilledNodes, "SpilledNodes"); + + std::cerr << "SelectStack (" << selectStack.size() << "): { "; + for(unsigned v : selectStack) std::cerr << "%vreg" << v << " "; + std::cerr << "}\n"; + + std::cerr << "WorklistMoves (" << worklistMoves.size() << ")\n"; + std::cerr << "ActiveMoves (" << activeMoves.size() << ")\n"; + + size_t final_nodes = coalescedNodes.size() + spilledNodes.size() + selectStack.size(); + std::cerr << "Total Final Nodes: " << final_nodes << "\n"; + std::cerr << "=======================================================\n"; +} + +std::string RISCv64RegAlloc::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"; + } +} + +std::string RISCv64RegAlloc::regIdToString(unsigned id) { + const unsigned offset = static_cast(PhysicalReg::PHYS_REG_START_ID); + + // 使用更健壮的检查方式 + if (id >= offset && precolored.count(id)) { + // 先减去偏移量，得到原始的、小的枚举值 + PhysicalReg reg = static_cast(id - offset); + // 再将原始枚举值传给 regToString + return regToString(reg); + } else { + return "%vreg" + std::to_string(id); + } +} + } // namespace sysy \ No newline at end of file diff --git a/src/include/backend/RISCv64/Handler/EliminateFrameIndices.h b/src/include/backend/RISCv64/Handler/EliminateFrameIndices.h new file mode 100644 index 0000000..155bdba --- /dev/null +++ b/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 \ No newline at end of file diff --git a/src/include/backend/RISCv64/RISCv64LLIR.h b/src/include/backend/RISCv64/RISCv64LLIR.h index be11528..2c2aec0 100644 --- a/src/include/backend/RISCv64/RISCv64LLIR.h +++ b/src/include/backend/RISCv64/RISCv64LLIR.h @@ -195,6 +195,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 +285,8 @@ struct StackFrameInfo { std::map alloca_offsets; // std::map spill_offsets; // <溢出vreg, 栈偏移> std::set used_callee_saved_regs; // 使用的保存寄存器 - std::map vreg_to_preg_map; - std::vector callee_saved_regs; // 用于存储需要保存的被调用者保存寄存器列表 + std::map vreg_to_preg_map; // [新增] RegAlloc最终的分配结果 + std::vector callee_saved_regs_to_store; // [新增] 已排序的、需要存取的被调用者保存寄存器 }; // 机器函数 diff --git a/src/include/backend/RISCv64/RISCv64Passes.h b/src/include/backend/RISCv64/RISCv64Passes.h index de08882..756be1d 100644 --- a/src/include/backend/RISCv64/RISCv64Passes.h +++ b/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 { diff --git a/src/include/backend/RISCv64/RISCv64RegAlloc.h b/src/include/backend/RISCv64/RISCv64RegAlloc.h index 992aa5c..caf8149 100644 --- a/src/include/backend/RISCv64/RISCv64RegAlloc.h +++ b/src/include/backend/RISCv64/RISCv64RegAlloc.h @@ -1,8 +1,14 @@ +// in file: RISCv64RegAlloc.h + #ifndef RISCV64_REGALLOC_H #define RISCV64_REGALLOC_H #include "RISCv64LLIR.h" #include "RISCv64ISel.h" // 包含 RISCv64ISel.h 以访问 ISel 和 Value 类型 +#include +#include +#include +#include extern int DEBUG; extern int DEEPDEBUG; @@ -17,58 +23,98 @@ public: void run(); private: - using LiveSet = std::set; // 活跃虚拟寄存器集合 - using InterferenceGraph = std::map>; + // 类型定义，与Python版本对应 + using VRegSet = std::set; + using InterferenceGraph = std::map; + using VRegStack = std::vector; // 使用vector模拟栈，方便遍历 + using MoveList = std::map>; + using AliasMap = std::map; + using ColorMap = std::map; + using VRegMoveSet = std::set; - // 栈帧管理 - 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 live_in_map; - std::map live_out_map; + RISCv64ISel* ISel; - // 干扰图 - InterferenceGraph interference_graph; - - // 图着色结果 - std::map color_map; // vreg -> preg - std::set spilled_vregs; // 被溢出的vreg集合 - - // 可用的物理寄存器池 + // --- 算法数据结构 --- + // 寄存器池 std::vector allocable_int_regs; std::vector allocable_fp_regs; + int K_int; // 整数寄存器数量 + int K_fp; // 浮点寄存器数量 - // 存储vreg到IR Value*的反向映射 - // 这个map将在run()函数开始时被填充，并在rewriteFunction()中使用。 - std::map vreg_to_value_map; - std::map 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 coalescedMoves; + std::set constrainedMoves; + std::set frozenMoves; + std::set worklistMoves; + std::set activeMoves; + + // 数据结构 + InterferenceGraph adjSet; + std::map adjList; // 邻接表 + std::map degree; + MoveList moveList; + AliasMap alias; + ColorMap color_map; + + // 活跃性分析结果 + std::map live_in_map; + std::map live_out_map; + // VReg -> Value* 和 VReg -> Type* 的映射 + const std::map& vreg_to_value_map; + const std::map& vreg_type_map; }; } // namespace sysy From f387aecc03a0e218001f0b00d5125a5d4f8d9583 Mon Sep 17 00:00:00 2001 From: Lixuanwang Date: Fri, 1 Aug 2025 02:47:40 +0800 Subject: [PATCH 02/55] =?UTF-8?q?[backend-IRC]=E8=BF=9B=E4=B8=80=E6=AD=A5?= =?UTF-8?q?=E6=9E=84=E5=BB=BA=E5=AF=84=E5=AD=98=E5=99=A8=E5=88=86=E9=85=8D?= =?UTF-8?q?=E9=80=BB=E8=BE=91?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../RISCv64/Handler/CalleeSavedHandler.cpp | 98 ++----- .../Handler/PrologueEpilogueInsertion.cpp | 277 ++++++++++++------ src/backend/RISCv64/RISCv64Backend.cpp | 41 ++- src/backend/RISCv64/RISCv64LLIR.cpp | 118 +++++++- src/backend/RISCv64/RISCv64RegAlloc.cpp | 2 +- src/include/backend/RISCv64/RISCv64LLIR.h | 3 +- 6 files changed, 360 insertions(+), 179 deletions(-) diff --git a/src/backend/RISCv64/Handler/CalleeSavedHandler.cpp b/src/backend/RISCv64/Handler/CalleeSavedHandler.cpp index b4cbc83..4ab73ea 100644 --- a/src/backend/RISCv64/Handler/CalleeSavedHandler.cpp +++ b/src/backend/RISCv64/Handler/CalleeSavedHandler.cpp @@ -8,10 +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; @@ -23,81 +19,33 @@ void CalleeSavedHandler::runOnMachineFunction(MachineFunction* mfunc) { if (used_callee_saved.empty()) { frame_info.callee_saved_size = 0; + frame_info.callee_saved_regs_to_store.clear(); return; } - // 1. 计算大小并排序，以便确定地生成代码 - frame_info.callee_saved_size = used_callee_saved.size() * 8; // 每个寄存器占8字节 - std::vector sorted_regs(used_callee_saved.begin(), used_callee_saved.end()); - std::sort(sorted_regs.begin(), sorted_regs.end(), [](PhysicalReg a, PhysicalReg b){ return static_cast(a) < static_cast(b); }); - frame_info.callee_saved_regs_to_store = sorted_regs; // 保存排序后的列表 - - // 2. 在函数序言中插入保存指令 - MachineBasicBlock* entry_block = mfunc->getBlocks().front().get(); - auto& entry_instrs = entry_block->getInstructions(); - auto insert_pos = entry_instrs.begin(); - // 确保插入在任何栈分配指令之后，但在其他代码之前。 - // PrologueEpilogueInsertionPass 会处理最终顺序，这里我们先插入。 - - std::vector> save_instrs; - int current_offset = -16; // 栈布局: [ra, s0] 在最顶层，然后是callee-saved - - for (PhysicalReg reg : sorted_regs) { - // s0/fp 已经在序言中由 PrologueEpilogueInsertionPass 特殊处理，这里跳过 - if (reg == PhysicalReg::S0) continue; - - current_offset -= 8; - RVOpcodes save_op = is_fp_reg(reg) ? RVOpcodes::FSD : RVOpcodes::SD; - - auto save_instr = std::make_unique(save_op); - save_instr->addOperand(std::make_unique(reg)); - save_instr->addOperand(std::make_unique( - std::make_unique(PhysicalReg::SP), // 基址为 SP - std::make_unique(0) // 偏移量将在PEI中修正 - )); - save_instrs.push_back(std::move(save_instr)); + // 1. 计算被调用者保存寄存器所需的总空间大小 + // s0 总是由 PEI Pass 单独处理，这里不计入大小，但要确保它在列表中 + int size = 0; + std::set regs_to_save = used_callee_saved; + if (regs_to_save.count(PhysicalReg::S0)) { + regs_to_save.erase(PhysicalReg::S0); } + size = regs_to_save.size() * 8; // 每个寄存器占8字节 (64-bit) + frame_info.callee_saved_size = size; - if (!save_instrs.empty()) { - // 在序言的开头插入保存指令（PEI会后续调整它们的偏移） - entry_instrs.insert(insert_pos, - std::make_move_iterator(save_instrs.begin()), - std::make_move_iterator(save_instrs.end())); - } + // 2. 创建一个有序的、需要保存的寄存器列表，以便后续 Pass 确定地生成代码 + // s0 不应包含在此列表中，因为它由 PEI Pass 特殊处理 + std::vector 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(a) < static_cast(b); + }); + frame_info.callee_saved_regs_to_store = sorted_regs; - // 3. 在函数结尾（ret之前）插入恢复指令 - for (auto& mbb : mfunc->getBlocks()) { - for (auto it = mbb->getInstructions().begin(); it != mbb->getInstructions().end(); ++it) { - if ((*it)->getOpcode() == RVOpcodes::RET) { - std::vector> restore_instrs; - current_offset = -16; - - // 以相反的顺序恢复寄存器 - for (auto reg_it = sorted_regs.rbegin(); reg_it != sorted_regs.rend(); ++reg_it) { - PhysicalReg reg = *reg_it; - if (reg == PhysicalReg::S0) continue; - - current_offset -= 8; - RVOpcodes restore_op = is_fp_reg(reg) ? RVOpcodes::FLD : RVOpcodes::LD; - - auto restore_instr = std::make_unique(restore_op); - restore_instr->addOperand(std::make_unique(reg)); - restore_instr->addOperand(std::make_unique( - std::make_unique(PhysicalReg::SP), - std::make_unique(0) // 偏移量同样由PEI修正 - )); - 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 \ No newline at end of file + +} // namespace sysy diff --git a/src/backend/RISCv64/Handler/PrologueEpilogueInsertion.cpp b/src/backend/RISCv64/Handler/PrologueEpilogueInsertion.cpp index 05532b7..86e3b30 100644 --- a/src/backend/RISCv64/Handler/PrologueEpilogueInsertion.cpp +++ b/src/backend/RISCv64/Handler/PrologueEpilogueInsertion.cpp @@ -1,6 +1,8 @@ #include "PrologueEpilogueInsertion.h" #include "RISCv64ISel.h" #include +#include +#include namespace sysy { @@ -8,7 +10,7 @@ char PrologueEpilogueInsertionPass::ID = 0; void PrologueEpilogueInsertionPass::runOnMachineFunction(MachineFunction* mfunc) { StackFrameInfo& frame_info = mfunc->getFrameInfo(); - + // 1. 删除 KEEPALIVE 伪指令 for (auto& mbb : mfunc->getBlocks()) { auto& instrs = mbb->getInstructions(); @@ -21,115 +23,200 @@ void PrologueEpilogueInsertionPass::runOnMachineFunction(MachineFunction* mfunc) instrs.end() ); } - - // 2. 计算最终的栈帧总大小 - // 总大小 = [ra, s0] + [被调用者保存寄存器] + [局部变量] + [溢出槽] + [调用其他函数的参数区] - // 假设调用参数区大小为0，因为它是在call指令周围动态分配和释放的 + + // 2. 计算最终的、对齐后的栈帧总大小 int total_stack_size = 16 + frame_info.callee_saved_size + frame_info.locals_size + frame_info.spill_size; - int aligned_stack_size = (total_stack_size + 15) & ~15; // 16字节对齐 + int aligned_stack_size = (total_stack_size + 15) & ~15; frame_info.total_size = aligned_stack_size; - // 只有在需要分配栈空间时才生成序言/尾声 - if (aligned_stack_size > 0) { - // --- 3. 插入序言 --- - MachineBasicBlock* entry_block = mfunc->getBlocks().front().get(); - auto& entry_instrs = entry_block->getInstructions(); - std::vector> prologue_instrs; + if (aligned_stack_size == 0) { + return; + } + + // --- 关键修正逻辑: 修正所有局部变量（即alloca）的偏移量 --- + // 这是最关键的一步，它解决了栈帧区域重叠的问题。 + // 在 EliminateFrameIndicesPass 运行时，它不知道 CalleeSavedHandler 后来会识别出 s1, s2 + // 并为其分配栈空间。因此，EliminateFrameIndicesPass 计算的偏移量是错误的。 + // 在这里，我们将偏移量向低地址方向整体移动，为 callee-saved 寄存器和溢出槽腾出空间。 + int callee_saved_and_spill_size = frame_info.callee_saved_size + frame_info.spill_size; + if (callee_saved_and_spill_size > 0) { + // 遍历所有局部变量的偏移量 Map，并进行修正 + for (auto& pair : mfunc->getFrameInfo().alloca_offsets) { + int old_offset = pair.second; // 初始偏移量（例如 -24） + int new_offset = old_offset - callee_saved_and_spill_size; + pair.second = new_offset; // 更新为修正后的偏移量 + } - // a. addi sp, sp, -aligned_stack_size - auto alloc_stack = std::make_unique(RVOpcodes::ADDI); - alloc_stack->addOperand(std::make_unique(PhysicalReg::SP)); - alloc_stack->addOperand(std::make_unique(PhysicalReg::SP)); - alloc_stack->addOperand(std::make_unique(-aligned_stack_size)); - prologue_instrs.push_back(std::move(alloc_stack)); - - // b. sd ra, (aligned_stack_size - 8)(sp) - auto save_ra = std::make_unique(RVOpcodes::SD); - save_ra->addOperand(std::make_unique(PhysicalReg::RA)); - save_ra->addOperand(std::make_unique( - std::make_unique(PhysicalReg::SP), - std::make_unique(aligned_stack_size - 8) - )); - prologue_instrs.push_back(std::move(save_ra)); - - // c. sd s0, (aligned_stack_size - 16)(sp) - auto save_fp = std::make_unique(RVOpcodes::SD); - save_fp->addOperand(std::make_unique(PhysicalReg::S0)); - save_fp->addOperand(std::make_unique( - std::make_unique(PhysicalReg::SP), - std::make_unique(aligned_stack_size - 16) - )); - prologue_instrs.push_back(std::move(save_fp)); - - // d. addi s0, sp, aligned_stack_size - auto set_fp = std::make_unique(RVOpcodes::ADDI); - set_fp->addOperand(std::make_unique(PhysicalReg::S0)); - set_fp->addOperand(std::make_unique(PhysicalReg::SP)); - set_fp->addOperand(std::make_unique(aligned_stack_size)); - prologue_instrs.push_back(std::move(set_fp)); - - // 将序言指令插入到函数入口 - entry_instrs.insert(entry_instrs.begin(), - std::make_move_iterator(prologue_instrs.begin()), - std::make_move_iterator(prologue_instrs.end())); - - // --- 4. 插入尾声 --- + // 重新遍历函数中的所有指令，用修正后的偏移量替换旧的立即数 for (auto& mbb : mfunc->getBlocks()) { - for (auto it = mbb->getInstructions().begin(); it != mbb->getInstructions().end(); ++it) { - if ((*it)->getOpcode() == RVOpcodes::RET) { - std::vector> epilogue_instrs; + for (auto& instr : mbb->getInstructions()) { + // 我们只修正那些使用立即数作为偏移量的内存访问指令 + if (instr->getOpcode() == RVOpcodes::ADDI) { + // ADDI 指令可能有 `addi rd, s0, offset` 的形式 + // 操作数是 [rd, s0, offset]，我们需要检查第2个操作数(s0)并修改第3个(offset) + if (instr->getOperands().size() > 2) { + if (auto reg_op = dynamic_cast(instr->getOperands()[1].get())) { + if (reg_op->getPReg() == PhysicalReg::S0) { + if (auto imm_op = dynamic_cast(instr->getOperands()[2].get())) { + // ImmOperand 是不可变的, 所以我们创建一个新的来替换它 + int64_t old_imm = imm_op->getValue(); + instr->getOperands()[2] = std::make_unique(old_imm - callee_saved_and_spill_size); + } + } + } + } + } else if (instr->getOpcode() == RVOpcodes::LD || instr->getOpcode() == RVOpcodes::SD || + instr->getOpcode() == RVOpcodes::FLW || instr->getOpcode() == RVOpcodes::FSW || + instr->getOpcode() == RVOpcodes::FLD || instr->getOpcode() == RVOpcodes::FSD) { + // Load/Store 指令的操作数是 [rd, MemOperand] + // 我们需要检查 MemOperand 的基址寄存器是否为 s0 + if (instr->getOperands().size() > 1) { + if (auto mem_op = dynamic_cast(instr->getOperands()[1].get())) { + if (mem_op->getBase() && mem_op->getBase()->getPReg() == PhysicalReg::S0) { + // MemOperand 和 ImmOperand 都是不可变的, 我们必须重新构建整个 MemOperand + RegOperand* base_reg_op = mem_op->getBase(); + ImmOperand* offset_op = mem_op->getOffset(); - // a. ld ra - auto restore_ra = std::make_unique(RVOpcodes::LD); - restore_ra->addOperand(std::make_unique(PhysicalReg::RA)); - restore_ra->addOperand(std::make_unique( - std::make_unique(PhysicalReg::SP), - std::make_unique(aligned_stack_size - 8) - )); - epilogue_instrs.push_back(std::move(restore_ra)); + if (base_reg_op && offset_op) { + int64_t old_offset = offset_op->getValue(); + int64_t new_offset = old_offset - callee_saved_and_spill_size; - // b. ld s0 - auto restore_fp = std::make_unique(RVOpcodes::LD); - restore_fp->addOperand(std::make_unique(PhysicalReg::S0)); - restore_fp->addOperand(std::make_unique( - std::make_unique(PhysicalReg::SP), - std::make_unique(aligned_stack_size - 16) - )); - epilogue_instrs.push_back(std::move(restore_fp)); - - // c. addi sp, sp, aligned_stack_size - auto dealloc_stack = std::make_unique(RVOpcodes::ADDI); - dealloc_stack->addOperand(std::make_unique(PhysicalReg::SP)); - dealloc_stack->addOperand(std::make_unique(PhysicalReg::SP)); - dealloc_stack->addOperand(std::make_unique(aligned_stack_size)); - epilogue_instrs.push_back(std::move(dealloc_stack)); - - mbb->getInstructions().insert(it, - std::make_move_iterator(epilogue_instrs.begin()), - std::make_move_iterator(epilogue_instrs.end())); - it++; // 跳过刚插入的指令和原有的RET - goto next_block; + // 重新创建基址寄存器操作数 (必须处理虚拟/物理寄存器) + std::unique_ptr new_base; + if (base_reg_op->isVirtual()) { + new_base = std::make_unique(base_reg_op->getVRegNum()); + } else { + new_base = std::make_unique(base_reg_op->getPReg()); + } + + // 创建新的偏移立即数操作数 + auto new_offset_imm = std::make_unique(new_offset); + + // 用新创建的 MemOperand 替换旧的 + instr->getOperands()[1] = std::make_unique(std::move(new_base), std::move(new_offset_imm)); + } + } + } + } } } - next_block:; } } - // --- 5. [新增] 修正所有基于S0的内存访问偏移量 --- - // CalleeSaved, Alloca, Spill 的偏移量都是相对于S0的负向偏移 + // --- 3. 插入完整的序言 --- + MachineBasicBlock* entry_block = mfunc->getBlocks().front().get(); + auto& entry_instrs = entry_block->getInstructions(); + std::vector> prologue_instrs; + + // a. addi sp, sp, -aligned_stack_size + auto alloc_stack = std::make_unique(RVOpcodes::ADDI); + alloc_stack->addOperand(std::make_unique(PhysicalReg::SP)); + alloc_stack->addOperand(std::make_unique(PhysicalReg::SP)); + alloc_stack->addOperand(std::make_unique(-aligned_stack_size)); + prologue_instrs.push_back(std::move(alloc_stack)); + + // b. sd ra, (aligned_stack_size - 8)(sp) + auto save_ra = std::make_unique(RVOpcodes::SD); + save_ra->addOperand(std::make_unique(PhysicalReg::RA)); + save_ra->addOperand(std::make_unique( + std::make_unique(PhysicalReg::SP), + std::make_unique(aligned_stack_size - 8) + )); + prologue_instrs.push_back(std::move(save_ra)); + + // c. sd s0, (aligned_stack_size - 16)(sp) + auto save_fp = std::make_unique(RVOpcodes::SD); + save_fp->addOperand(std::make_unique(PhysicalReg::S0)); + save_fp->addOperand(std::make_unique( + std::make_unique(PhysicalReg::SP), + std::make_unique(aligned_stack_size - 16) + )); + prologue_instrs.push_back(std::move(save_fp)); + + // d. 保存所有其他的被调用者保存寄存器，并记录它们的偏移量 + std::map callee_saved_offsets; + int current_offset = aligned_stack_size - 16; + for (PhysicalReg reg : frame_info.callee_saved_regs_to_store) { + current_offset -= 8; + callee_saved_offsets[reg] = current_offset; // 记录偏移量 + RVOpcodes save_op = (reg >= PhysicalReg::F0 && reg <= PhysicalReg::F31) ? RVOpcodes::FSD : RVOpcodes::SD; + + auto save_reg = std::make_unique(save_op); + save_reg->addOperand(std::make_unique(reg)); + save_reg->addOperand(std::make_unique( + std::make_unique(PhysicalReg::SP), + std::make_unique(current_offset) + )); + prologue_instrs.push_back(std::move(save_reg)); + } + + // e. addi s0, sp, aligned_stack_size + auto set_fp = std::make_unique(RVOpcodes::ADDI); + set_fp->addOperand(std::make_unique(PhysicalReg::S0)); + set_fp->addOperand(std::make_unique(PhysicalReg::SP)); + set_fp->addOperand(std::make_unique(aligned_stack_size)); + prologue_instrs.push_back(std::move(set_fp)); + + entry_instrs.insert(entry_instrs.begin(), + std::make_move_iterator(prologue_instrs.begin()), + std::make_move_iterator(prologue_instrs.end())); + + // --- 4. 插入完整的尾声 --- for (auto& mbb : mfunc->getBlocks()) { - for (auto& instr : mbb->getInstructions()) { - if (instr->getOperands().empty() || instr->getOperands().back()->getKind() != MachineOperand::KIND_MEM) { - continue; + for (auto it = mbb->getInstructions().begin(); it != mbb->getInstructions().end(); ++it) { + if ((*it)->getOpcode() == RVOpcodes::RET) { + std::vector> epilogue_instrs; + + // a. [关键修正] 恢复所有其他的被调用者保存寄存器 (以相反顺序) + const auto& regs_to_restore = frame_info.callee_saved_regs_to_store; + for (auto reg_it = regs_to_restore.rbegin(); reg_it != regs_to_restore.rend(); ++reg_it) { + PhysicalReg reg = *reg_it; + int offset = callee_saved_offsets.at(reg); // 使用之前记录的正确偏移量 + RVOpcodes restore_op = (reg >= PhysicalReg::F0 && reg <= PhysicalReg::F31) ? RVOpcodes::FLD : RVOpcodes::LD; + + auto restore_reg = std::make_unique(restore_op); + restore_reg->addOperand(std::make_unique(reg)); + restore_reg->addOperand(std::make_unique( + std::make_unique(PhysicalReg::SP), + std::make_unique(offset) + )); + epilogue_instrs.push_back(std::move(restore_reg)); + } + + // b. ld ra + auto restore_ra = std::make_unique(RVOpcodes::LD); + restore_ra->addOperand(std::make_unique(PhysicalReg::RA)); + restore_ra->addOperand(std::make_unique( + std::make_unique(PhysicalReg::SP), + std::make_unique(aligned_stack_size - 8) + )); + epilogue_instrs.push_back(std::move(restore_ra)); + + // c. ld s0 + auto restore_fp = std::make_unique(RVOpcodes::LD); + restore_fp->addOperand(std::make_unique(PhysicalReg::S0)); + restore_fp->addOperand(std::make_unique( + std::make_unique(PhysicalReg::SP), + std::make_unique(aligned_stack_size - 16) + )); + epilogue_instrs.push_back(std::move(restore_fp)); + + // d. addi sp, sp, aligned_stack_size + auto dealloc_stack = std::make_unique(RVOpcodes::ADDI); + dealloc_stack->addOperand(std::make_unique(PhysicalReg::SP)); + dealloc_stack->addOperand(std::make_unique(PhysicalReg::SP)); + dealloc_stack->addOperand(std::make_unique(aligned_stack_size)); + epilogue_instrs.push_back(std::move(dealloc_stack)); + + mbb->getInstructions().insert(it, + std::make_move_iterator(epilogue_instrs.begin()), + std::make_move_iterator(epilogue_instrs.end())); + + goto next_block; } - auto mem_op = static_cast(instr->getOperands().back().get()); - if (mem_op->getBase()->isVirtual() || mem_op->getBase()->getPReg() != PhysicalReg::S0) { - continue; - } - // 此时所有基于S0的偏移量都是负数，无需再次调整 - // 之前的RegAlloc/CalleeSavedHandler已经计算好了正确的相对于S0的偏移 } + next_block:; } } -} // namespace sysy \ No newline at end of file +} // namespace sysy diff --git a/src/backend/RISCv64/RISCv64Backend.cpp b/src/backend/RISCv64/RISCv64Backend.cpp index 3841eec..477fe42 100644 --- a/src/backend/RISCv64/RISCv64Backend.cpp +++ b/src/backend/RISCv64/RISCv64Backend.cpp @@ -116,41 +116,70 @@ std::string RISCv64CodeGen::function_gen(Function* 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 = 1; + // DEEPDEBUG = 1; if (DEBUG) { - RISCv64AsmPrinter printer_isel(mfunc.get()); - printer_isel.run(ss_after_isel, true); - std::cout << ss_after_isel.str(); + 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); + } + // // 阶段 2: 指令调度 (Instruction Scheduling) // PreRA_Scheduler scheduler; // scheduler.runOnMachineFunction(mfunc.get()); + DEBUG = 0; + DEEPDEBUG = 0; // 阶段 3: 物理寄存器分配 (Register Allocation) RISCv64RegAlloc reg_alloc(mfunc.get()); reg_alloc.run(); + // 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()); + // 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()); diff --git a/src/backend/RISCv64/RISCv64LLIR.cpp b/src/backend/RISCv64/RISCv64LLIR.cpp index 3816ad1..0a09d37 100644 --- a/src/backend/RISCv64/RISCv64LLIR.cpp +++ b/src/backend/RISCv64/RISCv64LLIR.cpp @@ -1,6 +1,122 @@ #include "RISCv64LLIR.h" #include +#include // 用于 std::ostream 和 std::cerr +#include // 用于 std::string namespace sysy { -} \ No newline at end of file +// 辅助函数：将 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"; +} + +} diff --git a/src/backend/RISCv64/RISCv64RegAlloc.cpp b/src/backend/RISCv64/RISCv64RegAlloc.cpp index 64ff4ef..234bccf 100644 --- a/src/backend/RISCv64/RISCv64RegAlloc.cpp +++ b/src/backend/RISCv64/RISCv64RegAlloc.cpp @@ -1108,7 +1108,7 @@ void RISCv64RegAlloc::combine(unsigned u, unsigned v) { moveList[u] = moveList.at(v); } enableMoves({v}); - for (unsigned t : adjacent(v)) { + for (unsigned t : adjList.at(v)) { addEdge(t, u); decrementDegree(t); } diff --git a/src/include/backend/RISCv64/RISCv64LLIR.h b/src/include/backend/RISCv64/RISCv64LLIR.h index 2c2aec0..1931617 100644 --- a/src/include/backend/RISCv64/RISCv64LLIR.h +++ b/src/include/backend/RISCv64/RISCv64LLIR.h @@ -3,6 +3,7 @@ #include "IR.h" // 确保包含了您自己的IR头文件 #include +#include #include #include #include @@ -300,7 +301,7 @@ public: StackFrameInfo& getFrameInfo() { return frame_info; } const std::vector>& getBlocks() const { return blocks; } std::vector>& getBlocks() { return blocks; } - + void dumpStackFrameInfo(std::ostream& os = std::cerr) const; void addBlock(std::unique_ptr block) { blocks.push_back(std::move(block)); } From 873dbf64d08564cbf6a07796472d6edda453e380 Mon Sep 17 00:00:00 2001 From: Lixuanwang Date: Fri, 1 Aug 2025 04:44:13 +0800 Subject: [PATCH 03/55] =?UTF-8?q?[backend-IRC]=E5=9F=BA=E6=9C=AC=E6=9E=84?= =?UTF-8?q?=E5=BB=BA=E4=BA=86IRC?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/backend/RISCv64/RISCv64Backend.cpp | 6 +- src/backend/RISCv64/RISCv64RegAlloc.cpp | 261 +++++++++++++++++------- 2 files changed, 186 insertions(+), 81 deletions(-) diff --git a/src/backend/RISCv64/RISCv64Backend.cpp b/src/backend/RISCv64/RISCv64Backend.cpp index 477fe42..ae1beb6 100644 --- a/src/backend/RISCv64/RISCv64Backend.cpp +++ b/src/backend/RISCv64/RISCv64Backend.cpp @@ -121,6 +121,8 @@ std::string RISCv64CodeGen::function_gen(Function* func) { // if (DEBUG) { // std::cout << ss_after_isel.str(); // } + // DEBUG = 0; + // DEEPDEBUG = 0; // DEBUG = 1; // DEEPDEBUG = 1; if (DEBUG) { @@ -143,8 +145,8 @@ std::string RISCv64CodeGen::function_gen(Function* func) { // PreRA_Scheduler scheduler; // scheduler.runOnMachineFunction(mfunc.get()); - DEBUG = 0; - DEEPDEBUG = 0; + // DEBUG = 0; + // DEEPDEBUG = 0; // 阶段 3: 物理寄存器分配 (Register Allocation) RISCv64RegAlloc reg_alloc(mfunc.get()); reg_alloc.run(); diff --git a/src/backend/RISCv64/RISCv64RegAlloc.cpp b/src/backend/RISCv64/RISCv64RegAlloc.cpp index 234bccf..763f401 100644 --- a/src/backend/RISCv64/RISCv64RegAlloc.cpp +++ b/src/backend/RISCv64/RISCv64RegAlloc.cpp @@ -255,20 +255,20 @@ void RISCv64RegAlloc::build() { RISCv64AsmPrinter printer_inside_build(MFunc); printer_inside_build.setStream(std::cerr); + // 1. 收集所有待分配的（既非物理也非预着色）虚拟寄存器到 initial 集合 for (const auto& mbb_ptr : MFunc->getBlocks()) { for (const auto& instr_ptr : mbb_ptr->getInstructions()) { const MachineInstr* instr = instr_ptr.get(); VRegSet use, def; getInstrUseDef_Liveness(instr, use, def); - // 调试输出 use 和 def + // 调试输出 use 和 def (保留您的调试逻辑) if (DEEPDEBUG) { std::cerr << "Instr:"; printer_inside_build.printInstruction(instr_ptr.get(), true); - // 修改 lambda 以捕获 this 指针，从而可以调用成员函数 auto print_set = [this](const VRegSet& s, const std::string& name) { std::cerr << " " << name << ": { "; - for(unsigned v : s) std::cerr << regIdToString(v) << " "; // 使用新函数 + for(unsigned v : s) std::cerr << regIdToString(v) << " "; std::cerr << "}\n"; }; print_set(def, "Def "); @@ -276,17 +276,26 @@ void RISCv64RegAlloc::build() { } for (unsigned v : use) { - if (!coloredNodes.count(v)) { + if (!coloredNodes.count(v) && !precolored.count(v)) { initial.insert(v); } else if (DEEPDEBUG) { - std::cerr << "Skipping %vreg" << v << " because it is in coloredNodes.\n"; + // 这里的调试信息可以更精确 + if (precolored.count(v)) { + std::cerr << "Skipping " << regIdToString(v) << " because it is a physical register.\n"; + } else { + std::cerr << "Skipping " << regIdToString(v) << " because it is a pre-colored virtual register.\n"; + } } } for (unsigned v : def) { - if (!coloredNodes.count(v)) { + if (!coloredNodes.count(v) && !precolored.count(v)) { initial.insert(v); } else if (DEEPDEBUG) { - std::cerr << "Skipping %vreg" << v << " because it is in coloredNodes.\n"; + if (precolored.count(v)) { + std::cerr << "Skipping " << regIdToString(v) << " because it is a physical register.\n"; + } else { + std::cerr << "Skipping " << regIdToString(v) << " because it is a pre-colored virtual register.\n"; + } } } } @@ -294,17 +303,25 @@ void RISCv64RegAlloc::build() { if (DEEPDEBUG) { std::cerr << "Initial set after build: { "; - for (unsigned v : initial) std::cerr << "%vreg" << v << " "; + for (unsigned v : initial) std::cerr << regIdToString(v) << " "; std::cerr << "}\n"; } - for(unsigned vreg : initial) { + // 2. 为所有参与图构建的虚拟寄存器（initial + coloredNodes）初始化数据结构 + VRegSet all_participating_vregs = initial; + all_participating_vregs.insert(coloredNodes.begin(), coloredNodes.end()); + + for (unsigned vreg : all_participating_vregs) { + // 物理寄存器ID不应作为key，此检查是安全的双重保障 + const unsigned offset = static_cast(PhysicalReg::PHYS_REG_START_ID); + if (vreg >= offset) { + continue; + } adjList[vreg] = {}; degree[vreg] = 0; - moveList[vreg] = {}; - // alias[vreg] = vreg; } + // 3. 构建冲突图 for (const auto& mbb_ptr : MFunc->getBlocks()) { if (DEEPDEBUG) std::cerr << "\n--- Building Graph for Basic Block: " << mbb_ptr->getName() << " ---\n"; for (const auto& instr_ptr : mbb_ptr->getInstructions()) { @@ -313,8 +330,8 @@ void RISCv64RegAlloc::build() { getInstrUseDef_Liveness(instr, use, def); const VRegSet& live_out = live_out_map.at(instr); + // 保留您的指令级调试输出 if (DEEPDEBUG) { - // 使用临时的 AsmPrinter 打印当前指令，便于观察 RISCv64AsmPrinter temp_printer(MFunc); temp_printer.setStream(std::cerr); std::cerr << "Instr: "; @@ -322,7 +339,7 @@ void RISCv64RegAlloc::build() { auto print_set = [this](const VRegSet& s, const std::string& name) { std::cerr << " " << name << ": { "; - for(unsigned v : s) std::cerr << regIdToString(v) << " "; // 使用新函数 + for(unsigned v : s) std::cerr << regIdToString(v) << " "; std::cerr << "}\n"; }; print_set(def, "Def "); @@ -333,46 +350,54 @@ void RISCv64RegAlloc::build() { bool is_move = instr->getOpcode() == RVOpcodes::MV; + // 保留您处理 moveList 的逻辑 if (is_move) { worklistMoves.insert(instr); VRegSet move_vregs; - for(const auto& op : instr->getOperands()) { + for(const auto& op : instr->getOperands()) { if (op->getKind() == MachineOperand::KIND_REG) { - auto reg_op = static_cast(op.get()); - if(reg_op->isVirtual()) move_vregs.insert(reg_op->getVRegNum()); + auto reg_op = static_cast(op.get()); + if(reg_op->isVirtual()) move_vregs.insert(reg_op->getVRegNum()); } } for (unsigned vreg : move_vregs) { + // 使用 operator[] 是安全的，如果vreg不存在会默认构造 moveList[vreg].insert(instr); } } - // --- 规则 1: Def 与 Live_Out 变量干扰 --- VRegSet live = live_out; if (is_move) { - for (unsigned u : use) { - live.erase(u); - } - } - for (unsigned d : def) { - for (unsigned l : live) { - addEdge(d, l); + for (unsigned u_op : use) { + live.erase(u_op); } } - // --- [新增的关键逻辑] 规则 2: 对于非move指令，强制def和use互相干扰 --- - // 这可以防止指令内部的源寄存器被目标寄存器错误地覆盖 - if (!is_move) { - for (unsigned d : def) { - for (unsigned u : use) { - addEdge(d, u); + // --- 规则 1 & 2: Def 与 Live/Use 变量干扰 --- + for (unsigned d : def) { + // [关键修正] Def必须是虚拟寄存器 + if (precolored.count(d)) continue; + + for (unsigned l : live) { + addEdge(d, l); + } + + if (!is_move) { + for (unsigned u_op : use) { + addEdge(d, u_op); } } } + + // --- 规则 3: Live_Out 集合内部的【虚拟寄存器】形成完全图 --- + // [优化与修正] 使用更高效的遍历，避免重复调用 addEdge(A,B) 和 addEdge(B,A) + for (auto it1 = live_out.begin(); it1 != live_out.end(); ++it1) { + unsigned l1 = *it1; + // [关键修正] 只为虚拟寄存器 l1 添加边 + if (precolored.count(l1)) continue; - // --- 规则 3: Live_Out 集合内部形成完全图 --- - for (unsigned l1 : live_out) { - for (unsigned l2 : live_out) { + for (auto it2 = std::next(it1); it2 != live_out.end(); ++it2) { + unsigned l2 = *it2; addEdge(l1, l2); } } @@ -552,6 +577,8 @@ void RISCv64RegAlloc::selectSpill() { void RISCv64RegAlloc::assignColors() { if (DEEPDEBUG) std::cerr << "[AssignColors] Starting...\n"; + + // 步骤 1: 完整处理 selectStack while (!selectStack.empty()) { unsigned n = selectStack.back(); selectStack.pop_back(); @@ -559,12 +586,8 @@ void RISCv64RegAlloc::assignColors() { const auto& available_regs = is_fp ? allocable_fp_regs : allocable_int_regs; std::set ok_colors(available_regs.begin(), available_regs.end()); - // 遍历 n 的所有邻居 w for (unsigned w : adjList.at(n)) { unsigned w_alias = getAlias(w); - - // [关键修正] 邻居 w 可能是一个已着色的虚拟寄存器， - // 或者它本身就是一个物理寄存器。两种情况都要处理！ bool is_colored_vreg = coloredNodes.count(w_alias); bool is_physical_reg = precolored.count(w_alias); const unsigned offset = static_cast(PhysicalReg::PHYS_REG_START_ID); @@ -572,10 +595,8 @@ void RISCv64RegAlloc::assignColors() { if (is_colored_vreg || is_physical_reg) { PhysicalReg neighbor_color; if (is_colored_vreg) { - // 如果是已着色的vreg，从 color_map 获取它的颜色 neighbor_color = color_map.at(w_alias); } else { - // 如果是物理寄存器，它的ID就是它的颜色 neighbor_color = static_cast(w_alias - offset); } ok_colors.erase(neighbor_color); @@ -589,18 +610,28 @@ void RISCv64RegAlloc::assignColors() { PhysicalReg c = *ok_colors.begin(); coloredNodes.insert(n); color_map[n] = c; - if (DEEPDEBUG) std::cerr << " -> Colored %vreg" << n << " with " << regToString(c) << " (ID: " << static_cast(c) << ").\n"; + if (DEEPDEBUG) std::cerr << " -> Colored %vreg" << n << " with " << regToString(c) << ".\n"; } } - // 为合并的节点上色（这部分逻辑是正确的） + // 步骤 2: 独立、完整地处理 coalescedNodes for (unsigned n : coalescedNodes) { unsigned root_alias = getAlias(n); - if (color_map.count(root_alias)) { + + // 情况 1: 别名是物理寄存器，直接获得该颜色 + if (precolored.count(root_alias)) { + const unsigned offset = static_cast(PhysicalReg::PHYS_REG_START_ID); + color_map[n] = static_cast(root_alias - offset); + if (DEEPDEBUG) std::cerr << " -> Coalesced " << regIdToString(n) << " gets color from physical alias " << regIdToString(root_alias) << ".\n"; + } + // 情况 2: 别名是虚拟寄存器，且在步骤1中已被成功着色 + else if (color_map.count(root_alias)) { color_map[n] = color_map.at(root_alias); - if (DEEPDEBUG) std::cerr << " -> Coalesced " << regIdToString(n) << " gets color of alias " << regIdToString(root_alias) << ".\n"; - } else { - if (DEEPDEBUG) std::cerr << " -> No color for alias of %vreg" << n << ". Spilling.\n"; + if (DEEPDEBUG) std::cerr << " -> Coalesced " << regIdToString(n) << " gets color of virtual alias " << regIdToString(root_alias) << ".\n"; + } + // 情况 3: 别名是虚拟寄存器，但在步骤1中未能着色（即被溢出） + else { + if (DEEPDEBUG) std::cerr << " -> Alias " << regIdToString(root_alias) << " of %vreg" << n << " was spilled. Spilling.\n"; spilledNodes.insert(n); } } @@ -798,14 +829,16 @@ void RISCv64RegAlloc::getInstrUseDef(const MachineInstr* instr, VRegSet& use, VR } /** - * @brief [新增] 获取一条指令完整的、包含物理寄存器的Use/Def集合 + * @brief [已修复] 获取一条指令完整的、包含物理寄存器的Use/Def集合 * 这个新函数将专门服务于活跃性分析。 */ void RISCv64RegAlloc::getInstrUseDef_Liveness(const MachineInstr* instr, VRegSet& use, VRegSet& def) { auto opcode = instr->getOpcode(); const auto& operands = instr->getOperands(); + // 映射表：指令操作码 -> {Def操作数索引列表, Use操作数索引列表} static const std::map, std::vector>> op_info = { + // ===== 已有指令定义 (保留) ===== {RVOpcodes::ADD, {{0}, {1, 2}}}, {RVOpcodes::SUB, {{0}, {1, 2}}}, {RVOpcodes::MUL, {{0}, {1, 2}}}, {RVOpcodes::DIV, {{0}, {1, 2}}}, {RVOpcodes::REM, {{0}, {1, 2}}}, {RVOpcodes::ADDW, {{0}, {1, 2}}}, {RVOpcodes::SUBW, {{0}, {1, 2}}}, {RVOpcodes::MULW, {{0}, {1, 2}}}, {RVOpcodes::DIVW, {{0}, {1, 2}}}, @@ -820,14 +853,42 @@ void RISCv64RegAlloc::getInstrUseDef_Liveness(const MachineInstr* instr, VRegSet {RVOpcodes::BNE, {{}, {0, 1}}}, {RVOpcodes::BLT, {{}, {0, 1}}}, {RVOpcodes::BGE, {{}, {0, 1}}}, {RVOpcodes::JALR, {{0}, {1}}}, {RVOpcodes::LI, {{0}, {}}}, {RVOpcodes::LA, {{0}, {}}}, {RVOpcodes::MV, {{0}, {1}}}, {RVOpcodes::SEQZ, {{0}, {1}}}, {RVOpcodes::SNEZ, {{0}, {1}}}, - {RVOpcodes::RET, {{}, {static_cast(PhysicalReg::A0), static_cast(PhysicalReg::F10)}}}, - {RVOpcodes::FADD_S, {{0}, {1, 2}}}, {RVOpcodes::FSUB_S, {{0}, {1, 2}}}, {RVOpcodes::FMUL_S, {{0}, {1, 2}}}, - {RVOpcodes::FDIV_S, {{0}, {1, 2}}}, {RVOpcodes::FEQ_S, {{0}, {1, 2}}}, {RVOpcodes::FLT_S, {{0}, {1, 2}}}, - {RVOpcodes::FLE_S, {{0}, {1, 2}}}, {RVOpcodes::FCVT_S_W, {{0}, {1}}}, {RVOpcodes::FCVT_W_S, {{0}, {1}}}, - {RVOpcodes::FMV_S, {{0}, {1}}}, {RVOpcodes::FMV_W_X, {{0}, {1}}}, {RVOpcodes::FMV_X_W, {{0}, {1}}}, - {RVOpcodes::FNEG_S, {{0}, {1}}} + {RVOpcodes::FADD_S, {{0}, {1, 2}}}, {RVOpcodes::FSUB_S, {{0}, {1, 2}}}, + {RVOpcodes::FMUL_S, {{0}, {1, 2}}}, {RVOpcodes::FDIV_S, {{0}, {1, 2}}}, {RVOpcodes::FEQ_S, {{0}, {1, 2}}}, + {RVOpcodes::FLT_S, {{0}, {1, 2}}}, {RVOpcodes::FLE_S, {{0}, {1, 2}}}, {RVOpcodes::FCVT_S_W, {{0}, {1}}}, + {RVOpcodes::FCVT_W_S, {{0}, {1}}}, {RVOpcodes::FMV_S, {{0}, {1}}}, {RVOpcodes::FMV_W_X, {{0}, {1}}}, + {RVOpcodes::FMV_X_W, {{0}, {1}}}, {RVOpcodes::FNEG_S, {{0}, {1}}}, + + // ===== 新增的指令定义开始 ===== + + // --- 逻辑指令 --- + {RVOpcodes::XOR, {{0}, {1, 2}}}, + {RVOpcodes::OR, {{0}, {1, 2}}}, + {RVOpcodes::AND, {{0}, {1, 2}}}, + {RVOpcodes::ORI, {{0}, {1}}}, + {RVOpcodes::ANDI, {{0}, {1}}}, + + // --- 移位指令 --- + {RVOpcodes::SLL, {{0}, {1, 2}}}, {RVOpcodes::SLLI, {{0}, {1}}}, + {RVOpcodes::SLLW, {{0}, {1, 2}}}, {RVOpcodes::SLLIW, {{0}, {1}}}, + {RVOpcodes::SRL, {{0}, {1, 2}}}, {RVOpcodes::SRLI, {{0}, {1}}}, + {RVOpcodes::SRLW, {{0}, {1, 2}}}, {RVOpcodes::SRLIW, {{0}, {1}}}, + {RVOpcodes::SRA, {{0}, {1, 2}}}, {RVOpcodes::SRAI, {{0}, {1}}}, + {RVOpcodes::SRAW, {{0}, {1, 2}}}, {RVOpcodes::SRAIW, {{0}, {1}}}, + + // --- 控制流指令 (补全) --- + {RVOpcodes::BLTU, {{}, {0, 1}}}, + {RVOpcodes::BGEU, {{}, {0, 1}}}, + // J 没有寄存器操作数，JAL 由CALL指令类似的特殊逻辑处理 + + // --- 伪指令 (补全) --- + {RVOpcodes::NEG, {{0}, {1}}}, + {RVOpcodes::NEGW, {{0}, {1}}}, + + // ===== 新增的指令定义结束 ===== }; + // 该lambda表达式用于获取操作数的寄存器ID（虚拟或物理），逻辑正确，保持不变 const unsigned offset = static_cast(PhysicalReg::PHYS_REG_START_ID); auto get_any_reg_id = [&](const MachineOperand* op) -> unsigned { if (op->getKind() == MachineOperand::KIND_REG) { @@ -843,39 +904,78 @@ void RISCv64RegAlloc::getInstrUseDef_Liveness(const MachineInstr* instr, VRegSet if (op_info.count(opcode)) { const auto& info = op_info.at(opcode); - for (int idx : info.first) if (idx < operands.size()) def.insert(get_any_reg_id(operands[idx].get())); - for (int idx : info.second) if (idx < operands.size()) use.insert(get_any_reg_id(operands[idx].get())); - for (const auto& op : operands) if (op->getKind() == MachineOperand::KIND_MEM) use.insert(get_any_reg_id(op.get())); - } else if (opcode == RVOpcodes::CALL) { - if (!operands.empty() && operands[0]->getKind() == MachineOperand::KIND_REG) def.insert(get_any_reg_id(operands[0].get())); - for (size_t i = 1; i < operands.size(); ++i) if (operands[i]->getKind() == MachineOperand::KIND_REG) use.insert(get_any_reg_id(operands[i].get())); - for (auto preg : getCallerSavedIntRegs()) def.insert(static_cast(preg)); - for (auto preg : getCallerSavedFpRegs()) def.insert(static_cast(preg)); - def.insert(static_cast(PhysicalReg::RA)); + for (int idx : info.first) if (idx < operands.size()) { + unsigned reg_id = get_any_reg_id(operands[idx].get()); + if (reg_id != (unsigned)-1) def.insert(reg_id); + } + for (int idx : info.second) if (idx < operands.size()) { + unsigned reg_id = get_any_reg_id(operands[idx].get()); + if (reg_id != (unsigned)-1) use.insert(reg_id); + } + // 不要忘记内存操作数中的基址寄存器永远是use + for (const auto& op : operands) { + if (op->getKind() == MachineOperand::KIND_MEM) { + unsigned reg_id = get_any_reg_id(op.get()); + if (reg_id != (unsigned)-1) use.insert(reg_id); + } + } + } + // CALL 和 RET 的特殊处理逻辑，保持不变 + else if (opcode == RVOpcodes::CALL) { + // 返回值是Def + if (!operands.empty() && operands[0]->getKind() == MachineOperand::KIND_REG) { + def.insert(get_any_reg_id(operands[0].get())); + } + // 函数名后的所有寄存器参数都是Use + for (size_t i = 1; i < operands.size(); ++i) { + if (operands[i]->getKind() == MachineOperand::KIND_REG) { + use.insert(get_any_reg_id(operands[i].get())); + } + } + // 所有调用者保存寄存器(caller-saved)被隐式定义（因为它们的值被破坏了） + for (auto preg : getCallerSavedIntRegs()) def.insert(offset + static_cast(preg)); + for (auto preg : getCallerSavedFpRegs()) def.insert(offset + static_cast(preg)); + // 返回地址寄存器RA也被隐式定义 + def.insert(offset + static_cast(PhysicalReg::RA)); + } + else if (opcode == RVOpcodes::RET) { + // 遵循调用约定，a0(整数/指针)和fa0(浮点)被隐式使用 + use.insert(offset + static_cast(PhysicalReg::A0)); + use.insert(offset + static_cast(PhysicalReg::F10)); // F10 is fa0 } } void RISCv64RegAlloc::addEdge(unsigned u, unsigned v) { if (u == v) return; - // 关键修正：只为虚拟寄存器（非预着色）更新邻接表和度数 - // 如果 u 是虚拟寄存器 - if (!precolored.count(u)) { - // 并且 u 和 v 之间还没有边 - if (adjList.at(u).find(v) == adjList.at(u).end()) { - adjList.at(u).insert(v); - degree.at(u)++; + // 检查两个节点是否都是虚拟寄存器 + if (!precolored.count(u) && !precolored.count(v)) { + // 只有当两个都是虚拟寄存器时，才为它们双方添加边和更新度数 + // 使用 operator[] 是安全的，如果键不存在，它会默认构造一个空的set + if (adjList[u].find(v) == adjList[u].end()) { + adjList[u].insert(v); + adjList[v].insert(u); + degree[u]++; + degree[v]++; } } - - // 对称地，如果 v 是虚拟寄存器 - if (!precolored.count(v)) { - // 并且 v 和 u 之间还没有边 - if (adjList.at(v).find(u) == adjList.at(v).end()) { - adjList.at(v).insert(u); - degree.at(v)++; + // 检查是否为 "虚拟-物理" 对 + else if (!precolored.count(u) && precolored.count(v)) { + // u是虚拟寄存器，v是物理寄存器，只更新u的邻接表和度数 + if (adjList[u].find(v) == adjList[u].end()) { + adjList[u].insert(v); + degree[u]++; } } + // 检查是否为 "物理-虚拟" 对 + else if (precolored.count(u) && !precolored.count(v)) { + // u是物理寄存器，v是虚拟寄存器，只更新v的邻接表和度数 + if (adjList[v].find(u) == adjList[v].end()) { + adjList[v].insert(u); + degree[v]++; + } + } + // 如果两个都是物理寄存器，则什么都不做，直接返回。 } RISCv64RegAlloc::VRegSet RISCv64RegAlloc::adjacent(unsigned n) { @@ -1112,10 +1212,13 @@ void RISCv64RegAlloc::combine(unsigned u, unsigned v) { addEdge(t, u); decrementDegree(t); } - int K = isFPVReg(u) ? K_fp : K_int; - if (degree.at(u) >= K && freezeWorklist.count(u)) { - freezeWorklist.erase(u); - spillWorklist.insert(u); + + if (!precolored.count(u)) { + int K = isFPVReg(u) ? K_fp : K_int; + if (degree.at(u) >= K && freezeWorklist.count(u)) { + freezeWorklist.erase(u); + spillWorklist.insert(u); + } } } From 166d0fc3721abfa955a84f115133ab067f387203 Mon Sep 17 00:00:00 2001 From: Lixuanwang Date: Fri, 1 Aug 2025 05:21:37 +0800 Subject: [PATCH 04/55] =?UTF-8?q?[backend-IRC]=E4=BF=AE=E5=A4=8D=E4=BA=86?= =?UTF-8?q?=E6=A0=88=E4=BC=A0=E9=80=92=E5=8F=82=E6=95=B0=E9=80=BB=E8=BE=91?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../RISCv64/Handler/EliminateFrameIndices.cpp | 25 +- .../Handler/PrologueEpilogueInsertion.cpp | 358 +++++++++--------- 2 files changed, 181 insertions(+), 202 deletions(-) diff --git a/src/backend/RISCv64/Handler/EliminateFrameIndices.cpp b/src/backend/RISCv64/Handler/EliminateFrameIndices.cpp index f2aa6fa..2dfa040 100644 --- a/src/backend/RISCv64/Handler/EliminateFrameIndices.cpp +++ b/src/backend/RISCv64/Handler/EliminateFrameIndices.cpp @@ -4,6 +4,7 @@ namespace sysy { +// getTypeSizeInBytes 是一个通用辅助函数，保持不变 unsigned EliminateFrameIndicesPass::getTypeSizeInBytes(Type* type) { if (!type) { assert(false && "Cannot get size of a null type."); @@ -31,25 +32,14 @@ void EliminateFrameIndicesPass::runOnMachineFunction(MachineFunction* mfunc) { Function* F = mfunc->getFunc(); RISCv64ISel* isel = mfunc->getISel(); - // 1. 为栈传递的参数计算偏移量 - if (F) { - int arg_idx = 0; - for (Argument* arg : F->getArguments()) { - // 只关心第8个索引及之后的参数 (即第9个参数开始) - if (arg_idx >= 8) { - // 第一个栈参数(idx=8)在0(s0), 第二个(idx=9)在8(s0) - int offset = (arg_idx - 8) * 8; - unsigned vreg = isel->getVReg(arg); - frame_info.alloca_offsets[vreg] = offset; - } - arg_idx++; - } - } + // 1. [已移除] 不再处理栈传递的参数 + // 原先处理栈参数 (arg_idx >= 8) 的逻辑已被移除。 + // 这项职责已完全转移到 PrologueEpilogueInsertionPass，以避免逻辑冲突和错误。 - // 2. 为局部变量分配空间，起始点在 [ra, s0] (16字节) 之后 + // 2. 只为局部变量(AllocaInst)分配栈空间和计算偏移量 + // 局部变量从 s0 下方（负偏移量）开始分配，紧接着为 ra 和 s0 预留的16字节之后 int local_var_offset = 16; - // 处理局部变量 (AllocaInst) if(F) { // 确保函数指针有效 for (auto& bb : F->getBasicBlocks()) { for (auto& inst : bb->getInstructions()) { @@ -73,7 +63,8 @@ void EliminateFrameIndicesPass::runOnMachineFunction(MachineFunction* mfunc) { // 记录仅由AllocaInst分配的局部变量的总大小 frame_info.locals_size = local_var_offset - 16; - // 3. 遍历所有机器指令，将伪指令展开为真实指令 + // 3. 遍历所有机器指令，将访问局部变量的伪指令展开为真实指令 + // 由于处理参数的逻辑已移除，这里的展开现在只针对局部变量，因此是正确的。 for (auto& mbb : mfunc->getBlocks()) { std::vector> new_instructions; for (auto& instr_ptr : mbb->getInstructions()) { diff --git a/src/backend/RISCv64/Handler/PrologueEpilogueInsertion.cpp b/src/backend/RISCv64/Handler/PrologueEpilogueInsertion.cpp index 86e3b30..9a257d3 100644 --- a/src/backend/RISCv64/Handler/PrologueEpilogueInsertion.cpp +++ b/src/backend/RISCv64/Handler/PrologueEpilogueInsertion.cpp @@ -1,8 +1,9 @@ #include "PrologueEpilogueInsertion.h" +#include "RISCv64LLIR.h" // 假设包含了 PhysicalReg, RVOpcodes 等定义 #include "RISCv64ISel.h" #include #include -#include +#include namespace sysy { @@ -10,8 +11,10 @@ char PrologueEpilogueInsertionPass::ID = 0; void PrologueEpilogueInsertionPass::runOnMachineFunction(MachineFunction* mfunc) { StackFrameInfo& frame_info = mfunc->getFrameInfo(); - - // 1. 删除 KEEPALIVE 伪指令 + Function* F = mfunc->getFunc(); + RISCv64ISel* isel = mfunc->getISel(); + + // 1. 清理 KEEPALIVE 伪指令 for (auto& mbb : mfunc->getBlocks()) { auto& instrs = mbb->getInstructions(); instrs.erase( @@ -23,200 +26,185 @@ void PrologueEpilogueInsertionPass::runOnMachineFunction(MachineFunction* mfunc) instrs.end() ); } + + // 2. [新增] 确定需要保存的被调用者保存寄存器 (callee-saved) + // 这部分逻辑从 CalleeSavedHandler Pass 移入，以集中管理序言生成 + auto& vreg_to_preg_map = frame_info.vreg_to_preg_map; + std::set used_callee_saved_regs_set; + const auto& callee_saved_int = getCalleeSavedIntRegs(); + const auto& callee_saved_fp = getCalleeSavedFpRegs(); - // 2. 计算最终的、对齐后的栈帧总大小 - int total_stack_size = 16 + frame_info.callee_saved_size + frame_info.locals_size + frame_info.spill_size; - int aligned_stack_size = (total_stack_size + 15) & ~15; + 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; // 16字节对齐 frame_info.total_size = aligned_stack_size; - if (aligned_stack_size == 0) { - return; - } - - // --- 关键修正逻辑: 修正所有局部变量（即alloca）的偏移量 --- - // 这是最关键的一步，它解决了栈帧区域重叠的问题。 - // 在 EliminateFrameIndicesPass 运行时，它不知道 CalleeSavedHandler 后来会识别出 s1, s2 - // 并为其分配栈空间。因此，EliminateFrameIndicesPass 计算的偏移量是错误的。 - // 在这里，我们将偏移量向低地址方向整体移动，为 callee-saved 寄存器和溢出槽腾出空间。 - int callee_saved_and_spill_size = frame_info.callee_saved_size + frame_info.spill_size; - if (callee_saved_and_spill_size > 0) { - // 遍历所有局部变量的偏移量 Map，并进行修正 - for (auto& pair : mfunc->getFrameInfo().alloca_offsets) { - int old_offset = pair.second; // 初始偏移量（例如 -24） - int new_offset = old_offset - callee_saved_and_spill_size; - pair.second = new_offset; // 更新为修正后的偏移量 - } + // 只有在需要分配栈空间时才生成序言和尾声 + if (aligned_stack_size > 0) { + // --- 4. 插入完整的序言 --- + MachineBasicBlock* entry_block = mfunc->getBlocks().front().get(); + auto& entry_instrs = entry_block->getInstructions(); + std::vector> prologue_instrs; - // 重新遍历函数中的所有指令，用修正后的偏移量替换旧的立即数 - for (auto& mbb : mfunc->getBlocks()) { - for (auto& instr : mbb->getInstructions()) { - // 我们只修正那些使用立即数作为偏移量的内存访问指令 - if (instr->getOpcode() == RVOpcodes::ADDI) { - // ADDI 指令可能有 `addi rd, s0, offset` 的形式 - // 操作数是 [rd, s0, offset]，我们需要检查第2个操作数(s0)并修改第3个(offset) - if (instr->getOperands().size() > 2) { - if (auto reg_op = dynamic_cast(instr->getOperands()[1].get())) { - if (reg_op->getPReg() == PhysicalReg::S0) { - if (auto imm_op = dynamic_cast(instr->getOperands()[2].get())) { - // ImmOperand 是不可变的, 所以我们创建一个新的来替换它 - int64_t old_imm = imm_op->getValue(); - instr->getOperands()[2] = std::make_unique(old_imm - callee_saved_and_spill_size); - } - } - } - } - } else if (instr->getOpcode() == RVOpcodes::LD || instr->getOpcode() == RVOpcodes::SD || - instr->getOpcode() == RVOpcodes::FLW || instr->getOpcode() == RVOpcodes::FSW || - instr->getOpcode() == RVOpcodes::FLD || instr->getOpcode() == RVOpcodes::FSD) { - // Load/Store 指令的操作数是 [rd, MemOperand] - // 我们需要检查 MemOperand 的基址寄存器是否为 s0 - if (instr->getOperands().size() > 1) { - if (auto mem_op = dynamic_cast(instr->getOperands()[1].get())) { - if (mem_op->getBase() && mem_op->getBase()->getPReg() == PhysicalReg::S0) { - // MemOperand 和 ImmOperand 都是不可变的, 我们必须重新构建整个 MemOperand - RegOperand* base_reg_op = mem_op->getBase(); - ImmOperand* offset_op = mem_op->getOffset(); + // 4.1. 分配栈帧: addi sp, sp, -aligned_stack_size + auto alloc_stack = std::make_unique(RVOpcodes::ADDI); + alloc_stack->addOperand(std::make_unique(PhysicalReg::SP)); + alloc_stack->addOperand(std::make_unique(PhysicalReg::SP)); + alloc_stack->addOperand(std::make_unique(-aligned_stack_size)); + prologue_instrs.push_back(std::move(alloc_stack)); - if (base_reg_op && offset_op) { - int64_t old_offset = offset_op->getValue(); - int64_t new_offset = old_offset - callee_saved_and_spill_size; - - // 重新创建基址寄存器操作数 (必须处理虚拟/物理寄存器) - std::unique_ptr new_base; - if (base_reg_op->isVirtual()) { - new_base = std::make_unique(base_reg_op->getVRegNum()); - } else { - new_base = std::make_unique(base_reg_op->getPReg()); - } - - // 创建新的偏移立即数操作数 - auto new_offset_imm = std::make_unique(new_offset); - - // 用新创建的 MemOperand 替换旧的 - instr->getOperands()[1] = std::make_unique(std::move(new_base), std::move(new_offset_imm)); - } - } - } - } - } - } - } - } - - // --- 3. 插入完整的序言 --- - MachineBasicBlock* entry_block = mfunc->getBlocks().front().get(); - auto& entry_instrs = entry_block->getInstructions(); - std::vector> prologue_instrs; - - // a. addi sp, sp, -aligned_stack_size - auto alloc_stack = std::make_unique(RVOpcodes::ADDI); - alloc_stack->addOperand(std::make_unique(PhysicalReg::SP)); - alloc_stack->addOperand(std::make_unique(PhysicalReg::SP)); - alloc_stack->addOperand(std::make_unique(-aligned_stack_size)); - prologue_instrs.push_back(std::move(alloc_stack)); - - // b. sd ra, (aligned_stack_size - 8)(sp) - auto save_ra = std::make_unique(RVOpcodes::SD); - save_ra->addOperand(std::make_unique(PhysicalReg::RA)); - save_ra->addOperand(std::make_unique( - std::make_unique(PhysicalReg::SP), - std::make_unique(aligned_stack_size - 8) - )); - prologue_instrs.push_back(std::move(save_ra)); - - // c. sd s0, (aligned_stack_size - 16)(sp) - auto save_fp = std::make_unique(RVOpcodes::SD); - save_fp->addOperand(std::make_unique(PhysicalReg::S0)); - save_fp->addOperand(std::make_unique( - std::make_unique(PhysicalReg::SP), - std::make_unique(aligned_stack_size - 16) - )); - prologue_instrs.push_back(std::move(save_fp)); - - // d. 保存所有其他的被调用者保存寄存器，并记录它们的偏移量 - std::map callee_saved_offsets; - int current_offset = aligned_stack_size - 16; - for (PhysicalReg reg : frame_info.callee_saved_regs_to_store) { - current_offset -= 8; - callee_saved_offsets[reg] = current_offset; // 记录偏移量 - RVOpcodes save_op = (reg >= PhysicalReg::F0 && reg <= PhysicalReg::F31) ? RVOpcodes::FSD : RVOpcodes::SD; - - auto save_reg = std::make_unique(save_op); - save_reg->addOperand(std::make_unique(reg)); - save_reg->addOperand(std::make_unique( + // 4.2. 保存 ra 和 s0 + // sd ra, (aligned_stack_size - 8)(sp) + auto save_ra = std::make_unique(RVOpcodes::SD); + save_ra->addOperand(std::make_unique(PhysicalReg::RA)); + save_ra->addOperand(std::make_unique( std::make_unique(PhysicalReg::SP), - std::make_unique(current_offset) + std::make_unique(aligned_stack_size - 8) )); - prologue_instrs.push_back(std::move(save_reg)); - } + prologue_instrs.push_back(std::move(save_ra)); + // sd s0, (aligned_stack_size - 16)(sp) + auto save_fp = std::make_unique(RVOpcodes::SD); + save_fp->addOperand(std::make_unique(PhysicalReg::S0)); + save_fp->addOperand(std::make_unique( + std::make_unique(PhysicalReg::SP), + std::make_unique(aligned_stack_size - 16) + )); + prologue_instrs.push_back(std::move(save_fp)); + + // 4.3. 设置新的帧指针 s0: addi s0, sp, aligned_stack_size + auto set_fp = std::make_unique(RVOpcodes::ADDI); + set_fp->addOperand(std::make_unique(PhysicalReg::S0)); + set_fp->addOperand(std::make_unique(PhysicalReg::SP)); + set_fp->addOperand(std::make_unique(aligned_stack_size)); + prologue_instrs.push_back(std::move(set_fp)); + + // 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(store_op); + save_cs_reg->addOperand(std::make_unique(reg)); + save_cs_reg->addOperand(std::make_unique( + std::make_unique(PhysicalReg::S0), + std::make_unique(callee_saved_offset) + )); + prologue_instrs.push_back(std::move(save_cs_reg)); + } - // e. addi s0, sp, aligned_stack_size - auto set_fp = std::make_unique(RVOpcodes::ADDI); - set_fp->addOperand(std::make_unique(PhysicalReg::S0)); - set_fp->addOperand(std::make_unique(PhysicalReg::SP)); - set_fp->addOperand(std::make_unique(aligned_stack_size)); - prologue_instrs.push_back(std::move(set_fp)); + // 4.5. [核心] 加载所有通过栈传递的参数 + // 这些参数位于 s0 上方 (正偏移量) + if (F && isel) { + int arg_idx = 0; + for (Argument* arg : F->getArguments()) { + if (arg_idx >= 8) { + unsigned vreg = isel->getVReg(arg); + if (vreg_to_preg_map.count(vreg)) { + // 计算正确的正偏移量 + int offset = (arg_idx - 8) * 8; + PhysicalReg dest_preg = vreg_to_preg_map.at(vreg); + Type* arg_type = arg->getType(); - entry_instrs.insert(entry_instrs.begin(), - std::make_move_iterator(prologue_instrs.begin()), - std::make_move_iterator(prologue_instrs.end())); - - // --- 4. 插入完整的尾声 --- - for (auto& mbb : mfunc->getBlocks()) { - for (auto it = mbb->getInstructions().begin(); it != mbb->getInstructions().end(); ++it) { - if ((*it)->getOpcode() == RVOpcodes::RET) { - std::vector> epilogue_instrs; - - // a. [关键修正] 恢复所有其他的被调用者保存寄存器 (以相反顺序) - const auto& regs_to_restore = frame_info.callee_saved_regs_to_store; - for (auto reg_it = regs_to_restore.rbegin(); reg_it != regs_to_restore.rend(); ++reg_it) { - PhysicalReg reg = *reg_it; - int offset = callee_saved_offsets.at(reg); // 使用之前记录的正确偏移量 - RVOpcodes restore_op = (reg >= PhysicalReg::F0 && reg <= PhysicalReg::F31) ? RVOpcodes::FLD : RVOpcodes::LD; - - auto restore_reg = std::make_unique(restore_op); - restore_reg->addOperand(std::make_unique(reg)); - restore_reg->addOperand(std::make_unique( - std::make_unique(PhysicalReg::SP), - std::make_unique(offset) - )); - epilogue_instrs.push_back(std::move(restore_reg)); + // 根据类型生成对应的加载指令 + RVOpcodes load_op = arg_type->isFloat() ? RVOpcodes::FLW : (arg_type->isPointer() ? RVOpcodes::LD : RVOpcodes::LW); + auto load_arg = std::make_unique(load_op); + load_arg->addOperand(std::make_unique(dest_preg)); + load_arg->addOperand(std::make_unique( + std::make_unique(PhysicalReg::S0), + std::make_unique(offset) + )); + prologue_instrs.push_back(std::move(load_arg)); + } } - - // b. ld ra - auto restore_ra = std::make_unique(RVOpcodes::LD); - restore_ra->addOperand(std::make_unique(PhysicalReg::RA)); - restore_ra->addOperand(std::make_unique( - std::make_unique(PhysicalReg::SP), - std::make_unique(aligned_stack_size - 8) - )); - epilogue_instrs.push_back(std::move(restore_ra)); - - // c. ld s0 - auto restore_fp = std::make_unique(RVOpcodes::LD); - restore_fp->addOperand(std::make_unique(PhysicalReg::S0)); - restore_fp->addOperand(std::make_unique( - std::make_unique(PhysicalReg::SP), - std::make_unique(aligned_stack_size - 16) - )); - epilogue_instrs.push_back(std::move(restore_fp)); - - // d. addi sp, sp, aligned_stack_size - auto dealloc_stack = std::make_unique(RVOpcodes::ADDI); - dealloc_stack->addOperand(std::make_unique(PhysicalReg::SP)); - dealloc_stack->addOperand(std::make_unique(PhysicalReg::SP)); - dealloc_stack->addOperand(std::make_unique(aligned_stack_size)); - epilogue_instrs.push_back(std::move(dealloc_stack)); - - mbb->getInstructions().insert(it, - std::make_move_iterator(epilogue_instrs.begin()), - std::make_move_iterator(epilogue_instrs.end())); - - goto next_block; + arg_idx++; } } - next_block:; + + // 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> 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(load_op); + restore_cs_reg->addOperand(std::make_unique(reg)); + restore_cs_reg->addOperand(std::make_unique( + std::make_unique(PhysicalReg::S0), + std::make_unique(callee_saved_offset) + )); + epilogue_instrs.push_back(std::move(restore_cs_reg)); + } + + // 5.2. 恢复 ra 和 s0 (注意基址现在是sp) + // ld ra, (aligned_stack_size - 8)(sp) + auto restore_ra = std::make_unique(RVOpcodes::LD); + restore_ra->addOperand(std::make_unique(PhysicalReg::RA)); + restore_ra->addOperand(std::make_unique( + std::make_unique(PhysicalReg::SP), + std::make_unique(aligned_stack_size - 8) + )); + epilogue_instrs.push_back(std::move(restore_ra)); + // ld s0, (aligned_stack_size - 16)(sp) + auto restore_fp = std::make_unique(RVOpcodes::LD); + restore_fp->addOperand(std::make_unique(PhysicalReg::S0)); + restore_fp->addOperand(std::make_unique( + std::make_unique(PhysicalReg::SP), + std::make_unique(aligned_stack_size - 16) + )); + epilogue_instrs.push_back(std::move(restore_fp)); + + // 5.3. 释放栈帧: addi sp, sp, aligned_stack_size + auto dealloc_stack = std::make_unique(RVOpcodes::ADDI); + dealloc_stack->addOperand(std::make_unique(PhysicalReg::SP)); + dealloc_stack->addOperand(std::make_unique(PhysicalReg::SP)); + dealloc_stack->addOperand(std::make_unique(aligned_stack_size)); + epilogue_instrs.push_back(std::move(dealloc_stack)); + + // 将尾声指令插入到 RET 指令之前 + mbb->getInstructions().insert(it, + std::make_move_iterator(epilogue_instrs.begin()), + std::make_move_iterator(epilogue_instrs.end())); + + // 一个基本块通常只有一个终止指令，处理完就可以跳到下一个块 + goto next_block; + } + } + next_block:; + } } } -} // namespace sysy +} // namespace sysy \ No newline at end of file From 8fe9867f33188dd541ecce5d41a3a6f88d10001c Mon Sep 17 00:00:00 2001 From: Lixuanwang Date: Fri, 1 Aug 2025 12:15:03 +0800 Subject: [PATCH 05/55] =?UTF-8?q?[backend-IRC]=E4=BF=AE=E5=A4=8D=E4=BA=86k?= =?UTF-8?q?eepalive=E4=BC=AA=E6=8C=87=E4=BB=A4=E5=A4=84=E7=90=86=E7=BC=BA?= =?UTF-8?q?=E5=A4=B1=E7=9A=84=E9=97=AE=E9=A2=98?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../RISCv64/Handler/EliminateFrameIndices.cpp | 52 ++- .../Handler/PrologueEpilogueInsertion.cpp | 30 +- src/backend/RISCv64/RISCv64Backend.cpp | 294 +++++++++---- src/backend/RISCv64/RISCv64RegAlloc.cpp | 388 +++++++++++------- 4 files changed, 494 insertions(+), 270 deletions(-) diff --git a/src/backend/RISCv64/Handler/EliminateFrameIndices.cpp b/src/backend/RISCv64/Handler/EliminateFrameIndices.cpp index 2dfa040..6973293 100644 --- a/src/backend/RISCv64/Handler/EliminateFrameIndices.cpp +++ b/src/backend/RISCv64/Handler/EliminateFrameIndices.cpp @@ -1,6 +1,7 @@ #include "EliminateFrameIndices.h" #include "RISCv64ISel.h" #include +#include // [新增] 为插入指令而包含 namespace sysy { @@ -35,6 +36,8 @@ void EliminateFrameIndicesPass::runOnMachineFunction(MachineFunction* mfunc) { // 1. [已移除] 不再处理栈传递的参数 // 原先处理栈参数 (arg_idx >= 8) 的逻辑已被移除。 // 这项职责已完全转移到 PrologueEpilogueInsertionPass，以避免逻辑冲突和错误。 + // [注释更新] -> 上述注释已过时。根据新方案，我们将在这里处理栈传递的参数， + // 以便在寄存器分配前就将数据流显式化，修复溢出逻辑的BUG。 // 2. 只为局部变量(AllocaInst)分配栈空间和计算偏移量 // 局部变量从 s0 下方（负偏移量）开始分配，紧接着为 ra 和 s0 预留的16字节之后 @@ -63,8 +66,55 @@ void EliminateFrameIndicesPass::runOnMachineFunction(MachineFunction* mfunc) { // 记录仅由AllocaInst分配的局部变量的总大小 frame_info.locals_size = local_var_offset - 16; - // 3. 遍历所有机器指令，将访问局部变量的伪指令展开为真实指令 + // 3. [核心修改] 在函数入口为所有栈传递的参数插入load指令 + // 这个步骤至关重要：它在寄存器分配之前，为这些参数的vreg创建了明确的“定义(def)”指令。 + // 这解决了在高寄存器压力下，当这些vreg被溢出时，`rewriteProgram`找不到其定义点而崩溃的问题。 + if (F && isel && !mfunc->getBlocks().empty()) { + MachineBasicBlock* entry_block = mfunc->getBlocks().front().get(); + std::vector> 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(load_op); + load_instr->addOperand(std::make_unique(arg_vreg)); + load_instr->addOperand(std::make_unique( + std::make_unique(PhysicalReg::S0), // 基址为帧指针 + std::make_unique(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> new_instructions; for (auto& instr_ptr : mbb->getInstructions()) { diff --git a/src/backend/RISCv64/Handler/PrologueEpilogueInsertion.cpp b/src/backend/RISCv64/Handler/PrologueEpilogueInsertion.cpp index 9a257d3..ef86ea7 100644 --- a/src/backend/RISCv64/Handler/PrologueEpilogueInsertion.cpp +++ b/src/backend/RISCv64/Handler/PrologueEpilogueInsertion.cpp @@ -114,33 +114,9 @@ void PrologueEpilogueInsertionPass::runOnMachineFunction(MachineFunction* mfunc) prologue_instrs.push_back(std::move(save_cs_reg)); } - // 4.5. [核心] 加载所有通过栈传递的参数 - // 这些参数位于 s0 上方 (正偏移量) - if (F && isel) { - int arg_idx = 0; - for (Argument* arg : F->getArguments()) { - if (arg_idx >= 8) { - unsigned vreg = isel->getVReg(arg); - if (vreg_to_preg_map.count(vreg)) { - // 计算正确的正偏移量 - int offset = (arg_idx - 8) * 8; - PhysicalReg dest_preg = vreg_to_preg_map.at(vreg); - Type* arg_type = arg->getType(); - - // 根据类型生成对应的加载指令 - RVOpcodes load_op = arg_type->isFloat() ? RVOpcodes::FLW : (arg_type->isPointer() ? RVOpcodes::LD : RVOpcodes::LW); - auto load_arg = std::make_unique(load_op); - load_arg->addOperand(std::make_unique(dest_preg)); - load_arg->addOperand(std::make_unique( - std::make_unique(PhysicalReg::S0), - std::make_unique(offset) - )); - prologue_instrs.push_back(std::move(load_arg)); - } - } - arg_idx++; - } - } + // 4.5. [核心修改] 加载栈传递参数的逻辑已从此移除 + // 这项工作已经前移至 `EliminateFrameIndicesPass` 中完成， + // 以确保在寄存器分配前就将相关虚拟寄存器定义，从而修复溢出逻辑的bug。 // 4.6. 将所有生成的序言指令一次性插入到函数入口 entry_instrs.insert(entry_instrs.begin(), diff --git a/src/backend/RISCv64/RISCv64Backend.cpp b/src/backend/RISCv64/RISCv64Backend.cpp index ae1beb6..dc9c089 100644 --- a/src/backend/RISCv64/RISCv64Backend.cpp +++ b/src/backend/RISCv64/RISCv64Backend.cpp @@ -108,94 +108,220 @@ std::string RISCv64CodeGen::module_gen() { } std::string RISCv64CodeGen::function_gen(Function* func) { - // === 完整的后端处理流水线 === - - // 阶段 1: 指令选择 (sysy::IR -> LLIR with virtual registers) - RISCv64ISel isel; - std::unique_ptr 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(); + // === 完整的后端处理流水线 === + + // 阶段 1: 指令选择 (sysy::IR -> LLIR with virtual registers) + DEBUG = 0; + DEEPDEBUG = 0; + + RISCv64ISel isel; + std::unique_ptr 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(); } - // DEBUG = 0; - // DEEPDEBUG = 0; - // [新增] 阶段 2: 消除帧索引 (展开伪指令，计算局部变量偏移) - // 这个Pass必须在寄存器分配之前运行 - EliminateFrameIndicesPass efi_pass; - efi_pass.runOnMachineFunction(mfunc.get()); + + + + + + + + + + + + + else { + // === 完整的后端处理流水线 === - if (DEBUG) { - std::cerr << "====== stack info after eliminate frame indices ======\n"; - mfunc->dumpStackFrameInfo(std::cerr); + // 阶段 1: 指令选择 (sysy::IR -> LLIR with virtual registers) + DEBUG = 0; + DEEPDEBUG = 0; + + RISCv64ISel isel; + std::unique_ptr 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(); } - - // // 阶段 2: 指令调度 (Instruction Scheduling) - // PreRA_Scheduler scheduler; - // scheduler.runOnMachineFunction(mfunc.get()); - - // DEBUG = 0; - // DEEPDEBUG = 0; - // 阶段 3: 物理寄存器分配 (Register Allocation) - RISCv64RegAlloc reg_alloc(mfunc.get()); - reg_alloc.run(); - - // 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 \ No newline at end of file diff --git a/src/backend/RISCv64/RISCv64RegAlloc.cpp b/src/backend/RISCv64/RISCv64RegAlloc.cpp index 763f401..3b12bab 100644 --- a/src/backend/RISCv64/RISCv64RegAlloc.cpp +++ b/src/backend/RISCv64/RISCv64RegAlloc.cpp @@ -564,6 +564,40 @@ void RISCv64RegAlloc::freeze() { freezeMoves(u); } +// // 选择溢出节点 +// // in file: RISCv64RegAlloc.cpp + +// void RISCv64RegAlloc::selectSpill() { +// // [核心逻辑修正] 遵从 George & Appel 论文的“乐观着色”策略。 +// // 此函数不再将节点直接放入 spilledNodes。 +// // 它的作用是选择一个“潜在溢出”节点，并将其移回 simplifyWorklist，以打破僵局。 +// // 真正的溢出决策被推迟到 AssignColors 阶段。 + +// // 使用启发式规则从 spillWorklist 中选择一个节点 m。 +// // 论文建议使用代价函数，这里我们继续使用度数最高的简单启发式。 +// auto it = std::max_element(spillWorklist.begin(), spillWorklist.end(), +// [&](unsigned a, unsigned b){ return degree.at(a) < degree.at(b); }); + +// // 理论上此时 spillWorklist 不应为空，但做保护性检查。 +// if (it == spillWorklist.end()) { +// return; +// } + +// unsigned m = *it; + +// // 1. 将选中的节点 m 从溢出工作列表移动到简化工作列表。 +// spillWorklist.erase(it); +// simplifyWorklist.insert(m); // + +// // 2. 冻结与 m 相关的所有传送指令，因为我们已经放弃了对它的合并尝试。 +// freezeMoves(m); // + +// if (DEEPDEBUG) { +// std::cerr << "[Spill] Optimistically moving %vreg" << m +// << " from spillWorklist to simplifyWorklist.\n"; +// } +// } + // 选择溢出节点 void RISCv64RegAlloc::selectSpill() { auto it = std::max_element(spillWorklist.begin(), spillWorklist.end(), @@ -578,7 +612,7 @@ void RISCv64RegAlloc::selectSpill() { void RISCv64RegAlloc::assignColors() { if (DEEPDEBUG) std::cerr << "[AssignColors] Starting...\n"; - // 步骤 1: 完整处理 selectStack + // 步骤 1: 为 selectStack 中的节点分配颜色 (此部分逻辑不变) while (!selectStack.empty()) { unsigned n = selectStack.back(); selectStack.pop_back(); @@ -586,26 +620,22 @@ void RISCv64RegAlloc::assignColors() { const auto& available_regs = is_fp ? allocable_fp_regs : allocable_int_regs; std::set ok_colors(available_regs.begin(), available_regs.end()); - for (unsigned w : adjList.at(n)) { - unsigned w_alias = getAlias(w); - bool is_colored_vreg = coloredNodes.count(w_alias); - bool is_physical_reg = precolored.count(w_alias); - const unsigned offset = static_cast(PhysicalReg::PHYS_REG_START_ID); - - if (is_colored_vreg || is_physical_reg) { - PhysicalReg neighbor_color; - if (is_colored_vreg) { - neighbor_color = color_map.at(w_alias); - } else { - neighbor_color = static_cast(w_alias - offset); + if (adjList.count(n)) { + for (unsigned w : adjList.at(n)) { + unsigned w_alias = getAlias(w); + + if (coloredNodes.count(w_alias)) { // 邻居是已着色的vreg + ok_colors.erase(color_map.at(w_alias)); + } else if (precolored.count(w_alias)) { // 邻居是物理寄存器 + const unsigned offset = static_cast(PhysicalReg::PHYS_REG_START_ID); + ok_colors.erase(static_cast(w_alias - offset)); } - ok_colors.erase(neighbor_color); } } if (ok_colors.empty()) { - if (DEEPDEBUG) std::cerr << " -> No color for %vreg" << n << ". Spilling.\n"; spilledNodes.insert(n); + if (DEEPDEBUG) std::cerr << " -> WARNING: No color for %vreg" << n << " from selectStack. Spilling.\n"; } else { PhysicalReg c = *ok_colors.begin(); coloredNodes.insert(n); @@ -614,41 +644,41 @@ void RISCv64RegAlloc::assignColors() { } } - // 步骤 2: 独立、完整地处理 coalescedNodes + // 步骤 2: [最终修正] 完整、正确地处理 coalescedNodes for (unsigned n : coalescedNodes) { unsigned root_alias = getAlias(n); + + // --- 新的、健壮的逻辑，处理所有三种可能性 --- - // 情况 1: 别名是物理寄存器，直接获得该颜色 + // 情况 1: 别名本身就是物理寄存器 (修复当前bug) if (precolored.count(root_alias)) { const unsigned offset = static_cast(PhysicalReg::PHYS_REG_START_ID); color_map[n] = static_cast(root_alias - offset); - if (DEEPDEBUG) std::cerr << " -> Coalesced " << regIdToString(n) << " gets color from physical alias " << regIdToString(root_alias) << ".\n"; - } - // 情况 2: 别名是虚拟寄存器，且在步骤1中已被成功着色 + if (DEEPDEBUG) std::cerr << " -> Coalesced %vreg" << n << " gets color from PHYSICAL alias " << regIdToString(root_alias) << ".\n"; + } + // 情况 2: 别名是被成功着色的虚拟寄存器 else if (color_map.count(root_alias)) { color_map[n] = color_map.at(root_alias); - if (DEEPDEBUG) std::cerr << " -> Coalesced " << regIdToString(n) << " gets color of virtual alias " << regIdToString(root_alias) << ".\n"; - } - // 情况 3: 别名是虚拟寄存器，但在步骤1中未能着色（即被溢出） + if (DEEPDEBUG) std::cerr << " -> Coalesced %vreg" << n << " gets color from VIRTUAL alias " << regIdToString(root_alias) << ".\n"; + } + // 情况 3: 别名是被溢出的虚拟寄存器 else { - if (DEEPDEBUG) std::cerr << " -> Alias " << regIdToString(root_alias) << " of %vreg" << n << " was spilled. Spilling.\n"; spilledNodes.insert(n); + if (DEEPDEBUG) std::cerr << " -> Alias " << regIdToString(root_alias) << " of %vreg" << n << " was SPILLED. Spilling %vreg" << n << " as well.\n"; } } } // 重写程序，插入溢出代码 void RISCv64RegAlloc::rewriteProgram() { - // 1. 为溢出的旧vreg在栈上分配空间 (这部分逻辑不变) + // 1. 为溢出的旧vreg在栈上分配空间 StackFrameInfo& frame_info = MFunc->getFrameInfo(); - // locals_size, callee_saved_size等已经由之前的步骤或上一次运行计算好 - // 我们在此基础上累加溢出区大小 int spill_base_offset = frame_info.locals_size + frame_info.callee_saved_size; for (unsigned vreg : spilledNodes) { - if (frame_info.spill_offsets.count(vreg)) continue; // 如果已经分配过则跳过 + if (frame_info.spill_offsets.count(vreg)) continue; - int size = 4; // 默认4字节 + int size = 4; if (isFPVReg(vreg)) { size = 4; // float } else if (vreg_type_map.count(vreg) && vreg_type_map.at(vreg)->isPointer()) { @@ -656,117 +686,113 @@ void RISCv64RegAlloc::rewriteProgram() { } spill_base_offset += size; - spill_base_offset = (spill_base_offset + 7) & ~7; // 8字节对齐 - frame_info.spill_offsets[vreg] = spill_base_offset; + spill_base_offset = (spill_base_offset + 7) & ~7; + frame_info.spill_offsets[vreg] = -spill_base_offset; // [修正] 溢出槽也使用负偏移量 } frame_info.spill_size = spill_base_offset - (frame_info.locals_size + frame_info.callee_saved_size); - // 2. 遍历所有指令，为溢出vreg的use/def插入load/store，并使用新的临时虚拟寄存器 + // 2. 遍历所有指令，重写代码 for (auto& mbb : MFunc->getBlocks()) { std::vector> new_instructions; for (auto& instr_ptr : mbb->getInstructions()) { - // 对每条指令，记录其使用的旧vreg到新临时vreg的映射 - std::map vreg_remap; + std::map use_remap; + std::map def_remap; - // a. 为每个溢出的 use 操作数，在原指令前插入 load 指令 VRegSet use, def; - getInstrUseDef_Liveness(instr_ptr.get(), use, def); // 假设此函数能正确处理operands + getInstrUseDef_Liveness(instr_ptr.get(), use, def); - for(auto& op : instr_ptr->getOperands()) { - if (op->getKind() == MachineOperand::KIND_REG) { - auto reg_op = static_cast(op.get()); - if (reg_op->isVirtual() && spilledNodes.count(reg_op->getVRegNum()) && use.count(reg_op->getVRegNum())) { - unsigned old_vreg = reg_op->getVRegNum(); - // 仅当还未为此vreg创建临时替身时才创建 - if (vreg_remap.find(old_vreg) == vreg_remap.end()) { - Type* type = vreg_type_map.count(old_vreg) ? vreg_type_map.at(old_vreg) : Type::getIntType(); - unsigned new_temp_vreg = ISel->getNewVReg(type); - vreg_remap[old_vreg] = new_temp_vreg; + // a. 为每个溢出的 use 操作数创建新vreg并插入 load + for (unsigned old_vreg : use) { + if (spilledNodes.count(old_vreg)) { + Type* type = vreg_type_map.count(old_vreg) ? vreg_type_map.at(old_vreg) : Type::getIntType(); + unsigned new_temp_vreg = ISel->getNewVReg(type); + use_remap[old_vreg] = new_temp_vreg; - RVOpcodes load_op; - if (isFPVReg(old_vreg)) load_op = RVOpcodes::FLW; - else if (type->isPointer()) load_op = RVOpcodes::LD; - else load_op = RVOpcodes::LW; + RVOpcodes load_op; + if (isFPVReg(old_vreg)) load_op = RVOpcodes::FLW; + else if (type->isPointer()) load_op = RVOpcodes::LD; + else load_op = RVOpcodes::LW; - auto load = std::make_unique(load_op); - load->addOperand(std::make_unique(new_temp_vreg)); - load->addOperand(std::make_unique( - std::make_unique(PhysicalReg::S0), - std::make_unique(-frame_info.spill_offsets.at(old_vreg)) // 偏移是相对于S0的负值 - )); - new_instructions.push_back(std::move(load)); - } - } - } else if (op->getKind() == MachineOperand::KIND_MEM) { - auto reg_op = static_cast(op.get())->getBase(); - if (reg_op->isVirtual() && spilledNodes.count(reg_op->getVRegNum())) { - unsigned old_vreg = reg_op->getVRegNum(); - if (vreg_remap.find(old_vreg) == vreg_remap.end()) { - Type* type = vreg_type_map.count(old_vreg) ? vreg_type_map.at(old_vreg) : Type::getIntType(); - unsigned new_temp_vreg = ISel->getNewVReg(type); - vreg_remap[old_vreg] = new_temp_vreg; - - RVOpcodes load_op = (type->isPointer()) ? RVOpcodes::LD : RVOpcodes::LW; - auto load = std::make_unique(load_op); - load->addOperand(std::make_unique(new_temp_vreg)); - load->addOperand(std::make_unique( - std::make_unique(PhysicalReg::S0), - std::make_unique(-frame_info.spill_offsets.at(old_vreg)) - )); - new_instructions.push_back(std::move(load)); - } - } + auto load = std::make_unique(load_op); + load->addOperand(std::make_unique(new_temp_vreg)); + load->addOperand(std::make_unique( + std::make_unique(PhysicalReg::S0), + std::make_unique(frame_info.spill_offsets.at(old_vreg)) + )); + new_instructions.push_back(std::move(load)); } } - - // b. 替换原指令中的操作数，并将其加入新指令列表 - for(auto& op : instr_ptr->getOperands()) { - if (op->getKind() == MachineOperand::KIND_REG) { - auto reg_op = static_cast(op.get()); - if (reg_op->isVirtual() && vreg_remap.count(reg_op->getVRegNum())) { - reg_op->setVRegNum(vreg_remap.at(reg_op->getVRegNum())); - } - } else if (op->getKind() == MachineOperand::KIND_MEM) { - auto reg_op = static_cast(op.get())->getBase(); - if (reg_op->isVirtual() && vreg_remap.count(reg_op->getVRegNum())) { - reg_op->setVRegNum(vreg_remap.at(reg_op->getVRegNum())); - } + + // b. 为每个溢出的 def 操作数创建新vreg + for (unsigned old_vreg : def) { + if (spilledNodes.count(old_vreg)) { + Type* type = vreg_type_map.count(old_vreg) ? vreg_type_map.at(old_vreg) : Type::getIntType(); + unsigned new_temp_vreg = ISel->getNewVReg(type); + def_remap[old_vreg] = new_temp_vreg; } } - new_instructions.push_back(std::move(instr_ptr)); - // c. 为每个溢出的 def 操作数，在原指令后插入 store 指令 - vreg_remap.clear(); // 清空映射，为def创建新的临时vreg - for(auto& op : new_instructions.back()->getOperands()) { - if (op->getKind() == MachineOperand::KIND_REG) { + // c. [核心修正] 创建一条全新的指令，用新vreg替换旧vreg + auto new_instr = std::make_unique(instr_ptr->getOpcode()); + for (const auto& op : instr_ptr->getOperands()) { + if (op->getKind() == MachineOperand::KIND_REG) { auto reg_op = static_cast(op.get()); - if (reg_op->isVirtual() && spilledNodes.count(reg_op->getVRegNum()) && def.count(reg_op->getVRegNum())) { + if (reg_op->isVirtual()) { unsigned old_vreg = reg_op->getVRegNum(); - if (vreg_remap.find(old_vreg) == vreg_remap.end()) { - Type* type = vreg_type_map.count(old_vreg) ? vreg_type_map.at(old_vreg) : Type::getIntType(); - unsigned new_temp_vreg = ISel->getNewVReg(type); - vreg_remap[old_vreg] = new_temp_vreg; // 记录从old到new的映射 - - // 再次修改指令，将def的vreg也换成新的临时vreg - reg_op->setVRegNum(new_temp_vreg); - - RVOpcodes store_op; - if (isFPVReg(old_vreg)) store_op = RVOpcodes::FSW; - else if (type->isPointer()) store_op = RVOpcodes::SD; - else store_op = RVOpcodes::SW; - - auto store = std::make_unique(store_op); - store->addOperand(std::make_unique(new_temp_vreg)); // 从新的临时vreg中存值 - store->addOperand(std::make_unique( - std::make_unique(PhysicalReg::S0), - std::make_unique(-frame_info.spill_offsets.at(old_vreg)) - )); - // 在原指令之后插入store - new_instructions.push_back(std::move(store)); + if (use.count(old_vreg) && use_remap.count(old_vreg)) { + new_instr->addOperand(std::make_unique(use_remap.at(old_vreg))); + } else if (def.count(old_vreg) && def_remap.count(old_vreg)) { + new_instr->addOperand(std::make_unique(def_remap.at(old_vreg))); + } else { + new_instr->addOperand(std::make_unique(old_vreg)); } + } else { + new_instr->addOperand(std::make_unique(reg_op->getPReg())); } - } + } else if (op->getKind() == MachineOperand::KIND_MEM) { + auto mem_op = static_cast(op.get()); + auto base_reg = mem_op->getBase(); + unsigned old_vreg = base_reg->isVirtual() ? base_reg->getVRegNum() : -1; + + if (base_reg->isVirtual() && use_remap.count(old_vreg)) { + new_instr->addOperand(std::make_unique( + std::make_unique(use_remap.at(old_vreg)), + std::make_unique(mem_op->getOffset()->getValue()) + )); + } else { + new_instr->addOperand(std::make_unique( + std::make_unique(*base_reg), + std::make_unique(mem_op->getOffset()->getValue()) + )); + } + } else { // 立即数、标签等直接复制 + if(op->getKind() == MachineOperand::KIND_IMM) + new_instr->addOperand(std::make_unique(*static_cast(op.get()))); + else if (op->getKind() == MachineOperand::KIND_LABEL) + new_instr->addOperand(std::make_unique(*static_cast(op.get()))); + } + } + new_instructions.push_back(std::move(new_instr)); + + // d. 为每个溢出的 def 操作数，在原指令后插入 store 指令 + for (const auto& pair : def_remap) { + unsigned old_vreg = pair.first; + unsigned new_temp_vreg = pair.second; + Type* type = vreg_type_map.count(old_vreg) ? vreg_type_map.at(old_vreg) : Type::getIntType(); + + RVOpcodes store_op; + if (isFPVReg(old_vreg)) store_op = RVOpcodes::FSW; + else if (type->isPointer()) store_op = RVOpcodes::SD; + else store_op = RVOpcodes::SW; + + auto store = std::make_unique(store_op); + store->addOperand(std::make_unique(new_temp_vreg)); + store->addOperand(std::make_unique( + std::make_unique(PhysicalReg::S0), + std::make_unique(frame_info.spill_offsets.at(old_vreg)) + )); + new_instructions.push_back(std::move(store)); } } mbb->getInstructions() = std::move(new_instructions); @@ -828,9 +854,11 @@ void RISCv64RegAlloc::getInstrUseDef(const MachineInstr* instr, VRegSet& use, VR } } +// in file: RISCv64RegAlloc.cpp + /** - * @brief [已修复] 获取一条指令完整的、包含物理寄存器的Use/Def集合 - * 这个新函数将专门服务于活跃性分析。 + * @brief [最终修复版] 获取一条指令完整的、包含物理寄存器的Use/Def集合 + * 这个函数专门服务于活跃性分析，现已补全所有指令（包括伪指令）的逻辑。 */ void RISCv64RegAlloc::getInstrUseDef_Liveness(const MachineInstr* instr, VRegSet& use, VRegSet& def) { auto opcode = instr->getOpcode(); @@ -838,57 +866,52 @@ void RISCv64RegAlloc::getInstrUseDef_Liveness(const MachineInstr* instr, VRegSet // 映射表：指令操作码 -> {Def操作数索引列表, Use操作数索引列表} static const std::map, std::vector>> op_info = { - // ===== 已有指令定义 (保留) ===== + // ===== 整数算术与逻辑指令 (R-type & I-type) ===== {RVOpcodes::ADD, {{0}, {1, 2}}}, {RVOpcodes::SUB, {{0}, {1, 2}}}, {RVOpcodes::MUL, {{0}, {1, 2}}}, {RVOpcodes::DIV, {{0}, {1, 2}}}, {RVOpcodes::REM, {{0}, {1, 2}}}, {RVOpcodes::ADDW, {{0}, {1, 2}}}, {RVOpcodes::SUBW, {{0}, {1, 2}}}, {RVOpcodes::MULW, {{0}, {1, 2}}}, {RVOpcodes::DIVW, {{0}, {1, 2}}}, {RVOpcodes::REMW, {{0}, {1, 2}}}, {RVOpcodes::SLT, {{0}, {1, 2}}}, {RVOpcodes::SLTU, {{0}, {1, 2}}}, + {RVOpcodes::XOR, {{0}, {1, 2}}}, {RVOpcodes::OR, {{0}, {1, 2}}}, {RVOpcodes::AND, {{0}, {1, 2}}}, {RVOpcodes::ADDI, {{0}, {1}}}, {RVOpcodes::ADDIW, {{0}, {1}}}, {RVOpcodes::XORI, {{0}, {1}}}, - {RVOpcodes::SLTI, {{0}, {1}}}, {RVOpcodes::SLTIU, {{0}, {1}}}, {RVOpcodes::LB, {{0}, {}}}, - {RVOpcodes::LH, {{0}, {}}}, {RVOpcodes::LW, {{0}, {}}}, {RVOpcodes::LD, {{0}, {}}}, - {RVOpcodes::LBU, {{0}, {}}}, {RVOpcodes::LHU, {{0}, {}}}, {RVOpcodes::LWU, {{0}, {}}}, - {RVOpcodes::FLW, {{0}, {}}}, {RVOpcodes::FLD, {{0}, {}}}, {RVOpcodes::SB, {{}, {0, 1}}}, - {RVOpcodes::SH, {{}, {0, 1}}}, {RVOpcodes::SW, {{}, {0, 1}}}, {RVOpcodes::SD, {{}, {0, 1}}}, - {RVOpcodes::FSW, {{}, {0, 1}}}, {RVOpcodes::FSD, {{}, {0, 1}}}, {RVOpcodes::BEQ, {{}, {0, 1}}}, - {RVOpcodes::BNE, {{}, {0, 1}}}, {RVOpcodes::BLT, {{}, {0, 1}}}, {RVOpcodes::BGE, {{}, {0, 1}}}, - {RVOpcodes::JALR, {{0}, {1}}}, {RVOpcodes::LI, {{0}, {}}}, {RVOpcodes::LA, {{0}, {}}}, - {RVOpcodes::MV, {{0}, {1}}}, {RVOpcodes::SEQZ, {{0}, {1}}}, {RVOpcodes::SNEZ, {{0}, {1}}}, - {RVOpcodes::FADD_S, {{0}, {1, 2}}}, {RVOpcodes::FSUB_S, {{0}, {1, 2}}}, - {RVOpcodes::FMUL_S, {{0}, {1, 2}}}, {RVOpcodes::FDIV_S, {{0}, {1, 2}}}, {RVOpcodes::FEQ_S, {{0}, {1, 2}}}, - {RVOpcodes::FLT_S, {{0}, {1, 2}}}, {RVOpcodes::FLE_S, {{0}, {1, 2}}}, {RVOpcodes::FCVT_S_W, {{0}, {1}}}, - {RVOpcodes::FCVT_W_S, {{0}, {1}}}, {RVOpcodes::FMV_S, {{0}, {1}}}, {RVOpcodes::FMV_W_X, {{0}, {1}}}, - {RVOpcodes::FMV_X_W, {{0}, {1}}}, {RVOpcodes::FNEG_S, {{0}, {1}}}, + {RVOpcodes::ORI, {{0}, {1}}}, {RVOpcodes::ANDI, {{0}, {1}}}, + {RVOpcodes::SLTI, {{0}, {1}}}, {RVOpcodes::SLTIU, {{0}, {1}}}, - // ===== 新增的指令定义开始 ===== - - // --- 逻辑指令 --- - {RVOpcodes::XOR, {{0}, {1, 2}}}, - {RVOpcodes::OR, {{0}, {1, 2}}}, - {RVOpcodes::AND, {{0}, {1, 2}}}, - {RVOpcodes::ORI, {{0}, {1}}}, - {RVOpcodes::ANDI, {{0}, {1}}}, - - // --- 移位指令 --- + // ===== 移位指令 ===== {RVOpcodes::SLL, {{0}, {1, 2}}}, {RVOpcodes::SLLI, {{0}, {1}}}, {RVOpcodes::SLLW, {{0}, {1, 2}}}, {RVOpcodes::SLLIW, {{0}, {1}}}, {RVOpcodes::SRL, {{0}, {1, 2}}}, {RVOpcodes::SRLI, {{0}, {1}}}, {RVOpcodes::SRLW, {{0}, {1, 2}}}, {RVOpcodes::SRLIW, {{0}, {1}}}, {RVOpcodes::SRA, {{0}, {1, 2}}}, {RVOpcodes::SRAI, {{0}, {1}}}, {RVOpcodes::SRAW, {{0}, {1, 2}}}, {RVOpcodes::SRAIW, {{0}, {1}}}, + + // ===== 内存加载指令 (Def: 0, Use: MemBase) ===== + {RVOpcodes::LB, {{0}, {}}}, {RVOpcodes::LH, {{0}, {}}}, {RVOpcodes::LW, {{0}, {}}}, {RVOpcodes::LD, {{0}, {}}}, + {RVOpcodes::LBU, {{0}, {}}}, {RVOpcodes::LHU, {{0}, {}}}, {RVOpcodes::LWU, {{0}, {}}}, + {RVOpcodes::FLW, {{0}, {}}}, {RVOpcodes::FLD, {{0}, {}}}, + + // ===== 内存存储指令 (Def: None, Use: ValToStore, MemBase) ===== + {RVOpcodes::SB, {{}, {0, 1}}}, {RVOpcodes::SH, {{}, {0, 1}}}, {RVOpcodes::SW, {{}, {0, 1}}}, {RVOpcodes::SD, {{}, {0, 1}}}, + {RVOpcodes::FSW, {{}, {0, 1}}}, {RVOpcodes::FSD, {{}, {0, 1}}}, - // --- 控制流指令 (补全) --- - {RVOpcodes::BLTU, {{}, {0, 1}}}, - {RVOpcodes::BGEU, {{}, {0, 1}}}, - // J 没有寄存器操作数，JAL 由CALL指令类似的特殊逻辑处理 + // ===== 控制流指令 ===== + {RVOpcodes::BEQ, {{}, {0, 1}}}, {RVOpcodes::BNE, {{}, {0, 1}}}, {RVOpcodes::BLT, {{}, {0, 1}}}, + {RVOpcodes::BGE, {{}, {0, 1}}}, {RVOpcodes::BLTU, {{}, {0, 1}}}, {RVOpcodes::BGEU, {{}, {0, 1}}}, + {RVOpcodes::JALR, {{0}, {1}}}, // def: ra (implicit) and op0, use: op1 + + // ===== 浮点指令 ===== + {RVOpcodes::FADD_S, {{0}, {1, 2}}}, {RVOpcodes::FSUB_S, {{0}, {1, 2}}}, + {RVOpcodes::FMUL_S, {{0}, {1, 2}}}, {RVOpcodes::FDIV_S, {{0}, {1, 2}}}, {RVOpcodes::FEQ_S, {{0}, {1, 2}}}, + {RVOpcodes::FLT_S, {{0}, {1, 2}}}, {RVOpcodes::FLE_S, {{0}, {1, 2}}}, {RVOpcodes::FCVT_S_W, {{0}, {1}}}, + {RVOpcodes::FCVT_W_S, {{0}, {1}}}, {RVOpcodes::FMV_S, {{0}, {1}}}, {RVOpcodes::FMV_W_X, {{0}, {1}}}, + {RVOpcodes::FMV_X_W, {{0}, {1}}}, {RVOpcodes::FNEG_S, {{0}, {1}}}, - // --- 伪指令 (补全) --- - {RVOpcodes::NEG, {{0}, {1}}}, - {RVOpcodes::NEGW, {{0}, {1}}}, - - // ===== 新增的指令定义结束 ===== + // ===== 伪指令 ===== + {RVOpcodes::LI, {{0}, {}}}, {RVOpcodes::LA, {{0}, {}}}, + {RVOpcodes::MV, {{0}, {1}}}, {RVOpcodes::SEQZ, {{0}, {1}}}, {RVOpcodes::SNEZ, {{0}, {1}}}, + {RVOpcodes::NEG, {{0}, {1}}}, {RVOpcodes::NEGW, {{0}, {1}}}, }; - // 该lambda表达式用于获取操作数的寄存器ID（虚拟或物理），逻辑正确，保持不变 + // lambda表达式用于获取操作数的寄存器ID（虚拟或物理） const unsigned offset = static_cast(PhysicalReg::PHYS_REG_START_ID); auto get_any_reg_id = [&](const MachineOperand* op) -> unsigned { if (op->getKind() == MachineOperand::KIND_REG) { @@ -902,6 +925,7 @@ void RISCv64RegAlloc::getInstrUseDef_Liveness(const MachineInstr* instr, VRegSet return (unsigned)-1; }; + // --- 主要处理逻辑 --- if (op_info.count(opcode)) { const auto& info = op_info.at(opcode); for (int idx : info.first) if (idx < operands.size()) { @@ -912,7 +936,7 @@ void RISCv64RegAlloc::getInstrUseDef_Liveness(const MachineInstr* instr, VRegSet unsigned reg_id = get_any_reg_id(operands[idx].get()); if (reg_id != (unsigned)-1) use.insert(reg_id); } - // 不要忘记内存操作数中的基址寄存器永远是use + // 对于所有内存操作，基址寄存器都必须是 use for (const auto& op : operands) { if (op->getKind() == MachineOperand::KIND_MEM) { unsigned reg_id = get_any_reg_id(op.get()); @@ -920,7 +944,7 @@ void RISCv64RegAlloc::getInstrUseDef_Liveness(const MachineInstr* instr, VRegSet } } } - // CALL 和 RET 的特殊处理逻辑，保持不变 + // --- 特殊指令处理逻辑 --- else if (opcode == RVOpcodes::CALL) { // 返回值是Def if (!operands.empty() && operands[0]->getKind() == MachineOperand::KIND_REG) { @@ -943,6 +967,16 @@ void RISCv64RegAlloc::getInstrUseDef_Liveness(const MachineInstr* instr, VRegSet use.insert(offset + static_cast(PhysicalReg::A0)); use.insert(offset + static_cast(PhysicalReg::F10)); // F10 is fa0 } + // [关键Bug修复] 添加对 PSEUDO_KEEPALIVE 的处理 + else if (opcode == RVOpcodes::PSEUDO_KEEPALIVE) { + // keepalive的所有操作数都是use，以确保它们的生命周期延续到该点 + for (const auto& op : operands) { + if (op->getKind() == MachineOperand::KIND_REG) { + unsigned reg_id = get_any_reg_id(op.get()); + if (reg_id != (unsigned)-1) use.insert(reg_id); + } + } + } } void RISCv64RegAlloc::addEdge(unsigned u, unsigned v) { @@ -1197,6 +1231,44 @@ bool RISCv64RegAlloc::georgeHeuristic(unsigned t, unsigned u) { return degree.at(t) < K || precolored.count(u) || adjList.at(t).count(u); } +// void RISCv64RegAlloc::combine(unsigned u, unsigned v) { +// // 1. 从相应的工作列表中移除即将被合并的节点 v +// if (freezeWorklist.count(v)) { +// freezeWorklist.erase(v); +// } else { +// spillWorklist.erase(v); +// } + +// // 2. 将 v 加入 coalescedNodes 集合，并设置其别名 +// coalescedNodes.insert(v); +// alias[v] = u; + +// // 3. 将 v 的传送指令列表合并到 u +// if (moveList.count(u) && moveList.count(v)) { +// moveList.at(u).insert(moveList.at(v).begin(), moveList.at(v).end()); +// } else if (moveList.count(v)) { +// moveList[u] = moveList.at(v); +// } + +// // [Bug修复] 移除了论文伪代码中不存在的 enableMoves({v}) 调用。 + +// // 4. [核心Bug修复] 遍历 v 的“当前有效”邻居 t (使用 adjacent(v) 而非 adjList.at(v)) +// // 将它们与 u 连接，并更新它们的度数。 +// for (unsigned t : adjacent(v)) { +// addEdge(t, u); +// decrementDegree(t); +// } + +// // 5. 检查合并后的节点 u 的状态，如果其度数变高，可能需要将其移到 spillWorklist +// if (!precolored.count(u)) { +// int K = isFPVReg(u) ? K_fp : K_int; +// if (degree.at(u) >= K && freezeWorklist.count(u)) { +// freezeWorklist.erase(u); +// spillWorklist.insert(u); +// } +// } +// } + void RISCv64RegAlloc::combine(unsigned u, unsigned v) { freezeWorklist.erase(v); spillWorklist.erase(v); From 373726b02f0138eff03d74f1087d329e0d662b0b Mon Sep 17 00:00:00 2001 From: Lixuanwang Date: Fri, 1 Aug 2025 17:29:18 +0800 Subject: [PATCH 06/55] =?UTF-8?q?[backend-IRC]=E4=BF=AE=E5=A4=8D=E4=BA=86?= =?UTF-8?q?=E6=9E=81=E5=85=B6=E9=9A=90=E8=94=BD=E7=9A=84=E5=AF=84=E5=AD=98?= =?UTF-8?q?=E5=99=A8=E5=88=86=E9=85=8D=E9=97=AE=E9=A2=98?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/backend/RISCv64/RISCv64RegAlloc.cpp | 25 ++++++++++++++++++------- 1 file changed, 18 insertions(+), 7 deletions(-) diff --git a/src/backend/RISCv64/RISCv64RegAlloc.cpp b/src/backend/RISCv64/RISCv64RegAlloc.cpp index 3b12bab..5216594 100644 --- a/src/backend/RISCv64/RISCv64RegAlloc.cpp +++ b/src/backend/RISCv64/RISCv64RegAlloc.cpp @@ -157,7 +157,7 @@ void RISCv64RegAlloc::precolorByCallingConvention() { // 修改部分：将物理寄存器ID转换为其字符串名称 for (unsigned v : precolored) std::cerr << regIdToString(v) << " "; std::cerr << "}\nColored nodes: { "; - for (unsigned v : coloredNodes) std::cerr << "%vreg" << v << " "; + for (unsigned v : coloredNodes) std::cerr << "<%vreg" << v << ", " << regToString(color_map.at(v)) << "> "; std::cerr << "}\n"; } } @@ -283,7 +283,7 @@ void RISCv64RegAlloc::build() { if (precolored.count(v)) { std::cerr << "Skipping " << regIdToString(v) << " because it is a physical register.\n"; } else { - std::cerr << "Skipping " << regIdToString(v) << " because it is a pre-colored virtual register.\n"; + std::cerr << "Skipping " << regIdToString(v) << " because it is a pre-colored virtual register with " << regToString(color_map.at(v)) << "\n"; } } } @@ -294,7 +294,7 @@ void RISCv64RegAlloc::build() { if (precolored.count(v)) { std::cerr << "Skipping " << regIdToString(v) << " because it is a physical register.\n"; } else { - std::cerr << "Skipping " << regIdToString(v) << " because it is a pre-colored virtual register.\n"; + std::cerr << "Skipping " << regIdToString(v) << " because it is a pre-colored virtual register with " << regToString(color_map.at(v)) << ".\n"; } } } @@ -611,7 +611,6 @@ void RISCv64RegAlloc::selectSpill() { void RISCv64RegAlloc::assignColors() { if (DEEPDEBUG) std::cerr << "[AssignColors] Starting...\n"; - // 步骤 1: 为 selectStack 中的节点分配颜色 (此部分逻辑不变) while (!selectStack.empty()) { unsigned n = selectStack.back(); @@ -983,7 +982,7 @@ void RISCv64RegAlloc::addEdge(unsigned u, unsigned v) { if (u == v) return; // 检查两个节点是否都是虚拟寄存器 - if (!precolored.count(u) && !precolored.count(v)) { + if (!precolored.count(u) && !precolored.count(v) && !coloredNodes.count(u) && !coloredNodes.count(v)) { // 只有当两个都是虚拟寄存器时，才为它们双方添加边和更新度数 // 使用 operator[] 是安全的，如果键不存在，它会默认构造一个空的set if (adjList[u].find(v) == adjList[u].end()) { @@ -994,7 +993,7 @@ void RISCv64RegAlloc::addEdge(unsigned u, unsigned v) { } } // 检查是否为 "虚拟-物理" 对 - else if (!precolored.count(u) && precolored.count(v)) { + else if (!precolored.count(u) && precolored.count(v) && !coloredNodes.count(u)) { // u是虚拟寄存器，v是物理寄存器，只更新u的邻接表和度数 if (adjList[u].find(v) == adjList[u].end()) { adjList[u].insert(v); @@ -1002,7 +1001,7 @@ void RISCv64RegAlloc::addEdge(unsigned u, unsigned v) { } } // 检查是否为 "物理-虚拟" 对 - else if (precolored.count(u) && !precolored.count(v)) { + else if (precolored.count(u) && !precolored.count(v) && !coloredNodes.count(v)) { // u是物理寄存器，v是虚拟寄存器，只更新v的邻接表和度数 if (adjList[v].find(u) == adjList[v].end()) { adjList[v].insert(u); @@ -1122,8 +1121,14 @@ void RISCv64RegAlloc::decrementDegree(unsigned m) { enableMoves(nodes_to_enable); spillWorklist.erase(m); if (moveRelated(m)) { + if (DEEPDEBUG) { + std::cerr << "[decrementDegree] Node " << regIdToString(m) << " has degree " << d << ", now decremented to " << degree.at(m) << ". Added to freezeWorklist.\n"; + } freezeWorklist.insert(m); } else { + if (DEEPDEBUG) { + std::cerr << "[decrementDegree] Node " << regIdToString(m) << " has degree " << d << ", now decremented to " << degree.at(m) << ". Added to simplifyWorklist.\n"; + } simplifyWorklist.insert(m); } } @@ -1160,6 +1165,9 @@ void RISCv64RegAlloc::addWorklist(unsigned u) { if (!moveRelated(u) && degree.at(u) < K) { freezeWorklist.erase(u); simplifyWorklist.insert(u); + if (DEEPDEBUG) { + std::cerr << "[addWorklist] Node " << regIdToString(u) << " added to simplifyWorklist (degree: " << degree.at(u) << ", K: " << K << ").\n"; + } } } @@ -1317,6 +1325,9 @@ void RISCv64RegAlloc::freezeMoves(unsigned u) { if (!precolored.count(v_alias) && nodeMoves(v_alias).empty() && degree.at(v_alias) < (isFPVReg(v_alias) ? K_fp : K_int)) { freezeWorklist.erase(v_alias); simplifyWorklist.insert(v_alias); + if (DEEPDEBUG) { + std::cerr << "[freezeMoves] Node " << regIdToString(v_alias) << " moved to simplifyWorklist (degree: " << degree.at(v_alias) << ").\n"; + } } } } From 57fe17dc21f42e2f85406805b7208f207952b167 Mon Sep 17 00:00:00 2001 From: Lixuanwang Date: Fri, 1 Aug 2025 21:20:04 +0800 Subject: [PATCH 07/55] =?UTF-8?q?[backend-IRC]=E4=B8=BA=E8=99=9A=E6=8B=9F?= =?UTF-8?q?=E5=AF=84=E5=AD=98=E5=99=A8=E4=B8=8E=E7=89=A9=E7=90=86=E5=AF=84?= =?UTF-8?q?=E5=AD=98=E5=99=A8=E4=B9=8B=E9=97=B4=E6=B7=BB=E5=8A=A0=E5=86=B2?= =?UTF-8?q?=E7=AA=81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/backend/RISCv64/RISCv64RegAlloc.cpp | 61 +++++++++++++++---------- 1 file changed, 36 insertions(+), 25 deletions(-) diff --git a/src/backend/RISCv64/RISCv64RegAlloc.cpp b/src/backend/RISCv64/RISCv64RegAlloc.cpp index 5216594..3eed7dd 100644 --- a/src/backend/RISCv64/RISCv64RegAlloc.cpp +++ b/src/backend/RISCv64/RISCv64RegAlloc.cpp @@ -124,29 +124,29 @@ void RISCv64RegAlloc::precolorByCallingConvention() { } } - // --- 部分2：为CALL指令的返回值预着色 --- - for (auto& mbb : MFunc->getBlocks()) { - for (auto& instr : mbb->getInstructions()) { - if (instr->getOpcode() == RVOpcodes::CALL) { - if (!instr->getOperands().empty() && - instr->getOperands().front()->getKind() == MachineOperand::KIND_REG) - { - auto reg_op = static_cast(instr->getOperands().front().get()); - if (reg_op->isVirtual()) { - unsigned ret_vreg = reg_op->getVRegNum(); - assert(vreg_to_value_map.count(ret_vreg) && "Return vreg not found!"); - Value* ret_val = vreg_to_value_map.at(ret_vreg); + // // --- 部分2：为CALL指令的返回值预着色 --- + // for (auto& mbb : MFunc->getBlocks()) { + // for (auto& instr : mbb->getInstructions()) { + // if (instr->getOpcode() == RVOpcodes::CALL) { + // if (!instr->getOperands().empty() && + // instr->getOperands().front()->getKind() == MachineOperand::KIND_REG) + // { + // auto reg_op = static_cast(instr->getOperands().front().get()); + // if (reg_op->isVirtual()) { + // unsigned ret_vreg = reg_op->getVRegNum(); + // assert(vreg_to_value_map.count(ret_vreg) && "Return vreg not found!"); + // Value* ret_val = vreg_to_value_map.at(ret_vreg); - if (ret_val->getType()->isFloat()) { - color_map[ret_vreg] = PhysicalReg::F10; // fa0 - } else { - color_map[ret_vreg] = PhysicalReg::A0; // a0 - } - } - } - } - } - } + // if (ret_val->getType()->isFloat()) { + // color_map[ret_vreg] = PhysicalReg::F10; // fa0 + // } else { + // color_map[ret_vreg] = PhysicalReg::A0; // a0 + // } + // } + // } + // } + // } + // } // 将所有预着色的vreg视为已着色节点 for(const auto& pair : color_map) { @@ -375,13 +375,17 @@ void RISCv64RegAlloc::build() { // --- 规则 1 & 2: Def 与 Live/Use 变量干扰 --- for (unsigned d : def) { - // [关键修正] Def必须是虚拟寄存器 - if (precolored.count(d)) continue; - + // 新逻辑：对于指令定义的所有寄存器d（无论是虚拟寄存器还是像call指令那样 + // 隐式定义的物理寄存器），它都与该指令之后的所有活跃寄存器l冲突。 + // addEdge函数内部会正确处理 vreg-vreg 和 vreg-preg 的情况， + // 并忽略 preg-preg 的情况。 for (unsigned l : live) { addEdge(d, l); } + // 对于非传送指令, Def还和Use冲突。 + // 这个逻辑主要用于确保在同一条指令内，例如 sub t0, t1, t0, + // 作为def的t0和作为use的t0被视为冲突。 if (!is_move) { for (unsigned u_op : use) { addEdge(d, u_op); @@ -961,6 +965,13 @@ void RISCv64RegAlloc::getInstrUseDef_Liveness(const MachineInstr* instr, VRegSet // 返回地址寄存器RA也被隐式定义 def.insert(offset + static_cast(PhysicalReg::RA)); } + else if (opcode == RVOpcodes::JALR) { + // JALR rd, rs1, imm. Def: rd, Use: rs1. + // 同时也隐式定义了ra(x1)，但通常rd就是ra。为精确，我们只处理显式操作数。 + // 旧版本逻辑：def.insert(ra); first_reg_is_def = false; -> 这是不精确的 + def.insert(get_any_reg_id(operands[0].get())); + use.insert(get_any_reg_id(operands[1].get())); + } else if (opcode == RVOpcodes::RET) { // 遵循调用约定，a0(整数/指针)和fa0(浮点)被隐式使用 use.insert(offset + static_cast(PhysicalReg::A0)); From 384f7c548b793b2227e3342a9fce5bff1428fd52 Mon Sep 17 00:00:00 2001 From: Lixuanwang Date: Fri, 1 Aug 2025 23:18:53 +0800 Subject: [PATCH 08/55] =?UTF-8?q?[backend-IRC]=E6=B7=BB=E5=8A=A0=E4=BA=86?= =?UTF-8?q?=E4=B8=89=E7=BA=A7=E8=B0=83=E8=AF=95=E6=89=93=E5=8D=B0=E9=80=BB?= =?UTF-8?q?=E8=BE=91?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/backend/RISCv64/RISCv64RegAlloc.cpp | 173 ++++++++---------- src/include/backend/RISCv64/RISCv64RegAlloc.h | 4 +- src/sysyc.cpp | 2 + 3 files changed, 85 insertions(+), 94 deletions(-) diff --git a/src/backend/RISCv64/RISCv64RegAlloc.cpp b/src/backend/RISCv64/RISCv64RegAlloc.cpp index 3eed7dd..76f003b 100644 --- a/src/backend/RISCv64/RISCv64RegAlloc.cpp +++ b/src/backend/RISCv64/RISCv64RegAlloc.cpp @@ -1,5 +1,3 @@ -// in file: RISCv64RegAlloc.cpp - #include "RISCv64RegAlloc.h" #include "RISCv64AsmPrinter.h" #include @@ -263,7 +261,7 @@ void RISCv64RegAlloc::build() { getInstrUseDef_Liveness(instr, use, def); // 调试输出 use 和 def (保留您的调试逻辑) - if (DEEPDEBUG) { + if (DEEPERDEBUG) { std::cerr << "Instr:"; printer_inside_build.printInstruction(instr_ptr.get(), true); auto print_set = [this](const VRegSet& s, const std::string& name) { @@ -278,7 +276,7 @@ void RISCv64RegAlloc::build() { for (unsigned v : use) { if (!coloredNodes.count(v) && !precolored.count(v)) { initial.insert(v); - } else if (DEEPDEBUG) { + } else if ((DEEPDEBUG && initial.size() < DEBUGLENGTH) || DEEPERDEBUG) { // 这里的调试信息可以更精确 if (precolored.count(v)) { std::cerr << "Skipping " << regIdToString(v) << " because it is a physical register.\n"; @@ -290,7 +288,7 @@ void RISCv64RegAlloc::build() { for (unsigned v : def) { if (!coloredNodes.count(v) && !precolored.count(v)) { initial.insert(v); - } else if (DEEPDEBUG) { + } else if ((DEEPDEBUG && initial.size() < DEBUGLENGTH) || DEEPERDEBUG) { if (precolored.count(v)) { std::cerr << "Skipping " << regIdToString(v) << " because it is a physical register.\n"; } else { @@ -302,9 +300,20 @@ void RISCv64RegAlloc::build() { } if (DEEPDEBUG) { - std::cerr << "Initial set after build: { "; - for (unsigned v : initial) std::cerr << regIdToString(v) << " "; - std::cerr << "}\n"; + if (initial.size() > DEBUGLENGTH && !DEEPERDEBUG) { + std::cerr << "Initial set too large, showing first " << DEBUGLENGTH << " elements:\n"; + } + std::cerr << "Initial set (" << initial.size() << "): { "; + unsigned count = 0; + for (unsigned v : initial) { + if (count++ >= DEBUGLENGTH && !DEEPERDEBUG) break; // 限制输出数量 + std::cerr << regIdToString(v) << " "; + } + if (count < initial.size()) { + std::cerr << "... (total " << initial.size() << " elements)\n"; + } else { + std::cerr << "}\n"; + } } // 2. 为所有参与图构建的虚拟寄存器（initial + coloredNodes）初始化数据结构 @@ -331,7 +340,7 @@ void RISCv64RegAlloc::build() { const VRegSet& live_out = live_out_map.at(instr); // 保留您的指令级调试输出 - if (DEEPDEBUG) { + if (DEEPERDEBUG) { RISCv64AsmPrinter temp_printer(MFunc); temp_printer.setStream(std::cerr); std::cerr << "Instr: "; @@ -417,7 +426,7 @@ void RISCv64RegAlloc::makeWorklist() { std::cerr << "Error: degree not initialized for %vreg" << n << "\n"; continue; } - if (DEEPDEBUG) { + if ((DEEPDEBUG && initial.size() < DEBUGLENGTH) || DEEPERDEBUG) { std::cerr << "Assigning %vreg" << n << " (degree=" << degree.at(n) << ", moveRelated=" << moveRelated(n) << ")\n"; } @@ -429,7 +438,7 @@ void RISCv64RegAlloc::makeWorklist() { simplifyWorklist.insert(n); } } - if (DEEPDEBUG) std::cerr << "--------------------------------\n"; + if (DEEPDEBUG || DEEPERDEBUG) std::cerr << "--------------------------------\n"; initial.clear(); } @@ -437,7 +446,7 @@ void RISCv64RegAlloc::makeWorklist() { void RISCv64RegAlloc::simplify() { unsigned n = *simplifyWorklist.begin(); simplifyWorklist.erase(simplifyWorklist.begin()); - if (DEEPDEBUG) std::cerr << "[Simplify] Popped %vreg" << n << ", pushing to stack.\n"; + if (DEEPERDEBUG) std::cerr << "[Simplify] Popped %vreg" << n << ", pushing to stack.\n"; selectStack.push_back(n); for (unsigned m : adjacent(n)) { decrementDegree(m); @@ -455,19 +464,19 @@ void RISCv64RegAlloc::coalesce() { unsigned u, v; if (precolored.count(y)) { u = y; v = x; } else { u = x; v = y; } - if (DEEPDEBUG) std::cerr << "[Coalesce] Processing move between " << regIdToString(x) + if (DEEPERDEBUG) std::cerr << "[Coalesce] Processing move between " << regIdToString(x) << " and " << regIdToString(y) << " (aliases " << regIdToString(u) << ", " << regIdToString(v) << ").\n"; if (u == v) { - if (DEEPDEBUG) std::cerr << " -> Trivial coalesce (u == v).\n"; + if (DEEPERDEBUG) std::cerr << " -> Trivial coalesce (u == v).\n"; coalescedMoves.insert(move); addWorklist(u); return; // 处理完毕，提前返回 } if (isFPVReg(u) != isFPVReg(v)) { - if (DEEPDEBUG) std::cerr << " -> Constrained (type mismatch: " << regIdToString(u) << " is " + if (DEEPERDEBUG) std::cerr << " -> Constrained (type mismatch: " << regIdToString(u) << " is " << (isFPVReg(u) ? "float" : "int") << ", " << regIdToString(v) << " is " << (isFPVReg(v) ? "float" : "int") << ").\n"; constrainedMoves.insert(move); @@ -481,7 +490,7 @@ void RISCv64RegAlloc::coalesce() { bool pre_interfere = adjList.at(v).count(u); if (pre_interfere) { - if (DEEPDEBUG) std::cerr << " -> Constrained (nodes already interfere).\n"; + if (DEEPERDEBUG) std::cerr << " -> Constrained (nodes already interfere).\n"; constrainedMoves.insert(move); addWorklist(u); addWorklist(v); @@ -493,13 +502,13 @@ void RISCv64RegAlloc::coalesce() { if (is_u_precolored) { // --- 场景1：u是物理寄存器，使用 George 启发式 --- - if (DEEPDEBUG) std::cerr << " -> Trying George Heuristic (u is precolored)...\n"; + if (DEEPERDEBUG) std::cerr << " -> Trying George Heuristic (u is precolored)...\n"; // ==================== [展开的 std::all_of 逻辑] ==================== // 步骤 1: 独立调用 adjacent(v) 获取邻居集合 VRegSet neighbors_of_v = adjacent(v); - if (DEEPDEBUG) { + if (DEEPERDEBUG) { std::cerr << " - Neighbors of " << regIdToString(v) << " to check are (" << neighbors_of_v.size() << "): { "; for (unsigned id : neighbors_of_v) std::cerr << regIdToString(id) << " "; std::cerr << "}\n"; @@ -508,14 +517,14 @@ void RISCv64RegAlloc::coalesce() { // 步骤 2: 使用显式的 for 循环来代替 std::all_of bool george_ok = true; // 默认假设成功，任何一个邻居失败都会将此设为 false for (unsigned t : neighbors_of_v) { - if (DEEPDEBUG) { + if (DEEPERDEBUG) { std::cerr << " - Checking neighbor " << regIdToString(t) << ":\n"; } // 步骤 3: 独立调用启发式函数 bool heuristic_result = georgeHeuristic(t, u); - if (DEEPDEBUG) { + if (DEEPERDEBUG) { std::cerr << " - georgeHeuristic(" << regIdToString(t) << ", " << regIdToString(u) << ") -> " << (heuristic_result ? "OK" : "FAIL") << "\n"; } @@ -525,7 +534,7 @@ void RISCv64RegAlloc::coalesce() { } } - if (DEEPDEBUG) { + if (DEEPERDEBUG) { std::cerr << " -> George Heuristic final result: " << (george_ok ? "OK" : "FAIL") << "\n"; } // ================================================================= @@ -536,10 +545,10 @@ void RISCv64RegAlloc::coalesce() { } else { // --- 场景2：u和v都是虚拟寄存器，使用 Briggs 启发式 --- - if (DEEPDEBUG) std::cerr << " -> Trying Briggs Heuristic (u and v are virtual)...\n"; + if (DEEPERDEBUG) std::cerr << " -> Trying Briggs Heuristic (u and v are virtual)...\n"; bool briggs_ok = briggsHeuristic(u, v); - if (DEEPDEBUG) std::cerr << " - briggsHeuristic(" << regIdToString(u) << ", " << regIdToString(v) << ") -> " << (briggs_ok ? "OK" : "FAIL") << "\n"; + if (DEEPERDEBUG) std::cerr << " - briggsHeuristic(" << regIdToString(u) << ", " << regIdToString(v) << ") -> " << (briggs_ok ? "OK" : "FAIL") << "\n"; if (briggs_ok) { can_coalesce = true; @@ -549,12 +558,12 @@ void RISCv64RegAlloc::coalesce() { // --- 根据启发式结果进行最终决策 --- if (can_coalesce) { - if (DEEPDEBUG) std::cerr << " -> Heuristic OK. Combining " << regIdToString(v) << " into " << regIdToString(u) << ".\n"; + if (DEEPERDEBUG) std::cerr << " -> Heuristic OK. Combining " << regIdToString(v) << " into " << regIdToString(u) << ".\n"; coalescedMoves.insert(move); combine(u, v); addWorklist(u); } else { - if (DEEPDEBUG) std::cerr << " -> Heuristic failed. Adding to active moves.\n"; + if (DEEPERDEBUG) std::cerr << " -> Heuristic failed. Adding to active moves.\n"; activeMoves.insert(move); } } @@ -563,58 +572,24 @@ void RISCv64RegAlloc::coalesce() { void RISCv64RegAlloc::freeze() { unsigned u = *freezeWorklist.begin(); freezeWorklist.erase(freezeWorklist.begin()); - if (DEEPDEBUG) std::cerr << "[Freeze] Freezing %vreg" << u << " and moving to simplify list.\n"; + if (DEEPERDEBUG) std::cerr << "[Freeze] Freezing %vreg" << u << " and moving to simplify list.\n"; simplifyWorklist.insert(u); freezeMoves(u); } -// // 选择溢出节点 -// // in file: RISCv64RegAlloc.cpp - -// void RISCv64RegAlloc::selectSpill() { -// // [核心逻辑修正] 遵从 George & Appel 论文的“乐观着色”策略。 -// // 此函数不再将节点直接放入 spilledNodes。 -// // 它的作用是选择一个“潜在溢出”节点，并将其移回 simplifyWorklist，以打破僵局。 -// // 真正的溢出决策被推迟到 AssignColors 阶段。 - -// // 使用启发式规则从 spillWorklist 中选择一个节点 m。 -// // 论文建议使用代价函数，这里我们继续使用度数最高的简单启发式。 -// auto it = std::max_element(spillWorklist.begin(), spillWorklist.end(), -// [&](unsigned a, unsigned b){ return degree.at(a) < degree.at(b); }); - -// // 理论上此时 spillWorklist 不应为空，但做保护性检查。 -// if (it == spillWorklist.end()) { -// return; -// } - -// unsigned m = *it; - -// // 1. 将选中的节点 m 从溢出工作列表移动到简化工作列表。 -// spillWorklist.erase(it); -// simplifyWorklist.insert(m); // - -// // 2. 冻结与 m 相关的所有传送指令，因为我们已经放弃了对它的合并尝试。 -// freezeMoves(m); // - -// if (DEEPDEBUG) { -// std::cerr << "[Spill] Optimistically moving %vreg" << m -// << " from spillWorklist to simplifyWorklist.\n"; -// } -// } - // 选择溢出节点 void RISCv64RegAlloc::selectSpill() { auto it = std::max_element(spillWorklist.begin(), spillWorklist.end(), [&](unsigned a, unsigned b){ return degree.at(a) < degree.at(b); }); unsigned m = *it; spillWorklist.erase(it); - if (DEEPDEBUG) std::cerr << "[Spill] Selecting %vreg" << m << " to spill.\n"; + if (DEEPERDEBUG) std::cerr << "[Spill] Selecting %vreg" << m << " to spill.\n"; simplifyWorklist.insert(m); freezeMoves(m); } void RISCv64RegAlloc::assignColors() { - if (DEEPDEBUG) std::cerr << "[AssignColors] Starting...\n"; + if (DEEPERDEBUG) std::cerr << "[AssignColors] Starting...\n"; // 步骤 1: 为 selectStack 中的节点分配颜色 (此部分逻辑不变) while (!selectStack.empty()) { unsigned n = selectStack.back(); @@ -638,12 +613,12 @@ void RISCv64RegAlloc::assignColors() { if (ok_colors.empty()) { spilledNodes.insert(n); - if (DEEPDEBUG) std::cerr << " -> WARNING: No color for %vreg" << n << " from selectStack. Spilling.\n"; + if (DEEPERDEBUG) std::cerr << " -> WARNING: No color for %vreg" << n << " from selectStack. Spilling.\n"; } else { PhysicalReg c = *ok_colors.begin(); coloredNodes.insert(n); color_map[n] = c; - if (DEEPDEBUG) std::cerr << " -> Colored %vreg" << n << " with " << regToString(c) << ".\n"; + if (DEEPERDEBUG) std::cerr << " -> Colored %vreg" << n << " with " << regToString(c) << ".\n"; } } @@ -657,17 +632,17 @@ void RISCv64RegAlloc::assignColors() { if (precolored.count(root_alias)) { const unsigned offset = static_cast(PhysicalReg::PHYS_REG_START_ID); color_map[n] = static_cast(root_alias - offset); - if (DEEPDEBUG) std::cerr << " -> Coalesced %vreg" << n << " gets color from PHYSICAL alias " << regIdToString(root_alias) << ".\n"; + if (DEEPERDEBUG) std::cerr << " -> Coalesced %vreg" << n << " gets color from PHYSICAL alias " << regIdToString(root_alias) << ".\n"; } // 情况 2: 别名是被成功着色的虚拟寄存器 else if (color_map.count(root_alias)) { color_map[n] = color_map.at(root_alias); - if (DEEPDEBUG) std::cerr << " -> Coalesced %vreg" << n << " gets color from VIRTUAL alias " << regIdToString(root_alias) << ".\n"; + if (DEEPERDEBUG) std::cerr << " -> Coalesced %vreg" << n << " gets color from VIRTUAL alias " << regIdToString(root_alias) << ".\n"; } // 情况 3: 别名是被溢出的虚拟寄存器 else { spilledNodes.insert(n); - if (DEEPDEBUG) std::cerr << " -> Alias " << regIdToString(root_alias) << " of %vreg" << n << " was SPILLED. Spilling %vreg" << n << " as well.\n"; + if (DEEPERDEBUG) std::cerr << " -> Alias " << regIdToString(root_alias) << " of %vreg" << n << " was SPILLED. Spilling %vreg" << n << " as well.\n"; } } } @@ -1024,14 +999,14 @@ void RISCv64RegAlloc::addEdge(unsigned u, unsigned v) { RISCv64RegAlloc::VRegSet RISCv64RegAlloc::adjacent(unsigned n) { // 仅在 DEEPDEBUG 模式下启用详细日志 - if (DEEPDEBUG) { + if (DEEPERDEBUG) { // 使用 regIdToString 打印节点 n，无论是物理还是虚拟 std::cerr << "\n[adjacent] >>>>> Executing for node " << regIdToString(n) << " <<<<<\n"; } // 1. 如果节点 n 是物理寄存器，它没有邻接表，直接返回空集 if (precolored.count(n)) { - if (DEEPDEBUG) { + if (DEEPERDEBUG) { std::cerr << "[adjacent] Node " << regIdToString(n) << " is precolored. Returning {}.\n"; } return {}; @@ -1039,7 +1014,7 @@ RISCv64RegAlloc::VRegSet RISCv64RegAlloc::adjacent(unsigned n) { // 安全检查：确保 n 在 adjList 中存在，防止 map::at 崩溃 if (adjList.count(n) == 0) { - if (DEEPDEBUG) { + if (DEEPERDEBUG) { std::cerr << "[adjacent] WARNING: Node " << regIdToString(n) << " not found in adjList. Returning {}.\n"; } return {}; @@ -1048,7 +1023,7 @@ RISCv64RegAlloc::VRegSet RISCv64RegAlloc::adjacent(unsigned n) { // 2. 获取 n 在冲突图中的所有邻居 VRegSet result = adjList.at(n); - if (DEEPDEBUG) { + if (DEEPERDEBUG) { // 定义一个局部的 lambda 方便打印集合 auto print_set = [this](const VRegSet& s, const std::string& name) { std::cerr << "[adjacent] " << name << " (" << s.size() << "): { "; @@ -1065,11 +1040,11 @@ RISCv64RegAlloc::VRegSet RISCv64RegAlloc::adjacent(unsigned n) { VRegSet removed_from_stack; // 仅用于调试打印 for (auto it = selectStack.rbegin(); it != selectStack.rend(); ++it) { if (result.count(*it)) { - if (DEEPDEBUG) removed_from_stack.insert(*it); + if (DEEPERDEBUG) removed_from_stack.insert(*it); result.erase(*it); } } - if (DEEPDEBUG && !removed_from_stack.empty()) { + if (DEEPERDEBUG && !removed_from_stack.empty()) { std::cerr << "[adjacent] - Removed from selectStack: { "; for(unsigned id : removed_from_stack) std::cerr << regIdToString(id) << " "; std::cerr << "}\n"; @@ -1079,18 +1054,18 @@ RISCv64RegAlloc::VRegSet RISCv64RegAlloc::adjacent(unsigned n) { VRegSet removed_from_coalesced; // 仅用于调试打印 for (unsigned cn : coalescedNodes) { if (result.count(cn)) { - if (DEEPDEBUG) removed_from_coalesced.insert(cn); + if (DEEPERDEBUG) removed_from_coalesced.insert(cn); result.erase(cn); } } - if (DEEPDEBUG && !removed_from_coalesced.empty()) { + if (DEEPERDEBUG && !removed_from_coalesced.empty()) { std::cerr << "[adjacent] - Removed from coalescedNodes: { "; for(unsigned id : removed_from_coalesced) std::cerr << regIdToString(id) << " "; std::cerr << "}\n"; } // 4. 返回最终的、过滤后的“有效”邻居集合 - if (DEEPDEBUG) { + if (DEEPERDEBUG) { std::cerr << "[adjacent] >>>>> Returning final adjacent set (" << result.size() << "): { "; for (unsigned id : result) std::cerr << regIdToString(id) << " "; std::cerr << "}\n\n"; @@ -1132,12 +1107,12 @@ void RISCv64RegAlloc::decrementDegree(unsigned m) { enableMoves(nodes_to_enable); spillWorklist.erase(m); if (moveRelated(m)) { - if (DEEPDEBUG) { + if (DEEPERDEBUG) { std::cerr << "[decrementDegree] Node " << regIdToString(m) << " has degree " << d << ", now decremented to " << degree.at(m) << ". Added to freezeWorklist.\n"; } freezeWorklist.insert(m); } else { - if (DEEPDEBUG) { + if (DEEPERDEBUG) { std::cerr << "[decrementDegree] Node " << regIdToString(m) << " has degree " << d << ", now decremented to " << degree.at(m) << ". Added to simplifyWorklist.\n"; } simplifyWorklist.insert(m); @@ -1176,7 +1151,7 @@ void RISCv64RegAlloc::addWorklist(unsigned u) { if (!moveRelated(u) && degree.at(u) < K) { freezeWorklist.erase(u); simplifyWorklist.insert(u); - if (DEEPDEBUG) { + if (DEEPERDEBUG) { std::cerr << "[addWorklist] Node " << regIdToString(u) << " added to simplifyWorklist (degree: " << degree.at(u) << ", K: " << K << ").\n"; } } @@ -1184,7 +1159,7 @@ void RISCv64RegAlloc::addWorklist(unsigned u) { // Briggs启发式 bool RISCv64RegAlloc::briggsHeuristic(unsigned u, unsigned v) { - if (DEEPDEBUG) { + if (DEEPERDEBUG) { std::cerr << "\n[Briggs] >>>>> Checking coalesce between " << regIdToString(u) << " and " << regIdToString(v) << " <<<<<\n"; } @@ -1196,7 +1171,7 @@ bool RISCv64RegAlloc::briggsHeuristic(unsigned u, unsigned v) { VRegSet all_adj = u_adj; all_adj.insert(v_adj.begin(), v_adj.end()); - if (DEEPDEBUG) { + if (DEEPERDEBUG) { auto print_set = [this](const VRegSet& s, const std::string& name) { std::cerr << "[Briggs] " << name << " (" << s.size() << "): { "; for (unsigned id : s) std::cerr << regIdToString(id) << " "; @@ -1209,14 +1184,14 @@ bool RISCv64RegAlloc::briggsHeuristic(unsigned u, unsigned v) { // 步骤 3: 遍历合并后的邻居集合，计算度数 >= K 的节点数量 int k = 0; - if (DEEPDEBUG) std::cerr << "[Briggs] Checking significance of combined neighbors:\n"; + if (DEEPERDEBUG) std::cerr << "[Briggs] Checking significance of combined neighbors:\n"; for (unsigned n : all_adj) { // 关键修正：只考虑那些在工作集中的邻居节点 n if (degree.count(n) > 0) { int K = isFPVReg(n) ? K_fp : K_int; if (degree.at(n) >= K) { k++; - if (DEEPDEBUG) { + if (DEEPERDEBUG) { std::cerr << "[Briggs] - Node " << regIdToString(n) << " is significant (degree " << degree.at(n) << " >= " << K << "). Count k is now " << k << ".\n"; } } @@ -1227,12 +1202,11 @@ bool RISCv64RegAlloc::briggsHeuristic(unsigned u, unsigned v) { int K_u = isFPVReg(u) ? K_fp : K_int; bool result = (k < K_u); - if (DEEPDEBUG) { + if (DEEPERDEBUG) { std::cerr << "[Briggs] Final count of significant neighbors (k) = " << k << ".\n"; std::cerr << "[Briggs] K value for node " << regIdToString(u) << " is " << K_u << ".\n"; std::cerr << "[Briggs] >>>>> Result (k < K): " << (result ? "OK (can coalesce)" : "FAIL (cannot coalesce)") << "\n\n"; } - return result; } @@ -1336,7 +1310,7 @@ void RISCv64RegAlloc::freezeMoves(unsigned u) { if (!precolored.count(v_alias) && nodeMoves(v_alias).empty() && degree.at(v_alias) < (isFPVReg(v_alias) ? K_fp : K_int)) { freezeWorklist.erase(v_alias); simplifyWorklist.insert(v_alias); - if (DEEPDEBUG) { + if (DEEPERDEBUG) { std::cerr << "[freezeMoves] Node " << regIdToString(v_alias) << " moved to simplifyWorklist (degree: " << degree.at(v_alias) << ").\n"; } } @@ -1431,9 +1405,26 @@ void RISCv64RegAlloc::dumpState(const std::string& stage) { if (!DEEPDEBUG) return; std::cerr << "\n=============== STATE DUMP (" << stage << ") ===============\n"; auto print_vreg_set = [&](const VRegSet& s, const std::string& name){ - std::cerr << name << " (" << s.size() << "): { "; - for(unsigned v : s) std::cerr << "%vreg" << v << " "; - std::cerr << "}\n"; + if (s.size() > DEBUGLENGTH) { + std::cerr << name << " (" << s.size() << ")\n"; + } + else { + std::cerr << name << " (" << s.size() << "): { "; + for(unsigned v : s) std::cerr << "%vreg" << v << " "; + std::cerr << "}\n"; + } + + }; + auto print_vreg_stack = [&](const VRegStack& s, const std::string& name){ + if (s.size() > DEBUGLENGTH) { + std::cerr << name << " (" << s.size() << ")\n"; + } + else { + std::cerr << name << " (" << s.size() << "): { "; + for(unsigned v : s) std::cerr << "%vreg" << v << " "; + std::cerr << "}\n"; + } + }; print_vreg_set(simplifyWorklist, "SimplifyWorklist"); print_vreg_set(freezeWorklist, "FreezeWorklist"); @@ -1441,9 +1432,7 @@ void RISCv64RegAlloc::dumpState(const std::string& stage) { print_vreg_set(coalescedNodes, "CoalescedNodes"); print_vreg_set(spilledNodes, "SpilledNodes"); - std::cerr << "SelectStack (" << selectStack.size() << "): { "; - for(unsigned v : selectStack) std::cerr << "%vreg" << v << " "; - std::cerr << "}\n"; + print_vreg_stack(selectStack, "SelectStack"); std::cerr << "WorklistMoves (" << worklistMoves.size() << ")\n"; std::cerr << "ActiveMoves (" << activeMoves.size() << ")\n"; diff --git a/src/include/backend/RISCv64/RISCv64RegAlloc.h b/src/include/backend/RISCv64/RISCv64RegAlloc.h index caf8149..bea9ddc 100644 --- a/src/include/backend/RISCv64/RISCv64RegAlloc.h +++ b/src/include/backend/RISCv64/RISCv64RegAlloc.h @@ -1,5 +1,3 @@ -// in file: RISCv64RegAlloc.h - #ifndef RISCV64_REGALLOC_H #define RISCV64_REGALLOC_H @@ -12,6 +10,8 @@ extern int DEBUG; extern int DEEPDEBUG; +extern int DEBUGLENGTH; // 用于限制调试输出的长度 +extern int DEEPERDEBUG; // 用于更深层次的调试输出 namespace sysy { diff --git a/src/sysyc.cpp b/src/sysyc.cpp index 04da485..747eb89 100644 --- a/src/sysyc.cpp +++ b/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; From 004ef8248859598ba8ff27bf552078b3154cf401 Mon Sep 17 00:00:00 2001 From: Lixuanwang Date: Sat, 2 Aug 2025 15:10:19 +0800 Subject: [PATCH 09/55] =?UTF-8?q?[backend-IRC]=E4=BF=AE=E5=A4=8D=E4=BA=86?= =?UTF-8?q?=E5=90=8E=E7=AB=AF=E4=B8=8D=E9=80=82=E9=85=8D=E4=B8=AD=E7=AB=AF?= =?UTF-8?q?=E5=85=A8=E5=B1=80=E5=8F=98=E9=87=8F=E5=AE=9A=E4=B9=89=E7=9A=84?= =?UTF-8?q?=E9=97=AE=E9=A2=98?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/backend/RISCv64/RISCv64Backend.cpp | 103 +++++++++++++++---- src/include/backend/RISCv64/RISCv64Backend.h | 3 + 2 files changed, 87 insertions(+), 19 deletions(-) diff --git a/src/backend/RISCv64/RISCv64Backend.cpp b/src/backend/RISCv64/RISCv64Backend.cpp index dc9c089..90caeef 100644 --- a/src/backend/RISCv64/RISCv64Backend.cpp +++ b/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(); + // 递归调用以计算元素大小 + 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(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(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()->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()->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()->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()->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"; } } } @@ -161,10 +224,10 @@ std::string RISCv64CodeGen::function_gen(Function* func) { RISCv64RegAlloc reg_alloc(mfunc.get()); reg_alloc.run(); - DEBUG = 0; - DEEPDEBUG = 0; - // DEBUG = 1; - // DEEPDEBUG = 1; + // DEBUG = 0; + // DEEPDEBUG = 0; + DEBUG = 1; + DEEPDEBUG = 1; if (DEBUG) { std::cerr << "====== stack info after reg alloc ======\n"; mfunc->dumpStackFrameInfo(std::cerr); @@ -207,6 +270,8 @@ std::string RISCv64CodeGen::function_gen(Function* func) { ss << "\n\n; --- Intermediate Representation after Instruction Selection ---\n" << ss_after_isel.str(); } + DEBUG = 1; + DEEPDEBUG = 1; return ss.str(); } diff --git a/src/include/backend/RISCv64/RISCv64Backend.h b/src/include/backend/RISCv64/RISCv64Backend.h index 403d586..7b9afe7 100644 --- a/src/include/backend/RISCv64/RISCv64Backend.h +++ b/src/include/backend/RISCv64/RISCv64Backend.h @@ -22,6 +22,9 @@ private: // 函数级代码生成 (实现新的流水线) std::string function_gen(Function* func); + // 私有辅助函数，用于根据类型计算其占用的字节数。 + unsigned getTypeSizeInBytes(Type* type); + Module* module; }; From a1cf60c420f17386232deaf3c7194a9fa1aac468 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=AD=AA=E6=AF=94=E6=AD=AA=E6=AF=94?= <15734459+yzllzyaaa@user.noreply.gitee.com> Date: Sat, 2 Aug 2025 22:48:21 +0800 Subject: [PATCH 10/55] =?UTF-8?q?[midend-BuildCFG]=E6=96=B0=E5=A2=9EBuildC?= =?UTF-8?q?FG=E4=BC=98=E5=8C=96=E9=80=9A=E9=81=93=EF=BC=8C=E5=AE=9E?= =?UTF-8?q?=E7=8E=B0=E6=8E=A7=E5=88=B6=E6=B5=81=E5=9B=BE=E7=9A=84=E6=9E=84?= =?UTF-8?q?=E5=BB=BA=E4=B8=8E=E5=88=86=E6=9E=90?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/include/midend/Pass/Optimize/BuildCFG.h | 33 ++++++ src/midend/Pass/Optimize/BuildCFG.cpp | 121 ++++++++++++++++++++ src/midend/Pass/Pass.cpp | 11 ++ 3 files changed, 165 insertions(+) create mode 100644 src/include/midend/Pass/Optimize/BuildCFG.h create mode 100644 src/midend/Pass/Optimize/BuildCFG.cpp diff --git a/src/include/midend/Pass/Optimize/BuildCFG.h b/src/include/midend/Pass/Optimize/BuildCFG.h new file mode 100644 index 0000000..4054c54 --- /dev/null +++ b/src/include/midend/Pass/Optimize/BuildCFG.h @@ -0,0 +1,33 @@ +#pragma once + +#include "Pass.h" +#include "IR.h" +#include "Instruction.h" +#include +#include + +namespace sysy { + +class DominatorTreeAnalysisPass; +class LivenessAnalysisPass; + +class BuildCFG : public OptimizationPass { +public: + // Pass的唯一ID，用于PassRegistry + static char ID; + + BuildCFG() : OptimizationPass("BuildCFG", Pass::Granularity::Function, Pass::PassKind::Optimization) {} + + // 重载 runOnFunction 方法，实现具体的优化逻辑 + bool runOnFunction(Function *F, AnalysisManager& AM) override; + + // 提供PassID + void *getPassID() const override { return &ID; } + + // 声明Pass的分析使用 + // BuildCFG不依赖任何分析，但会使其他依赖CFG的分析失效 + void getAnalysisUsage(std::set &analysisDependencies, + std::set &analysisInvalidations) override; +}; + +} // namespace sysy \ No newline at end of file diff --git a/src/midend/Pass/Optimize/BuildCFG.cpp b/src/midend/Pass/Optimize/BuildCFG.cpp new file mode 100644 index 0000000..823d126 --- /dev/null +++ b/src/midend/Pass/Optimize/BuildCFG.cpp @@ -0,0 +1,121 @@ +#include "BuildCFG.h" +#include "Instruction.h" +#include "IR.h" +#include "Liveness.h" // 包含活跃性分析的头文件以引用其ID +#include "Dom.h" // 包含支配树分析的头文件以引用其ID +#include +#include +#include + +namespace sysy { + +char BuildCFG::ID = 0; + +// 声明Pass的分析使用 +void BuildCFG::getAnalysisUsage(std::set &analysisDependencies, + std::set &analysisInvalidations) { + // BuildCFG不依赖其他分析 + // analysisDependencies.insert(&DominatorTreeAnalysisPass::ID); // 错误的例子 + + // BuildCFG会使所有依赖于CFG的分析结果失效，所以它必须声明这些失效 + analysisInvalidations.insert(&DominatorTreeAnalysisPass::ID); + analysisInvalidations.insert(&LivenessAnalysisPass::ID); +} + +bool BuildCFG::runOnFunction(Function *F, AnalysisManager& AM) { + if (DEBUG) { + std::cout << "Running BuildCFG pass on function: " << F->getName() << std::endl; + } + + bool changed = false; + + // 1. 清空所有基本块的前驱和后继列表 + for (auto &bb : *F) { + bb->predecessors.clear(); + bb->successors.clear(); + } + + // 2. 遍历每个基本块，重建CFG + for (auto &bb : *F) { + // 获取基本块的最后一条指令 + Instruction *termInst = bb->getTerminator(); + + // 确保基本块有终结指令 + if (!termInst) { + continue; + } + + // 根据终结指令类型，建立前驱后继关系 + if (auto brInst = dynamic_cast(termInst)) { + // 无条件跳转 + if (brInst->getNumOperands() == 1) { + BasicBlock *succ = dynamic_cast(brInst->getOperand(0)); + assert(succ && "Branch instruction's target must be a BasicBlock"); + + bb->successors.push_back(succ); + succ->predecessors.push_back(bb.get()); + changed = true; + + // 条件跳转 + } else if (brInst->getNumOperands() == 3) { + BasicBlock *trueSucc = dynamic_cast(brInst->getOperand(1)); + BasicBlock *falseSucc = dynamic_cast(brInst->getOperand(2)); + + assert(trueSucc && falseSucc && "Branch instruction's targets must be BasicBlocks"); + + bb->successors.push_back(trueSucc); + trueSucc->predecessors.push_back(bb.get()); + + bb->successors.push_back(falseSucc); + falseSucc->predecessors.push_back(bb.get()); + changed = true; + } + } else if (auto retInst = dynamic_cast(termInst)) { + // RetInst没有后继，无需处理 + // ... + } + } + + // 3. 额外处理：可达性分析，标记不可达基本块 + std::queue q; + std::set visited; + + // 默认所有块不可达 + for (auto &bb : *F) { + bb->setreachableFalse(); + } + + // 从函数入口基本块开始 + BasicBlock* entryBB = F->getEntryBlock(); + if (entryBB) { + q.push(entryBB); + visited.insert(entryBB); + entryBB->setreachableTrue(); + } + + // 广度优先搜索 (BFS) 遍历所有可达的基本块 + while (!q.empty()) { + BasicBlock* currentBB = q.front(); + q.pop(); + + for (auto& succ : currentBB->successors) { + if (visited.find(succ) == visited.end()) { + q.push(succ); + visited.insert(succ); + succ->setreachableTrue(); + } + } + } + + // 将未访问到的基本块标记为不可达 + for (auto& bb : *F) { + if (visited.find(bb.get()) == visited.end()) { + bb->setreachableFalse(); + changed = true; // 发现不可达块，视为改变 + } + } + + return changed; +} + +} // namespace sysy \ No newline at end of file diff --git a/src/midend/Pass/Pass.cpp b/src/midend/Pass/Pass.cpp index f4ec5ab..c293853 100644 --- a/src/midend/Pass/Pass.cpp +++ b/src/midend/Pass/Pass.cpp @@ -6,6 +6,7 @@ #include "Mem2Reg.h" #include "Reg2Mem.h" #include "SCCP.h" +#include "BuildCFG.h" #include "Pass.h" #include #include @@ -39,6 +40,7 @@ void PassManager::runOptimizationPipeline(Module* moduleIR, IRBuilder* builderIR registerAnalysisPass(); // 注册优化遍 + registerOptimizationPass(builderIR); registerOptimizationPass(); registerOptimizationPass(); registerOptimizationPass(); @@ -58,6 +60,15 @@ void PassManager::runOptimizationPipeline(Module* moduleIR, IRBuilder* builderIR if (DEBUG) std::cout << "Applying -O1 optimizations.\n"; if (DEBUG) std::cout << "--- Running custom optimization sequence ---\n"; + if(DEBUG) { + std::cout << "=== IR Before CFGOpt Optimizations ===\n"; + printPasses(); + } + + this->clearPasses(); + this->addPass(&&BuildCFG::ID); + this->run(); + this->clearPasses(); this->addPass(&SysYDelInstAfterBrPass::ID); this->addPass(&SysYDelNoPreBLockPass::ID); From 32ea24df560b8811f91007a12c53461c4a2b73b9 Mon Sep 17 00:00:00 2001 From: rain2133 <1370973498@qq.com> Date: Sun, 3 Aug 2025 00:51:49 +0800 Subject: [PATCH 11/55] =?UTF-8?q?[midend]=E4=BF=AE=E5=A4=8DentryBB?= =?UTF-8?q?=E5=92=8CfuncBodyEntry=E7=9A=84=E5=88=9D=E5=A7=8B=E5=8C=96?= =?UTF-8?q?=EF=BC=8CDom=E8=AE=A1=E7=AE=97=E5=BC=95=E8=BF=9B=E9=80=86?= =?UTF-8?q?=E5=90=8E=E7=BB=AD=E9=81=8D=E5=8E=86=E5=92=8CLT=E7=AE=97?= =?UTF-8?q?=E6=B3=95=EF=BC=8CPass=E5=85=88=E9=BB=98=E8=AE=A4=E5=85=B3?= =?UTF-8?q?=E6=8E=89CFGOpt?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/include/midend/Pass/Analysis/Dom.h | 68 +++- src/midend/Pass/Analysis/Dom.cpp | 409 ++++++++++++++++++------- src/midend/Pass/Pass.cpp | 16 +- src/midend/SysYIRGenerator.cpp | 1 + 4 files changed, 368 insertions(+), 126 deletions(-) diff --git a/src/include/midend/Pass/Analysis/Dom.h b/src/include/midend/Pass/Analysis/Dom.h index 80e0883..5ad5fe3 100644 --- a/src/include/midend/Pass/Analysis/Dom.h +++ b/src/include/midend/Pass/Analysis/Dom.h @@ -6,30 +6,82 @@ #include #include #include +#include namespace sysy { -// 支配树分析结果类 (保持不变) +// 支配树分析结果类 class DominatorTree : public AnalysisResultBase { public: DominatorTree(Function* F); + // 获取指定基本块的所有支配者 const std::set* getDominators(BasicBlock* BB) const; - BasicBlock* getImmediateDominator(BasicBlock* BB) const; - const std::set* getDominanceFrontier(BasicBlock* BB) const; + // 获取指定基本块的即时支配者 (Immediate Dominator) + BasicBlock* getImmediateDominator(BasicBlock* BB) const; + // 获取指定基本块的支配边界 (Dominance Frontier) + const std::set* getDominanceFrontier(BasicBlock* BB) const; + // 获取指定基本块在支配树中的子节点 const std::set* getDominatorTreeChildren(BasicBlock* BB) const; + // 额外的 Getter：获取所有支配者、即时支配者和支配边界的完整映射（可选，主要用于调试或特定场景） const std::map>& getDominatorsMap() const { return Dominators; } const std::map& getIDomsMap() const { return IDoms; } const std::map>& getDominanceFrontiersMap() const { return DominanceFrontiers; } + + // 计算所有基本块的支配者集合 void computeDominators(Function* F); - void computeIDoms(Function* F); + // 计算所有基本块的即时支配者（内部使用 Lengauer-Tarjan 算法） + void computeIDoms(Function* F); + // 计算所有基本块的支配边界 void computeDominanceFrontiers(Function* F); + // 计算支配树的结构（即每个节点的直接子节点） void computeDominatorTreeChildren(Function* F); private: + // 与该支配树关联的函数 Function* AssociatedFunction; - std::map> Dominators; - std::map IDoms; - std::map> DominanceFrontiers; - std::map> DominatorTreeChildren; + std::map> Dominators; // 每个基本块的支配者集合 + std::map IDoms; // 每个基本块的即时支配者 + std::map> DominanceFrontiers; // 每个基本块的支配边界 + std::map> DominatorTreeChildren; // 支配树中每个基本块的子节点 + + // ========================================================== + // Lengauer-Tarjan 算法内部所需的数据结构和辅助函数 + // 这些成员是私有的，以封装 LT 算法的复杂性并避免命名空间污染 + // ========================================================== + + // DFS 遍历相关： + std::map dfnum_map; // 存储每个基本块的 DFS 编号 + std::vector vertex_vec; // 通过 DFS 编号反向查找对应的基本块指针 + std::map parent_map; // 存储 DFS 树中每个基本块的父节点 + int df_counter; // DFS 计数器，也代表 DFS 遍历的总节点数 (N) + + // 半支配者 (Semi-dominator) 相关： + std::map sdom_map; // 存储每个基本块的半支配者 + std::map idom_map; // 存储每个基本块的即时支配者 (IDom) + std::map> bucket_map; // 桶结构，用于存储具有相同半支配者的节点，以延迟 IDom 计算 + + // 并查集 (Union-Find) 相关（用于 evalAndCompress 函数）： + std::map ancestor_map; // 并查集中的父节点（用于路径压缩） + std::map label_map; // 并查集中，每个集合的代表节点（或其路径上 sdom 最小的节点） + + // ========================================================== + // 辅助计算函数 (私有) + // ========================================================== + + // 计算基本块的逆后序遍历 (Reverse Post Order, RPO) 顺序 + // RPO 用于优化支配者计算和 LT 算法的效率 + std::vector 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); }; diff --git a/src/midend/Pass/Analysis/Dom.cpp b/src/midend/Pass/Analysis/Dom.cpp index 77b2bba..b4054c9 100644 --- a/src/midend/Pass/Analysis/Dom.cpp +++ b/src/midend/Pass/Analysis/Dom.cpp @@ -1,21 +1,30 @@ #include "Dom.h" -#include // for std::set_intersection, std::set_difference, std::set_union +#include // for std::set_intersection, std::reverse #include // for debug output #include // for std::numeric_limits #include +#include // for std::function +#include +#include +#include namespace sysy { -// 初始化 支配树静态 ID +// ============================================================== +// DominatorTreeAnalysisPass 的静态ID +// ============================================================== void *DominatorTreeAnalysisPass::ID = (void *)&DominatorTreeAnalysisPass::ID; + // ============================================================== // DominatorTree 结果类的实现 // ============================================================== +// 构造函数：初始化关联函数，但不进行计算 DominatorTree::DominatorTree(Function *F) : AssociatedFunction(F) { - // 构造时可以不计算，在分析遍运行里计算并填充 + // 构造时不需要计算，在分析遍运行里计算并填充 } +// Getter 方法 (保持不变) const std::set *DominatorTree::getDominators(BasicBlock *BB) const { auto it = Dominators.find(BB); if (it != Dominators.end()) { @@ -48,7 +57,7 @@ const std::set *DominatorTree::getDominatorTreeChildren(BasicBlock return nullptr; } -// 辅助函数：打印 BasicBlock 集合 +// 辅助函数：打印 BasicBlock 集合 (保持不变) void printBBSet(const std::string &prefix, const std::set &s) { if (!DEBUG) return; @@ -63,24 +72,52 @@ void printBBSet(const std::string &prefix, const std::set &s) { std::cout << "}" << std::endl; } +// 辅助函数：计算逆后序遍历 (RPO) - 保持不变 +std::vector DominatorTree::computeReversePostOrder(Function* F) { + std::vector postOrder; + std::set visited; + + std::function 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 bbs_in_order; // 用于确定遍历顺序，如果需要的话 + std::vector bbs_rpo = computeReversePostOrder(F); - // 初始化：入口块只被自己支配，其他块被所有块支配 - for (const auto &bb_ptr : F->getBasicBlocks()) { - BasicBlock *bb = bb_ptr.get(); - bbs_in_order.push_back(bb); // 收集所有块 + for (BasicBlock *bb : bbs_rpo) { if (bb == entryBlock) { + Dominators[bb].clear(); Dominators[bb].insert(bb); - if (DEBUG) - std::cout << "Init Dominators[" << bb->getName() << "]: {" << bb->getName() << "}" << std::endl; + if (DEBUG) std::cout << "Init Dominators[" << bb->getName() << "]: {" << bb->getName() << "}" << std::endl; } else { - for (const auto &all_bb_ptr : F->getBasicBlocks()) { - Dominators[bb].insert(all_bb_ptr.get()); + Dominators[bb].clear(); + for (BasicBlock *all_bb : bbs_rpo) { + Dominators[bb].insert(all_bb); } if (DEBUG) { std::cout << "Init Dominators[" << bb->getName() << "]: "; @@ -94,35 +131,29 @@ 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; - // 确保遍历顺序一致性，例如可以按照DFS或BFS顺序，或者简单的迭代器顺序 - // 如果Function::getBasicBlocks()返回的迭代器顺序稳定，则无需bbs_in_order - for (const auto &bb_ptr : F->getBasicBlocks()) { // 假设这个迭代器顺序稳定 - BasicBlock *bb = bb_ptr.get(); - if (bb == entryBlock) - continue; + for (BasicBlock *bb : bbs_rpo) { + if (bb == entryBlock) continue; - // 计算所有前驱的支配者集合的交集 std::set newDom; bool firstPredProcessed = false; for (BasicBlock *pred : bb->getPredecessors()) { - // 确保前驱的支配者集合已经计算过 - if (Dominators.count(pred)) { - if (!firstPredProcessed) { - newDom = Dominators[pred]; - firstPredProcessed = true; - } else { - std::set intersection; - std::set_intersection(newDom.begin(), newDom.end(), Dominators[pred].begin(), Dominators[pred].end(), - std::inserter(intersection, intersection.begin())); - newDom = intersection; - } + if(DEBUG){ + std::cout << " Processing predecessor: " << pred->getName() << std::endl; } + if (!firstPredProcessed) { + newDom = Dominators[pred]; + firstPredProcessed = true; + } else { + std::set intersection; + std::set_intersection(newDom.begin(), newDom.end(), Dominators[pred].begin(), Dominators[pred].end(), + std::inserter(intersection, intersection.begin())); + newDom = intersection; + } } - newDom.insert(bb); // BB 永远支配自己 + newDom.insert(bb); if (newDom != Dominators[bb]) { if (DEBUG) { @@ -140,78 +171,242 @@ void DominatorTree::computeDominators(Function *F) { std::cout << "--- Dominators Computation Finished ---" << std::endl; } -void DominatorTree::computeIDoms(Function *F) { - if (DEBUG) - std::cout << "--- Computing Immediate Dominators (IDoms) ---" << std::endl; +// ============================================================== +// Lengauer-Tarjan 算法辅助数据结构和函数 (私有成员) +// ============================================================== - BasicBlock *entryBlock = F->getEntryBlock(); - IDoms[entryBlock] = nullptr; // 入口块没有即时支配者 - - // 遍历所有非入口块 - for (const auto &bb_ptr : F->getBasicBlocks()) { - BasicBlock *bb = bb_ptr.get(); - if (bb == entryBlock) - continue; - - BasicBlock *currentIDom = nullptr; - const std::set *domsOfBB = getDominators(bb); - if (!domsOfBB) { - if (DEBUG) - std::cerr << "Warning: Dominators for " << bb->getName() << " not found!" << std::endl; - continue; +// 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++; - // 遍历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 *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; + 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); } - } - if (D_candidate_is_IDom) { - currentIDom = D_candidate; - break; // 找到即时支配者，可以退出循环，因为它是唯一的 - } } - IDoms[bb] = currentIDom; - if (DEBUG) { - std::cout << " IDom[" << bb->getName() << "] = " << (currentIDom ? currentIDom->getName() : "nullptr") - << std::endl; - } - } - if (DEBUG) - std::cout << "--- Immediate Dominators Computation Finished ---" << std::endl; } -/* -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} -*/ +// 并查集：找到集合的代表，并进行路径压缩 +// 同时更新 label，确保 label[i] 总是指向其祖先链中 sdom_map 最小的节点 +// 对应用户代码的 find 函数，也包含了 eval 的逻辑 +BasicBlock* DominatorTree::evalAndCompress_lt_helper(BasicBlock* i) { + if (DEBUG) std::cout << " Eval: Processing " << i->getName() << std::endl; + // 如果 i 是根 (ancestor_map[i] == nullptr) + if (ancestor_map.find(i) == ancestor_map.end() || ancestor_map[i] == nullptr) { + if (DEBUG) std::cout << " Eval: " << i->getName() << " is root, returning itself." << std::endl; + return i; // 根节点自身就是路径上sdom最小的，因为它没有祖先 + } + + // 如果 i 的祖先不是根，则递归查找并进行路径压缩 + BasicBlock* root_ancestor = evalAndCompress_lt_helper(ancestor_map[i]); + + // 路径压缩时，根据 sdom_map 比较并更新 label_map + // 确保 label_map[i] 存储的是 i 到 root_ancestor 路径上 sdom_map 最小的节点 + // 注意：这里的 ancestor_map[i] 已经被递归调用压缩过一次了，所以是root_ancestor的旧路径 + // 应该比较的是 label_map[ancestor_map[i]] 和 label_map[i] + if (sdom_map.count(label_map[ancestor_map[i]]) && // 确保 label_map[ancestor_map[i]] 存在 sdom + sdom_map.count(label_map[i]) && // 确保 label_map[i] 存在 sdom + dfnum_map[sdom_map[label_map[ancestor_map[i]]]] < dfnum_map[sdom_map[label_map[i]]]) { + if (DEBUG) std::cout << " Eval: Updating label for " << i->getName() << " from " + << label_map[i]->getName() << " to " << label_map[ancestor_map[i]]->getName() << std::endl; + label_map[i] = label_map[ancestor_map[i]]; + } + + ancestor_map[i] = root_ancestor; // 执行路径压缩：将 i 直接指向其所属集合的根 + if (DEBUG) std::cout << " Eval: Path compression for " << i->getName() << ", new ancestor = " + << (root_ancestor ? root_ancestor->getName() : "nullptr") << std::endl; + + return label_map[i]; // <-- **将这里改为返回 label_map[i]** +} + +// Link 函数：将 v 加入 u 的 DFS 树子树中 (实际上是并查集操作) +// 对应用户代码的 fa[u] = fth[u]; +void DominatorTree::link_lt_helper(BasicBlock* u_parent, BasicBlock* v_child) { + ancestor_map[v_child] = u_parent; // 设置并查集父节点 + label_map[v_child] = v_child; // 初始化 label 为自身 + if (DEBUG) std::cout << " Link: " << v_child->getName() << " linked to " << u_parent->getName() << std::endl; +} + +// ============================================================== +// Lengauer-Tarjan 算法实现 computeIDoms +// ============================================================== +void DominatorTree::computeIDoms(Function *F) { + if (DEBUG) std::cout << "--- Computing Immediate Dominators (IDoms) using Lengauer-Tarjan ---" << std::endl; + + BasicBlock *entryBlock = F->getEntryBlock(); + + // 1. 初始化所有 LT 相关的数据结构 + dfnum_map.clear(); + vertex_vec.clear(); + parent_map.clear(); + sdom_map.clear(); + idom_map.clear(); + bucket_map.clear(); + ancestor_map.clear(); + label_map.clear(); + df_counter = 0; // DFS 计数器从 0 开始 + + // 预分配 vertex_vec 的大小，避免频繁resize + vertex_vec.resize(F->getBasicBlocks().size() + 1); + // 在 DFS 遍历之前，先为所有基本块初始化 sdom 和 label + // 这是 Lengauer-Tarjan 算法的要求，确保所有节点在 Phase 2 开始前都在 map 中 + for (auto &bb_ptr : F->getBasicBlocks()) { + BasicBlock* bb = bb_ptr.get(); + sdom_map[bb] = bb; // sdom(bb) 初始化为 bb 自身 + label_map[bb] = bb; // label(bb) 初始化为 bb 自身 (用于 Union-Find 的路径压缩) + } + // 确保入口块也被正确初始化（如果它不在 F->getBasicBlocks() 的正常迭代中） + sdom_map[entryBlock] = entryBlock; + label_map[entryBlock] = entryBlock; + // Phase 1: DFS 遍历并预处理 + // 对应用户代码的 dfs(st) + dfs_lt_helper(entryBlock); + idom_map[entryBlock] = nullptr; // 入口块没有即时支配者 + if (DEBUG) std::cout << " IDom[" << entryBlock->getName() << "] = nullptr" << std::endl; + + if (DEBUG) std::cout << " Sdom[" << entryBlock->getName() << "] = " << entryBlock->getName() << std::endl; + + // 初始化并查集的祖先和 label + for (auto const& [bb_key, dfn_val] : dfnum_map) { + ancestor_map[bb_key] = nullptr; // 初始为独立集合的根 + label_map[bb_key] = bb_key; // 初始 label 为自身 + } + + if (DEBUG) { + std::cout << " --- DFS Phase Complete ---" << std::endl; + std::cout << " dfnum_map:" << std::endl; + for (auto const& [bb, dfn] : dfnum_map) { + std::cout << " " << bb->getName() << " -> " << dfn << std::endl; + } + std::cout << " vertex_vec (by dfnum):" << std::endl; + for (size_t k = 0; k < df_counter; ++k) { + if (vertex_vec[k]) std::cout << " [" << k << "] -> " << vertex_vec[k]->getName() << std::endl; + } + std::cout << " parent_map:" << std::endl; + for (auto const& [child, parent] : parent_map) { + std::cout << " " << child->getName() << " -> " << (parent ? parent->getName() : "nullptr") << std::endl; + } + std::cout << " ------------------------" << std::endl; + } + + + // Phase 2: 计算半支配者 (sdom) + // 对应用户代码的 for (int i = dfc; i >= 2; --i) 循环的上半部分 + // 按照 DFS 编号递减的顺序遍历所有节点 (除了 entryBlock，它的 DFS 编号是 0) + if (DEBUG) std::cout << "--- Phase 2: Computing Semi-Dominators (sdom) ---" << std::endl; + for (int i = df_counter - 1; i >= 1; --i) { // 从 DFS 编号最大的节点开始，到 1 + BasicBlock* w = vertex_vec[i]; // 当前处理的节点 + if (DEBUG) std::cout << " Processing node w: " << w->getName() << " (dfnum=" << i << ")" << std::endl; + + + // 对于 w 的每个前驱 v + for (BasicBlock* v : w->getPredecessors()) { + if (DEBUG) std::cout << " Considering predecessor v: " << v->getName() << std::endl; + // 如果前驱 v 未被 DFS 访问过 (即不在 dfnum_map 中)，则跳过 + if (dfnum_map.find(v) == dfnum_map.end()) { + if (DEBUG) std::cout << " Predecessor " << v->getName() << " not in DFS tree, skipping." << std::endl; + continue; + } + + // 调用 evalAndCompress 来找到 v 在其 DFS 树祖先链上具有最小 sdom 的节点 + BasicBlock* u_with_min_sdom_on_path = evalAndCompress_lt_helper(v); + if (DEBUG) std::cout << " Eval(" << v->getName() << ") returned " + << u_with_min_sdom_on_path->getName() << std::endl; + if (DEBUG && sdom_map.count(u_with_min_sdom_on_path) && sdom_map.count(w)) { + std::cout << " Comparing sdom: dfnum[" << sdom_map[u_with_min_sdom_on_path]->getName() << "] (" << dfnum_map[sdom_map[u_with_min_sdom_on_path]] + << ") vs dfnum[" << sdom_map[w]->getName() << "] (" << dfnum_map[sdom_map[w]] << ")" << std::endl; + } + // 比较 sdom(u) 和 sdom(w) + if (sdom_map.count(u_with_min_sdom_on_path) && sdom_map.count(w) && + dfnum_map[sdom_map[u_with_min_sdom_on_path]] < dfnum_map[sdom_map[w]]) { + if (DEBUG) std::cout << " Updating sdom[" << w->getName() << "] from " + << sdom_map[w]->getName() << " to " + << sdom_map[u_with_min_sdom_on_path]->getName() << std::endl; + sdom_map[w] = sdom_map[u_with_min_sdom_on_path]; // 更新 sdom(w) + if (DEBUG) std::cout << " Sdom update applied. New sdom[" << w->getName() << "] = " << sdom_map[w]->getName() << std::endl; + } + } + + // 将 w 加入 sdom(w) 对应的桶中 + bucket_map[sdom_map[w]].push_back(w); + if (DEBUG) std::cout << " Adding " << w->getName() << " to bucket of sdom(" << w->getName() << "): " + << sdom_map[w]->getName() << std::endl; + + // 将 w 的父节点加入并查集 (link 操作) + if (parent_map.count(w) && parent_map[w] != nullptr) { + link_lt_helper(parent_map[w], w); + } + + // Phase 3-part 1: 处理 parent[w] 的桶中所有节点，确定部分 idom + if (parent_map.count(w) && parent_map[w] != nullptr) { + BasicBlock* p = parent_map[w]; // p 是 w 的父节点 + if (DEBUG) std::cout << " Processing bucket for parent " << p->getName() << std::endl; + + // 注意：这里需要复制桶的内容，因为原始桶在循环中会被clear + std::vector nodes_in_p_bucket_copy = bucket_map[p]; + for (BasicBlock* y : nodes_in_p_bucket_copy) { + if (DEBUG) std::cout << " Processing node y from bucket: " << y->getName() << std::endl; + // 找到 y 在其 DFS 树祖先链上具有最小 sdom 的节点 + BasicBlock* u = evalAndCompress_lt_helper(y); + if (DEBUG) std::cout << " Eval(" << y->getName() << ") returned " << u->getName() << std::endl; + + // 确定 idom(y) + // if sdom(eval(y)) == sdom(parent(w)), then idom(y) = parent(w) + // else idom(y) = eval(y) + if (sdom_map.count(u) && sdom_map.count(p) && + dfnum_map[sdom_map[u]] < dfnum_map[sdom_map[p]]) { + idom_map[y] = u; // 确定的 idom + if (DEBUG) std::cout << " IDom[" << y->getName() << "] set to " << u->getName() << std::endl; + } else { + idom_map[y] = p; // p 是 y 的 idom + if (DEBUG) std::cout << " IDom[" << y->getName() << "] set to " << p->getName() << std::endl; + } + } + bucket_map[p].clear(); // 清空桶，防止重复处理 + if (DEBUG) std::cout << " Cleared bucket for parent " << p->getName() << std::endl; + } + } + + // Phase 3-part 2: 最终确定 idom (处理那些 idom != sdom 的节点) + if (DEBUG) std::cout << "--- Phase 3: Finalizing Immediate Dominators (idom) ---" << std::endl; + for (int i = 1; i < df_counter; ++i) { // 从 DFS 编号最小的节点 (除了 entryBlock) 开始 + BasicBlock* w = vertex_vec[i]; + if (DEBUG) std::cout << " Finalizing node w: " << w->getName() << std::endl; + if (idom_map.count(w) && sdom_map.count(w) && idom_map[w] != sdom_map[w]) { + // idom[w] 的 idom 是其真正的 idom + if (DEBUG) std::cout << " idom[" << w->getName() << "] (" << idom_map[w]->getName() + << ") != sdom[" << w->getName() << "] (" << sdom_map[w]->getName() << ")" << std::endl; + if (idom_map.count(idom_map[w])) { + idom_map[w] = idom_map[idom_map[w]]; + if (DEBUG) std::cout << " Updating idom[" << w->getName() << "] to idom(idom(w)): " + << idom_map[w]->getName() << std::endl; + } else { + if (DEBUG) std::cout << " Warning: idom(idom(" << w->getName() << ")) not found, leaving idom[" << w->getName() << "] as is." << std::endl; + } + } + if (DEBUG) { + std::cout << " Final IDom[" << w->getName() << "] = " << (idom_map[w] ? idom_map[w]->getName() : "nullptr") << std::endl; + } + } + + // 将计算结果从 idom_map 存储到 DominatorTree 的成员变量 IDoms 中 + IDoms = idom_map; + + if (DEBUG) std::cout << "--- Immediate Dominators Computation Finished ---" << std::endl; +} + +// ============================================================== +// computeDominanceFrontiers 和 computeDominatorTreeChildren (保持不变) +// ============================================================== void DominatorTree::computeDominanceFrontiers(Function *F) { if (DEBUG) @@ -221,21 +416,17 @@ 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 *domsOfZ = getDominators(Z); - // 如果 X 不支配 Z，则 Z 与 DF(X) 无关 - if (!domsOfZ || domsOfZ->find(X) == domsOfZ->end()) { + if (!domsOfZ || domsOfZ->find(X) == domsOfZ->end()) { // Z 不被 X 支配 continue; } - // 遍历 Z 的所有后继 Y for (BasicBlock *Y : Z->getSuccessors()) { - // 如果 Y 不被 X 严格支配，则 Y 在 DF(X) 中 - // Y 不被 X 严格支配意味着 (Y不被X支配) 或 (Y就是X) const std::set *domsOfY = getDominators(Y); + // 如果 Y == X，或者 Y 不被 X 严格支配 (即 Y 不被 X 支配) if (Y == X || (domsOfY && domsOfY->find(X) == domsOfY->end())) { DominanceFrontiers[X].insert(Y); } @@ -274,23 +465,21 @@ void DominatorTree::computeDominatorTreeChildren(Function *F) { } // ============================================================== -// DominatorTreeAnalysisPass 的实现 +// DominatorTreeAnalysisPass 的实现 (保持不变) // ============================================================== bool DominatorTreeAnalysisPass::runOnFunction(Function *F, AnalysisManager &AM) { // 每次运行时清空旧数据，确保重新计算 CurrentDominatorTree = std::make_unique(F); - // 不需要手动清空map，unique_ptr会创建新的DominatorTree对象，其map是空的 CurrentDominatorTree->computeDominators(F); - CurrentDominatorTree->computeIDoms(F); // 修正后的IDoms算法 + CurrentDominatorTree->computeIDoms(F); // 修正后的LT算法 CurrentDominatorTree->computeDominanceFrontiers(F); CurrentDominatorTree->computeDominatorTreeChildren(F); - return false; // 分析遍通常返回 false，表示不修改 IR + return false; } std::unique_ptr DominatorTreeAnalysisPass::getResult() { - // 返回计算好的 DominatorTree 实例，所有权转移给 AnalysisManager return std::move(CurrentDominatorTree); } diff --git a/src/midend/Pass/Pass.cpp b/src/midend/Pass/Pass.cpp index f4ec5ab..3c91c00 100644 --- a/src/midend/Pass/Pass.cpp +++ b/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"; diff --git a/src/midend/SysYIRGenerator.cpp b/src/midend/SysYIRGenerator.cpp index 97b25b5..16f9423 100644 --- a/src/midend/SysYIRGenerator.cpp +++ b/src/midend/SysYIRGenerator.cpp @@ -1037,6 +1037,7 @@ std::any SysYIRGenerator::visitFuncDef(SysYParser::FuncDefContext *ctx){ // 从 entryBB 无条件跳转到 funcBodyEntry builder.createUncondBrInst(funcBodyEntry); + BasicBlock::conectBlocks(entry, funcBodyEntry); // 连接 entryBB 和 funcBodyEntry builder.setPosition(funcBodyEntry,funcBodyEntry->end()); // 将插入点设置到 funcBodyEntry for (auto item : ctx->blockStmt()->blockItem()) { From f312792fe9aec24ff3daf567012eac1e2109ee01 Mon Sep 17 00:00:00 2001 From: CGH0S7 <776459475@qq.com> Date: Sun, 3 Aug 2025 13:46:42 +0800 Subject: [PATCH 12/55] =?UTF-8?q?[optimze]=E6=B7=BB=E5=8A=A0=E5=9F=BA?= =?UTF-8?q?=E7=A1=80=E7=9A=84=E9=99=A4=E6=B3=95=E6=8C=87=E4=BB=A4=E4=BC=98?= =?UTF-8?q?=E5=8C=96=EF=BC=8C=E7=9B=AE=E5=89=8D=E5=8F=AA=E5=AF=B9=E9=99=A4?= =?UTF-8?q?=E4=BB=A52=E7=9A=84=E5=B9=82=E6=95=B0=E7=94=9F=E6=95=88?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/backend/RISCv64/CMakeLists.txt | 1 + .../RISCv64/Optimize/DivStrengthReduction.cpp | 329 ++++++++++++++++++ src/backend/RISCv64/RISCv64Backend.cpp | 6 +- src/backend/RISCv64/RISCv64ISel.cpp | 11 +- .../RISCv64/Optimize/DivStrengthReduction.h | 30 ++ src/include/backend/RISCv64/RISCv64Passes.h | 2 + src/include/midend/IR.h | 18 +- src/include/midend/IRBuilder.h | 3 + src/midend/SysYIRGenerator.cpp | 21 +- src/midend/SysYIRPrinter.cpp | 4 + 10 files changed, 419 insertions(+), 6 deletions(-) create mode 100644 src/backend/RISCv64/Optimize/DivStrengthReduction.cpp create mode 100644 src/include/backend/RISCv64/Optimize/DivStrengthReduction.h diff --git a/src/backend/RISCv64/CMakeLists.txt b/src/backend/RISCv64/CMakeLists.txt index eb9f37f..f1e8f55 100644 --- a/src/backend/RISCv64/CMakeLists.txt +++ b/src/backend/RISCv64/CMakeLists.txt @@ -11,6 +11,7 @@ add_library(riscv64_backend_lib STATIC Optimize/Peephole.cpp Optimize/PostRA_Scheduler.cpp Optimize/PreRA_Scheduler.cpp + Optimize/DivStrengthReduction.cpp ) # 包含后端模块所需的头文件路径 diff --git a/src/backend/RISCv64/Optimize/DivStrengthReduction.cpp b/src/backend/RISCv64/Optimize/DivStrengthReduction.cpp new file mode 100644 index 0000000..c052c5d --- /dev/null +++ b/src/backend/RISCv64/Optimize/DivStrengthReduction.cpp @@ -0,0 +1,329 @@ +#include "DivStrengthReduction.h" + +namespace sysy { + +char DivStrengthReduction::ID = 0; + +bool DivStrengthReduction::runOnFunction(Function *F, AnalysisManager& AM) { + // This pass works on MachineFunction level, not IR level + return false; +} + +void DivStrengthReduction::runOnMachineFunction(MachineFunction *mfunc) { + if (!mfunc) + return; + + bool debug = false; // Set to true for debugging + if (debug) + std::cout << "Running DivStrengthReduction optimization..." << std::endl; + + // 虚拟寄存器分配器 + int next_temp_reg = 1000; + auto createTempReg = [&]() -> int { + return next_temp_reg++; + }; + + // Magic number 信息结构 + struct MagicInfo { + int64_t magic; + int shift; + bool add_indicator; // 是否需要额外的加法修正 + }; + + // 针对缺少MULH指令的简化magic number计算 + auto computeMagicNumber = [](int64_t divisor, bool is_32bit) -> MagicInfo { + if (divisor == 0) return {0, 0, false}; + if (divisor == 1) return {1, 0, false}; + if (divisor == -1) return {-1, 0, false}; + + // 对于没有MULH的情况，我们使用更简单但有效的算法 + // 基于 2^n / divisor 的近似 + + bool neg = divisor < 0; + int64_t d = neg ? -divisor : divisor; + + int word_size = is_32bit ? 32 : 64; + + // 计算合适的移位量 + int shift = word_size; + int64_t magic = ((1LL << shift) + d - 1) / d; + + // 调整magic number以适应MUL指令 + if (is_32bit) { + // 32位情况：调整magic使其适合符号扩展后的乘法 + shift = 32; + magic = ((1LL << shift) + d - 1) / d; + } else { + // 64位情况：使用更保守的算法 + shift = 32; // 使用32位作为基础移位 + magic = ((1LL << shift) + d - 1) / d; + } + + bool add_indicator = false; + + // 检查是否需要加法修正 + if (magic >= (1LL << (word_size - 1))) { + add_indicator = true; + magic -= (1LL << word_size); + } + + if (neg) { + magic = -magic; + } + + return {magic, shift, add_indicator}; + }; + + // 检查是否为2的幂次 + auto isPowerOfTwo = [](int64_t n) -> bool { + return n > 0 && (n & (n - 1)) == 0; + }; + + // 获取2的幂次的指数 + auto getPowerOfTwoExponent = [](int64_t n) -> int { + if (n <= 0 || (n & (n - 1)) != 0) return -1; + int shift = 0; + while (n > 1) { + n >>= 1; + shift++; + } + return shift; + }; + + // 收集需要替换的指令 + struct InstructionReplacement { + size_t index; + std::vector> newInstrs; + }; + + for (auto &mbb_uptr : mfunc->getBlocks()) { + auto &mbb = *mbb_uptr; + auto &instrs = mbb.getInstructions(); + std::vector replacements; + + for (size_t i = 0; i < instrs.size(); ++i) { + auto *instr = instrs[i].get(); + + bool is_32bit = (instr->getOpcode() == RVOpcodes::DIVW); + + // 只处理 DIV 和 DIVW 指令 + if (instr->getOpcode() != RVOpcodes::DIV && !is_32bit) { + continue; + } + + if (instr->getOperands().size() != 3) { + continue; + } + + auto *dst_op = instr->getOperands()[0].get(); + auto *src1_op = instr->getOperands()[1].get(); + auto *src2_op = instr->getOperands()[2].get(); + + // 检查操作数类型 + if (dst_op->getKind() != MachineOperand::KIND_REG || + src1_op->getKind() != MachineOperand::KIND_REG || + src2_op->getKind() != MachineOperand::KIND_IMM) { + continue; + } + + auto *dst_reg = static_cast(dst_op); + auto *src1_reg = static_cast(src1_op); + auto *src2_imm = static_cast(src2_op); + + int64_t divisor = src2_imm->getValue(); + + // 跳过除数为0的情况 + if (divisor == 0) continue; + + std::vector> newInstrs; + + // 情况1: 除数为1 + if (divisor == 1) { + // dst = src1 (直接复制) + auto moveInstr = std::make_unique(is_32bit ? RVOpcodes::ADDW : RVOpcodes::ADD); + moveInstr->addOperand(std::make_unique(*dst_reg)); + moveInstr->addOperand(std::make_unique(*src1_reg)); + moveInstr->addOperand(std::make_unique(PhysicalReg::ZERO)); + newInstrs.push_back(std::move(moveInstr)); + } + // 情况2: 除数为-1 + else if (divisor == -1) { + // dst = -src1 + auto negInstr = std::make_unique(is_32bit ? RVOpcodes::SUBW : RVOpcodes::SUB); + negInstr->addOperand(std::make_unique(*dst_reg)); + negInstr->addOperand(std::make_unique(PhysicalReg::ZERO)); + negInstr->addOperand(std::make_unique(*src1_reg)); + newInstrs.push_back(std::move(negInstr)); + } + // 情况3: 正的2的幂次除法 + else if (isPowerOfTwo(divisor)) { + int shift = getPowerOfTwoExponent(divisor); + int temp_reg = createTempReg(); + + // 对于有符号除法，需要处理负数的舍入 + // if (src1 < 0) src1 += (divisor - 1) + + // 获取符号位：temp = src1 >> (word_size - 1) + auto sraSignInstr = std::make_unique(is_32bit ? RVOpcodes::SRAIW : RVOpcodes::SRAI); + sraSignInstr->addOperand(std::make_unique(temp_reg)); + sraSignInstr->addOperand(std::make_unique(*src1_reg)); + sraSignInstr->addOperand(std::make_unique(is_32bit ? 31 : 63)); + newInstrs.push_back(std::move(sraSignInstr)); + + // 计算偏移：temp = temp >> (word_size - shift) + if (shift < (is_32bit ? 32 : 64)) { + auto srlInstr = std::make_unique(is_32bit ? RVOpcodes::SRLIW : RVOpcodes::SRLI); + srlInstr->addOperand(std::make_unique(temp_reg)); + srlInstr->addOperand(std::make_unique(temp_reg)); + srlInstr->addOperand(std::make_unique((is_32bit ? 32 : 64) - shift)); + newInstrs.push_back(std::move(srlInstr)); + } + + // 加上偏移：temp = src1 + temp + auto addInstr = std::make_unique(is_32bit ? RVOpcodes::ADDW : RVOpcodes::ADD); + addInstr->addOperand(std::make_unique(temp_reg)); + addInstr->addOperand(std::make_unique(*src1_reg)); + addInstr->addOperand(std::make_unique(temp_reg)); + newInstrs.push_back(std::move(addInstr)); + + // 最终右移：dst = temp >> shift + auto sraInstr = std::make_unique(is_32bit ? RVOpcodes::SRAIW : RVOpcodes::SRAI); + sraInstr->addOperand(std::make_unique(*dst_reg)); + sraInstr->addOperand(std::make_unique(temp_reg)); + sraInstr->addOperand(std::make_unique(shift)); + newInstrs.push_back(std::move(sraInstr)); + } + // 情况4: 负的2的幂次除法 + else if (divisor < 0 && isPowerOfTwo(-divisor)) { + int shift = getPowerOfTwoExponent(-divisor); + int temp_reg = createTempReg(); + + // 先按正数处理 + auto sraSignInstr = std::make_unique(is_32bit ? RVOpcodes::SRAIW : RVOpcodes::SRAI); + sraSignInstr->addOperand(std::make_unique(temp_reg)); + sraSignInstr->addOperand(std::make_unique(*src1_reg)); + sraSignInstr->addOperand(std::make_unique(is_32bit ? 31 : 63)); + newInstrs.push_back(std::move(sraSignInstr)); + + if (shift < (is_32bit ? 32 : 64)) { + auto srlInstr = std::make_unique(is_32bit ? RVOpcodes::SRLIW : RVOpcodes::SRLI); + srlInstr->addOperand(std::make_unique(temp_reg)); + srlInstr->addOperand(std::make_unique(temp_reg)); + srlInstr->addOperand(std::make_unique((is_32bit ? 32 : 64) - shift)); + newInstrs.push_back(std::move(srlInstr)); + } + + auto addInstr = std::make_unique(is_32bit ? RVOpcodes::ADDW : RVOpcodes::ADD); + addInstr->addOperand(std::make_unique(temp_reg)); + addInstr->addOperand(std::make_unique(*src1_reg)); + addInstr->addOperand(std::make_unique(temp_reg)); + newInstrs.push_back(std::move(addInstr)); + + auto sraInstr = std::make_unique(is_32bit ? RVOpcodes::SRAIW : RVOpcodes::SRAI); + sraInstr->addOperand(std::make_unique(temp_reg)); + sraInstr->addOperand(std::make_unique(temp_reg)); + sraInstr->addOperand(std::make_unique(shift)); + newInstrs.push_back(std::move(sraInstr)); + + // 然后取反 + auto negInstr = std::make_unique(is_32bit ? RVOpcodes::SUBW : RVOpcodes::SUB); + negInstr->addOperand(std::make_unique(*dst_reg)); + negInstr->addOperand(std::make_unique(PhysicalReg::ZERO)); + negInstr->addOperand(std::make_unique(temp_reg)); + newInstrs.push_back(std::move(negInstr)); + } + // 情况5: 通用magic number算法（针对没有MULH的情况进行了简化） + else { + // 对于一般除法，在没有MULH的情况下，我们采用更保守的策略 + // 只处理一些简单的常数除法，复杂的情况保持原始除法指令 + + // 检查是否为小的常数（可以用简单乘法处理） + if (std::abs(divisor) <= 1024) { // 限制在较小的除数范围内 + auto magic_info = computeMagicNumber(divisor, is_32bit); + + if (magic_info.magic == 0) continue; + + int magic_reg = createTempReg(); + int temp_reg = createTempReg(); + + // 加载magic number到寄存器 + auto loadInstr = std::make_unique(RVOpcodes::LI); + loadInstr->addOperand(std::make_unique(magic_reg)); + loadInstr->addOperand(std::make_unique(magic_info.magic)); + newInstrs.push_back(std::move(loadInstr)); + + // 使用普通乘法模拟高位乘法 + if (is_32bit) { + // 32位：使用MULW + auto mulInstr = std::make_unique(RVOpcodes::MULW); + mulInstr->addOperand(std::make_unique(temp_reg)); + mulInstr->addOperand(std::make_unique(*src1_reg)); + mulInstr->addOperand(std::make_unique(magic_reg)); + newInstrs.push_back(std::move(mulInstr)); + + // 右移得到近似结果 + auto sraInstr = std::make_unique(RVOpcodes::SRAIW); + sraInstr->addOperand(std::make_unique(temp_reg)); + sraInstr->addOperand(std::make_unique(temp_reg)); + sraInstr->addOperand(std::make_unique(magic_info.shift)); + newInstrs.push_back(std::move(sraInstr)); + } else { + // 64位：使用MUL + auto mulInstr = std::make_unique(RVOpcodes::MUL); + mulInstr->addOperand(std::make_unique(temp_reg)); + mulInstr->addOperand(std::make_unique(*src1_reg)); + mulInstr->addOperand(std::make_unique(magic_reg)); + newInstrs.push_back(std::move(mulInstr)); + + // 右移得到近似结果 + auto sraInstr = std::make_unique(RVOpcodes::SRAI); + sraInstr->addOperand(std::make_unique(temp_reg)); + sraInstr->addOperand(std::make_unique(temp_reg)); + sraInstr->addOperand(std::make_unique(magic_info.shift)); + newInstrs.push_back(std::move(sraInstr)); + } + + // 符号修正：处理负数被除数 + int sign_reg = createTempReg(); + + // 获取被除数的符号位 + auto sraSignInstr = std::make_unique(is_32bit ? RVOpcodes::SRAIW : RVOpcodes::SRAI); + sraSignInstr->addOperand(std::make_unique(sign_reg)); + sraSignInstr->addOperand(std::make_unique(*src1_reg)); + sraSignInstr->addOperand(std::make_unique(is_32bit ? 31 : 63)); + newInstrs.push_back(std::move(sraSignInstr)); + + // 最终结果：dst = temp - sign（对于正除数）或 dst = temp + sign（对于负除数） + if (divisor > 0) { + auto finalSubInstr = std::make_unique(is_32bit ? RVOpcodes::SUBW : RVOpcodes::SUB); + finalSubInstr->addOperand(std::make_unique(*dst_reg)); + finalSubInstr->addOperand(std::make_unique(temp_reg)); + finalSubInstr->addOperand(std::make_unique(sign_reg)); + newInstrs.push_back(std::move(finalSubInstr)); + } else { + auto finalAddInstr = std::make_unique(is_32bit ? RVOpcodes::ADDW : RVOpcodes::ADD); + finalAddInstr->addOperand(std::make_unique(*dst_reg)); + finalAddInstr->addOperand(std::make_unique(temp_reg)); + finalAddInstr->addOperand(std::make_unique(sign_reg)); + newInstrs.push_back(std::move(finalAddInstr)); + } + } + // 对于大的除数或复杂情况，保持原始除法指令不变 + } + + if (!newInstrs.empty()) { + replacements.push_back({i, std::move(newInstrs)}); + } + } + + // 批量应用替换（从后往前处理避免索引问题） + for (auto it = replacements.rbegin(); it != replacements.rend(); ++it) { + instrs.erase(instrs.begin() + it->index); + instrs.insert(instrs.begin() + it->index, + std::make_move_iterator(it->newInstrs.begin()), + std::make_move_iterator(it->newInstrs.end())); + } + } +} + +} // namespace sysy \ No newline at end of file diff --git a/src/backend/RISCv64/RISCv64Backend.cpp b/src/backend/RISCv64/RISCv64Backend.cpp index 2797eb7..ae45d65 100644 --- a/src/backend/RISCv64/RISCv64Backend.cpp +++ b/src/backend/RISCv64/RISCv64Backend.cpp @@ -119,7 +119,11 @@ std::string RISCv64CodeGen::function_gen(Function* func) { RISCv64AsmPrinter printer1(mfunc.get()); printer1.run(ss1, true); - // 阶段 2: 指令调度 (Instruction Scheduling) + // 阶段 2: 除法强度削弱优化 (Division Strength Reduction) + DivStrengthReduction div_strength_reduction; + div_strength_reduction.runOnMachineFunction(mfunc.get()); + + // 阶段 2.1: 指令调度 (Instruction Scheduling) PreRA_Scheduler scheduler; scheduler.runOnMachineFunction(mfunc.get()); diff --git a/src/backend/RISCv64/RISCv64ISel.cpp b/src/backend/RISCv64/RISCv64ISel.cpp index 871a3e7..e6b0929 100644 --- a/src/backend/RISCv64/RISCv64ISel.cpp +++ b/src/backend/RISCv64/RISCv64ISel.cpp @@ -539,6 +539,15 @@ void RISCv64ISel::selectNode(DAGNode* node) { CurMBB->addInstruction(std::move(instr)); break; } + case Instruction::kSRA: { + auto rhs_const = dynamic_cast(rhs); + auto instr = std::make_unique(RVOpcodes::SRAIW); + instr->addOperand(std::make_unique(dest_vreg)); + instr->addOperand(std::make_unique(lhs_vreg)); + instr->addOperand(std::make_unique(rhs_const->getInt())); + CurMBB->addInstruction(std::move(instr)); + break; + } case BinaryInst::kICmpEQ: { // 等于 (a == b) -> (subw; seqz) auto sub = std::make_unique(RVOpcodes::SUBW); sub->addOperand(std::make_unique(dest_vreg)); @@ -1473,7 +1482,7 @@ std::vector> RISCv64ISel::build_dag(BasicB } } } - if (bin->getKind() >= Instruction::kFAdd) { // 假设浮点指令枚举值更大 + if (bin->isFPBinary()) { // 假设浮点指令枚举值更大 auto fbin_node = create_node(DAGNode::FBINARY, bin, value_to_node, nodes_storage); fbin_node->operands.push_back(get_operand_node(bin->getLhs(), value_to_node, nodes_storage)); fbin_node->operands.push_back(get_operand_node(bin->getRhs(), value_to_node, nodes_storage)); diff --git a/src/include/backend/RISCv64/Optimize/DivStrengthReduction.h b/src/include/backend/RISCv64/Optimize/DivStrengthReduction.h new file mode 100644 index 0000000..685bb19 --- /dev/null +++ b/src/include/backend/RISCv64/Optimize/DivStrengthReduction.h @@ -0,0 +1,30 @@ +#ifndef RISCV64_DIV_STRENGTH_REDUCTION_H +#define RISCV64_DIV_STRENGTH_REDUCTION_H + +#include "RISCv64LLIR.h" +#include "Pass.h" + +namespace sysy { + +/** + * @class DivStrengthReduction + * @brief 除法强度削弱优化器 + * * 将除法运算转换为乘法运算，使用magic number算法 + * 适用于除数为常数的情况，可以显著提高性能 + */ +class DivStrengthReduction : public Pass { +public: + static char ID; + + DivStrengthReduction() : Pass("div-strength-reduction", Granularity::Function, PassKind::Optimization) {} + + void *getPassID() const override { return &ID; } + + bool runOnFunction(Function *F, AnalysisManager& AM) override; + + void runOnMachineFunction(MachineFunction* mfunc); +}; + +} // namespace sysy + +#endif // RISCV64_DIV_STRENGTH_REDUCTION_H \ No newline at end of file diff --git a/src/include/backend/RISCv64/RISCv64Passes.h b/src/include/backend/RISCv64/RISCv64Passes.h index de08882..b456994 100644 --- a/src/include/backend/RISCv64/RISCv64Passes.h +++ b/src/include/backend/RISCv64/RISCv64Passes.h @@ -9,6 +9,8 @@ #include "LegalizeImmediates.h" #include "PrologueEpilogueInsertion.h" #include "Pass.h" +#include "DivStrengthReduction.h" + namespace sysy { diff --git a/src/include/midend/IR.h b/src/include/midend/IR.h index 901a3b7..2e4d72b 100644 --- a/src/include/midend/IR.h +++ b/src/include/midend/IR.h @@ -708,6 +708,8 @@ class Instruction : public User { kPhi = 0x1UL << 39, kBitItoF = 0x1UL << 40, kBitFtoI = 0x1UL << 41, + kSRA = 0x1UL << 42, + kMulh = 0x1UL << 43, }; protected: @@ -804,6 +806,12 @@ public: return "Memset"; case kPhi: return "Phi"; + case kBitItoF: + return "BitItoF"; + case kBitFtoI: + return "BitFtoI"; + case kSRA: + return "SRA"; default: return "Unknown"; } @@ -815,11 +823,15 @@ public: bool isBinary() const { static constexpr uint64_t BinaryOpMask = - (kAdd | kSub | kMul | kDiv | kRem | kAnd | kOr) | - (kICmpEQ | kICmpNE | kICmpLT | kICmpGT | kICmpLE | kICmpGE) | + (kAdd | kSub | kMul | kDiv | kRem | kAnd | kOr | kSRA) | + (kICmpEQ | kICmpNE | kICmpLT | kICmpGT | kICmpLE | kICmpGE); + return kind & BinaryOpMask; + } + bool isFPBinary() const { + static constexpr uint64_t FPBinaryOpMask = (kFAdd | kFSub | kFMul | kFDiv) | (kFCmpEQ | kFCmpNE | kFCmpLT | kFCmpGT | kFCmpLE | kFCmpGE); - return kind & BinaryOpMask; + return kind & FPBinaryOpMask; } bool isUnary() const { static constexpr uint64_t UnaryOpMask = diff --git a/src/include/midend/IRBuilder.h b/src/include/midend/IRBuilder.h index 73e40e5..c232578 100644 --- a/src/include/midend/IRBuilder.h +++ b/src/include/midend/IRBuilder.h @@ -217,6 +217,9 @@ class IRBuilder { BinaryInst * createOrInst(Value *lhs, Value *rhs, const std::string &name = "") { return createBinaryInst(Instruction::kOr, Type::getIntType(), lhs, rhs, name); } ///< 创建按位或指令 + BinaryInst * createSRAInst(Value *lhs, Value *rhs, const std::string &name = "") { + return createBinaryInst(Instruction::kSRA, Type::getIntType(), lhs, rhs, name); + } ///< 创建算术右移指令 CallInst * createCallInst(Function *callee, const std::vector &args, const std::string &name = "") { std::string newName; if (name.empty() && callee->getReturnType() != Type::getVoidType()) { diff --git a/src/midend/SysYIRGenerator.cpp b/src/midend/SysYIRGenerator.cpp index 812bd39..0b2d751 100644 --- a/src/midend/SysYIRGenerator.cpp +++ b/src/midend/SysYIRGenerator.cpp @@ -249,7 +249,26 @@ void SysYIRGenerator::compute() { case BinaryOp::ADD: resultValue = builder.createAddInst(lhs, rhs); break; case BinaryOp::SUB: resultValue = builder.createSubInst(lhs, rhs); break; case BinaryOp::MUL: resultValue = builder.createMulInst(lhs, rhs); break; - case BinaryOp::DIV: resultValue = builder.createDivInst(lhs, rhs); break; + case BinaryOp::DIV: { + ConstantInteger *rhsConst = dynamic_cast(rhs); + if (rhsConst) { + int divisor = rhsConst->getInt(); + if (divisor > 0 && (divisor & (divisor - 1)) == 0) { + int shift = 0; + int temp = divisor; + while (temp > 1) { + temp >>= 1; + shift++; + } + resultValue = builder.createSRAInst(lhs, ConstantInteger::get(shift)); + } else { + resultValue = builder.createDivInst(lhs, rhs); + } + } else { + resultValue = builder.createDivInst(lhs, rhs); + } + break; + } case BinaryOp::MOD: resultValue = builder.createRemInst(lhs, rhs); break; } } else if (commonType == Type::getFloatType()) { diff --git a/src/midend/SysYIRPrinter.cpp b/src/midend/SysYIRPrinter.cpp index 0a024d2..7891bca 100644 --- a/src/midend/SysYIRPrinter.cpp +++ b/src/midend/SysYIRPrinter.cpp @@ -240,6 +240,8 @@ void SysYPrinter::printInst(Instruction *pInst) { case Kind::kMul: case Kind::kDiv: case Kind::kRem: + case Kind::kSRA: + case Kind::kMulh: case Kind::kFAdd: case Kind::kFSub: case Kind::kFMul: @@ -272,6 +274,8 @@ void SysYPrinter::printInst(Instruction *pInst) { case Kind::kMul: std::cout << "mul"; break; case Kind::kDiv: std::cout << "sdiv"; break; case Kind::kRem: std::cout << "srem"; break; + case Kind::kSRA: std::cout << "ashr"; break; + case Kind::kMulh: std::cout << "mulh"; break; case Kind::kFAdd: std::cout << "fadd"; break; case Kind::kFSub: std::cout << "fsub"; break; case Kind::kFMul: std::cout << "fmul"; break; From 0ce742a86eca84071c32c4215a3099586326772f Mon Sep 17 00:00:00 2001 From: CGH0S7 <776459475@qq.com> Date: Sun, 3 Aug 2025 14:37:33 +0800 Subject: [PATCH 13/55] =?UTF-8?q?[optimize]=E6=B7=BB=E5=8A=A0=E6=9B=B4?= =?UTF-8?q?=E4=B8=BA=E9=80=9A=E7=94=A8=E7=9A=84=E9=99=A4=E6=B3=95=E5=BC=BA?= =?UTF-8?q?=E5=BA=A6=E5=89=8A=E5=87=8FPass,=20=E4=B8=8D=E5=8F=97=E9=99=A4?= =?UTF-8?q?=E6=95=B0=E9=99=90=E5=88=B6=E6=9B=BF=E6=8D=A2div=E6=8C=87?= =?UTF-8?q?=E4=BB=A4=EF=BC=8C=E4=B8=8D=E5=BD=B1=E5=93=8D=E5=BD=93=E5=89=8D?= =?UTF-8?q?=E5=88=86=E6=95=B0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../RISCv64/Optimize/DivStrengthReduction.cpp | 319 ++++++++---------- src/backend/RISCv64/RISCv64AsmPrinter.cpp | 2 +- src/include/backend/RISCv64/RISCv64LLIR.h | 2 +- src/include/midend/IR.h | 4 +- src/include/midend/IRBuilder.h | 3 + src/midend/SysYIRGenerator.cpp | 23 ++ test_div_optimization.sy | 9 + 7 files changed, 175 insertions(+), 187 deletions(-) create mode 100644 test_div_optimization.sy diff --git a/src/backend/RISCv64/Optimize/DivStrengthReduction.cpp b/src/backend/RISCv64/Optimize/DivStrengthReduction.cpp index c052c5d..bcd7bda 100644 --- a/src/backend/RISCv64/Optimize/DivStrengthReduction.cpp +++ b/src/backend/RISCv64/Optimize/DivStrengthReduction.cpp @@ -1,4 +1,6 @@ #include "DivStrengthReduction.h" +#include +#include namespace sysy { @@ -17,69 +19,49 @@ void DivStrengthReduction::runOnMachineFunction(MachineFunction *mfunc) { if (debug) std::cout << "Running DivStrengthReduction optimization..." << std::endl; - // 虚拟寄存器分配器 int next_temp_reg = 1000; auto createTempReg = [&]() -> int { return next_temp_reg++; }; - // Magic number 信息结构 struct MagicInfo { int64_t magic; int shift; - bool add_indicator; // 是否需要额外的加法修正 }; - // 针对缺少MULH指令的简化magic number计算 - auto computeMagicNumber = [](int64_t divisor, bool is_32bit) -> MagicInfo { - if (divisor == 0) return {0, 0, false}; - if (divisor == 1) return {1, 0, false}; - if (divisor == -1) return {-1, 0, false}; - - // 对于没有MULH的情况，我们使用更简单但有效的算法 - // 基于 2^n / divisor 的近似 - - bool neg = divisor < 0; - int64_t d = neg ? -divisor : divisor; - + auto computeMagic = [](int64_t d, bool is_32bit) -> MagicInfo { int word_size = is_32bit ? 32 : 64; + uint64_t ad = std::abs(d); - // 计算合适的移位量 - int shift = word_size; - int64_t magic = ((1LL << shift) + d - 1) / d; + if (ad == 0) return {0, 0}; - // 调整magic number以适应MUL指令 + int l = std::floor(std::log2(ad)); + if ((ad & (ad - 1)) == 0) { // power of 2 + l = 0; // special case for power of 2, shift will be calculated differently + } + + __int128_t one = 1; + __int128_t num; + int total_shift; + if (is_32bit) { - // 32位情况：调整magic使其适合符号扩展后的乘法 - shift = 32; - magic = ((1LL << shift) + d - 1) / d; + total_shift = 31 + l; + num = one << total_shift; } else { - // 64位情况：使用更保守的算法 - shift = 32; // 使用32位作为基础移位 - magic = ((1LL << shift) + d - 1) / d; + total_shift = 63 + l; + num = one << total_shift; } - bool add_indicator = false; + __int128_t den = ad; + int64_t magic = (num / den) + 1; - // 检查是否需要加法修正 - if (magic >= (1LL << (word_size - 1))) { - add_indicator = true; - magic -= (1LL << word_size); - } - - if (neg) { - magic = -magic; - } - - return {magic, shift, add_indicator}; + return {magic, total_shift}; }; - // 检查是否为2的幂次 auto isPowerOfTwo = [](int64_t n) -> bool { return n > 0 && (n & (n - 1)) == 0; }; - // 获取2的幂次的指数 auto getPowerOfTwoExponent = [](int64_t n) -> int { if (n <= 0 || (n & (n - 1)) != 0) return -1; int shift = 0; @@ -90,9 +72,9 @@ void DivStrengthReduction::runOnMachineFunction(MachineFunction *mfunc) { return shift; }; - // 收集需要替换的指令 struct InstructionReplacement { size_t index; + size_t count_to_erase; std::vector> newInstrs; }; @@ -106,7 +88,6 @@ void DivStrengthReduction::runOnMachineFunction(MachineFunction *mfunc) { bool is_32bit = (instr->getOpcode() == RVOpcodes::DIVW); - // 只处理 DIV 和 DIVW 指令 if (instr->getOpcode() != RVOpcodes::DIV && !is_32bit) { continue; } @@ -118,100 +99,74 @@ void DivStrengthReduction::runOnMachineFunction(MachineFunction *mfunc) { auto *dst_op = instr->getOperands()[0].get(); auto *src1_op = instr->getOperands()[1].get(); auto *src2_op = instr->getOperands()[2].get(); - - // 检查操作数类型 - if (dst_op->getKind() != MachineOperand::KIND_REG || - src1_op->getKind() != MachineOperand::KIND_REG || - src2_op->getKind() != MachineOperand::KIND_IMM) { + + int64_t divisor = 0; + bool const_divisor_found = false; + size_t instructions_to_replace = 1; + + if (src2_op->getKind() == MachineOperand::KIND_IMM) { + divisor = static_cast(src2_op)->getValue(); + const_divisor_found = true; + } else if (src2_op->getKind() == MachineOperand::KIND_REG) { + if (i > 0) { + auto *prev_instr = instrs[i - 1].get(); + if (prev_instr->getOpcode() == RVOpcodes::LI && prev_instr->getOperands().size() == 2) { + auto *li_dst_op = prev_instr->getOperands()[0].get(); + auto *li_imm_op = prev_instr->getOperands()[1].get(); + if (li_dst_op->getKind() == MachineOperand::KIND_REG && li_imm_op->getKind() == MachineOperand::KIND_IMM) { + auto *div_reg_op = static_cast(src2_op); + auto *li_dst_reg_op = static_cast(li_dst_op); + if (div_reg_op->isVirtual() && li_dst_reg_op->isVirtual() && + div_reg_op->getVRegNum() == li_dst_reg_op->getVRegNum()) { + divisor = static_cast(li_imm_op)->getValue(); + const_divisor_found = true; + instructions_to_replace = 2; + } + } + } + } + } + + if (!const_divisor_found) { continue; } auto *dst_reg = static_cast(dst_op); auto *src1_reg = static_cast(src1_op); - auto *src2_imm = static_cast(src2_op); - int64_t divisor = src2_imm->getValue(); - - // 跳过除数为0的情况 if (divisor == 0) continue; std::vector> newInstrs; - // 情况1: 除数为1 if (divisor == 1) { - // dst = src1 (直接复制) auto moveInstr = std::make_unique(is_32bit ? RVOpcodes::ADDW : RVOpcodes::ADD); moveInstr->addOperand(std::make_unique(*dst_reg)); moveInstr->addOperand(std::make_unique(*src1_reg)); moveInstr->addOperand(std::make_unique(PhysicalReg::ZERO)); newInstrs.push_back(std::move(moveInstr)); } - // 情况2: 除数为-1 else if (divisor == -1) { - // dst = -src1 auto negInstr = std::make_unique(is_32bit ? RVOpcodes::SUBW : RVOpcodes::SUB); negInstr->addOperand(std::make_unique(*dst_reg)); negInstr->addOperand(std::make_unique(PhysicalReg::ZERO)); negInstr->addOperand(std::make_unique(*src1_reg)); newInstrs.push_back(std::move(negInstr)); } - // 情况3: 正的2的幂次除法 - else if (isPowerOfTwo(divisor)) { - int shift = getPowerOfTwoExponent(divisor); + else if (isPowerOfTwo(std::abs(divisor))) { + int shift = getPowerOfTwoExponent(std::abs(divisor)); int temp_reg = createTempReg(); - // 对于有符号除法，需要处理负数的舍入 - // if (src1 < 0) src1 += (divisor - 1) - - // 获取符号位：temp = src1 >> (word_size - 1) auto sraSignInstr = std::make_unique(is_32bit ? RVOpcodes::SRAIW : RVOpcodes::SRAI); sraSignInstr->addOperand(std::make_unique(temp_reg)); sraSignInstr->addOperand(std::make_unique(*src1_reg)); sraSignInstr->addOperand(std::make_unique(is_32bit ? 31 : 63)); newInstrs.push_back(std::move(sraSignInstr)); - // 计算偏移：temp = temp >> (word_size - shift) - if (shift < (is_32bit ? 32 : 64)) { - auto srlInstr = std::make_unique(is_32bit ? RVOpcodes::SRLIW : RVOpcodes::SRLI); - srlInstr->addOperand(std::make_unique(temp_reg)); - srlInstr->addOperand(std::make_unique(temp_reg)); - srlInstr->addOperand(std::make_unique((is_32bit ? 32 : 64) - shift)); - newInstrs.push_back(std::move(srlInstr)); - } - - // 加上偏移：temp = src1 + temp - auto addInstr = std::make_unique(is_32bit ? RVOpcodes::ADDW : RVOpcodes::ADD); - addInstr->addOperand(std::make_unique(temp_reg)); - addInstr->addOperand(std::make_unique(*src1_reg)); - addInstr->addOperand(std::make_unique(temp_reg)); - newInstrs.push_back(std::move(addInstr)); - - // 最终右移：dst = temp >> shift - auto sraInstr = std::make_unique(is_32bit ? RVOpcodes::SRAIW : RVOpcodes::SRAI); - sraInstr->addOperand(std::make_unique(*dst_reg)); - sraInstr->addOperand(std::make_unique(temp_reg)); - sraInstr->addOperand(std::make_unique(shift)); - newInstrs.push_back(std::move(sraInstr)); - } - // 情况4: 负的2的幂次除法 - else if (divisor < 0 && isPowerOfTwo(-divisor)) { - int shift = getPowerOfTwoExponent(-divisor); - int temp_reg = createTempReg(); - - // 先按正数处理 - auto sraSignInstr = std::make_unique(is_32bit ? RVOpcodes::SRAIW : RVOpcodes::SRAI); - sraSignInstr->addOperand(std::make_unique(temp_reg)); - sraSignInstr->addOperand(std::make_unique(*src1_reg)); - sraSignInstr->addOperand(std::make_unique(is_32bit ? 31 : 63)); - newInstrs.push_back(std::move(sraSignInstr)); - - if (shift < (is_32bit ? 32 : 64)) { - auto srlInstr = std::make_unique(is_32bit ? RVOpcodes::SRLIW : RVOpcodes::SRLI); - srlInstr->addOperand(std::make_unique(temp_reg)); - srlInstr->addOperand(std::make_unique(temp_reg)); - srlInstr->addOperand(std::make_unique((is_32bit ? 32 : 64) - shift)); - newInstrs.push_back(std::move(srlInstr)); - } + auto srlInstr = std::make_unique(is_32bit ? RVOpcodes::SRLIW : RVOpcodes::SRLI); + srlInstr->addOperand(std::make_unique(temp_reg)); + srlInstr->addOperand(std::make_unique(temp_reg)); + srlInstr->addOperand(std::make_unique((is_32bit ? 32 : 64) - shift)); + newInstrs.push_back(std::move(srlInstr)); auto addInstr = std::make_unique(is_32bit ? RVOpcodes::ADDW : RVOpcodes::ADD); addInstr->addOperand(std::make_unique(temp_reg)); @@ -224,101 +179,99 @@ void DivStrengthReduction::runOnMachineFunction(MachineFunction *mfunc) { sraInstr->addOperand(std::make_unique(temp_reg)); sraInstr->addOperand(std::make_unique(shift)); newInstrs.push_back(std::move(sraInstr)); - - // 然后取反 - auto negInstr = std::make_unique(is_32bit ? RVOpcodes::SUBW : RVOpcodes::SUB); - negInstr->addOperand(std::make_unique(*dst_reg)); - negInstr->addOperand(std::make_unique(PhysicalReg::ZERO)); - negInstr->addOperand(std::make_unique(temp_reg)); - newInstrs.push_back(std::move(negInstr)); + + if (divisor < 0) { + auto negInstr = std::make_unique(is_32bit ? RVOpcodes::SUBW : RVOpcodes::SUB); + negInstr->addOperand(std::make_unique(*dst_reg)); + negInstr->addOperand(std::make_unique(PhysicalReg::ZERO)); + negInstr->addOperand(std::make_unique(temp_reg)); + newInstrs.push_back(std::move(negInstr)); + } else { + auto moveInstr = std::make_unique(is_32bit ? RVOpcodes::ADDW : RVOpcodes::ADD); + moveInstr->addOperand(std::make_unique(*dst_reg)); + moveInstr->addOperand(std::make_unique(temp_reg)); + moveInstr->addOperand(std::make_unique(PhysicalReg::ZERO)); + newInstrs.push_back(std::move(moveInstr)); + } } - // 情况5: 通用magic number算法（针对没有MULH的情况进行了简化） else { - // 对于一般除法，在没有MULH的情况下，我们采用更保守的策略 - // 只处理一些简单的常数除法，复杂的情况保持原始除法指令 - - // 检查是否为小的常数（可以用简单乘法处理） - if (std::abs(divisor) <= 1024) { // 限制在较小的除数范围内 - auto magic_info = computeMagicNumber(divisor, is_32bit); + auto magic_info = computeMagic(divisor, is_32bit); + int magic_reg = createTempReg(); + int temp_reg = createTempReg(); + + auto loadInstr = std::make_unique(RVOpcodes::LI); + loadInstr->addOperand(std::make_unique(magic_reg)); + loadInstr->addOperand(std::make_unique(magic_info.magic)); + newInstrs.push_back(std::move(loadInstr)); + + if (is_32bit) { + auto mulInstr = std::make_unique(RVOpcodes::MUL); + mulInstr->addOperand(std::make_unique(temp_reg)); + mulInstr->addOperand(std::make_unique(*src1_reg)); + mulInstr->addOperand(std::make_unique(magic_reg)); + newInstrs.push_back(std::move(mulInstr)); + + auto sraInstr = std::make_unique(RVOpcodes::SRAI); + sraInstr->addOperand(std::make_unique(temp_reg)); + sraInstr->addOperand(std::make_unique(temp_reg)); + sraInstr->addOperand(std::make_unique(magic_info.shift)); + newInstrs.push_back(std::move(sraInstr)); + } else { + auto mulhInstr = std::make_unique(RVOpcodes::MULH); + mulhInstr->addOperand(std::make_unique(temp_reg)); + mulhInstr->addOperand(std::make_unique(*src1_reg)); + mulhInstr->addOperand(std::make_unique(magic_reg)); + newInstrs.push_back(std::move(mulhInstr)); - if (magic_info.magic == 0) continue; - - int magic_reg = createTempReg(); - int temp_reg = createTempReg(); - - // 加载magic number到寄存器 - auto loadInstr = std::make_unique(RVOpcodes::LI); - loadInstr->addOperand(std::make_unique(magic_reg)); - loadInstr->addOperand(std::make_unique(magic_info.magic)); - newInstrs.push_back(std::move(loadInstr)); - - // 使用普通乘法模拟高位乘法 - if (is_32bit) { - // 32位：使用MULW - auto mulInstr = std::make_unique(RVOpcodes::MULW); - mulInstr->addOperand(std::make_unique(temp_reg)); - mulInstr->addOperand(std::make_unique(*src1_reg)); - mulInstr->addOperand(std::make_unique(magic_reg)); - newInstrs.push_back(std::move(mulInstr)); - - // 右移得到近似结果 - auto sraInstr = std::make_unique(RVOpcodes::SRAIW); - sraInstr->addOperand(std::make_unique(temp_reg)); - sraInstr->addOperand(std::make_unique(temp_reg)); - sraInstr->addOperand(std::make_unique(magic_info.shift)); - newInstrs.push_back(std::move(sraInstr)); - } else { - // 64位：使用MUL - auto mulInstr = std::make_unique(RVOpcodes::MUL); - mulInstr->addOperand(std::make_unique(temp_reg)); - mulInstr->addOperand(std::make_unique(*src1_reg)); - mulInstr->addOperand(std::make_unique(magic_reg)); - newInstrs.push_back(std::move(mulInstr)); - - // 右移得到近似结果 + int post_shift = magic_info.shift - 63; + if (post_shift > 0) { auto sraInstr = std::make_unique(RVOpcodes::SRAI); sraInstr->addOperand(std::make_unique(temp_reg)); sraInstr->addOperand(std::make_unique(temp_reg)); - sraInstr->addOperand(std::make_unique(magic_info.shift)); + sraInstr->addOperand(std::make_unique(post_shift)); newInstrs.push_back(std::move(sraInstr)); } - - // 符号修正：处理负数被除数 - int sign_reg = createTempReg(); - - // 获取被除数的符号位 - auto sraSignInstr = std::make_unique(is_32bit ? RVOpcodes::SRAIW : RVOpcodes::SRAI); - sraSignInstr->addOperand(std::make_unique(sign_reg)); - sraSignInstr->addOperand(std::make_unique(*src1_reg)); - sraSignInstr->addOperand(std::make_unique(is_32bit ? 31 : 63)); - newInstrs.push_back(std::move(sraSignInstr)); - - // 最终结果：dst = temp - sign（对于正除数）或 dst = temp + sign（对于负除数） - if (divisor > 0) { - auto finalSubInstr = std::make_unique(is_32bit ? RVOpcodes::SUBW : RVOpcodes::SUB); - finalSubInstr->addOperand(std::make_unique(*dst_reg)); - finalSubInstr->addOperand(std::make_unique(temp_reg)); - finalSubInstr->addOperand(std::make_unique(sign_reg)); - newInstrs.push_back(std::move(finalSubInstr)); - } else { - auto finalAddInstr = std::make_unique(is_32bit ? RVOpcodes::ADDW : RVOpcodes::ADD); - finalAddInstr->addOperand(std::make_unique(*dst_reg)); - finalAddInstr->addOperand(std::make_unique(temp_reg)); - finalAddInstr->addOperand(std::make_unique(sign_reg)); - newInstrs.push_back(std::move(finalAddInstr)); - } } - // 对于大的除数或复杂情况，保持原始除法指令不变 + + int sign_reg = createTempReg(); + auto sraSignInstr = std::make_unique(is_32bit ? RVOpcodes::SRAIW : RVOpcodes::SRAI); + sraSignInstr->addOperand(std::make_unique(sign_reg)); + sraSignInstr->addOperand(std::make_unique(*src1_reg)); + sraSignInstr->addOperand(std::make_unique(is_32bit ? 31 : 63)); + newInstrs.push_back(std::move(sraSignInstr)); + + auto subInstr = std::make_unique(is_32bit ? RVOpcodes::SUBW : RVOpcodes::SUB); + subInstr->addOperand(std::make_unique(temp_reg)); + subInstr->addOperand(std::make_unique(temp_reg)); + subInstr->addOperand(std::make_unique(sign_reg)); + newInstrs.push_back(std::move(subInstr)); + + if (divisor < 0) { + auto negInstr = std::make_unique(is_32bit ? RVOpcodes::SUBW : RVOpcodes::SUB); + negInstr->addOperand(std::make_unique(*dst_reg)); + negInstr->addOperand(std::make_unique(PhysicalReg::ZERO)); + negInstr->addOperand(std::make_unique(temp_reg)); + newInstrs.push_back(std::move(negInstr)); + } else { + auto moveInstr = std::make_unique(is_32bit ? RVOpcodes::ADDW : RVOpcodes::ADD); + moveInstr->addOperand(std::make_unique(*dst_reg)); + moveInstr->addOperand(std::make_unique(temp_reg)); + moveInstr->addOperand(std::make_unique(PhysicalReg::ZERO)); + newInstrs.push_back(std::move(moveInstr)); + } } if (!newInstrs.empty()) { - replacements.push_back({i, std::move(newInstrs)}); + size_t start_index = i; + if (instructions_to_replace == 2) { + start_index = i - 1; + } + replacements.push_back({start_index, instructions_to_replace, std::move(newInstrs)}); } } - // 批量应用替换（从后往前处理避免索引问题） for (auto it = replacements.rbegin(); it != replacements.rend(); ++it) { - instrs.erase(instrs.begin() + it->index); + instrs.erase(instrs.begin() + it->index, instrs.begin() + it->index + it->count_to_erase); instrs.insert(instrs.begin() + it->index, std::make_move_iterator(it->newInstrs.begin()), std::make_move_iterator(it->newInstrs.end())); @@ -326,4 +279,4 @@ void DivStrengthReduction::runOnMachineFunction(MachineFunction *mfunc) { } } -} // namespace sysy \ No newline at end of file +} // namespace sysy diff --git a/src/backend/RISCv64/RISCv64AsmPrinter.cpp b/src/backend/RISCv64/RISCv64AsmPrinter.cpp index 183003c..5e73cd2 100644 --- a/src/backend/RISCv64/RISCv64AsmPrinter.cpp +++ b/src/backend/RISCv64/RISCv64AsmPrinter.cpp @@ -60,7 +60,7 @@ void RISCv64AsmPrinter::printInstruction(MachineInstr* instr, bool debug) { case RVOpcodes::ADD: *OS << "add "; break; case RVOpcodes::ADDI: *OS << "addi "; break; case RVOpcodes::ADDW: *OS << "addw "; break; case RVOpcodes::ADDIW: *OS << "addiw "; break; case RVOpcodes::SUB: *OS << "sub "; break; case RVOpcodes::SUBW: *OS << "subw "; break; - case RVOpcodes::MUL: *OS << "mul "; break; case RVOpcodes::MULW: *OS << "mulw "; break; + case RVOpcodes::MUL: *OS << "mul "; break; case RVOpcodes::MULW: *OS << "mulw "; break; case RVOpcodes::MULH: *OS << "mulh "; break; case RVOpcodes::DIV: *OS << "div "; break; case RVOpcodes::DIVW: *OS << "divw "; break; case RVOpcodes::REM: *OS << "rem "; break; case RVOpcodes::REMW: *OS << "remw "; break; case RVOpcodes::XOR: *OS << "xor "; break; case RVOpcodes::XORI: *OS << "xori "; break; diff --git a/src/include/backend/RISCv64/RISCv64LLIR.h b/src/include/backend/RISCv64/RISCv64LLIR.h index be11528..3c8710e 100644 --- a/src/include/backend/RISCv64/RISCv64LLIR.h +++ b/src/include/backend/RISCv64/RISCv64LLIR.h @@ -45,7 +45,7 @@ enum class PhysicalReg { // RISC-V 指令操作码枚举 enum class RVOpcodes { // 算术指令 - ADD, ADDI, ADDW, ADDIW, SUB, SUBW, MUL, MULW, DIV, DIVW, REM, REMW, + ADD, ADDI, ADDW, ADDIW, SUB, SUBW, MUL, MULW, MULH, DIV, DIVW, REM, REMW, // 逻辑指令 XOR, XORI, OR, ORI, AND, ANDI, // 移位指令 diff --git a/src/include/midend/IR.h b/src/include/midend/IR.h index 2e4d72b..9423a8c 100644 --- a/src/include/midend/IR.h +++ b/src/include/midend/IR.h @@ -709,7 +709,7 @@ class Instruction : public User { kBitItoF = 0x1UL << 40, kBitFtoI = 0x1UL << 41, kSRA = 0x1UL << 42, - kMulh = 0x1UL << 43, + kMulh = 0x1UL << 43 }; protected: @@ -823,7 +823,7 @@ public: bool isBinary() const { static constexpr uint64_t BinaryOpMask = - (kAdd | kSub | kMul | kDiv | kRem | kAnd | kOr | kSRA) | + (kAdd | kSub | kMul | kDiv | kRem | kAnd | kOr | kSRA | kMulh) | (kICmpEQ | kICmpNE | kICmpLT | kICmpGT | kICmpLE | kICmpGE); return kind & BinaryOpMask; } diff --git a/src/include/midend/IRBuilder.h b/src/include/midend/IRBuilder.h index c232578..ab50173 100644 --- a/src/include/midend/IRBuilder.h +++ b/src/include/midend/IRBuilder.h @@ -220,6 +220,9 @@ class IRBuilder { BinaryInst * createSRAInst(Value *lhs, Value *rhs, const std::string &name = "") { return createBinaryInst(Instruction::kSRA, Type::getIntType(), lhs, rhs, name); } ///< 创建算术右移指令 + BinaryInst * createMulhInst(Value *lhs, Value *rhs, const std::string &name = "") { + return createBinaryInst(Instruction::kMulh, Type::getIntType(), lhs, rhs, name); + } ///< 创建高位乘法指令 CallInst * createCallInst(Function *callee, const std::vector &args, const std::string &name = "") { std::string newName; if (name.empty() && callee->getReturnType() != Type::getVoidType()) { diff --git a/src/midend/SysYIRGenerator.cpp b/src/midend/SysYIRGenerator.cpp index 0b2d751..3228257 100644 --- a/src/midend/SysYIRGenerator.cpp +++ b/src/midend/SysYIRGenerator.cpp @@ -15,6 +15,29 @@ using namespace std; namespace sysy { +std::pair calculate_signed_magic(int d) { + if (d == 0) throw std::runtime_error("Division by zero"); + if (d == 1 || d == -1) return {0, 0}; // Not used by strength reduction + + int k = 0; + unsigned int ad = (d > 0) ? d : -d; + unsigned int temp = ad; + while (temp > 0) { + temp >>= 1; + k++; + } + if ((ad & (ad - 1)) == 0) { // if power of 2 + k--; + } + + unsigned __int128 m_val = 1; + m_val <<= (32 + k - 1); + unsigned __int128 m_prime = m_val / ad; + long long m = m_prime + 1; + + return {m, k}; +} + // std::vector BinaryValueStack; ///< 用于存储value的栈 // std::vector BinaryOpStack; ///< 用于存储二元表达式的操作符栈 diff --git a/test_div_optimization.sy b/test_div_optimization.sy new file mode 100644 index 0000000..30c0bb1 --- /dev/null +++ b/test_div_optimization.sy @@ -0,0 +1,9 @@ +int main() { + int a = 100; + int b = a / 4; + int c = a / 8; + int d = a / 16; + int e = a / 7; + int f = a / 3; + return b + c + d + e; +} From 9c5d9ea78c836133bd8a0e0266a3c18abe1bdc5c Mon Sep 17 00:00:00 2001 From: CGH0S7 <776459475@qq.com> Date: Sun, 3 Aug 2025 14:38:27 +0800 Subject: [PATCH 14/55] =?UTF-8?q?[optimize]=E5=88=A0=E9=99=A4=E5=A4=9A?= =?UTF-8?q?=E4=BD=99=E6=B5=8B=E8=AF=95=E6=96=87=E4=BB=B6?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- test_div_optimization.sy | 9 --------- 1 file changed, 9 deletions(-) delete mode 100644 test_div_optimization.sy diff --git a/test_div_optimization.sy b/test_div_optimization.sy deleted file mode 100644 index 30c0bb1..0000000 --- a/test_div_optimization.sy +++ /dev/null @@ -1,9 +0,0 @@ -int main() { - int a = 100; - int b = a / 4; - int c = a / 8; - int d = a / 16; - int e = a / 7; - int f = a / 3; - return b + c + d + e; -} From 845f969c2ea6891a47a60049378e72bfdabb4359 Mon Sep 17 00:00:00 2001 From: Lixuanwang Date: Sun, 3 Aug 2025 14:42:19 +0800 Subject: [PATCH 15/55] =?UTF-8?q?[backend-IRC]=E4=BF=AE=E5=A4=8D=E4=BA=86?= =?UTF-8?q?=E7=8E=B0=E5=9C=BA=E7=AE=A1=E7=90=86=E4=B8=8E=E6=BA=A2=E5=87=BA?= =?UTF-8?q?=E5=A4=84=E7=90=86=E7=9A=84=E6=A0=88=E5=81=8F=E7=A7=BB=E9=87=8F?= =?UTF-8?q?=E9=94=99=E8=AF=AF=E9=97=AE=E9=A2=98?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- script/runit-riscv64.sh | 6 +- .../RISCv64/Handler/EliminateFrameIndices.cpp | 53 ++++++++++++++-- .../Handler/PrologueEpilogueInsertion.cpp | 61 ++++++++----------- src/backend/RISCv64/RISCv64RegAlloc.cpp | 31 ++++++++-- src/include/backend/RISCv64/RISCv64LLIR.h | 3 +- 5 files changed, 101 insertions(+), 53 deletions(-) diff --git a/script/runit-riscv64.sh b/script/runit-riscv64.sh index 3a0026f..00e65a4 100644 --- a/script/runit-riscv64.sh +++ b/script/runit-riscv64.sh @@ -60,11 +60,7 @@ display_file_content() { # 清理临时文件的函数 clean_tmp() { echo "正在清理临时目录: ${TMP_DIR}" - rm -rf "${TMP_DIR}"/*.s \ - "${TMP_DIR}"/*_sysyc_riscv64 \ - "${TMP_DIR}"/*_sysyc_riscv64.actual_out \ - "${TMP_DIR}"/*_sysyc_riscv64.expected_stdout \ - "${TMP_DIR}"/*_sysyc_riscv64.o + rm -rf "${TMP_DIR}"/* echo "清理完成。" } diff --git a/src/backend/RISCv64/Handler/EliminateFrameIndices.cpp b/src/backend/RISCv64/Handler/EliminateFrameIndices.cpp index 6973293..59f4db3 100644 --- a/src/backend/RISCv64/Handler/EliminateFrameIndices.cpp +++ b/src/backend/RISCv64/Handler/EliminateFrameIndices.cpp @@ -29,6 +29,8 @@ unsigned EliminateFrameIndicesPass::getTypeSizeInBytes(Type* type) { } void EliminateFrameIndicesPass::runOnMachineFunction(MachineFunction* mfunc) { +// [方案一修改] 这是修改后完整的函数代码。 +// 主要的逻辑变更在原注释"[核心修改]"部分。 StackFrameInfo& frame_info = mfunc->getFrameInfo(); Function* F = mfunc->getFunc(); RISCv64ISel* isel = mfunc->getISel(); @@ -65,6 +67,8 @@ void EliminateFrameIndicesPass::runOnMachineFunction(MachineFunction* mfunc) { // 记录仅由AllocaInst分配的局部变量的总大小 frame_info.locals_size = local_var_offset - 16; + // [新增] 记录局部变量区域分配结束的最终偏移量 + frame_info.locals_end_offset = -local_var_offset; // 3. [核心修改] 在函数入口为所有栈传递的参数插入load指令 // 这个步骤至关重要：它在寄存器分配之前，为这些参数的vreg创建了明确的“定义(def)”指令。 @@ -72,6 +76,8 @@ void EliminateFrameIndicesPass::runOnMachineFunction(MachineFunction* mfunc) { if (F && isel && !mfunc->getBlocks().empty()) { MachineBasicBlock* entry_block = mfunc->getBlocks().front().get(); std::vector> arg_load_instrs; + + // 步骤 3.1: 生成所有加载栈参数的指令，暂存起来 int arg_idx = 0; for (Argument* arg : F->getArguments()) { // 根据ABI，前8个整型/指针参数通过寄存器传递，这里只处理超出部分。 @@ -104,13 +110,48 @@ void EliminateFrameIndicesPass::runOnMachineFunction(MachineFunction* mfunc) { 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())); - } + // [方案一修改] 仅当有需要加载的栈参数时，才执行插入逻辑 + if (!arg_load_instrs.empty()) { + auto& entry_instrs = entry_block->getInstructions(); + auto insertion_point = entry_instrs.begin(); // 默认插入点为块的开头 + auto last_arg_save_it = entry_instrs.end(); + // 步骤 3.2: 寻找一个安全的插入点。 + // 遍历入口块的指令，找到最后一条保存“寄存器传递参数”的伪指令。 + // 这样可以确保我们在所有 a0-a7 参数被保存之后，才执行可能覆盖它们的加载指令。 + for (auto it = entry_instrs.begin(); it != entry_instrs.end(); ++it) { + MachineInstr* instr = it->get(); + // 寻找代表保存参数到栈的伪指令 + if (instr->getOpcode() == RVOpcodes::FRAME_STORE_W || + instr->getOpcode() == RVOpcodes::FRAME_STORE_D || + instr->getOpcode() == RVOpcodes::FRAME_STORE_F) { + + // 检查被保存的值是否是寄存器参数 (arg_no < 8) + auto& operands = instr->getOperands(); + if (operands.empty() || operands[0]->getKind() != MachineOperand::KIND_REG) continue; + + unsigned src_vreg = static_cast(operands[0].get())->getVRegNum(); + Value* ir_value = isel->getVRegValueMap().count(src_vreg) ? isel->getVRegValueMap().at(src_vreg) : nullptr; + + if (auto ir_arg = dynamic_cast(ir_value)) { + if (ir_arg->getIndex() < 8) { + last_arg_save_it = it; // 找到了一个保存寄存器参数的指令，更新位置 + } + } + } + } + + // 如果找到了这样的保存指令，我们的插入点就在它之后 + if (last_arg_save_it != entry_instrs.end()) { + insertion_point = std::next(last_arg_save_it); + } + + // 步骤 3.3: 在计算出的安全位置，一次性插入所有新创建的参数加载指令 + entry_instrs.insert(insertion_point, + std::make_move_iterator(arg_load_instrs.begin()), + std::make_move_iterator(arg_load_instrs.end())); + } + } // 4. 遍历所有机器指令，将访问局部变量的伪指令展开为真实指令 // 由于处理参数的逻辑已移除，这里的展开现在只针对局部变量，因此是正确的。 diff --git a/src/backend/RISCv64/Handler/PrologueEpilogueInsertion.cpp b/src/backend/RISCv64/Handler/PrologueEpilogueInsertion.cpp index ef86ea7..245a275 100644 --- a/src/backend/RISCv64/Handler/PrologueEpilogueInsertion.cpp +++ b/src/backend/RISCv64/Handler/PrologueEpilogueInsertion.cpp @@ -9,7 +9,12 @@ namespace sysy { char PrologueEpilogueInsertionPass::ID = 0; +// [函数上下文] +// ... + void PrologueEpilogueInsertionPass::runOnMachineFunction(MachineFunction* mfunc) { +// [最终修正] 这是修正后完整的函数代码。 +// 序言(4.4)和尾声(5.1)中的循环逻辑现在完全一致。 StackFrameInfo& frame_info = mfunc->getFrameInfo(); Function* F = mfunc->getFunc(); RISCv64ISel* isel = mfunc->getISel(); @@ -27,8 +32,7 @@ void PrologueEpilogueInsertionPass::runOnMachineFunction(MachineFunction* mfunc) ); } - // 2. [新增] 确定需要保存的被调用者保存寄存器 (callee-saved) - // 这部分逻辑从 CalleeSavedHandler Pass 移入，以集中管理序言生成 + // 2. 确定需要保存的被调用者保存寄存器 (callee-saved) auto& vreg_to_preg_map = frame_info.vreg_to_preg_map; std::set used_callee_saved_regs_set; const auto& callee_saved_int = getCalleeSavedIntRegs(); @@ -36,38 +40,34 @@ void PrologueEpilogueInsertionPass::runOnMachineFunction(MachineFunction* mfunc) 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字节 + frame_info.callee_saved_size = frame_info.callee_saved_regs_to_store.size() * 8; // 3. 计算最终的栈帧总大小 int total_stack_size = frame_info.locals_size + frame_info.spill_size + frame_info.callee_saved_size + - 16; // 为 ra 和 s0 固定的16字节 + 16; - int aligned_stack_size = (total_stack_size + 15) & ~15; // 16字节对齐 + int aligned_stack_size = (total_stack_size + 15) & ~15; frame_info.total_size = aligned_stack_size; - // 只有在需要分配栈空间时才生成序言和尾声 if (aligned_stack_size > 0) { // --- 4. 插入完整的序言 --- MachineBasicBlock* entry_block = mfunc->getBlocks().front().get(); auto& entry_instrs = entry_block->getInstructions(); std::vector> prologue_instrs; - // 4.1. 分配栈帧: addi sp, sp, -aligned_stack_size + // 4.1. 分配栈帧 auto alloc_stack = std::make_unique(RVOpcodes::ADDI); alloc_stack->addOperand(std::make_unique(PhysicalReg::SP)); alloc_stack->addOperand(std::make_unique(PhysicalReg::SP)); @@ -75,7 +75,6 @@ void PrologueEpilogueInsertionPass::runOnMachineFunction(MachineFunction* mfunc) prologue_instrs.push_back(std::move(alloc_stack)); // 4.2. 保存 ra 和 s0 - // sd ra, (aligned_stack_size - 8)(sp) auto save_ra = std::make_unique(RVOpcodes::SD); save_ra->addOperand(std::make_unique(PhysicalReg::RA)); save_ra->addOperand(std::make_unique( @@ -83,7 +82,6 @@ void PrologueEpilogueInsertionPass::runOnMachineFunction(MachineFunction* mfunc) std::make_unique(aligned_stack_size - 8) )); prologue_instrs.push_back(std::move(save_ra)); - // sd s0, (aligned_stack_size - 16)(sp) auto save_fp = std::make_unique(RVOpcodes::SD); save_fp->addOperand(std::make_unique(PhysicalReg::S0)); save_fp->addOperand(std::make_unique( @@ -92,60 +90,55 @@ void PrologueEpilogueInsertionPass::runOnMachineFunction(MachineFunction* mfunc) )); prologue_instrs.push_back(std::move(save_fp)); - // 4.3. 设置新的帧指针 s0: addi s0, sp, aligned_stack_size + // 4.3. 设置新的帧指针 s0 auto set_fp = std::make_unique(RVOpcodes::ADDI); set_fp->addOperand(std::make_unique(PhysicalReg::S0)); set_fp->addOperand(std::make_unique(PhysicalReg::SP)); set_fp->addOperand(std::make_unique(aligned_stack_size)); prologue_instrs.push_back(std::move(set_fp)); - // 4.4. [新增] 保存所有使用到的被调用者保存寄存器 - // 它们保存在 s0 下方，紧接着 ra/s0 的位置 - int callee_saved_offset = -16; + // 4.4. 保存所有使用到的被调用者保存寄存器 + int next_available_offset = -(16 + frame_info.locals_size + frame_info.spill_size); 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; + // [修正] 采用“先使用，后更新”逻辑 + RVOpcodes store_op = isFPR(reg) ? RVOpcodes::FSD : RVOpcodes::SD; auto save_cs_reg = std::make_unique(store_op); save_cs_reg->addOperand(std::make_unique(reg)); save_cs_reg->addOperand(std::make_unique( std::make_unique(PhysicalReg::S0), - std::make_unique(callee_saved_offset) + std::make_unique(next_available_offset) // 使用当前偏移 )); prologue_instrs.push_back(std::move(save_cs_reg)); + next_available_offset -= 8; // 为下一个寄存器准备偏移 } - // 4.5. [核心修改] 加载栈传递参数的逻辑已从此移除 - // 这项工作已经前移至 `EliminateFrameIndicesPass` 中完成， - // 以确保在寄存器分配前就将相关虚拟寄存器定义，从而修复溢出逻辑的bug。 - - // 4.6. 将所有生成的序言指令一次性插入到函数入口 + // 4.5. 将所有生成的序言指令一次性插入到函数入口 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> epilogue_instrs; - // 5.1. [新增] 恢复被调用者保存寄存器 - callee_saved_offset = -16; + // 5.1. 恢复被调用者保存寄存器 + // [修正] 采用与序言完全相同的“先使用，后更新”逻辑 + int next_available_offset_restore = -(16 + frame_info.locals_size + frame_info.spill_size); 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; + RVOpcodes load_op = isFPR(reg) ? RVOpcodes::FLD : RVOpcodes::LD; auto restore_cs_reg = std::make_unique(load_op); restore_cs_reg->addOperand(std::make_unique(reg)); restore_cs_reg->addOperand(std::make_unique( std::make_unique(PhysicalReg::S0), - std::make_unique(callee_saved_offset) + std::make_unique(next_available_offset_restore) // 使用当前偏移 )); epilogue_instrs.push_back(std::move(restore_cs_reg)); + next_available_offset_restore -= 8; // 为下一个寄存器准备偏移 } - // 5.2. 恢复 ra 和 s0 (注意基址现在是sp) - // ld ra, (aligned_stack_size - 8)(sp) + // 5.2. 恢复 ra 和 s0 auto restore_ra = std::make_unique(RVOpcodes::LD); restore_ra->addOperand(std::make_unique(PhysicalReg::RA)); restore_ra->addOperand(std::make_unique( @@ -153,7 +146,6 @@ void PrologueEpilogueInsertionPass::runOnMachineFunction(MachineFunction* mfunc) std::make_unique(aligned_stack_size - 8) )); epilogue_instrs.push_back(std::move(restore_ra)); - // ld s0, (aligned_stack_size - 16)(sp) auto restore_fp = std::make_unique(RVOpcodes::LD); restore_fp->addOperand(std::make_unique(PhysicalReg::S0)); restore_fp->addOperand(std::make_unique( @@ -162,7 +154,7 @@ void PrologueEpilogueInsertionPass::runOnMachineFunction(MachineFunction* mfunc) )); epilogue_instrs.push_back(std::move(restore_fp)); - // 5.3. 释放栈帧: addi sp, sp, aligned_stack_size + // 5.3. 释放栈帧 auto dealloc_stack = std::make_unique(RVOpcodes::ADDI); dealloc_stack->addOperand(std::make_unique(PhysicalReg::SP)); dealloc_stack->addOperand(std::make_unique(PhysicalReg::SP)); @@ -174,7 +166,6 @@ void PrologueEpilogueInsertionPass::runOnMachineFunction(MachineFunction* mfunc) std::make_move_iterator(epilogue_instrs.begin()), std::make_move_iterator(epilogue_instrs.end())); - // 一个基本块通常只有一个终止指令，处理完就可以跳到下一个块 goto next_block; } } diff --git a/src/backend/RISCv64/RISCv64RegAlloc.cpp b/src/backend/RISCv64/RISCv64RegAlloc.cpp index 76f003b..aa6c956 100644 --- a/src/backend/RISCv64/RISCv64RegAlloc.cpp +++ b/src/backend/RISCv64/RISCv64RegAlloc.cpp @@ -647,11 +647,22 @@ void RISCv64RegAlloc::assignColors() { } } +// 在文件 RISCv64RegAlloc.cpp 中: + +// [函数上下文] +// ... +// 我将修改下面这个函数 +// ... + // 重写程序，插入溢出代码 void RISCv64RegAlloc::rewriteProgram() { - // 1. 为溢出的旧vreg在栈上分配空间 StackFrameInfo& frame_info = MFunc->getFrameInfo(); - int spill_base_offset = frame_info.locals_size + frame_info.callee_saved_size; + // 使用 EFI Pass 确定的 locals_end_offset 作为溢出分配的基准。 + // locals_end_offset 本身是负数，代表局部变量区域的下边界地址。 + int spill_current_offset = frame_info.locals_end_offset; + + // [新增] 保存溢出区域的起始点，用于最后计算总的 spill_size + const int spill_start_offset = frame_info.locals_end_offset; for (unsigned vreg : spilledNodes) { if (frame_info.spill_offsets.count(vreg)) continue; @@ -663,11 +674,19 @@ void RISCv64RegAlloc::rewriteProgram() { size = 8; // pointer } - spill_base_offset += size; - spill_base_offset = (spill_base_offset + 7) & ~7; - frame_info.spill_offsets[vreg] = -spill_base_offset; // [修正] 溢出槽也使用负偏移量 + // [修改] 在当前偏移基础上继续向下(地址变得更负)分配空间 + spill_current_offset -= size; + + // [修改] 对齐新的、更小的地址，RISC-V 要求8字节对齐 + spill_current_offset = spill_current_offset & ~7; + + // 将计算出的、不会冲突的正确偏移量存入 spill_offsets + frame_info.spill_offsets[vreg] = spill_current_offset; } - frame_info.spill_size = spill_base_offset - (frame_info.locals_size + frame_info.callee_saved_size); + + // [修改] 更新总的溢出区域大小。 + // spill_size = -(结束偏移 - 开始偏移) + frame_info.spill_size = -(spill_current_offset - spill_start_offset); // 2. 遍历所有指令，重写代码 for (auto& mbb : MFunc->getBlocks()) { diff --git a/src/include/backend/RISCv64/RISCv64LLIR.h b/src/include/backend/RISCv64/RISCv64LLIR.h index 1931617..0cd6b9b 100644 --- a/src/include/backend/RISCv64/RISCv64LLIR.h +++ b/src/include/backend/RISCv64/RISCv64LLIR.h @@ -39,7 +39,7 @@ enum class PhysicalReg { // 用于内部表示物理寄存器在干扰图中的节点ID（一个简单的特殊ID，确保不与vreg_counter冲突） // 假设 vreg_counter 不会达到这么大的值 - PHYS_REG_START_ID = 100000, + PHYS_REG_START_ID = 1000000, PHYS_REG_END_ID = PHYS_REG_START_ID + 320, // 预留足够的空间 }; @@ -280,6 +280,7 @@ private: // 栈帧信息 struct StackFrameInfo { int locals_size = 0; // 仅为AllocaInst分配的大小 + int locals_end_offset = 0; // [新增] 记录局部变量分配结束后的偏移量(相对于s0，为负) int spill_size = 0; // 仅为溢出分配的大小 int total_size = 0; // 总大小 int callee_saved_size = 0; // 保存寄存器的大小 From f8e423f579b7d1d068d8c2b14c8e9b7c6cbb9b8e Mon Sep 17 00:00:00 2001 From: Lixuanwang Date: Sun, 3 Aug 2025 15:18:52 +0800 Subject: [PATCH 16/55] =?UTF-8?q?=E5=90=88=E5=B9=B6backend=E3=80=81backend?= =?UTF-8?q?-IRC=E5=88=B0midend?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- script/runit-riscv64.sh | 6 +- script/runit-single.sh | 12 +- src/backend/RISCv64/CMakeLists.txt | 1 + .../RISCv64/Handler/CalleeSavedHandler.cpp | 128 +- .../RISCv64/Handler/EliminateFrameIndices.cpp | 231 ++ .../Handler/PrologueEpilogueInsertion.cpp | 145 +- src/backend/RISCv64/RISCv64AsmPrinter.cpp | 2 +- src/backend/RISCv64/RISCv64Backend.cpp | 47 +- src/backend/RISCv64/RISCv64ISel.cpp | 28 +- src/backend/RISCv64/RISCv64LLIR.cpp | 118 +- src/backend/RISCv64/RISCv64RegAlloc.cpp | 2214 ++++++++++------- .../RISCv64/Handler/EliminateFrameIndices.h | 20 + src/include/backend/RISCv64/RISCv64Backend.h | 1 - src/include/backend/RISCv64/RISCv64LLIR.h | 15 +- src/include/backend/RISCv64/RISCv64Passes.h | 1 + src/include/backend/RISCv64/RISCv64RegAlloc.h | 130 +- src/sysyc.cpp | 2 + 17 files changed, 1966 insertions(+), 1135 deletions(-) create mode 100644 src/backend/RISCv64/Handler/EliminateFrameIndices.cpp create mode 100644 src/include/backend/RISCv64/Handler/EliminateFrameIndices.h diff --git a/script/runit-riscv64.sh b/script/runit-riscv64.sh index 3a0026f..00e65a4 100644 --- a/script/runit-riscv64.sh +++ b/script/runit-riscv64.sh @@ -60,11 +60,7 @@ display_file_content() { # 清理临时文件的函数 clean_tmp() { echo "正在清理临时目录: ${TMP_DIR}" - rm -rf "${TMP_DIR}"/*.s \ - "${TMP_DIR}"/*_sysyc_riscv64 \ - "${TMP_DIR}"/*_sysyc_riscv64.actual_out \ - "${TMP_DIR}"/*_sysyc_riscv64.expected_stdout \ - "${TMP_DIR}"/*_sysyc_riscv64.o + rm -rf "${TMP_DIR}"/* echo "清理完成。" } diff --git a/script/runit-single.sh b/script/runit-single.sh index 8b7804f..ed32181 100644 --- a/script/runit-single.sh +++ b/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}" diff --git a/src/backend/RISCv64/CMakeLists.txt b/src/backend/RISCv64/CMakeLists.txt index f1e8f55..4330e40 100644 --- a/src/backend/RISCv64/CMakeLists.txt +++ b/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 diff --git a/src/backend/RISCv64/Handler/CalleeSavedHandler.cpp b/src/backend/RISCv64/Handler/CalleeSavedHandler.cpp index cdbccc1..e7587b9 100644 --- a/src/backend/RISCv64/Handler/CalleeSavedHandler.cpp +++ b/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 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(op.get())); - } else if (op->getKind() == MachineOperand::KIND_MEM) { - check_and_insert_reg(static_cast(op.get())->getBase()); - } - } - } - } + const std::set& 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 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 regs_to_save = used_callee_saved; + if (regs_to_save.count(PhysicalReg::S0)) { + regs_to_save.erase(PhysicalReg::S0); } - - std::vector> 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 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(a) < static_cast(b); + }); + frame_info.callee_saved_regs_to_store = sorted_regs; - auto save_instr = std::make_unique(save_op); - save_instr->addOperand(std::make_unique(reg)); - save_instr->addOperand(std::make_unique( - std::make_unique(PhysicalReg::S0), // 基址为帧指针 s0 - std::make_unique(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> 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(restore_op); - restore_instr->addOperand(std::make_unique(reg)); - restore_instr->addOperand(std::make_unique( - std::make_unique(PhysicalReg::S0), - std::make_unique(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 \ No newline at end of file +} // namespace sysy diff --git a/src/backend/RISCv64/Handler/EliminateFrameIndices.cpp b/src/backend/RISCv64/Handler/EliminateFrameIndices.cpp new file mode 100644 index 0000000..d343fbf --- /dev/null +++ b/src/backend/RISCv64/Handler/EliminateFrameIndices.cpp @@ -0,0 +1,231 @@ +#include "EliminateFrameIndices.h" +#include "RISCv64ISel.h" +#include +#include + +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(); + 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(); + + // 在这里处理栈传递的参数，以便在寄存器分配前就将数据流显式化，修复溢出逻辑的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(inst.get())) { + Type* allocated_type = alloca->getType()->as()->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; + // 记录局部变量区域分配结束的最终偏移量 + frame_info.locals_end_offset = -local_var_offset; + + // 在函数入口为所有栈传递的参数插入load指令 + // 这个步骤至关重要：它在寄存器分配之前，为这些参数的vreg创建了明确的“定义(def)”指令。 + // 这解决了在高寄存器压力下，当这些vreg被溢出时，`rewriteProgram`找不到其定义点而崩溃的问题。 + if (F && isel && !mfunc->getBlocks().empty()) { + MachineBasicBlock* entry_block = mfunc->getBlocks().front().get(); + std::vector> arg_load_instrs; + + // 步骤 3.1: 生成所有加载栈参数的指令，暂存起来 + 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(load_op); + load_instr->addOperand(std::make_unique(arg_vreg)); + load_instr->addOperand(std::make_unique( + std::make_unique(PhysicalReg::S0), // 基址为帧指针 + std::make_unique(offset) + )); + arg_load_instrs.push_back(std::move(load_instr)); + } + arg_idx++; + } + + //仅当有需要加载的栈参数时，才执行插入逻辑 + if (!arg_load_instrs.empty()) { + auto& entry_instrs = entry_block->getInstructions(); + auto insertion_point = entry_instrs.begin(); // 默认插入点为块的开头 + auto last_arg_save_it = entry_instrs.end(); + + // 步骤 3.2: 寻找一个安全的插入点。 + // 遍历入口块的指令，找到最后一条保存“寄存器传递参数”的伪指令。 + // 这样可以确保我们在所有 a0-a7 参数被保存之后，才执行可能覆盖它们的加载指令。 + for (auto it = entry_instrs.begin(); it != entry_instrs.end(); ++it) { + MachineInstr* instr = it->get(); + // 寻找代表保存参数到栈的伪指令 + if (instr->getOpcode() == RVOpcodes::FRAME_STORE_W || + instr->getOpcode() == RVOpcodes::FRAME_STORE_D || + instr->getOpcode() == RVOpcodes::FRAME_STORE_F) { + + // 检查被保存的值是否是寄存器参数 (arg_no < 8) + auto& operands = instr->getOperands(); + if (operands.empty() || operands[0]->getKind() != MachineOperand::KIND_REG) continue; + + unsigned src_vreg = static_cast(operands[0].get())->getVRegNum(); + Value* ir_value = isel->getVRegValueMap().count(src_vreg) ? isel->getVRegValueMap().at(src_vreg) : nullptr; + + if (auto ir_arg = dynamic_cast(ir_value)) { + if (ir_arg->getIndex() < 8) { + last_arg_save_it = it; // 找到了一个保存寄存器参数的指令，更新位置 + } + } + } + } + + // 如果找到了这样的保存指令，我们的插入点就在它之后 + if (last_arg_save_it != entry_instrs.end()) { + insertion_point = std::next(last_arg_save_it); + } + + // 步骤 3.3: 在计算出的安全位置，一次性插入所有新创建的参数加载指令 + entry_instrs.insert(insertion_point, + std::make_move_iterator(arg_load_instrs.begin()), + std::make_move_iterator(arg_load_instrs.end())); + } + } + + // 4. 遍历所有机器指令，将访问局部变量的伪指令展开为真实指令 + for (auto& mbb : mfunc->getBlocks()) { + std::vector> 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(operands[0].get())->getVRegNum(); + unsigned alloca_vreg = static_cast(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(RVOpcodes::ADDI); + addi->addOperand(std::make_unique(addr_vreg)); + addi->addOperand(std::make_unique(PhysicalReg::S0)); + addi->addOperand(std::make_unique(offset)); + new_instructions.push_back(std::move(addi)); + + // 展开为: lw/ld/flw dest_vreg, 0(addr_vreg) + auto load_instr = std::make_unique(real_load_op); + load_instr->addOperand(std::make_unique(dest_vreg)); + load_instr->addOperand(std::make_unique( + std::make_unique(addr_vreg), + std::make_unique(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(operands[0].get())->getVRegNum(); + unsigned alloca_vreg = static_cast(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(RVOpcodes::ADDI); + addi->addOperand(std::make_unique(addr_vreg)); + addi->addOperand(std::make_unique(PhysicalReg::S0)); + addi->addOperand(std::make_unique(offset)); + new_instructions.push_back(std::move(addi)); + + // 展开为: sw/sd/fsw src_vreg, 0(addr_vreg) + auto store_instr = std::make_unique(real_store_op); + store_instr->addOperand(std::make_unique(src_vreg)); + store_instr->addOperand(std::make_unique( + std::make_unique(addr_vreg), + std::make_unique(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(operands[0].get())->getVRegNum(); + unsigned alloca_vreg = static_cast(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(RVOpcodes::ADDI); + addi->addOperand(std::make_unique(dest_vreg)); + addi->addOperand(std::make_unique(PhysicalReg::S0)); + addi->addOperand(std::make_unique(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 \ No newline at end of file diff --git a/src/backend/RISCv64/Handler/PrologueEpilogueInsertion.cpp b/src/backend/RISCv64/Handler/PrologueEpilogueInsertion.cpp index 30fa6bd..0eef863 100644 --- a/src/backend/RISCv64/Handler/PrologueEpilogueInsertion.cpp +++ b/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 +#include +#include 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& instr) { @@ -22,39 +27,49 @@ 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) auto& vreg_to_preg_map = frame_info.vreg_to_preg_map; + std::set 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; + 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.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; + + // 3. 计算最终的栈帧总大小 int total_stack_size = frame_info.locals_size + frame_info.spill_size + frame_info.callee_saved_size + - 16; // 为 ra 和 s0 固定的16字节 + 16; int aligned_stack_size = (total_stack_size + 15) & ~15; 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> prologue_instrs; - // 1. addi sp, sp, -aligned_stack_size + // 4.1. 分配栈帧 auto alloc_stack = std::make_unique(RVOpcodes::ADDI); alloc_stack->addOperand(std::make_unique(PhysicalReg::SP)); alloc_stack->addOperand(std::make_unique(PhysicalReg::SP)); alloc_stack->addOperand(std::make_unique(-aligned_stack_size)); prologue_instrs.push_back(std::move(alloc_stack)); - // 2. sd ra, (aligned_stack_size - 8)(sp) + // 4.2. 保存 ra 和 s0 auto save_ra = std::make_unique(RVOpcodes::SD); save_ra->addOperand(std::make_unique(PhysicalReg::RA)); save_ra->addOperand(std::make_unique( @@ -62,8 +77,6 @@ void PrologueEpilogueInsertionPass::runOnMachineFunction(MachineFunction* mfunc) std::make_unique(aligned_stack_size - 8) )); prologue_instrs.push_back(std::move(save_ra)); - - // 3. sd s0, (aligned_stack_size - 16)(sp) auto save_fp = std::make_unique(RVOpcodes::SD); save_fp->addOperand(std::make_unique(PhysicalReg::S0)); save_fp->addOperand(std::make_unique( @@ -72,66 +85,54 @@ void PrologueEpilogueInsertionPass::runOnMachineFunction(MachineFunction* mfunc) )); prologue_instrs.push_back(std::move(save_fp)); - // 4. addi s0, sp, aligned_stack_size + // 4.3. 设置新的帧指针 s0 auto set_fp = std::make_unique(RVOpcodes::ADDI); set_fp->addOperand(std::make_unique(PhysicalReg::S0)); set_fp->addOperand(std::make_unique(PhysicalReg::SP)); set_fp->addOperand(std::make_unique(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(RVOpcodes::FLW); - load_arg->addOperand(std::make_unique(dest_preg)); - load_arg->addOperand(std::make_unique( - std::make_unique(PhysicalReg::S0), - std::make_unique(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(load_op); - load_arg->addOperand(std::make_unique(dest_preg)); - load_arg->addOperand(std::make_unique( - std::make_unique(PhysicalReg::S0), - std::make_unique(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. 保存所有使用到的被调用者保存寄存器 + int next_available_offset = -(16 + frame_info.locals_size + frame_info.spill_size); + for (const auto& reg : frame_info.callee_saved_regs_to_store) { + // 采用“先使用，后更新”逻辑 + RVOpcodes store_op = isFPR(reg) ? RVOpcodes::FSD : RVOpcodes::SD; + auto save_cs_reg = std::make_unique(store_op); + save_cs_reg->addOperand(std::make_unique(reg)); + save_cs_reg->addOperand(std::make_unique( + std::make_unique(PhysicalReg::S0), + std::make_unique(next_available_offset) // 使用当前偏移 + )); + prologue_instrs.push_back(std::move(save_cs_reg)); + next_available_offset -= 8; // 为下一个寄存器准备偏移 } - // --- 2. 插入尾声 (此部分逻辑保持不变) --- + // 4.5. 将所有生成的序言指令一次性插入到函数入口 + 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()) { for (auto it = mbb->getInstructions().begin(); it != mbb->getInstructions().end(); ++it) { if ((*it)->getOpcode() == RVOpcodes::RET) { std::vector> epilogue_instrs; + + // 5.1. 恢复被调用者保存寄存器 + int next_available_offset_restore = -(16 + frame_info.locals_size + frame_info.spill_size); + for (const auto& reg : frame_info.callee_saved_regs_to_store) { + RVOpcodes load_op = isFPR(reg) ? RVOpcodes::FLD : RVOpcodes::LD; + auto restore_cs_reg = std::make_unique(load_op); + restore_cs_reg->addOperand(std::make_unique(reg)); + restore_cs_reg->addOperand(std::make_unique( + std::make_unique(PhysicalReg::S0), + std::make_unique(next_available_offset_restore) // 使用当前偏移 + )); + epilogue_instrs.push_back(std::move(restore_cs_reg)); + next_available_offset_restore -= 8; // 为下一个寄存器准备偏移 + } - // 1. ld ra + // 5.2. 恢复 ra 和 s0 auto restore_ra = std::make_unique(RVOpcodes::LD); restore_ra->addOperand(std::make_unique(PhysicalReg::RA)); restore_ra->addOperand(std::make_unique( @@ -139,8 +140,6 @@ void PrologueEpilogueInsertionPass::runOnMachineFunction(MachineFunction* mfunc) std::make_unique(aligned_stack_size - 8) )); epilogue_instrs.push_back(std::move(restore_ra)); - - // 2. ld s0 auto restore_fp = std::make_unique(RVOpcodes::LD); restore_fp->addOperand(std::make_unique(PhysicalReg::S0)); restore_fp->addOperand(std::make_unique( @@ -149,18 +148,18 @@ void PrologueEpilogueInsertionPass::runOnMachineFunction(MachineFunction* mfunc) )); epilogue_instrs.push_back(std::move(restore_fp)); - // 3. addi sp, sp, aligned_stack_size + // 5.3. 释放栈帧 auto dealloc_stack = std::make_unique(RVOpcodes::ADDI); dealloc_stack->addOperand(std::make_unique(PhysicalReg::SP)); dealloc_stack->addOperand(std::make_unique(PhysicalReg::SP)); dealloc_stack->addOperand(std::make_unique(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; } } diff --git a/src/backend/RISCv64/RISCv64AsmPrinter.cpp b/src/backend/RISCv64/RISCv64AsmPrinter.cpp index 5e73cd2..fcedb43 100644 --- a/src/backend/RISCv64/RISCv64AsmPrinter.cpp +++ b/src/backend/RISCv64/RISCv64AsmPrinter.cpp @@ -104,7 +104,7 @@ void RISCv64AsmPrinter::printInstruction(MachineInstr* instr, bool debug) { case RVOpcodes::FMV_S: *OS << "fmv.s "; break; case RVOpcodes::FMV_W_X: *OS << "fmv.w.x "; break; case RVOpcodes::FMV_X_W: *OS << "fmv.x.w "; break; - case RVOpcodes::CALL: { // [核心修改] 为CALL指令添加特殊处理逻辑 + case RVOpcodes::CALL: { // 为CALL指令添加特殊处理逻辑 *OS << "call "; // 遍历所有操作数，只寻找并打印函数名标签 for (const auto& op : instr->getOperands()) { diff --git a/src/backend/RISCv64/RISCv64Backend.cpp b/src/backend/RISCv64/RISCv64Backend.cpp index 0f948f0..e45248f 100644 --- a/src/backend/RISCv64/RISCv64Backend.cpp +++ b/src/backend/RISCv64/RISCv64Backend.cpp @@ -73,7 +73,7 @@ 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(); @@ -174,13 +174,37 @@ std::string RISCv64CodeGen::function_gen(Function* func) { // === 完整的后端处理流水线 === // 阶段 1: 指令选择 (sysy::IR -> LLIR with virtual registers) + DEBUG = 0; + DEEPDEBUG = 0; + RISCv64ISel isel; std::unique_ptr mfunc = isel.runOnFunction(func); // 第一次调试打印输出 - std::stringstream ss1; - RISCv64AsmPrinter printer1(mfunc.get()); - printer1.run(ss1, true); + 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(); + } + if (DEBUG) { + std::cerr << "====== Intermediate Representation after Instruction Selection ======\n" + << ss_after_isel.str(); + } + + // 阶段 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: 除法强度削弱优化 (Division Strength Reduction) DivStrengthReduction div_strength_reduction; @@ -194,10 +218,20 @@ std::string RISCv64CodeGen::function_gen(Function* func) { RISCv64RegAlloc reg_alloc(mfunc.get()); reg_alloc.run(); + 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()); @@ -210,7 +244,7 @@ std::string RISCv64CodeGen::function_gen(Function* func) { PrologueEpilogueInsertionPass pei_pass; pei_pass.runOnMachineFunction(mfunc.get()); - // 阶段 3.3: 清理产生的大立即数 + // 阶段 3.3: 大立即数合法化 LegalizeImmediatesPass legalizer; legalizer.runOnMachineFunction(mfunc.get()); @@ -218,8 +252,9 @@ std::string RISCv64CodeGen::function_gen(Function* func) { std::stringstream ss; RISCv64AsmPrinter printer(mfunc.get()); printer.run(ss); - if (DEBUG) ss << "\n" << ss1.str(); // 将指令选择阶段的结果也包含在最终输出中 + return ss.str(); + } } // namespace sysy \ No newline at end of file diff --git a/src/backend/RISCv64/RISCv64ISel.cpp b/src/backend/RISCv64/RISCv64ISel.cpp index e6b0929..2f7c9ae 100644 --- a/src/backend/RISCv64/RISCv64ISel.cpp +++ b/src/backend/RISCv64/RISCv64ISel.cpp @@ -2,8 +2,8 @@ #include #include #include -#include // For std::fabs -#include // For std::numeric_limits +#include +#include #include namespace sysy { @@ -402,7 +402,7 @@ void RISCv64ISel::selectNode(DAGNode* node) { Value* base = nullptr; Value* offset = nullptr; - // [修改] 扩展基地址的判断，使其可以识别 AllocaInst 或 GlobalValue + // 扩展基地址的判断，使其可以识别 AllocaInst 或 GlobalValue if (dynamic_cast(lhs) || dynamic_cast(lhs)) { base = lhs; offset = rhs; @@ -421,7 +421,7 @@ void RISCv64ISel::selectNode(DAGNode* node) { CurMBB->addInstruction(std::move(li)); } - // 2. [修改] 根据基地址的类型，生成不同的指令来获取基地址 + // 2. 根据基地址的类型，生成不同的指令来获取基地址 auto base_addr_vreg = getNewVReg(Type::getIntType()); // 创建一个新的临时vreg来存放基地址 // 情况一：基地址是局部栈变量 @@ -452,7 +452,7 @@ void RISCv64ISel::selectNode(DAGNode* node) { } } - // [V2优点] 在BINARY节点内部按需加载常量操作数。 + // 在BINARY节点内部按需加载常量操作数。 auto load_val_if_const = [&](Value* val) { if (auto c = dynamic_cast(val)) { if (DEBUG) { @@ -483,7 +483,7 @@ void RISCv64ISel::selectNode(DAGNode* node) { auto dest_vreg = getVReg(bin); auto lhs_vreg = getVReg(lhs); - // [V2优点] 融合 ADDIW 优化。 + // 融合 ADDIW 优化。 if (rhs_is_imm_opt) { auto rhs_const = dynamic_cast(rhs); auto instr = std::make_unique(RVOpcodes::ADDIW); @@ -952,7 +952,7 @@ void RISCv64ISel::selectNode(DAGNode* node) { // --- 步骤 3: 生成CALL指令 --- auto call_instr = std::make_unique(RVOpcodes::CALL); - // [协议] 如果函数有返回值，将它的目标虚拟寄存器作为第一个操作数 + // 如果函数有返回值，将它的目标虚拟寄存器作为第一个操作数 if (!call->getType()->isVoid()) { unsigned dest_vreg = getVReg(call); call_instr->addOperand(std::make_unique(dest_vreg)); @@ -1029,7 +1029,7 @@ void RISCv64ISel::selectNode(DAGNode* node) { } else { // --- 处理整数/指针返回值 --- // 返回值需要被放入 a0 - // [V2优点] 在RETURN节点内加载常量返回值 + // 在RETURN节点内加载常量返回值 if (auto const_val = dynamic_cast(ret_val)) { auto li_instr = std::make_unique(RVOpcodes::LI); li_instr->addOperand(std::make_unique(PhysicalReg::A0)); @@ -1043,7 +1043,7 @@ void RISCv64ISel::selectNode(DAGNode* node) { } } } - // [V1设计保留] 函数尾声（epilogue）不由RETURN节点生成， + // 函数尾声（epilogue）不由RETURN节点生成， // 而是由后续的AsmPrinter或其它Pass统一处理，这是一种常见且有效的模块化设计。 auto ret_mi = std::make_unique(RVOpcodes::RET); CurMBB->addInstruction(std::move(ret_mi)); @@ -1057,7 +1057,7 @@ void RISCv64ISel::selectNode(DAGNode* node) { auto then_bb_name = cond_br->getThenBlock()->getName(); auto else_bb_name = cond_br->getElseBlock()->getName(); - // [优化] 检查分支条件是否为编译期常量 + // 检查分支条件是否为编译期常量 if (auto const_cond = dynamic_cast(condition)) { // 如果条件是常量，直接生成一个无条件跳转J，而不是BNE if (const_cond->getInt() != 0) { // 条件为 true @@ -1072,7 +1072,7 @@ void RISCv64ISel::selectNode(DAGNode* node) { } // 如果条件不是常量，则执行标准流程 else { - // [修复] 为条件变量生成加载指令（如果它是常量的话，尽管上面已经处理了） + // 为条件变量生成加载指令（如果它是常量的话，尽管上面已经处理了） // 这一步是为了逻辑完整，以防有其他类型的常量没有被捕获 if (auto const_val = dynamic_cast(condition)) { auto li = std::make_unique(RVOpcodes::LI); @@ -1106,7 +1106,7 @@ void RISCv64ISel::selectNode(DAGNode* node) { } case DAGNode::MEMSET: { - // [V1设计保留] Memset的核心展开逻辑在虚拟寄存器层面是正确的，无需修改。 + // Memset的核心展开逻辑在虚拟寄存器层面是正确的，无需修改。 // 之前的bug是由于其输入（地址、值、大小）的虚拟寄存器未被正确初始化。 // 在修复了CONSTANT/ALLOCA_ADDR的加载问题后，此处的逻辑现在可以正常工作。 @@ -1454,7 +1454,7 @@ std::vector> RISCv64ISel::build_dag(BasicB // 依次添加所有索引作为后续的操作数 for (auto index : gep->getIndices()) { - // [修复] 从 Use 对象中获取真正的 Value* + // 从 Use 对象中获取真正的 Value* gep_node->operands.push_back(get_operand_node(index->getValue(), value_to_node, nodes_storage)); } } else if (auto load = dynamic_cast(inst)) { @@ -1558,7 +1558,7 @@ unsigned RISCv64ISel::getTypeSizeInBytes(Type* type) { } } -// [新] 打印DAG图以供调试的辅助函数 +// 打印DAG图以供调试的辅助函数 void RISCv64ISel::print_dag(const std::vector>& dag, const std::string& bb_name) { // 检查是否有DEBUG宏或者全局变量，避免在非调试模式下打印 // if (!DEBUG) return; diff --git a/src/backend/RISCv64/RISCv64LLIR.cpp b/src/backend/RISCv64/RISCv64LLIR.cpp index 3816ad1..3a580d7 100644 --- a/src/backend/RISCv64/RISCv64LLIR.cpp +++ b/src/backend/RISCv64/RISCv64LLIR.cpp @@ -1,6 +1,122 @@ #include "RISCv64LLIR.h" #include +#include // 用于 std::ostream 和 std::cerr +#include // 用于 std::string namespace sysy { -} \ No newline at end of file +// 辅助函数：将 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"; +} + +} diff --git a/src/backend/RISCv64/RISCv64RegAlloc.cpp b/src/backend/RISCv64/RISCv64RegAlloc.cpp index cf73191..a1cd77c 100644 --- a/src/backend/RISCv64/RISCv64RegAlloc.cpp +++ b/src/backend/RISCv64/RISCv64RegAlloc.cpp @@ -1,128 +1,120 @@ #include "RISCv64RegAlloc.h" -#include "RISCv64ISel.h" -#include "RISCv64AsmPrinter.h" // For DEBUG output -#include "LegalizeImmediates.h" +#include "RISCv64AsmPrinter.h" #include -#include -#include // For DEBUG output -#include // For assert +#include +#include +#include namespace sysy { -RISCv64RegAlloc::RISCv64RegAlloc(MachineFunction* mfunc) : MFunc(mfunc) { +// 构造函数：初始化寄存器池和数据结构 +RISCv64RegAlloc::RISCv64RegAlloc(MachineFunction* mfunc) + : MFunc(mfunc), + ISel(mfunc->getISel()), + vreg_to_value_map(ISel->getVRegValueMap()), + vreg_type_map(ISel->getVRegTypeMap()) { // 1. 初始化可分配的整数寄存器池 allocable_int_regs = { - PhysicalReg::T0, PhysicalReg::T1, PhysicalReg::T2, PhysicalReg::T3, - PhysicalReg::T4, /*PhysicalReg::T5,*/ PhysicalReg::T6, // T5是大立即数传送寄存器 - PhysicalReg::A0, PhysicalReg::A1, PhysicalReg::A2, PhysicalReg::A3, - PhysicalReg::A4, PhysicalReg::A5, PhysicalReg::A6, PhysicalReg::A7, - PhysicalReg::S0, PhysicalReg::S1, PhysicalReg::S2, PhysicalReg::S3, - PhysicalReg::S4, PhysicalReg::S5, PhysicalReg::S6, PhysicalReg::S7, + PhysicalReg::T0, PhysicalReg::T1, PhysicalReg::T2, PhysicalReg::T3, PhysicalReg::T4, /* T5保留 */ PhysicalReg::T6, + PhysicalReg::A0, PhysicalReg::A1, PhysicalReg::A2, PhysicalReg::A3, PhysicalReg::A4, PhysicalReg::A5, PhysicalReg::A6, PhysicalReg::A7, + PhysicalReg::S1, PhysicalReg::S2, PhysicalReg::S3, PhysicalReg::S4, PhysicalReg::S5, PhysicalReg::S6, PhysicalReg::S7, PhysicalReg::S8, PhysicalReg::S9, PhysicalReg::S10, PhysicalReg::S11, + // S0 是帧指针，不参与分配 }; + K_int = allocable_int_regs.size(); // 2. 初始化可分配的浮点寄存器池 allocable_fp_regs = { - // 浮点临时寄存器 ft0-ft11 - PhysicalReg::F0, PhysicalReg::F1, PhysicalReg::F2, PhysicalReg::F3, - PhysicalReg::F4, PhysicalReg::F5, PhysicalReg::F6, PhysicalReg::F7, + PhysicalReg::F0, PhysicalReg::F1, PhysicalReg::F2, PhysicalReg::F3, PhysicalReg::F4, PhysicalReg::F5, PhysicalReg::F6, PhysicalReg::F7, + PhysicalReg::F10, PhysicalReg::F11, PhysicalReg::F12, PhysicalReg::F13, PhysicalReg::F14, PhysicalReg::F15, PhysicalReg::F16, PhysicalReg::F17, + PhysicalReg::F8, PhysicalReg::F9, PhysicalReg::F18, PhysicalReg::F19, PhysicalReg::F20, PhysicalReg::F21, PhysicalReg::F22, + PhysicalReg::F23, PhysicalReg::F24, PhysicalReg::F25, PhysicalReg::F26, PhysicalReg::F27, PhysicalReg::F28, PhysicalReg::F29, PhysicalReg::F30, PhysicalReg::F31, - // 浮点参数/返回值寄存器 fa0-fa7 - PhysicalReg::F10, PhysicalReg::F11, PhysicalReg::F12, PhysicalReg::F13, - PhysicalReg::F14, PhysicalReg::F15, PhysicalReg::F16, PhysicalReg::F17, - // 浮点保存寄存器 fs0-fs11 - PhysicalReg::F8, PhysicalReg::F9, - PhysicalReg::F18, PhysicalReg::F19, PhysicalReg::F20, PhysicalReg::F21, - PhysicalReg::F22, PhysicalReg::F23, PhysicalReg::F24, PhysicalReg::F25, - PhysicalReg::F26, PhysicalReg::F27 }; - - // 3. 映射所有物理寄存器（包括整数、浮点和特殊寄存器）到特殊的虚拟寄存器ID - // 这是为了让活跃性分析和干扰图构建能够统一处理所有类型的寄存器 - for (int i = 0; i < static_cast(PhysicalReg::PHYS_REG_START_ID); ++i) { - auto preg = static_cast(i); - preg_to_vreg_id_map[preg] = static_cast(PhysicalReg::PHYS_REG_START_ID) + i; - } + K_fp = allocable_fp_regs.size(); + + // 3. 预着色所有物理寄存器 + const unsigned offset = static_cast(PhysicalReg::PHYS_REG_START_ID); + for (const auto& reg : allocable_int_regs) precolored.insert(offset + static_cast(reg)); + for (const auto& reg : allocable_fp_regs) precolored.insert(offset + static_cast(reg)); + precolored.insert(offset + static_cast(PhysicalReg::S0)); + precolored.insert(offset + static_cast(PhysicalReg::RA)); + precolored.insert(offset + static_cast(PhysicalReg::SP)); + precolored.insert(offset + static_cast(PhysicalReg::ZERO)); } -// 寄存器分配的主入口点 +// 主入口: 迭代运行分配算法直到无溢出 void RISCv64RegAlloc::run() { - // --- 在所有流程开始前，构建完整的vreg到Value的反向映射 --- - const auto& vreg_map_from_isel = MFunc->getISel()->getVRegMap(); - for (const auto& pair : vreg_map_from_isel) { - Value* val = pair.first; - unsigned vreg = pair.second; - vreg_to_value_map[vreg] = val; + if (DEBUG) std::cerr << "===== LLIR Before Running Graph Coloring Register Allocation " << MFunc->getName() << " =====\n"; + std::stringstream ss_before_reg_alloc; + if (DEBUG) { + RISCv64AsmPrinter printer_reg_alloc(MFunc); + printer_reg_alloc.run(ss_before_reg_alloc, true); + std::cout << ss_before_reg_alloc.str(); } - // 阶段 1: 处理函数调用约定（参数寄存器预着色） - handleCallingConvention(); - // 阶段 2: 消除帧索引（为局部变量和栈参数分配栈偏移） - eliminateFrameIndices(); - // 调试输出当前的LLIR状态 - { // 使用大括号创建一个局部作用域，避免printer变量泄露 - if (DEBUG) { - std::cerr << "\n===== LLIR after eliminateFrameIndices for function: " - << MFunc->getName() << " =====\n"; - // 1. 创建一个 AsmPrinter 实例，传入当前的 MachineFunction - RISCv64AsmPrinter printer(MFunc); - // 2. 调用 run 方法，将结果打印到标准错误流 (std::cerr) - // 3. 必须将 debug 参数设为 true！ - // 因为此时指令中仍然包含虚拟寄存器 (%vreg)， - // debug模式下的 AsmPrinter 才能正确处理它们而不会报错。 - printer.run(std::cerr, true); - std::cerr << "===== End of LLIR =====\n\n"; + if (DEBUG) std::cerr << "===== Running Graph Coloring Register Allocation for function: " << MFunc->getName() << " =====\n"; + + while (true) { + if (doAllocation()) { + break; + } else { + rewriteProgram(); + if (DEBUG) std::cerr << "--- Spilling detected, re-running allocation ---\n"; } } - // 阶段 3: 活跃性分析 - analyzeLiveness(); - // 阶段 4: 构建干扰图（包含CALL指令对调用者保存寄存器的影响） - buildInterferenceGraph(); - // 阶段 5: 图着色算法分配物理寄存器 - colorGraph(); - // 阶段 6: 重写函数（插入溢出/填充代码，替换虚拟寄存器为物理寄存器） - rewriteFunction(); + applyColoring(); - // 将最终的寄存器分配结果保存到MachineFunction的帧信息中，供后续Pass使用 MFunc->getFrameInfo().vreg_to_preg_map = this->color_map; + collectUsedCalleeSavedRegs(); + if (DEBUG) std::cerr << "===== Finished Graph Coloring Register Allocation =====\n\n"; } -/** - * @brief 处理调用约定，预先为函数参数和调用返回值分配物理寄存器。 - * 这个函数现在负责处理调用约定的两个方面： - * 1. 作为被调用者(callee)，如何接收传入的参数。 - * 2. 作为调用者(caller)，如何接收调用的其他函数的返回值。 - */ -void RISCv64RegAlloc::handleCallingConvention() { - Function* F = MFunc->getFunc(); - RISCv64ISel* isel = MFunc->getISel(); - - // --- 部分1：处理函数传入参数的预着色 --- - if (F) { - auto& args = F->getArguments(); - - // [修改] 为整数参数和浮点参数分别维护索引 - int int_arg_idx = 0; - int float_arg_idx = 0; +// 单次分配的核心流程 +bool RISCv64RegAlloc::doAllocation() { + initialize(); + precolorByCallingConvention(); + analyzeLiveness(); + build(); + makeWorklist(); - for (Argument* arg : args) { - // [修改] 根据参数类型决定使用哪个寄存器池和索引 - if (arg->getType()->isFloat()) { - // --- 处理浮点参数 --- - if (float_arg_idx >= 8) continue; // fa0-fa7 - - unsigned vreg = isel->getVReg(arg); - // 浮点参数使用 fa10-fa17 (在RISC-V ABI中对应F10-F17) + while (!simplifyWorklist.empty() || !worklistMoves.empty() || !freezeWorklist.empty() || !spillWorklist.empty()) { + if (DEEPDEBUG) dumpState("Loop Start"); + if (!simplifyWorklist.empty()) simplify(); + else if (!worklistMoves.empty()) coalesce(); + else if (!freezeWorklist.empty()) freeze(); + else if (!spillWorklist.empty()) selectSpill(); + } + + if (DEEPDEBUG) dumpState("Before AssignColors"); + assignColors(); + return spilledNodes.empty(); +} + +void RISCv64RegAlloc::precolorByCallingConvention() { + // 在处理前，先清空颜色相关的状态，确保重试时不会出错 + color_map.clear(); + coloredNodes.clear(); + + Function* F = MFunc->getFunc(); + if (!F) return; + + // --- 部分1：处理函数传入参数的预着色 --- + int int_arg_idx = 0; + int float_arg_idx = 0; + + for (Argument* arg : F->getArguments()) { + unsigned vreg = ISel->getVReg(arg); + + if (arg->getType()->isFloat()) { + if (float_arg_idx < 8) { // fa0-fa7 auto preg = static_cast(static_cast(PhysicalReg::F10) + float_arg_idx); color_map[vreg] = preg; float_arg_idx++; - - } else { - // --- 处理整数/指针参数 (原有逻辑) --- - if (int_arg_idx >= 8) continue; // a0-a7 - - unsigned vreg = isel->getVReg(arg); + } + } else { // 整数或指针 + if (int_arg_idx < 8) { // a0-a7 auto preg = static_cast(static_cast(PhysicalReg::A0) + int_arg_idx); color_map[vreg] = preg; int_arg_idx++; @@ -130,881 +122,1339 @@ void RISCv64RegAlloc::handleCallingConvention() { } } - // --- 部分2：为CALL指令的返回值预着色 --- - for (auto& mbb : MFunc->getBlocks()) { - for (auto& instr : mbb->getInstructions()) { - if (instr->getOpcode() == RVOpcodes::CALL) { - // 根据协议，如果CALL有返回值，其目标vreg是第一个操作数 - if (!instr->getOperands().empty() && - instr->getOperands().front()->getKind() == MachineOperand::KIND_REG) - { - auto reg_op = static_cast(instr->getOperands().front().get()); - if (reg_op->isVirtual()) { - unsigned ret_vreg = reg_op->getVRegNum(); - - // [修改] 检查返回值的类型，预着色到 a0 或 fa0 - assert(MFunc->getISel()->getVRegValueMap().count(ret_vreg) && "Return vreg not found in value map!"); - Value* ret_val = MFunc->getISel()->getVRegValueMap().at(ret_vreg); + // // --- 部分2：为CALL指令的返回值预着色 --- + // for (auto& mbb : MFunc->getBlocks()) { + // for (auto& instr : mbb->getInstructions()) { + // if (instr->getOpcode() == RVOpcodes::CALL) { + // if (!instr->getOperands().empty() && + // instr->getOperands().front()->getKind() == MachineOperand::KIND_REG) + // { + // auto reg_op = static_cast(instr->getOperands().front().get()); + // if (reg_op->isVirtual()) { + // unsigned ret_vreg = reg_op->getVRegNum(); + // assert(vreg_to_value_map.count(ret_vreg) && "Return vreg not found!"); + // Value* ret_val = vreg_to_value_map.at(ret_vreg); - if (ret_val->getType()->isFloat()) { - // 浮点返回值预着色到 fa0 (F10) - color_map[ret_vreg] = PhysicalReg::F10; - } else { - // 整数/指针返回值预着色到 a0 - color_map[ret_vreg] = PhysicalReg::A0; - } - } - } - } - } + // if (ret_val->getType()->isFloat()) { + // color_map[ret_vreg] = PhysicalReg::F10; // fa0 + // } else { + // color_map[ret_vreg] = PhysicalReg::A0; // a0 + // } + // } + // } + // } + // } + // } + + // 将所有预着色的vreg视为已着色节点 + for(const auto& pair : color_map) { + coloredNodes.insert(pair.first); + } + if (DEEPDEBUG) { + std::cerr << "Precolored registers: { "; + // 修改部分：将物理寄存器ID转换为其字符串名称 + for (unsigned v : precolored) std::cerr << regIdToString(v) << " "; + std::cerr << "}\nColored nodes: { "; + for (unsigned v : coloredNodes) std::cerr << "<%vreg" << v << ", " << regToString(color_map.at(v)) << "> "; + std::cerr << "}\n"; } } -/** - * @brief 消除帧索引，为局部变量和栈参数分配栈偏移量，并展开伪指令。 - */ -void RISCv64RegAlloc::eliminateFrameIndices() { - StackFrameInfo& frame_info = MFunc->getFrameInfo(); - Function* F = MFunc->getFunc(); - RISCv64ISel* isel = MFunc->getISel(); - - // 在处理局部变量前，首先为栈参数计算偏移量。 - if (F) { - int arg_idx = 0; - for (Argument* arg : F->getArguments()) { - // 我们只关心第8个索引及之后的参数（即第9个参数开始） - if (arg_idx >= 8) { - // 计算偏移量：第一个栈参数(idx=8)在0(s0)，第二个(idx=9)在8(s0)，以此类推。 - int offset = (arg_idx - 8) * 8; - unsigned vreg = isel->getVReg(arg); +// 初始化/重置所有数据结构 +void RISCv64RegAlloc::initialize() { + initial.clear(); + simplifyWorklist.clear(); + freezeWorklist.clear(); + spillWorklist.clear(); + spilledNodes.clear(); + coalescedNodes.clear(); + coloredNodes.clear(); + selectStack.clear(); - // 将这个vreg和它的栈偏移存入map。 - // 我们可以复用alloca_offsets，因为它们都代表“vreg到栈偏移”的映射。 - frame_info.alloca_offsets[vreg] = offset; - } - arg_idx++; - } - } + coalescedMoves.clear(); + constrainedMoves.clear(); + frozenMoves.clear(); + worklistMoves.clear(); + activeMoves.clear(); - // [关键修改] 为局部变量分配空间时，起始点必须考虑为ra, s0以及所有callee-saved寄存器预留的空间。 - // 布局顺序为: [s0/ra, 16字节] -> [callee-saved, callee_saved_size字节] -> [局部变量...] - int local_var_offset = 16 + frame_info.callee_saved_size; - int locals_start_offset = local_var_offset; // 记录局部变量区域的起始点，用于计算总大小 - - // 处理局部变量 (AllocaInst) - for (auto& bb : F->getBasicBlocks()) { - for (auto& inst : bb->getInstructions()) { - if (auto alloca = dynamic_cast(inst.get())) { - Type* allocated_type = alloca->getType()->as()->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; - } - } - } - - // [修复] 正确计算并设置locals_size - // 它只应该包含由AllocaInst分配的局部变量的总大小。 - frame_info.locals_size = local_var_offset - locals_start_offset; - - // 遍历所有机器指令，将伪指令展开为真实指令 - for (auto& mbb : MFunc->getBlocks()) { - std::vector> new_instructions; - for (auto& instr_ptr : mbb->getInstructions()) { - RVOpcodes opcode = instr_ptr->getOpcode(); - - // --- MODIFICATION START: 处理区分宽度的伪指令 --- - if (opcode == RVOpcodes::FRAME_LOAD_W || opcode == RVOpcodes::FRAME_LOAD_D) { - // 确定要生成的真实加载指令是 lw 还是 ld - RVOpcodes real_load_op = (opcode == RVOpcodes::FRAME_LOAD_W) ? RVOpcodes::LW : RVOpcodes::LD; - - auto& operands = instr_ptr->getOperands(); - unsigned dest_vreg = static_cast(operands[0].get())->getVRegNum(); - unsigned alloca_vreg = static_cast(operands[1].get())->getVRegNum(); - int offset = frame_info.alloca_offsets.at(alloca_vreg); - auto addr_vreg = isel->getNewVReg(); - - // 展开为: addi addr_vreg, s0, offset - auto addi = std::make_unique(RVOpcodes::ADDI); - addi->addOperand(std::make_unique(addr_vreg)); - addi->addOperand(std::make_unique(PhysicalReg::S0)); - addi->addOperand(std::make_unique(offset)); - new_instructions.push_back(std::move(addi)); - - // 展开为: lw/ld dest_vreg, 0(addr_vreg) - auto load_instr = std::make_unique(real_load_op); - load_instr->addOperand(std::make_unique(dest_vreg)); - load_instr->addOperand(std::make_unique( - std::make_unique(addr_vreg), - std::make_unique(0))); - new_instructions.push_back(std::move(load_instr)); - - } else if (opcode == RVOpcodes::FRAME_LOAD_F) { - // 展开浮点加载伪指令 - RVOpcodes real_load_op = RVOpcodes::FLW; // 对应的真实指令是 flw - - auto& operands = instr_ptr->getOperands(); - unsigned dest_vreg = static_cast(operands[0].get())->getVRegNum(); - unsigned alloca_vreg = static_cast(operands[1].get())->getVRegNum(); - int offset = frame_info.alloca_offsets.at(alloca_vreg); - auto addr_vreg = isel->getNewVReg(); - - // 展开为: addi addr_vreg, s0, offset - auto addi = std::make_unique(RVOpcodes::ADDI); - addi->addOperand(std::make_unique(addr_vreg)); - addi->addOperand(std::make_unique(PhysicalReg::S0)); - addi->addOperand(std::make_unique(offset)); - new_instructions.push_back(std::move(addi)); - - // 展开为: flw dest_vreg, 0(addr_vreg) - auto load_instr = std::make_unique(real_load_op); - load_instr->addOperand(std::make_unique(dest_vreg)); - load_instr->addOperand(std::make_unique( - std::make_unique(addr_vreg), - std::make_unique(0))); - new_instructions.push_back(std::move(load_instr)); - } else if (opcode == RVOpcodes::FRAME_STORE_W || opcode == RVOpcodes::FRAME_STORE_D) { - // 确定要生成的真实存储指令是 sw 还是 sd - RVOpcodes real_store_op = (opcode == RVOpcodes::FRAME_STORE_W) ? RVOpcodes::SW : RVOpcodes::SD; - - auto& operands = instr_ptr->getOperands(); - unsigned src_vreg = static_cast(operands[0].get())->getVRegNum(); - unsigned alloca_vreg = static_cast(operands[1].get())->getVRegNum(); - int offset = frame_info.alloca_offsets.at(alloca_vreg); - auto addr_vreg = isel->getNewVReg(); - - // 展开为: addi addr_vreg, s0, offset - auto addi = std::make_unique(RVOpcodes::ADDI); - addi->addOperand(std::make_unique(addr_vreg)); - addi->addOperand(std::make_unique(PhysicalReg::S0)); - addi->addOperand(std::make_unique(offset)); - new_instructions.push_back(std::move(addi)); - - // 展开为: sw/sd src_vreg, 0(addr_vreg) - auto store_instr = std::make_unique(real_store_op); - store_instr->addOperand(std::make_unique(src_vreg)); - store_instr->addOperand(std::make_unique( - std::make_unique(addr_vreg), - std::make_unique(0))); - new_instructions.push_back(std::move(store_instr)); - - } else if (opcode == RVOpcodes::FRAME_STORE_F) { - // 展开浮点存储伪指令 - RVOpcodes real_store_op = RVOpcodes::FSW; // 对应的真实指令是 fsw - - auto& operands = instr_ptr->getOperands(); - unsigned src_vreg = static_cast(operands[0].get())->getVRegNum(); - unsigned alloca_vreg = static_cast(operands[1].get())->getVRegNum(); - int offset = frame_info.alloca_offsets.at(alloca_vreg); - auto addr_vreg = isel->getNewVReg(); - - // 展开为: addi addr_vreg, s0, offset - auto addi = std::make_unique(RVOpcodes::ADDI); - addi->addOperand(std::make_unique(addr_vreg)); - addi->addOperand(std::make_unique(PhysicalReg::S0)); - addi->addOperand(std::make_unique(offset)); - new_instructions.push_back(std::move(addi)); - - // 展开为: fsw src_vreg, 0(addr_vreg) - auto store_instr = std::make_unique(real_store_op); - store_instr->addOperand(std::make_unique(src_vreg)); - store_instr->addOperand(std::make_unique( - std::make_unique(addr_vreg), - std::make_unique(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(operands[0].get())->getVRegNum(); - unsigned alloca_vreg = static_cast(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(RVOpcodes::ADDI); - addi->addOperand(std::make_unique(dest_vreg)); - addi->addOperand(std::make_unique(PhysicalReg::S0)); - addi->addOperand(std::make_unique(offset)); - new_instructions.push_back(std::move(addi)); - } else { - new_instructions.push_back(std::move(instr_ptr)); - } - // --- MODIFICATION END --- - } - mbb->getInstructions() = std::move(new_instructions); - } -} - -/** - * @brief 计算给定 MachineInstr 的 Use (读取) 和 Def (写入) 寄存器集合。 - * 这是活跃性分析的基础。 - * @param instr 要分析的机器指令。 - * @param use 存储 Use 寄存器（虚拟寄存器 ID）的集合。 - * @param def 存储 Def 寄存器（虚拟寄存器 ID）的集合。 - */ -void RISCv64RegAlloc::getInstrUseDef(MachineInstr* instr, LiveSet& use, LiveSet& def) { - bool first_reg_is_def = true; // 默认情况下，指令的第一个寄存器操作数是定义 (def) - auto opcode = instr->getOpcode(); - - if (opcode == RVOpcodes::PSEUDO_KEEPALIVE) { - for (auto& op : instr->getOperands()) { - if (op->getKind() == MachineOperand::KIND_REG) { - auto reg_op = static_cast(op.get()); - if (reg_op->isVirtual()) { - use.insert(reg_op->getVRegNum()); // 它的所有操作数都是 "use" - } - } - } - return; // 处理完毕 - } - - // 1. 特殊指令的 `is_def` 标志调整 - // 这些指令的第一个寄存器操作数是源操作数 (use)，而不是目标操作数 (def)。 - if (opcode == RVOpcodes::SW || opcode == RVOpcodes::SD || opcode == RVOpcodes::FSW || - opcode == RVOpcodes::BEQ || opcode == RVOpcodes::BNE || - opcode == RVOpcodes::BLT || opcode == RVOpcodes::BGE || - opcode == RVOpcodes::BLTU || opcode == RVOpcodes::BGEU || - opcode == RVOpcodes::RET || opcode == RVOpcodes::J) { - first_reg_is_def = false; - } - - // JAL 和 JALR 指令定义 ra (x1) - if (opcode == RVOpcodes::JAL || opcode == RVOpcodes::JALR) { - // 使用 ra 对应的特殊虚拟寄存器ID - def.insert(preg_to_vreg_id_map.at(PhysicalReg::RA)); - first_reg_is_def = false; // JAL/JALR 的第一个操作数是 ra，已经处理为 def - } - - // 2. CALL 指令的特殊处理 - if (opcode == RVOpcodes::CALL) { - // 根据 s1 分支 ISel 定义的协议来解析操作数列表 - bool first_reg_operand_is_def = true; - for (auto& op : instr->getOperands()) { - if (op->getKind() == MachineOperand::KIND_REG) { - auto reg_op = static_cast(op.get()); - if (reg_op->isVirtual()) { - // 协议：第一个寄存器操作数是返回值 (def) - if (first_reg_operand_is_def) { - def.insert(reg_op->getVRegNum()); - first_reg_operand_is_def = false; - } else { - // 后续所有寄存器操作数都是参数 (use) - use.insert(reg_op->getVRegNum()); - } - } else { // [修复] CALL指令也可能定义物理寄存器（如a0） - if (first_reg_operand_is_def) { - auto it = preg_to_vreg_id_map.find(reg_op->getPReg()); - if (it != preg_to_vreg_id_map.end()) { - def.insert(it->second); - } - first_reg_operand_is_def = false; - } else { - auto it = preg_to_vreg_id_map.find(reg_op->getPReg()); - if (it != preg_to_vreg_id_map.end()) { - use.insert(it->second); - } - } - } - } - } - return; // CALL 指令处理完毕 - } - - // 2.1 浮点比较指令添加特殊规则 - // 它们的源操作数是浮点寄存器，但目标操作数是整数寄存器 - if (opcode == RVOpcodes::FEQ_S || opcode == RVOpcodes::FLT_S || opcode == RVOpcodes::FLE_S) { - auto& operands = instr->getOperands(); - // Def: 第一个操作数 (整数vreg) - if (operands[0]->getKind() == MachineOperand::KIND_REG) { - auto reg_op = static_cast(operands[0].get()); - if(reg_op->isVirtual()) def.insert(reg_op->getVRegNum()); - } - // Use: 第二、三个操作数 (浮点vreg) - if (operands[1]->getKind() == MachineOperand::KIND_REG) { - auto reg_op = static_cast(operands[1].get()); - if(reg_op->isVirtual()) use.insert(reg_op->getVRegNum()); - } - if (operands[2]->getKind() == MachineOperand::KIND_REG) { - auto reg_op = static_cast(operands[2].get()); - if(reg_op->isVirtual()) use.insert(reg_op->getVRegNum()); - } - return; // 处理完毕 - } - - // 3. 对其他所有指令的通用处理逻辑 [已重构和修复] - for (const auto& op : instr->getOperands()) { - if (op->getKind() == MachineOperand::KIND_REG) { - auto reg_op = static_cast(op.get()); - - if (first_reg_is_def) { - // --- 处理定义（Def） --- - if (reg_op->isVirtual()) { - def.insert(reg_op->getVRegNum()); - } else { // 物理寄存器也可以是 Def - auto it = preg_to_vreg_id_map.find(reg_op->getPReg()); - if (it != preg_to_vreg_id_map.end()) { - def.insert(it->second); - } - } - first_reg_is_def = false; // **关键**：处理完第一个寄存器后，立即更新标志 - } else { - // --- 处理使用（Use） --- - if (reg_op->isVirtual()) { - use.insert(reg_op->getVRegNum()); - } else { // 物理寄存器也可以是 Use - auto it = preg_to_vreg_id_map.find(reg_op->getPReg()); - if (it != preg_to_vreg_id_map.end()) { - use.insert(it->second); - } - } - } - } else if (op->getKind() == MachineOperand::KIND_MEM) { - // 内存操作数的处理逻辑看起来是正确的 - auto mem_op = static_cast(op.get()); - auto base_reg = mem_op->getBase(); - if (base_reg->isVirtual()) { - use.insert(base_reg->getVRegNum()); - } else { - PhysicalReg preg = base_reg->getPReg(); - auto it = preg_to_vreg_id_map.find(preg); - if (it != preg_to_vreg_id_map.end()) { - use.insert(it->second); - } - } - - // 对于存储内存指令 (SW, SD)，要存储的值（第一个操作数）也是 `use` - if ((opcode == RVOpcodes::SW || opcode == RVOpcodes::SD || opcode == RVOpcodes::FSW) && - !instr->getOperands().empty() && - instr->getOperands().front()->getKind() == MachineOperand::KIND_REG) { - auto src_reg_op = static_cast(instr->getOperands().front().get()); - if (src_reg_op->isVirtual()) { - use.insert(src_reg_op->getVRegNum()); - } else { - auto it = preg_to_vreg_id_map.find(src_reg_op->getPReg()); - if (it != preg_to_vreg_id_map.end()) { - use.insert(it->second); - } - } - } - } - } -} - -/** - * @brief 计算一个类型在内存中占用的字节数。 - * @param type 需要计算大小的IR类型。 - * @return 该类型占用的字节数。 - */ -unsigned RISCv64RegAlloc::getTypeSizeInBytes(Type* type) { - if (!type) { - assert(false && "Cannot get size of a null type."); - return 0; - } - - switch (type->getKind()) { - // 对于SysY语言，基本类型int和float都占用4字节 - case Type::kInt: - case Type::kFloat: - return 4; - - // 指针类型在RISC-V 64位架构下占用8字节 - // 虽然SysY没有'int*'语法，但数组变量在IR层面本身就是指针类型 - case Type::kPointer: - return 8; - - // 数组类型的总大小 = 元素数量 * 单个元素的大小 - case Type::kArray: { - auto arrayType = type->as(); - // 递归调用以计算元素大小 - return arrayType->getNumElements() * getTypeSizeInBytes(arrayType->getElementType()); - } - - // 其他类型，如Void, Label等不占用栈空间，或者不应该出现在这里 - default: - // 如果遇到未处理的类型，触发断言，方便调试 - assert(false && "Unsupported type for size calculation."); - return 0; - } + adjList.clear(); + degree.clear(); + moveList.clear(); + alias.clear(); + color_map.clear(); } +// 活跃性分析（此部分为标准数据流分析，与现有版本类似但更精细） void RISCv64RegAlloc::analyzeLiveness() { - // === 阶段 1: 预计算每个基本块的 use 和 def 集合 === - // 这样可以避免在主循环中重复计算 - std::map block_uses; - std::map block_defs; - for (auto& mbb_ptr : MFunc->getBlocks()) { - MachineBasicBlock* mbb = mbb_ptr.get(); - LiveSet uses, defs; - for (auto& instr_ptr : mbb->getInstructions()) { - LiveSet instr_use, instr_def; - getInstrUseDef(instr_ptr.get(), instr_use, instr_def); - // use[B] = use[B] U (instr_use - def[B]) + live_in_map.clear(); + live_out_map.clear(); + + std::map block_uses; + std::map block_defs; + + for (const auto& mbb_ptr : MFunc->getBlocks()) { + const MachineBasicBlock* mbb = mbb_ptr.get(); + VRegSet uses, defs; + for (const auto& instr_ptr : mbb->getInstructions()) { + VRegSet instr_use, instr_def; + getInstrUseDef_Liveness(instr_ptr.get(), instr_use, instr_def); for (unsigned u : instr_use) { - if (defs.find(u) == defs.end()) { - uses.insert(u); - } + if (defs.find(u) == defs.end()) uses.insert(u); } - // def[B] = def[B] U instr_def defs.insert(instr_def.begin(), instr_def.end()); } block_uses[mbb] = uses; block_defs[mbb] = defs; } - // === 阶段 2: 在“块”粒度上进行迭代数据流分析，直到收敛 === - std::map block_live_in; - std::map block_live_out; bool changed = true; + std::map live_in, live_out; while (changed) { changed = false; - // 以逆后序遍历基本块，可以加速收敛，但简单的逆序对于大多数情况也有效 for (auto it = MFunc->getBlocks().rbegin(); it != MFunc->getBlocks().rend(); ++it) { - auto& mbb = *it; - - // 2.1 计算 live_out[B] = U_{S in succ(B)} live_in[S] - LiveSet new_live_out; + const auto& mbb_ptr = *it; + const MachineBasicBlock* mbb = mbb_ptr.get(); + VRegSet new_out; for (auto succ : mbb->successors) { - new_live_out.insert(block_live_in[succ].begin(), block_live_in[succ].end()); + new_out.insert(live_in[succ].begin(), live_in[succ].end()); } - - // 2.2 计算 live_in[B] = use[B] U (live_out[B] - def[B]) - LiveSet live_out_minus_def = new_live_out; - for (unsigned d : block_defs[mbb.get()]) { - live_out_minus_def.erase(d); - } - LiveSet new_live_in = block_uses[mbb.get()]; - new_live_in.insert(live_out_minus_def.begin(), live_out_minus_def.end()); - - // 2.3 检查 live_in 和 live_out 是否变化，以判断是否达到不动点 - if (block_live_out[mbb.get()] != new_live_out) { + VRegSet new_in = block_uses[mbb]; + VRegSet out_minus_def = new_out; + for (unsigned d : block_defs[mbb]) out_minus_def.erase(d); + new_in.insert(out_minus_def.begin(), out_minus_def.end()); + if (live_out[mbb] != new_out || live_in[mbb] != new_in) { changed = true; - block_live_out[mbb.get()] = new_live_out; - } - if (block_live_in[mbb.get()] != new_live_in) { - changed = true; - block_live_in[mbb.get()] = new_live_in; + live_out[mbb] = new_out; + live_in[mbb] = new_in; } } } - // === 阶段 3: 进行一次指令粒度的遍历，填充最终的 live_in_map 和 live_out_map === - // 此时块级别的活跃信息已经稳定，我们只需遍历一次即可 - for (auto& mbb_ptr : MFunc->getBlocks()) { - MachineBasicBlock* mbb = mbb_ptr.get(); - LiveSet live_out = block_live_out[mbb]; // 从已收敛的块级 live_out 开始 - + for (const auto& mbb_ptr : MFunc->getBlocks()) { + const MachineBasicBlock* mbb = mbb_ptr.get(); + VRegSet current_live = live_out[mbb]; for (auto instr_it = mbb->getInstructions().rbegin(); instr_it != mbb->getInstructions().rend(); ++instr_it) { - MachineInstr* instr = instr_it->get(); - live_out_map[instr] = live_out; + const MachineInstr* instr = instr_it->get(); + live_out_map[instr] = current_live; + VRegSet use, def; - LiveSet use, def; - getInstrUseDef(instr, use, def); - - LiveSet live_in = use; - LiveSet diff = live_out; - for (auto vreg : def) { - diff.erase(vreg); - } - live_in.insert(diff.begin(), diff.end()); - live_in_map[instr] = live_in; - - // 更新 live_out，为块内的上一条指令做准备 - live_out = live_in; + getInstrUseDef_Liveness(instr, use, def); + for(auto d : def) current_live.erase(d); + for(auto u : use) current_live.insert(u); + live_in_map[instr] = current_live; } } } -// 辅助函数，用于清晰地打印寄存器集合。可以放在 .cpp 文件的顶部。 -void RISCv64RegAlloc::printLiveSet(const LiveSet& s, const std::string& name, std::ostream& os) { - os << " " << name << ": { "; - for (unsigned vreg : s) { - // 为了可读性，将物理寄存器对应的特殊ID进行转换 - if (vreg >= static_cast(sysy::PhysicalReg::PHYS_REG_START_ID)) { - os << "preg(" << (vreg - static_cast(sysy::PhysicalReg::PHYS_REG_START_ID)) << ") "; - } else { - os << "%vreg" << vreg << " "; - } - } - os << "}\n"; -} +void RISCv64RegAlloc::build() { + initial.clear(); + RISCv64AsmPrinter printer_inside_build(MFunc); + printer_inside_build.setStream(std::cerr); -void RISCv64RegAlloc::buildInterferenceGraph() { - std::set all_vregs; - // 收集所有虚拟寄存器和物理寄存器在干扰图中的节点ID - for (auto& mbb : MFunc->getBlocks()) { - for(auto& instr : mbb->getInstructions()) { - LiveSet use, def; - getInstrUseDef(instr.get(), use, def); - for(auto u : use) all_vregs.insert(u); - for(auto d : def) all_vregs.insert(d); - } - } - // 添加所有物理寄存器对应的特殊虚拟寄存器ID到all_vregs，作为干扰图节点 - for (auto preg : allocable_int_regs) { - all_vregs.insert(preg_to_vreg_id_map.at(preg)); - } + // 1. 收集所有待分配的（既非物理也非预着色）虚拟寄存器到 initial 集合 + for (const auto& mbb_ptr : MFunc->getBlocks()) { + for (const auto& instr_ptr : mbb_ptr->getInstructions()) { + const MachineInstr* instr = instr_ptr.get(); + VRegSet use, def; + getInstrUseDef_Liveness(instr, use, def); - // 初始化干扰图邻接表 - for (auto vreg : all_vregs) { interference_graph[vreg] = {}; } - - // 创建一个临时的AsmPrinter用于打印指令，方便调试 - RISCv64AsmPrinter temp_printer(MFunc); - temp_printer.setStream(std::cerr); - - for (auto& mbb : MFunc->getBlocks()) { - if (DEEPDEBUG) std::cerr << "--- Building Graph for Basic Block: " << mbb->getName() << " ---\n"; - for (auto& instr_ptr : mbb->getInstructions()) { - MachineInstr* instr = instr_ptr.get(); - if (DEEPDEBUG) { - // 打印当前正在处理的指令 - std::cerr << " Instr: "; - temp_printer.printInstruction(instr, true); // 使用 true 来打印虚拟寄存器 - } - - LiveSet def, use; - getInstrUseDef(instr, use, def); - const LiveSet& live_out = live_out_map.at(instr); - - // [新增调试逻辑] 打印所有相关的寄存器集合 - if (DEEPDEBUG) { - printLiveSet(use, "Use ", std::cerr); - printLiveSet(def, "Def ", std::cerr); - printLiveSet(live_out, "Live_Out", std::cerr); // 这是我们最关心的信息 - } - - // 标准干扰图构建：def 与 live_out 中的其他变量干扰 - for (unsigned d : def) { - for (unsigned l : live_out) { - if (d != l) { - // [新增调试逻辑] 打印添加的干扰边及其原因 - if (DEEPDEBUG && interference_graph[d].find(l) == interference_graph[d].end()) { - std::cerr << " Edge (Def-LiveOut): %vreg" << d << " <-> %vreg" << l << "\n"; - } - interference_graph[d].insert(l); - interference_graph[l].insert(d); - } - } - } - - // 所有在某一点上同时活跃的寄存器（即live_out集合中的所有成员）， - // 它们之间必须两两互相干扰。 - // 这会根据我们修正后的 liveness 信息，在所有参数vreg之间构建一个完全图（clique）。 - std::vector live_out_vec(live_out.begin(), live_out.end()); - for (size_t i = 0; i < live_out_vec.size(); ++i) { - for (size_t j = i + 1; j < live_out_vec.size(); ++j) { - unsigned u = live_out_vec[i]; - unsigned v = live_out_vec[j]; - if (DEEPDEBUG && interference_graph[u].find(v) == interference_graph[u].end()) { - std::cerr << " Edge (Live-Live): %vreg" << u << " <-> %vreg" << v << "\n"; - } - interference_graph[u].insert(v); - interference_graph[v].insert(u); - } - } - - // 在非move指令中，def 与 use 互相干扰 - if (instr->getOpcode() != RVOpcodes::MV) { - for (unsigned d : def) { - for (unsigned u : use) { - if (d != u) { - // [新增调试逻辑] 打印添加的干扰边及其原因 - if (DEEPDEBUG && interference_graph[d].find(u) == interference_graph[d].end()) { - std::cerr << " Edge (Def-Use) : %vreg" << d << " <-> %vreg" << u << "\n"; - } - interference_graph[d].insert(u); - interference_graph[u].insert(d); - } - } - } - } - - // *** 处理 CALL 指令的隐式 def *** - if (instr->getOpcode() == RVOpcodes::CALL) { - // 你的原始CALL调试信息 - if (DEEPDEBUG) { - std::string live_out_str; - for (unsigned vreg : live_out) { - live_out_str += "%vreg" + std::to_string(vreg) + " "; - } - std::cerr << "[DEEPDEBUG] buildInterferenceGraph: CALL instruction found. Live out set is: {" - << live_out_str << "}" << std::endl; - } - // CALL 指令会定义（杀死）所有调用者保存的寄存器。 - // 因此，所有调用者保存的物理寄存器都与 CALL 指令的 live_out 中的所有变量冲突。 - - // 辅助函数，用于判断一个vreg是整数类型还是浮点类型 - auto is_fp_vreg = [&](unsigned vreg) { - if (vreg_to_value_map.count(vreg)) { - return vreg_to_value_map.at(vreg)->getType()->isFloat(); - } - // 对于ISel创建的、没有直接IR Value对应的临时vreg， - // 默认其为整数类型。这是一个合理的兜底策略。 - return false; + // 调试输出 use 和 def (保留您的调试逻辑) + if (DEEPERDEBUG) { + std::cerr << "Instr:"; + printer_inside_build.printInstruction(instr_ptr.get(), true); + auto print_set = [this](const VRegSet& s, const std::string& name) { + std::cerr << " " << name << ": { "; + for(unsigned v : s) std::cerr << regIdToString(v) << " "; + std::cerr << "}\n"; }; + print_set(def, "Def "); + print_set(use, "Use "); + } - // --- 处理整数寄存器干扰 --- - const std::vector& caller_saved_int_regs = getCallerSavedIntRegs(); - for (PhysicalReg cs_reg : caller_saved_int_regs) { - // 确保物理寄存器在映射表中，我们已在构造函数中保证了这一点 - unsigned cs_vreg_id = preg_to_vreg_id_map.at(cs_reg); - - for (unsigned live_vreg_out : live_out) { - // 只为整数vreg添加与整数preg的干扰 - if (!is_fp_vreg(live_vreg_out)) { - if (cs_vreg_id != live_vreg_out) { - if (DEEPDEBUG && interference_graph[cs_vreg_id].find(live_vreg_out) == interference_graph[cs_vreg_id].end()) { - std::cerr << " Edge (CALL, Int): preg(" << static_cast(cs_reg) << ") <-> %vreg" << live_vreg_out << "\n"; - } - interference_graph[cs_vreg_id].insert(live_vreg_out); - interference_graph[live_vreg_out].insert(cs_vreg_id); - } - } - } - } - - // --- 处理浮点寄存器干扰 --- - const std::vector& caller_saved_fp_regs = getCallerSavedFpRegs(); - for (PhysicalReg cs_reg : caller_saved_fp_regs) { - unsigned cs_vreg_id = preg_to_vreg_id_map.at(cs_reg); - - for (unsigned live_vreg_out : live_out) { - // 只为浮点vreg添加与浮点preg的干扰 - if (is_fp_vreg(live_vreg_out)) { - if (cs_vreg_id != live_vreg_out) { - // 添加与整数版本一致的调试代码 - if (DEEPDEBUG && interference_graph[cs_vreg_id].find(live_vreg_out) == interference_graph[cs_vreg_id].end()) { - std::cerr << " Edge (CALL, FP): preg(" << static_cast(cs_reg) << ") <-> %vreg" << live_vreg_out << "\n"; - } - interference_graph[cs_vreg_id].insert(live_vreg_out); - interference_graph[live_vreg_out].insert(cs_vreg_id); - } - } + for (unsigned v : use) { + if (!coloredNodes.count(v) && !precolored.count(v)) { + initial.insert(v); + } else if ((DEEPDEBUG && initial.size() < DEBUGLENGTH) || DEEPERDEBUG) { + // 这里的调试信息可以更精确 + if (precolored.count(v)) { + std::cerr << "Skipping " << regIdToString(v) << " because it is a physical register.\n"; + } else { + std::cerr << "Skipping " << regIdToString(v) << " because it is a pre-colored virtual register with " << regToString(color_map.at(v)) << "\n"; } } } - if (DEEPDEBUG) std::cerr << " ----------------\n"; - } - } -} - -void RISCv64RegAlloc::colorGraph() { - std::vector sorted_vregs; - for (auto const& [vreg, neighbors] : interference_graph) { - // 只为未预着色的虚拟寄存器排序和着色 - if (color_map.find(vreg) == color_map.end() && vreg < static_cast(PhysicalReg::PHYS_REG_START_ID)) { - sorted_vregs.push_back(vreg); - } - } - - // 排序 - std::sort(sorted_vregs.begin(), sorted_vregs.end(), [&](unsigned a, unsigned b) { - return interference_graph[a].size() > interference_graph[b].size(); - }); - - // [调试] 辅助函数，用于判断一个vreg是整数还是浮点类型，并打印详细诊断信息 - auto is_fp_vreg = [&](unsigned vreg) { - if (DEEPDEBUG) { - std::cout << " [Debug is_fp_vreg] Checking vreg" << vreg << ": "; - } - if (vreg_to_value_map.count(vreg)) { - Value* val = vreg_to_value_map.at(vreg); - bool is_float = val->getType()->isFloat(); - if (DEEPDEBUG) { - std::cout << "Found in map. Value is '" << val->getName() - << "', Type is " << (is_float ? "FLOAT" : "INT") - << ". Returning " << (is_float ? "true" : "false") << ".\n"; - } - return is_float; - } - - if (DEEPDEBUG) { - std::cout << "NOT found in vreg_to_value_map. Defaulting to INT. Returning false.\n"; - } - // 对于ISel创建的、没有直接IR Value对应的临时vreg，默认其为整数类型。 - return false; - }; - - // 着色 - for (unsigned vreg : sorted_vregs) { - std::set used_colors; - for (unsigned neighbor_id : interference_graph.at(vreg)) { - // 收集邻居颜色的逻辑保持不变 - if (color_map.count(neighbor_id)) { - used_colors.insert(color_map.at(neighbor_id)); - } - else if (neighbor_id >= static_cast(PhysicalReg::PHYS_REG_START_ID)) { - PhysicalReg neighbor_preg = static_cast(neighbor_id - static_cast(PhysicalReg::PHYS_REG_START_ID)); - used_colors.insert(neighbor_preg); - } - } - - bool is_float = is_fp_vreg(vreg); - const auto& allocable_regs = is_float ? allocable_fp_regs : allocable_int_regs; - - // [调试] 打印着色决策过程 - if (DEBUG) { - std::cout << "[DEBUG] Coloring %vreg" << vreg - << ": Type is " << (is_float ? "FLOAT" : "INT") - << ", choosing from " << (is_float ? "Float" : "Integer") << " pool.\n"; - } - - bool colored = false; - for (PhysicalReg preg : allocable_regs) { - if (used_colors.find(preg) == used_colors.end()) { - color_map[vreg] = preg; - colored = true; - if (DEBUG) { - RISCv64AsmPrinter p(MFunc); // For regToString - std::cout << " -> Assigned to physical register: " << p.regToString(preg) << "\n"; + for (unsigned v : def) { + if (!coloredNodes.count(v) && !precolored.count(v)) { + initial.insert(v); + } else if ((DEEPDEBUG && initial.size() < DEBUGLENGTH) || DEEPERDEBUG) { + if (precolored.count(v)) { + std::cerr << "Skipping " << regIdToString(v) << " because it is a physical register.\n"; + } else { + std::cerr << "Skipping " << regIdToString(v) << " because it is a pre-colored virtual register with " << regToString(color_map.at(v)) << ".\n"; + } } - break; } } - if (!colored) { - spilled_vregs.insert(vreg); - if (DEBUG) { - std::cout << " -> FAILED to color. Spilling.\n"; + } + + if (DEEPDEBUG) { + if (initial.size() > DEBUGLENGTH && !DEEPERDEBUG) { + std::cerr << "Initial set too large, showing first " << DEBUGLENGTH << " elements:\n"; + } + std::cerr << "Initial set (" << initial.size() << "): { "; + unsigned count = 0; + for (unsigned v : initial) { + if (count++ >= DEBUGLENGTH && !DEEPERDEBUG) break; // 限制输出数量 + std::cerr << regIdToString(v) << " "; + } + if (count < initial.size()) { + std::cerr << "... (total " << initial.size() << " elements)\n"; + } else { + std::cerr << "}\n"; + } + } + + // 2. 为所有参与图构建的虚拟寄存器（initial + coloredNodes）初始化数据结构 + VRegSet all_participating_vregs = initial; + all_participating_vregs.insert(coloredNodes.begin(), coloredNodes.end()); + + for (unsigned vreg : all_participating_vregs) { + // 物理寄存器ID不应作为key，此检查是安全的双重保障 + const unsigned offset = static_cast(PhysicalReg::PHYS_REG_START_ID); + if (vreg >= offset) { + continue; + } + adjList[vreg] = {}; + degree[vreg] = 0; + } + + // 3. 构建冲突图 + for (const auto& mbb_ptr : MFunc->getBlocks()) { + if (DEEPDEBUG) std::cerr << "\n--- Building Graph for Basic Block: " << mbb_ptr->getName() << " ---\n"; + for (const auto& instr_ptr : mbb_ptr->getInstructions()) { + const MachineInstr* instr = instr_ptr.get(); + VRegSet use, def; + getInstrUseDef_Liveness(instr, use, def); + const VRegSet& live_out = live_out_map.at(instr); + + // 保留您的指令级调试输出 + if (DEEPERDEBUG) { + RISCv64AsmPrinter temp_printer(MFunc); + temp_printer.setStream(std::cerr); + std::cerr << "Instr: "; + temp_printer.printInstruction(const_cast(instr), true); + + auto print_set = [this](const VRegSet& s, const std::string& name) { + std::cerr << " " << name << ": { "; + for(unsigned v : s) std::cerr << regIdToString(v) << " "; + std::cerr << "}\n"; + }; + print_set(def, "Def "); + print_set(use, "Use "); + print_set(live_out, "Live_Out"); + std::cerr << " ----------------\n"; + } + + bool is_move = instr->getOpcode() == RVOpcodes::MV; + + // 保留您处理 moveList 的逻辑 + if (is_move) { + worklistMoves.insert(instr); + VRegSet move_vregs; + for(const auto& op : instr->getOperands()) { + if (op->getKind() == MachineOperand::KIND_REG) { + auto reg_op = static_cast(op.get()); + if(reg_op->isVirtual()) move_vregs.insert(reg_op->getVRegNum()); + } + } + for (unsigned vreg : move_vregs) { + // 使用 operator[] 是安全的，如果vreg不存在会默认构造 + moveList[vreg].insert(instr); + } + } + + VRegSet live = live_out; + if (is_move) { + for (unsigned u_op : use) { + live.erase(u_op); + } + } + + // --- 规则 1 & 2: Def 与 Live/Use 变量干扰 --- + for (unsigned d : def) { + // 新逻辑：对于指令定义的所有寄存器d（无论是虚拟寄存器还是像call指令那样 + // 隐式定义的物理寄存器），它都与该指令之后的所有活跃寄存器l冲突。 + // addEdge函数内部会正确处理 vreg-vreg 和 vreg-preg 的情况， + // 并忽略 preg-preg 的情况。 + for (unsigned l : live) { + addEdge(d, l); + } + + // 对于非传送指令, Def还和Use冲突。 + // 这个逻辑主要用于确保在同一条指令内，例如 sub t0, t1, t0, + // 作为def的t0和作为use的t0被视为冲突。 + if (!is_move) { + for (unsigned u_op : use) { + addEdge(d, u_op); + } + } + } + + // --- 规则 3: Live_Out 集合内部的【虚拟寄存器】形成完全图 --- + // 使用更高效的遍历，避免重复调用 addEdge(A,B) 和 addEdge(B,A) + for (auto it1 = live_out.begin(); it1 != live_out.end(); ++it1) { + unsigned l1 = *it1; + // 只为虚拟寄存器 l1 添加边 + if (precolored.count(l1)) continue; + + for (auto it2 = std::next(it1); it2 != live_out.end(); ++it2) { + unsigned l2 = *it2; + addEdge(l1, l2); + } } } } } -void RISCv64RegAlloc::rewriteFunction() { +// 将节点放入初始工作列表 +void RISCv64RegAlloc::makeWorklist() { + for (unsigned n : initial) { + int K = isFPVReg(n) ? K_fp : K_int; + if (degree.count(n) == 0) { + std::cerr << "Error: degree not initialized for %vreg" << n << "\n"; + continue; + } + if ((DEEPDEBUG && initial.size() < DEBUGLENGTH) || DEEPERDEBUG) { + std::cerr << "Assigning %vreg" << n << " (degree=" << degree.at(n) + << ", moveRelated=" << moveRelated(n) << ")\n"; + } + if (degree.at(n) >= K) { + spillWorklist.insert(n); + } else if (moveRelated(n)) { + freezeWorklist.insert(n); + } else { + simplifyWorklist.insert(n); + } + } + if (DEEPDEBUG || DEEPERDEBUG) std::cerr << "--------------------------------\n"; + initial.clear(); +} + +// 简化阶段 +void RISCv64RegAlloc::simplify() { + unsigned n = *simplifyWorklist.begin(); + simplifyWorklist.erase(simplifyWorklist.begin()); + if (DEEPERDEBUG) std::cerr << "[Simplify] Popped %vreg" << n << ", pushing to stack.\n"; + selectStack.push_back(n); + for (unsigned m : adjacent(n)) { + decrementDegree(m); + } +} + +// 合并阶段 +void RISCv64RegAlloc::coalesce() { + const MachineInstr* move = *worklistMoves.begin(); + worklistMoves.erase(worklistMoves.begin()); + VRegSet use, def; + getInstrUseDef_Liveness(move, use, def); + unsigned x = getAlias(*def.begin()); + unsigned y = getAlias(*use.begin()); + unsigned u, v; + if (precolored.count(y)) { u = y; v = x; } else { u = x; v = y; } + + if (DEEPERDEBUG) std::cerr << "[Coalesce] Processing move between " << regIdToString(x) + << " and " << regIdToString(y) << " (aliases " << regIdToString(u) + << ", " << regIdToString(v) << ").\n"; + + if (u == v) { + if (DEEPERDEBUG) std::cerr << " -> Trivial coalesce (u == v).\n"; + coalescedMoves.insert(move); + addWorklist(u); + return; // 处理完毕，提前返回 + } + + if (isFPVReg(u) != isFPVReg(v)) { + if (DEEPERDEBUG) std::cerr << " -> Constrained (type mismatch: " << regIdToString(u) << " is " + << (isFPVReg(u) ? "float" : "int") << ", " << regIdToString(v) << " is " + << (isFPVReg(v) ? "float" : "int") << ").\n"; + constrainedMoves.insert(move); + addWorklist(u); + addWorklist(v); + return; // 立即返回，不再进行后续检查 + } + + bool pre_interfere = adjList.at(v).count(u); + + if (pre_interfere) { + if (DEEPERDEBUG) std::cerr << " -> Constrained (nodes already interfere).\n"; + constrainedMoves.insert(move); + addWorklist(u); + addWorklist(v); + return; + } + + bool is_u_precolored = precolored.count(u); + bool can_coalesce = false; + + if (is_u_precolored) { + // --- 场景1：u是物理寄存器，使用 George 启发式 --- + if (DEEPERDEBUG) std::cerr << " -> Trying George Heuristic (u is precolored)...\n"; + + // 步骤 1: 独立调用 adjacent(v) 获取邻居集合 + VRegSet neighbors_of_v = adjacent(v); + if (DEEPERDEBUG) { + std::cerr << " - Neighbors of " << regIdToString(v) << " to check are (" << neighbors_of_v.size() << "): { "; + for (unsigned id : neighbors_of_v) std::cerr << regIdToString(id) << " "; + std::cerr << "}\n"; + } + + // 步骤 2: 使用显式的 for 循环来代替 std::all_of + bool george_ok = true; // 默认假设成功，任何一个邻居失败都会将此设为 false + for (unsigned t : neighbors_of_v) { + if (DEEPERDEBUG) { + std::cerr << " - Checking neighbor " << regIdToString(t) << ":\n"; + } + + // 步骤 3: 独立调用启发式函数 + bool heuristic_result = georgeHeuristic(t, u); + + if (DEEPERDEBUG) { + std::cerr << " - georgeHeuristic(" << regIdToString(t) << ", " << regIdToString(u) << ") -> " << (heuristic_result ? "OK" : "FAIL") << "\n"; + } + + if (!heuristic_result) { + george_ok = false; // 只要有一个邻居不满足条件，整个检查就失败 + break; // 并且可以立即停止检查其他邻居 + } + } + + if (DEEPERDEBUG) { + std::cerr << " -> George Heuristic final result: " << (george_ok ? "OK" : "FAIL") << "\n"; + } + + if (george_ok) { + can_coalesce = true; + } + + } else { + // --- 场景2：u和v都是虚拟寄存器，使用 Briggs 启发式 --- + if (DEEPERDEBUG) std::cerr << " -> Trying Briggs Heuristic (u and v are virtual)...\n"; + + bool briggs_ok = briggsHeuristic(u, v); + if (DEEPERDEBUG) std::cerr << " - briggsHeuristic(" << regIdToString(u) << ", " << regIdToString(v) << ") -> " << (briggs_ok ? "OK" : "FAIL") << "\n"; + + if (briggs_ok) { + can_coalesce = true; + } + } + + // --- 根据启发式结果进行最终决策 --- + + if (can_coalesce) { + if (DEEPERDEBUG) std::cerr << " -> Heuristic OK. Combining " << regIdToString(v) << " into " << regIdToString(u) << ".\n"; + coalescedMoves.insert(move); + combine(u, v); + addWorklist(u); + } else { + if (DEEPERDEBUG) std::cerr << " -> Heuristic failed. Adding to active moves.\n"; + activeMoves.insert(move); + } +} + +// 冻结阶段 +void RISCv64RegAlloc::freeze() { + unsigned u = *freezeWorklist.begin(); + freezeWorklist.erase(freezeWorklist.begin()); + if (DEEPERDEBUG) std::cerr << "[Freeze] Freezing %vreg" << u << " and moving to simplify list.\n"; + simplifyWorklist.insert(u); + freezeMoves(u); +} + +// 选择溢出节点 +void RISCv64RegAlloc::selectSpill() { + auto it = std::max_element(spillWorklist.begin(), spillWorklist.end(), + [&](unsigned a, unsigned b){ return degree.at(a) < degree.at(b); }); + unsigned m = *it; + spillWorklist.erase(it); + if (DEEPERDEBUG) std::cerr << "[Spill] Selecting %vreg" << m << " to spill.\n"; + simplifyWorklist.insert(m); + freezeMoves(m); +} + +void RISCv64RegAlloc::assignColors() { + if (DEEPERDEBUG) std::cerr << "[AssignColors] Starting...\n"; + // 步骤 1: 为 selectStack 中的节点分配颜色 (此部分逻辑不变) + while (!selectStack.empty()) { + unsigned n = selectStack.back(); + selectStack.pop_back(); + bool is_fp = isFPVReg(n); + const auto& available_regs = is_fp ? allocable_fp_regs : allocable_int_regs; + std::set ok_colors(available_regs.begin(), available_regs.end()); + + if (adjList.count(n)) { + for (unsigned w : adjList.at(n)) { + unsigned w_alias = getAlias(w); + + if (coloredNodes.count(w_alias)) { // 邻居是已着色的vreg + ok_colors.erase(color_map.at(w_alias)); + } else if (precolored.count(w_alias)) { // 邻居是物理寄存器 + const unsigned offset = static_cast(PhysicalReg::PHYS_REG_START_ID); + ok_colors.erase(static_cast(w_alias - offset)); + } + } + } + + if (ok_colors.empty()) { + spilledNodes.insert(n); + if (DEEPERDEBUG) std::cerr << " -> WARNING: No color for %vreg" << n << " from selectStack. Spilling.\n"; + } else { + PhysicalReg c = *ok_colors.begin(); + coloredNodes.insert(n); + color_map[n] = c; + if (DEEPERDEBUG) std::cerr << " -> Colored %vreg" << n << " with " << regToString(c) << ".\n"; + } + } + + // 步骤 2: 处理 coalescedNodes + for (unsigned n : coalescedNodes) { + unsigned root_alias = getAlias(n); + + // --- 处理所有三种可能性 --- + + // 情况 1: 别名本身就是物理寄存器 (修复当前bug) + if (precolored.count(root_alias)) { + const unsigned offset = static_cast(PhysicalReg::PHYS_REG_START_ID); + color_map[n] = static_cast(root_alias - offset); + if (DEEPERDEBUG) std::cerr << " -> Coalesced %vreg" << n << " gets color from PHYSICAL alias " << regIdToString(root_alias) << ".\n"; + } + // 情况 2: 别名是被成功着色的虚拟寄存器 + else if (color_map.count(root_alias)) { + color_map[n] = color_map.at(root_alias); + if (DEEPERDEBUG) std::cerr << " -> Coalesced %vreg" << n << " gets color from VIRTUAL alias " << regIdToString(root_alias) << ".\n"; + } + // 情况 3: 别名是被溢出的虚拟寄存器 + else { + spilledNodes.insert(n); + if (DEEPERDEBUG) std::cerr << " -> Alias " << regIdToString(root_alias) << " of %vreg" << n << " was SPILLED. Spilling %vreg" << n << " as well.\n"; + } + } +} + +// 重写程序，插入溢出代码 +void RISCv64RegAlloc::rewriteProgram() { StackFrameInfo& frame_info = MFunc->getFrameInfo(); - int current_offset = frame_info.locals_size; + // 使用 EFI Pass 确定的 locals_end_offset 作为溢出分配的基准。 + // locals_end_offset 本身是负数，代表局部变量区域的下边界地址。 + int spill_current_offset = frame_info.locals_end_offset; - // --- 动态计算溢出槽大小 --- - // 根据溢出虚拟寄存器的真实类型，为其在栈上分配正确大小的空间。 - for (unsigned vreg : spilled_vregs) { - // 从反向映射中查找 vreg 对应的 IR Value - assert(vreg_to_value_map.count(vreg) && "Spilled vreg not found in map!"); - Value* val = vreg_to_value_map.at(vreg); - - // 使用辅助函数获取类型大小 - int size = getTypeSizeInBytes(val->getType()); - - // 保持栈8字节对齐 - current_offset += size; - current_offset = (current_offset + 7) & ~7; + // 保存溢出区域的起始点，用于最后计算总的 spill_size + const int spill_start_offset = frame_info.locals_end_offset; - frame_info.spill_offsets[vreg] = -current_offset; + for (unsigned vreg : spilledNodes) { + if (frame_info.spill_offsets.count(vreg)) continue; + + int size = 4; + if (isFPVReg(vreg)) { + size = 4; // float + } else if (vreg_type_map.count(vreg) && vreg_type_map.at(vreg)->isPointer()) { + size = 8; // pointer + } + + // 在当前偏移基础上继续向下(地址变得更负)分配空间 + spill_current_offset -= size; + + // 对齐新的、更小的地址，RISC-V 要求8字节对齐 + spill_current_offset = spill_current_offset & ~7; + + // 将计算出的、不会冲突的正确偏移量存入 spill_offsets + frame_info.spill_offsets[vreg] = spill_current_offset; } - frame_info.spill_size = current_offset - frame_info.locals_size; - // 定义专用的溢出寄存器 - const PhysicalReg INT_SPILL_REG = PhysicalReg::T6; // t6 - const PhysicalReg FP_SPILL_REG = PhysicalReg::F7; // ft7 + // 更新总的溢出区域大小。 + // spill_size = -(结束偏移 - 开始偏移) + frame_info.spill_size = -(spill_current_offset - spill_start_offset); + // 2. 遍历所有指令，重写代码 for (auto& mbb : MFunc->getBlocks()) { std::vector> new_instructions; + for (auto& instr_ptr : mbb->getInstructions()) { - LiveSet use, def; - getInstrUseDef(instr_ptr.get(), use, def); + std::map use_remap; + std::map def_remap; + + VRegSet use, def; + getInstrUseDef_Liveness(instr_ptr.get(), use, def); + + // a. 为每个溢出的 use 操作数创建新vreg并插入 load + for (unsigned old_vreg : use) { + if (spilledNodes.count(old_vreg)) { + Type* type = vreg_type_map.count(old_vreg) ? vreg_type_map.at(old_vreg) : Type::getIntType(); + unsigned new_temp_vreg = ISel->getNewVReg(type); + use_remap[old_vreg] = new_temp_vreg; - // --- 为溢出的 'use' 操作数插入正确的加载指令 --- - for (unsigned vreg : use) { - if (spilled_vregs.count(vreg)) { - // 同样地，根据 vreg 的类型决定使用 lw 还是 ld - assert(vreg_to_value_map.count(vreg)); - Value* val = vreg_to_value_map.at(vreg); - - // 根据vreg类型决定加载指令(lw/ld/flw)和目标物理寄存器(t6/ft7) RVOpcodes load_op; - PhysicalReg target_preg; - if (val->getType()->isFloat()) { - load_op = RVOpcodes::FLW; - target_preg = FP_SPILL_REG; - } else if (val->getType()->isPointer()) { - load_op = RVOpcodes::LD; - target_preg = INT_SPILL_REG; - } else { - load_op = RVOpcodes::LW; - target_preg = INT_SPILL_REG; - } + if (isFPVReg(old_vreg)) load_op = RVOpcodes::FLW; + else if (type->isPointer()) load_op = RVOpcodes::LD; + else load_op = RVOpcodes::LW; - int offset = frame_info.spill_offsets.at(vreg); auto load = std::make_unique(load_op); - load->addOperand(std::make_unique(target_preg)); // 加载到专用溢出寄存器 + load->addOperand(std::make_unique(new_temp_vreg)); load->addOperand(std::make_unique( std::make_unique(PhysicalReg::S0), - std::make_unique(offset) + std::make_unique(frame_info.spill_offsets.at(old_vreg)) )); new_instructions.push_back(std::move(load)); } } - new_instructions.push_back(std::move(instr_ptr)); - - // --- 为溢出的 'def' 操作数插入正确的存储指令 --- - for (unsigned vreg : def) { - if (spilled_vregs.count(vreg)) { - assert(vreg_to_value_map.count(vreg)); - Value* val = vreg_to_value_map.at(vreg); - - // 根据vreg类型决定存储指令(sw/sd/fsw)和源物理寄存器(t6/ft7) - RVOpcodes store_op; - PhysicalReg src_preg; - if (val->getType()->isFloat()) { - store_op = RVOpcodes::FSW; - src_preg = FP_SPILL_REG; - } else if (val->getType()->isPointer()) { - store_op = RVOpcodes::SD; - src_preg = INT_SPILL_REG; - } else { - store_op = RVOpcodes::SW; - src_preg = INT_SPILL_REG; - } - - int offset = frame_info.spill_offsets.at(vreg); - auto store = std::make_unique(store_op); - store->addOperand(std::make_unique(src_preg)); // 从专用溢出寄存器存储 - store->addOperand(std::make_unique( - std::make_unique(PhysicalReg::S0), - std::make_unique(offset) - )); - new_instructions.push_back(std::move(store)); + // b. 为每个溢出的 def 操作数创建新vreg + for (unsigned old_vreg : def) { + if (spilledNodes.count(old_vreg)) { + Type* type = vreg_type_map.count(old_vreg) ? vreg_type_map.at(old_vreg) : Type::getIntType(); + unsigned new_temp_vreg = ISel->getNewVReg(type); + def_remap[old_vreg] = new_temp_vreg; } } + + // c. 创建一条全新的指令，用新vreg替换旧vreg + auto new_instr = std::make_unique(instr_ptr->getOpcode()); + for (const auto& op : instr_ptr->getOperands()) { + if (op->getKind() == MachineOperand::KIND_REG) { + auto reg_op = static_cast(op.get()); + if (reg_op->isVirtual()) { + unsigned old_vreg = reg_op->getVRegNum(); + if (use.count(old_vreg) && use_remap.count(old_vreg)) { + new_instr->addOperand(std::make_unique(use_remap.at(old_vreg))); + } else if (def.count(old_vreg) && def_remap.count(old_vreg)) { + new_instr->addOperand(std::make_unique(def_remap.at(old_vreg))); + } else { + new_instr->addOperand(std::make_unique(old_vreg)); + } + } else { + new_instr->addOperand(std::make_unique(reg_op->getPReg())); + } + } else if (op->getKind() == MachineOperand::KIND_MEM) { + auto mem_op = static_cast(op.get()); + auto base_reg = mem_op->getBase(); + unsigned old_vreg = base_reg->isVirtual() ? base_reg->getVRegNum() : -1; + + if (base_reg->isVirtual() && use_remap.count(old_vreg)) { + new_instr->addOperand(std::make_unique( + std::make_unique(use_remap.at(old_vreg)), + std::make_unique(mem_op->getOffset()->getValue()) + )); + } else { + new_instr->addOperand(std::make_unique( + std::make_unique(*base_reg), + std::make_unique(mem_op->getOffset()->getValue()) + )); + } + } else { // 立即数、标签等直接复制 + if(op->getKind() == MachineOperand::KIND_IMM) + new_instr->addOperand(std::make_unique(*static_cast(op.get()))); + else if (op->getKind() == MachineOperand::KIND_LABEL) + new_instr->addOperand(std::make_unique(*static_cast(op.get()))); + } + } + new_instructions.push_back(std::move(new_instr)); + + // d. 为每个溢出的 def 操作数，在原指令后插入 store 指令 + for (const auto& pair : def_remap) { + unsigned old_vreg = pair.first; + unsigned new_temp_vreg = pair.second; + Type* type = vreg_type_map.count(old_vreg) ? vreg_type_map.at(old_vreg) : Type::getIntType(); + + RVOpcodes store_op; + if (isFPVReg(old_vreg)) store_op = RVOpcodes::FSW; + else if (type->isPointer()) store_op = RVOpcodes::SD; + else store_op = RVOpcodes::SW; + + auto store = std::make_unique(store_op); + store->addOperand(std::make_unique(new_temp_vreg)); + store->addOperand(std::make_unique( + std::make_unique(PhysicalReg::S0), + std::make_unique(frame_info.spill_offsets.at(old_vreg)) + )); + new_instructions.push_back(std::move(store)); + } } mbb->getInstructions() = std::move(new_instructions); } - // 最后的虚拟寄存器到物理寄存器的替换过程保持不变 + // 清空溢出节点集合，为下一次迭代分配做准备 + spilledNodes.clear(); +} + +/** + * @brief 获取一条指令完整的【虚拟】使用/定义寄存器集合 + * 这个函数将服务于图的构建（收集initial节点等）。 + */ +void RISCv64RegAlloc::getInstrUseDef(const MachineInstr* instr, VRegSet& use, VRegSet& def) { + auto opcode = instr->getOpcode(); + const auto& operands = instr->getOperands(); + + static const std::map, std::vector>> op_info = { + {RVOpcodes::ADD, {{0}, {1, 2}}}, {RVOpcodes::SUB, {{0}, {1, 2}}}, {RVOpcodes::MUL, {{0}, {1, 2}}}, + {RVOpcodes::DIV, {{0}, {1, 2}}}, {RVOpcodes::REM, {{0}, {1, 2}}}, {RVOpcodes::ADDW, {{0}, {1, 2}}}, + {RVOpcodes::SUBW, {{0}, {1, 2}}}, {RVOpcodes::MULW, {{0}, {1, 2}}}, {RVOpcodes::DIVW, {{0}, {1, 2}}}, + {RVOpcodes::REMW, {{0}, {1, 2}}}, {RVOpcodes::SLT, {{0}, {1, 2}}}, {RVOpcodes::SLTU, {{0}, {1, 2}}}, + {RVOpcodes::ADDI, {{0}, {1}}}, {RVOpcodes::ADDIW, {{0}, {1}}}, {RVOpcodes::XORI, {{0}, {1}}}, + {RVOpcodes::SLTI, {{0}, {1}}}, {RVOpcodes::SLTIU, {{0}, {1}}}, {RVOpcodes::LB, {{0}, {}}}, + {RVOpcodes::LH, {{0}, {}}}, {RVOpcodes::LW, {{0}, {}}}, {RVOpcodes::LD, {{0}, {}}}, + {RVOpcodes::LBU, {{0}, {}}}, {RVOpcodes::LHU, {{0}, {}}}, {RVOpcodes::LWU, {{0}, {}}}, + {RVOpcodes::FLW, {{0}, {}}}, {RVOpcodes::FLD, {{0}, {}}}, {RVOpcodes::SB, {{}, {0, 1}}}, + {RVOpcodes::SH, {{}, {0, 1}}}, {RVOpcodes::SW, {{}, {0, 1}}}, {RVOpcodes::SD, {{}, {0, 1}}}, + {RVOpcodes::FSW, {{}, {0, 1}}}, {RVOpcodes::FSD, {{}, {0, 1}}}, {RVOpcodes::BEQ, {{}, {0, 1}}}, + {RVOpcodes::BNE, {{}, {0, 1}}}, {RVOpcodes::BLT, {{}, {0, 1}}}, {RVOpcodes::BGE, {{}, {0, 1}}}, + {RVOpcodes::JALR, {{0}, {1}}}, {RVOpcodes::LI, {{0}, {}}}, {RVOpcodes::LA, {{0}, {}}}, + {RVOpcodes::MV, {{0}, {1}}}, {RVOpcodes::SEQZ, {{0}, {1}}}, {RVOpcodes::SNEZ, {{0}, {1}}}, + {RVOpcodes::RET, {{}, {}}}, {RVOpcodes::FADD_S, {{0}, {1, 2}}}, {RVOpcodes::FSUB_S, {{0}, {1, 2}}}, + {RVOpcodes::FMUL_S, {{0}, {1, 2}}}, {RVOpcodes::FDIV_S, {{0}, {1, 2}}}, {RVOpcodes::FEQ_S, {{0}, {1, 2}}}, + {RVOpcodes::FLT_S, {{0}, {1, 2}}}, {RVOpcodes::FLE_S, {{0}, {1, 2}}}, {RVOpcodes::FCVT_S_W, {{0}, {1}}}, + {RVOpcodes::FCVT_W_S, {{0}, {1}}}, {RVOpcodes::FMV_S, {{0}, {1}}}, {RVOpcodes::FMV_W_X, {{0}, {1}}}, + {RVOpcodes::FMV_X_W, {{0}, {1}}}, {RVOpcodes::FNEG_S, {{0}, {1}}} + }; + + auto get_vreg_id_if_virtual = [&](const MachineOperand* op, VRegSet& s) { + if (op->getKind() == MachineOperand::KIND_REG) { + auto reg_op = static_cast(op); + if (reg_op->isVirtual()) s.insert(reg_op->getVRegNum()); + } else if (op->getKind() == MachineOperand::KIND_MEM) { + auto mem_op = static_cast(op); + auto reg_op = mem_op->getBase(); + if (reg_op->isVirtual()) s.insert(reg_op->getVRegNum()); + } + }; + + if (op_info.count(opcode)) { + const auto& info = op_info.at(opcode); + for (int idx : info.first) if (idx < operands.size()) get_vreg_id_if_virtual(operands[idx].get(), def); + for (int idx : info.second) if (idx < operands.size()) get_vreg_id_if_virtual(operands[idx].get(), use); + for (const auto& op : operands) if (op->getKind() == MachineOperand::KIND_MEM) get_vreg_id_if_virtual(op.get(), use); + } else if (opcode == RVOpcodes::CALL) { + if (!operands.empty() && operands[0]->getKind() == MachineOperand::KIND_REG) get_vreg_id_if_virtual(operands[0].get(), def); + for (size_t i = 1; i < operands.size(); ++i) if (operands[i]->getKind() == MachineOperand::KIND_REG) get_vreg_id_if_virtual(operands[i].get(), use); + } +} + +/** + * @brief 获取一条指令完整的、包含物理寄存器的Use/Def集合 + * 这个函数专门服务于活跃性分析，现已补全所有指令（包括伪指令）的逻辑。 + */ +void RISCv64RegAlloc::getInstrUseDef_Liveness(const MachineInstr* instr, VRegSet& use, VRegSet& def) { + auto opcode = instr->getOpcode(); + const auto& operands = instr->getOperands(); + + // 映射表：指令操作码 -> {Def操作数索引列表, Use操作数索引列表} + static const std::map, std::vector>> op_info = { + // ===== 整数算术与逻辑指令 (R-type & I-type) ===== + {RVOpcodes::ADD, {{0}, {1, 2}}}, {RVOpcodes::SUB, {{0}, {1, 2}}}, {RVOpcodes::MUL, {{0}, {1, 2}}}, + {RVOpcodes::DIV, {{0}, {1, 2}}}, {RVOpcodes::REM, {{0}, {1, 2}}}, {RVOpcodes::ADDW, {{0}, {1, 2}}}, + {RVOpcodes::SUBW, {{0}, {1, 2}}}, {RVOpcodes::MULW, {{0}, {1, 2}}}, {RVOpcodes::DIVW, {{0}, {1, 2}}}, + {RVOpcodes::REMW, {{0}, {1, 2}}}, {RVOpcodes::SLT, {{0}, {1, 2}}}, {RVOpcodes::SLTU, {{0}, {1, 2}}}, + {RVOpcodes::XOR, {{0}, {1, 2}}}, {RVOpcodes::OR, {{0}, {1, 2}}}, {RVOpcodes::AND, {{0}, {1, 2}}}, + {RVOpcodes::ADDI, {{0}, {1}}}, {RVOpcodes::ADDIW, {{0}, {1}}}, {RVOpcodes::XORI, {{0}, {1}}}, + {RVOpcodes::ORI, {{0}, {1}}}, {RVOpcodes::ANDI, {{0}, {1}}}, + {RVOpcodes::SLTI, {{0}, {1}}}, {RVOpcodes::SLTIU, {{0}, {1}}}, + + // ===== 移位指令 ===== + {RVOpcodes::SLL, {{0}, {1, 2}}}, {RVOpcodes::SLLI, {{0}, {1}}}, + {RVOpcodes::SLLW, {{0}, {1, 2}}}, {RVOpcodes::SLLIW, {{0}, {1}}}, + {RVOpcodes::SRL, {{0}, {1, 2}}}, {RVOpcodes::SRLI, {{0}, {1}}}, + {RVOpcodes::SRLW, {{0}, {1, 2}}}, {RVOpcodes::SRLIW, {{0}, {1}}}, + {RVOpcodes::SRA, {{0}, {1, 2}}}, {RVOpcodes::SRAI, {{0}, {1}}}, + {RVOpcodes::SRAW, {{0}, {1, 2}}}, {RVOpcodes::SRAIW, {{0}, {1}}}, + + // ===== 内存加载指令 (Def: 0, Use: MemBase) ===== + {RVOpcodes::LB, {{0}, {}}}, {RVOpcodes::LH, {{0}, {}}}, {RVOpcodes::LW, {{0}, {}}}, {RVOpcodes::LD, {{0}, {}}}, + {RVOpcodes::LBU, {{0}, {}}}, {RVOpcodes::LHU, {{0}, {}}}, {RVOpcodes::LWU, {{0}, {}}}, + {RVOpcodes::FLW, {{0}, {}}}, {RVOpcodes::FLD, {{0}, {}}}, + + // ===== 内存存储指令 (Def: None, Use: ValToStore, MemBase) ===== + {RVOpcodes::SB, {{}, {0, 1}}}, {RVOpcodes::SH, {{}, {0, 1}}}, {RVOpcodes::SW, {{}, {0, 1}}}, {RVOpcodes::SD, {{}, {0, 1}}}, + {RVOpcodes::FSW, {{}, {0, 1}}}, {RVOpcodes::FSD, {{}, {0, 1}}}, + + // ===== 控制流指令 ===== + {RVOpcodes::BEQ, {{}, {0, 1}}}, {RVOpcodes::BNE, {{}, {0, 1}}}, {RVOpcodes::BLT, {{}, {0, 1}}}, + {RVOpcodes::BGE, {{}, {0, 1}}}, {RVOpcodes::BLTU, {{}, {0, 1}}}, {RVOpcodes::BGEU, {{}, {0, 1}}}, + {RVOpcodes::JALR, {{0}, {1}}}, // def: ra (implicit) and op0, use: op1 + + // ===== 浮点指令 ===== + {RVOpcodes::FADD_S, {{0}, {1, 2}}}, {RVOpcodes::FSUB_S, {{0}, {1, 2}}}, + {RVOpcodes::FMUL_S, {{0}, {1, 2}}}, {RVOpcodes::FDIV_S, {{0}, {1, 2}}}, {RVOpcodes::FEQ_S, {{0}, {1, 2}}}, + {RVOpcodes::FLT_S, {{0}, {1, 2}}}, {RVOpcodes::FLE_S, {{0}, {1, 2}}}, {RVOpcodes::FCVT_S_W, {{0}, {1}}}, + {RVOpcodes::FCVT_W_S, {{0}, {1}}}, {RVOpcodes::FMV_S, {{0}, {1}}}, {RVOpcodes::FMV_W_X, {{0}, {1}}}, + {RVOpcodes::FMV_X_W, {{0}, {1}}}, {RVOpcodes::FNEG_S, {{0}, {1}}}, + + // ===== 伪指令 ===== + {RVOpcodes::LI, {{0}, {}}}, {RVOpcodes::LA, {{0}, {}}}, + {RVOpcodes::MV, {{0}, {1}}}, {RVOpcodes::SEQZ, {{0}, {1}}}, {RVOpcodes::SNEZ, {{0}, {1}}}, + {RVOpcodes::NEG, {{0}, {1}}}, {RVOpcodes::NEGW, {{0}, {1}}}, + }; + + // lambda表达式用于获取操作数的寄存器ID（虚拟或物理） + const unsigned offset = static_cast(PhysicalReg::PHYS_REG_START_ID); + auto get_any_reg_id = [&](const MachineOperand* op) -> unsigned { + if (op->getKind() == MachineOperand::KIND_REG) { + auto reg_op = static_cast(op); + return reg_op->isVirtual() ? reg_op->getVRegNum() : (offset + static_cast(reg_op->getPReg())); + } else if (op->getKind() == MachineOperand::KIND_MEM) { + auto mem_op = static_cast(op); + auto reg_op = mem_op->getBase(); + return reg_op->isVirtual() ? reg_op->getVRegNum() : (offset + static_cast(reg_op->getPReg())); + } + return (unsigned)-1; + }; + + // --- 主要处理逻辑 --- + if (op_info.count(opcode)) { + const auto& info = op_info.at(opcode); + for (int idx : info.first) if (idx < operands.size()) { + unsigned reg_id = get_any_reg_id(operands[idx].get()); + if (reg_id != (unsigned)-1) def.insert(reg_id); + } + for (int idx : info.second) if (idx < operands.size()) { + unsigned reg_id = get_any_reg_id(operands[idx].get()); + if (reg_id != (unsigned)-1) use.insert(reg_id); + } + // 对于所有内存操作，基址寄存器都必须是 use + for (const auto& op : operands) { + if (op->getKind() == MachineOperand::KIND_MEM) { + unsigned reg_id = get_any_reg_id(op.get()); + if (reg_id != (unsigned)-1) use.insert(reg_id); + } + } + } + // --- 特殊指令处理逻辑 --- + else if (opcode == RVOpcodes::CALL) { + // 返回值是Def + if (!operands.empty() && operands[0]->getKind() == MachineOperand::KIND_REG) { + def.insert(get_any_reg_id(operands[0].get())); + } + // 函数名后的所有寄存器参数都是Use + for (size_t i = 1; i < operands.size(); ++i) { + if (operands[i]->getKind() == MachineOperand::KIND_REG) { + use.insert(get_any_reg_id(operands[i].get())); + } + } + // 所有调用者保存寄存器(caller-saved)被隐式定义（因为它们的值被破坏了） + for (auto preg : getCallerSavedIntRegs()) def.insert(offset + static_cast(preg)); + for (auto preg : getCallerSavedFpRegs()) def.insert(offset + static_cast(preg)); + // 返回地址寄存器RA也被隐式定义 + def.insert(offset + static_cast(PhysicalReg::RA)); + } + else if (opcode == RVOpcodes::JALR) { + // JALR rd, rs1, imm. Def: rd, Use: rs1. + // 同时也隐式定义了ra(x1)，但通常rd就是ra。为精确，我们只处理显式操作数。 + def.insert(get_any_reg_id(operands[0].get())); + use.insert(get_any_reg_id(operands[1].get())); + } + else if (opcode == RVOpcodes::RET) { + // 遵循调用约定，a0(整数/指针)和fa0(浮点)被隐式使用 + use.insert(offset + static_cast(PhysicalReg::A0)); + use.insert(offset + static_cast(PhysicalReg::F10)); // F10 is fa0 + } + // 添加对 PSEUDO_KEEPALIVE 的处理 + else if (opcode == RVOpcodes::PSEUDO_KEEPALIVE) { + // keepalive的所有操作数都是use，以确保它们的生命周期延续到该点 + for (const auto& op : operands) { + if (op->getKind() == MachineOperand::KIND_REG) { + unsigned reg_id = get_any_reg_id(op.get()); + if (reg_id != (unsigned)-1) use.insert(reg_id); + } + } + } +} + +void RISCv64RegAlloc::addEdge(unsigned u, unsigned v) { + if (u == v) return; + + // 检查两个节点是否都是虚拟寄存器 + if (!precolored.count(u) && !precolored.count(v) && !coloredNodes.count(u) && !coloredNodes.count(v)) { + // 只有当两个都是虚拟寄存器时，才为它们双方添加边和更新度数 + // 使用 operator[] 是安全的，如果键不存在，它会默认构造一个空的set + if (adjList[u].find(v) == adjList[u].end()) { + adjList[u].insert(v); + adjList[v].insert(u); + degree[u]++; + degree[v]++; + } + } + // 检查是否为 "虚拟-物理" 对 + else if (!precolored.count(u) && precolored.count(v) && !coloredNodes.count(u)) { + // u是虚拟寄存器，v是物理寄存器，只更新u的邻接表和度数 + if (adjList[u].find(v) == adjList[u].end()) { + adjList[u].insert(v); + degree[u]++; + } + } + // 检查是否为 "物理-虚拟" 对 + else if (precolored.count(u) && !precolored.count(v) && !coloredNodes.count(v)) { + // u是物理寄存器，v是虚拟寄存器，只更新v的邻接表和度数 + if (adjList[v].find(u) == adjList[v].end()) { + adjList[v].insert(u); + degree[v]++; + } + } + // 如果两个都是物理寄存器，则什么都不做，直接返回。 +} + +RISCv64RegAlloc::VRegSet RISCv64RegAlloc::adjacent(unsigned n) { + // 仅在 DEEPDEBUG 模式下启用详细日志 + if (DEEPERDEBUG) { + // 使用 regIdToString 打印节点 n，无论是物理还是虚拟 + std::cerr << "\n[adjacent] >>>>> Executing for node " << regIdToString(n) << " <<<<<\n"; + } + + // 1. 如果节点 n 是物理寄存器，它没有邻接表，直接返回空集 + if (precolored.count(n)) { + if (DEEPERDEBUG) { + std::cerr << "[adjacent] Node " << regIdToString(n) << " is precolored. Returning {}.\n"; + } + return {}; + } + + // 安全检查：确保 n 在 adjList 中存在，防止 map::at 崩溃 + if (adjList.count(n) == 0) { + if (DEEPERDEBUG) { + std::cerr << "[adjacent] WARNING: Node " << regIdToString(n) << " not found in adjList. Returning {}.\n"; + } + return {}; + } + + // 2. 获取 n 在冲突图中的所有邻居 + VRegSet result = adjList.at(n); + + if (DEEPERDEBUG) { + // 定义一个局部的 lambda 方便打印集合 + auto print_set = [this](const VRegSet& s, const std::string& name) { + std::cerr << "[adjacent] " << name << " (" << s.size() << "): { "; + for (unsigned id : s) std::cerr << regIdToString(id) << " "; + std::cerr << "}\n"; + }; + print_set(result, "Initial full neighbors"); + } + + // 3. 过滤掉那些已经在 selectStack 或 coalescedNodes 中的邻居 + // 这些节点被认为是“已移除”的，不参与当前的启发式判断 + + // 3a. 从 selectStack 中移除 + VRegSet removed_from_stack; // 仅用于调试打印 + for (auto it = selectStack.rbegin(); it != selectStack.rend(); ++it) { + if (result.count(*it)) { + if (DEEPERDEBUG) removed_from_stack.insert(*it); + result.erase(*it); + } + } + if (DEEPERDEBUG && !removed_from_stack.empty()) { + std::cerr << "[adjacent] - Removed from selectStack: { "; + for(unsigned id : removed_from_stack) std::cerr << regIdToString(id) << " "; + std::cerr << "}\n"; + } + + // 3b. 从 coalescedNodes 中移除 + VRegSet removed_from_coalesced; // 仅用于调试打印 + for (unsigned cn : coalescedNodes) { + if (result.count(cn)) { + if (DEEPERDEBUG) removed_from_coalesced.insert(cn); + result.erase(cn); + } + } + if (DEEPERDEBUG && !removed_from_coalesced.empty()) { + std::cerr << "[adjacent] - Removed from coalescedNodes: { "; + for(unsigned id : removed_from_coalesced) std::cerr << regIdToString(id) << " "; + std::cerr << "}\n"; + } + + // 4. 返回最终的、过滤后的“有效”邻居集合 + if (DEEPERDEBUG) { + std::cerr << "[adjacent] >>>>> Returning final adjacent set (" << result.size() << "): { "; + for (unsigned id : result) std::cerr << regIdToString(id) << " "; + std::cerr << "}\n\n"; + } + + return result; +} + +RISCv64RegAlloc::VRegMoveSet RISCv64RegAlloc::nodeMoves(unsigned n) { + if (precolored.count(n) || !moveList.count(n)) { + return {}; + } + + VRegMoveSet result; + const VRegMoveSet& moves = moveList.at(n); + for (const auto& move : moves) { + if (activeMoves.count(move) || worklistMoves.count(move)) { + result.insert(move); + } + } + return result; +} + +bool RISCv64RegAlloc::moveRelated(unsigned n) { + return !nodeMoves(n).empty(); +} + +void RISCv64RegAlloc::decrementDegree(unsigned m) { + if (precolored.count(m)) { + return; + } + + int K = isFPVReg(m) ? K_fp : K_int; + int d = degree.at(m); + degree.at(m)--; + if (d == K) { + VRegSet nodes_to_enable = adjacent(m); + nodes_to_enable.insert(m); + enableMoves(nodes_to_enable); + spillWorklist.erase(m); + if (moveRelated(m)) { + if (DEEPERDEBUG) { + std::cerr << "[decrementDegree] Node " << regIdToString(m) << " has degree " << d << ", now decremented to " << degree.at(m) << ". Added to freezeWorklist.\n"; + } + freezeWorklist.insert(m); + } else { + if (DEEPERDEBUG) { + std::cerr << "[decrementDegree] Node " << regIdToString(m) << " has degree " << d << ", now decremented to " << degree.at(m) << ". Added to simplifyWorklist.\n"; + } + simplifyWorklist.insert(m); + } + } +} + +void RISCv64RegAlloc::enableMoves(const VRegSet& nodes) { + for (unsigned n : nodes) { + VRegMoveSet moves = nodeMoves(n); + for (const auto& move : moves) { + if (activeMoves.count(move)) { + activeMoves.erase(move); + worklistMoves.insert(move); + } + } + } +} + +unsigned RISCv64RegAlloc::getAlias(unsigned n) { + if (precolored.count(n)) { + return n; + } + if (alias.count(n)) { + // 路径压缩 + alias.at(n) = getAlias(alias.at(n)); + return alias.at(n); + } + return n; +} + +void RISCv64RegAlloc::addWorklist(unsigned u) { + if (precolored.count(u)) return; + + int K = isFPVReg(u) ? K_fp : K_int; + if (!moveRelated(u) && degree.at(u) < K) { + freezeWorklist.erase(u); + simplifyWorklist.insert(u); + if (DEEPERDEBUG) { + std::cerr << "[addWorklist] Node " << regIdToString(u) << " added to simplifyWorklist (degree: " << degree.at(u) << ", K: " << K << ").\n"; + } + } +} + +// Briggs启发式 +bool RISCv64RegAlloc::briggsHeuristic(unsigned u, unsigned v) { + if (DEEPERDEBUG) { + std::cerr << "\n[Briggs] >>>>> Checking coalesce between " << regIdToString(u) << " and " << regIdToString(v) << " <<<<<\n"; + } + + // 步骤 1: 分别获取 u 和 v 的邻居 + VRegSet u_adj = adjacent(u); + VRegSet v_adj = adjacent(v); + + // 步骤 2: 合并两个邻居集合 + VRegSet all_adj = u_adj; + all_adj.insert(v_adj.begin(), v_adj.end()); + + if (DEEPERDEBUG) { + auto print_set = [this](const VRegSet& s, const std::string& name) { + std::cerr << "[Briggs] " << name << " (" << s.size() << "): { "; + for (unsigned id : s) std::cerr << regIdToString(id) << " "; + std::cerr << "}\n"; + }; + print_set(u_adj, "Neighbors of u"); + print_set(v_adj, "Neighbors of v"); + print_set(all_adj, "Combined neighbors"); + } + + // 步骤 3: 遍历合并后的邻居集合，计算度数 >= K 的节点数量 + int k = 0; + if (DEEPERDEBUG) std::cerr << "[Briggs] Checking significance of combined neighbors:\n"; + for (unsigned n : all_adj) { + // 关键修正：只考虑那些在工作集中的邻居节点 n + if (degree.count(n) > 0) { + int K = isFPVReg(n) ? K_fp : K_int; + if (degree.at(n) >= K) { + k++; + if (DEEPERDEBUG) { + std::cerr << "[Briggs] - Node " << regIdToString(n) << " is significant (degree " << degree.at(n) << " >= " << K << "). Count k is now " << k << ".\n"; + } + } + } + } + + // 步骤 4: 比较 "重要" 邻居的数量是否小于 K + int K_u = isFPVReg(u) ? K_fp : K_int; + bool result = (k < K_u); + + if (DEEPERDEBUG) { + std::cerr << "[Briggs] Final count of significant neighbors (k) = " << k << ".\n"; + std::cerr << "[Briggs] K value for node " << regIdToString(u) << " is " << K_u << ".\n"; + std::cerr << "[Briggs] >>>>> Result (k < K): " << (result ? "OK (can coalesce)" : "FAIL (cannot coalesce)") << "\n\n"; + } + return result; +} + +// George启发式 +bool RISCv64RegAlloc::georgeHeuristic(unsigned t, unsigned u) { + // 如果 t 不是一个待分配的虚拟寄存器（即它是物理寄存器）， + // 那么它已经被预着色，总是满足 George 启发式条件。 + // 我们通过检查 degree.count(t) 来判断 t 是否在我们的虚拟寄存器工作集中。 + if (degree.count(t) == 0) { + return true; + } + + int K = isFPVReg(t) ? K_fp : K_int; + // adjList.at(t) 现在是安全的，因为 degree.count(t) > 0 保证了 adjList.count(t) > 0 + return degree.at(t) < K || precolored.count(u) || adjList.at(t).count(u); +} + +void RISCv64RegAlloc::combine(unsigned u, unsigned v) { + freezeWorklist.erase(v); + spillWorklist.erase(v); + coalescedNodes.insert(v); + alias[v] = u; + if (moveList.count(u) && moveList.count(v)) { + moveList.at(u).insert(moveList.at(v).begin(), moveList.at(v).end()); + } else if (moveList.count(v)) { + moveList[u] = moveList.at(v); + } + enableMoves({v}); + for (unsigned t : adjList.at(v)) { + addEdge(t, u); + decrementDegree(t); + } + + if (!precolored.count(u)) { + int K = isFPVReg(u) ? K_fp : K_int; + if (degree.at(u) >= K && freezeWorklist.count(u)) { + freezeWorklist.erase(u); + spillWorklist.insert(u); + } + } +} + +void RISCv64RegAlloc::freezeMoves(unsigned u) { + if (precolored.count(u)) return; + + VRegMoveSet moves = nodeMoves(u); + for (const auto& move : moves) { + VRegSet use, def; + getInstrUseDef_Liveness(move, use, def); + unsigned x = *def.begin(); + unsigned y = *use.begin(); + unsigned v_alias; + + if (getAlias(y) == getAlias(u)) { + v_alias = getAlias(x); + } else { + v_alias = getAlias(y); + } + + activeMoves.erase(move); + frozenMoves.insert(move); + + if (!precolored.count(v_alias) && nodeMoves(v_alias).empty() && degree.at(v_alias) < (isFPVReg(v_alias) ? K_fp : K_int)) { + freezeWorklist.erase(v_alias); + simplifyWorklist.insert(v_alias); + if (DEEPERDEBUG) { + std::cerr << "[freezeMoves] Node " << regIdToString(v_alias) << " moved to simplifyWorklist (degree: " << degree.at(v_alias) << ").\n"; + } + } + } +} + +// 检查vreg是否为浮点类型 +bool RISCv64RegAlloc::isFPVReg(unsigned vreg) const { + // 1. 检查是否为虚拟寄存器 + if (vreg_type_map.count(vreg)) { + return vreg_type_map.at(vreg)->isFloat(); + } + + // 2. 检查是否为物理寄存器 (ID >= 100000) + const unsigned offset = static_cast(PhysicalReg::PHYS_REG_START_ID); + if (vreg >= offset) { + // 先减去偏移，还原成原始的、小的枚举值 + unsigned raw_preg_id = vreg - offset; + + // 再用原始枚举值判断是否在浮点寄存器范围内 + if (raw_preg_id >= static_cast(PhysicalReg::F0) && raw_preg_id <= static_cast(PhysicalReg::F31)) { + return true; + } + } + + // 3. 其他所有情况（如未知的vreg，或整数物理寄存器）都默认为整数 + return false; +} + +// 收集被使用的被调用者保存寄存器 +void RISCv64RegAlloc::collectUsedCalleeSavedRegs() { + StackFrameInfo& frame_info = MFunc->getFrameInfo(); + frame_info.used_callee_saved_regs.clear(); + + const auto& callee_saved_int = getCalleeSavedIntRegs(); + const auto& callee_saved_fp = getCalleeSavedFpRegs(); + std::set callee_saved_set(callee_saved_int.begin(), callee_saved_int.end()); + callee_saved_set.insert(callee_saved_fp.begin(), callee_saved_fp.end()); + // s0总是被使用作为帧指针 + callee_saved_set.insert(PhysicalReg::S0); + + + for(const auto& pair : color_map) { + PhysicalReg preg = pair.second; + if(callee_saved_set.count(preg)) { + frame_info.used_callee_saved_regs.insert(preg); + } + } +} + +/** + * @brief 将最终的寄存器分配结果应用到所有机器指令上。 + * 遍历所有操作数，将虚拟寄存器替换为分配到的物理寄存器。 + */ +void RISCv64RegAlloc::applyColoring() { for (auto& mbb : MFunc->getBlocks()) { for (auto& instr_ptr : mbb->getInstructions()) { for (auto& op_ptr : instr_ptr->getOperands()) { - // 定义一个处理寄存器操作数的 lambda 函数 - auto process_reg_op = [&](RegOperand* reg_op) { + if (op_ptr->getKind() == MachineOperand::KIND_REG) { + auto reg_op = static_cast(op_ptr.get()); + if (reg_op->isVirtual()) { + unsigned vreg = reg_op->getVRegNum(); + if (color_map.count(vreg)) { + // 使用 setPReg 将虚拟寄存器转换为物理寄存器 + reg_op->setPReg(color_map.at(vreg)); + } else { + // 如果一个vreg在成功分配后仍然没有颜色，这是一个错误 + std::cerr << "FATAL: Virtual register %vreg" << vreg << " has no color after allocation!\n"; + assert(false && "Virtual register has no color after allocation!"); + reg_op->setPReg(PhysicalReg::T6); + } + } + } else if (op_ptr->getKind() == MachineOperand::KIND_MEM) { + auto mem_op = static_cast(op_ptr.get()); + auto reg_op = mem_op->getBase(); if (reg_op->isVirtual()) { unsigned vreg = reg_op->getVRegNum(); if (color_map.count(vreg)) { reg_op->setPReg(color_map.at(vreg)); - } else if (spilled_vregs.count(vreg)) { - // 根据vreg类型，替换为对应的专用溢出寄存器 - assert(vreg_to_value_map.count(vreg)); - Value* val = vreg_to_value_map.at(vreg); - if (val->getType()->isFloat()) { - reg_op->setPReg(FP_SPILL_REG); - } else { - reg_op->setPReg(INT_SPILL_REG); - } + } else { + assert(false && "Virtual register in memory operand has no color!"); + reg_op->setPReg(PhysicalReg::T6); } } - }; - - if(op_ptr->getKind() == MachineOperand::KIND_REG) { - process_reg_op(static_cast(op_ptr.get())); - } else if (op_ptr->getKind() == MachineOperand::KIND_MEM) { - process_reg_op(static_cast(op_ptr.get())->getBase()); } } } } } +void RISCv64RegAlloc::dumpState(const std::string& stage) { + if (!DEEPDEBUG) return; + std::cerr << "\n=============== STATE DUMP (" << stage << ") ===============\n"; + auto print_vreg_set = [&](const VRegSet& s, const std::string& name){ + if (s.size() > DEBUGLENGTH) { + std::cerr << name << " (" << s.size() << ")\n"; + } + else { + std::cerr << name << " (" << s.size() << "): { "; + for(unsigned v : s) std::cerr << "%vreg" << v << " "; + std::cerr << "}\n"; + } + + }; + auto print_vreg_stack = [&](const VRegStack& s, const std::string& name){ + if (s.size() > DEBUGLENGTH) { + std::cerr << name << " (" << s.size() << ")\n"; + } + else { + std::cerr << name << " (" << s.size() << "): { "; + for(unsigned v : s) std::cerr << "%vreg" << v << " "; + std::cerr << "}\n"; + } + + }; + print_vreg_set(simplifyWorklist, "SimplifyWorklist"); + print_vreg_set(freezeWorklist, "FreezeWorklist"); + print_vreg_set(spillWorklist, "SpillWorklist"); + print_vreg_set(coalescedNodes, "CoalescedNodes"); + print_vreg_set(spilledNodes, "SpilledNodes"); + + print_vreg_stack(selectStack, "SelectStack"); + + std::cerr << "WorklistMoves (" << worklistMoves.size() << ")\n"; + std::cerr << "ActiveMoves (" << activeMoves.size() << ")\n"; + + size_t final_nodes = coalescedNodes.size() + spilledNodes.size() + selectStack.size(); + std::cerr << "Total Final Nodes: " << final_nodes << "\n"; + std::cerr << "=======================================================\n"; +} + +std::string RISCv64RegAlloc::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"; + } +} + +std::string RISCv64RegAlloc::regIdToString(unsigned id) { + const unsigned offset = static_cast(PhysicalReg::PHYS_REG_START_ID); + + if (id >= offset && precolored.count(id)) { + // 先减去偏移量，得到原始的、小的枚举值 + PhysicalReg reg = static_cast(id - offset); + // 再将原始枚举值传给 regToString + return regToString(reg); + } else { + return "%vreg" + std::to_string(id); + } +} + } // namespace sysy \ No newline at end of file diff --git a/src/include/backend/RISCv64/Handler/EliminateFrameIndices.h b/src/include/backend/RISCv64/Handler/EliminateFrameIndices.h new file mode 100644 index 0000000..155bdba --- /dev/null +++ b/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 \ No newline at end of file diff --git a/src/include/backend/RISCv64/RISCv64Backend.h b/src/include/backend/RISCv64/RISCv64Backend.h index 9e179d9..4f8ebf0 100644 --- a/src/include/backend/RISCv64/RISCv64Backend.h +++ b/src/include/backend/RISCv64/RISCv64Backend.h @@ -22,7 +22,6 @@ private: // 函数级代码生成 (实现新的流水线) std::string function_gen(Function* func); - // 私有辅助函数，用于根据类型计算其占用的字节数。 unsigned getTypeSizeInBytes(Type* type); diff --git a/src/include/backend/RISCv64/RISCv64LLIR.h b/src/include/backend/RISCv64/RISCv64LLIR.h index 3c8710e..b2111ff 100644 --- a/src/include/backend/RISCv64/RISCv64LLIR.h +++ b/src/include/backend/RISCv64/RISCv64LLIR.h @@ -3,6 +3,7 @@ #include "IR.h" // 确保包含了您自己的IR头文件 #include +#include #include #include #include @@ -38,7 +39,7 @@ enum class PhysicalReg { // 用于内部表示物理寄存器在干扰图中的节点ID（一个简单的特殊ID，确保不与vreg_counter冲突） // 假设 vreg_counter 不会达到这么大的值 - PHYS_REG_START_ID = 100000, + PHYS_REG_START_ID = 1000000, PHYS_REG_END_ID = PHYS_REG_START_ID + 320, // 预留足够的空间 }; @@ -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; @@ -274,14 +280,15 @@ private: // 栈帧信息 struct StackFrameInfo { int locals_size = 0; // 仅为AllocaInst分配的大小 + int locals_end_offset = 0; // 记录局部变量分配结束后的偏移量(相对于s0，为负) int spill_size = 0; // 仅为溢出分配的大小 int total_size = 0; // 总大小 int callee_saved_size = 0; // 保存寄存器的大小 std::map alloca_offsets; // std::map spill_offsets; // <溢出vreg, 栈偏移> std::set used_callee_saved_regs; // 使用的保存寄存器 - std::map vreg_to_preg_map; - std::vector callee_saved_regs; // 用于存储需要保存的被调用者保存寄存器列表 + std::map vreg_to_preg_map; // RegAlloc最终的分配结果 + std::vector callee_saved_regs_to_store; // 已排序的、需要存取的被调用者保存寄存器 }; // 机器函数 @@ -295,7 +302,7 @@ public: StackFrameInfo& getFrameInfo() { return frame_info; } const std::vector>& getBlocks() const { return blocks; } std::vector>& getBlocks() { return blocks; } - + void dumpStackFrameInfo(std::ostream& os = std::cerr) const; void addBlock(std::unique_ptr block) { blocks.push_back(std::move(block)); } diff --git a/src/include/backend/RISCv64/RISCv64Passes.h b/src/include/backend/RISCv64/RISCv64Passes.h index b456994..b6a5427 100644 --- a/src/include/backend/RISCv64/RISCv64Passes.h +++ b/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" #include "DivStrengthReduction.h" diff --git a/src/include/backend/RISCv64/RISCv64RegAlloc.h b/src/include/backend/RISCv64/RISCv64RegAlloc.h index 992aa5c..bea9ddc 100644 --- a/src/include/backend/RISCv64/RISCv64RegAlloc.h +++ b/src/include/backend/RISCv64/RISCv64RegAlloc.h @@ -3,9 +3,15 @@ #include "RISCv64LLIR.h" #include "RISCv64ISel.h" // 包含 RISCv64ISel.h 以访问 ISel 和 Value 类型 +#include +#include +#include +#include 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; // 活跃虚拟寄存器集合 - using InterferenceGraph = std::map>; + // 类型定义，与Python版本对应 + using VRegSet = std::set; + using InterferenceGraph = std::map; + using VRegStack = std::vector; // 使用vector模拟栈，方便遍历 + using MoveList = std::map>; + using AliasMap = std::map; + using ColorMap = std::map; + using VRegMoveSet = std::set; - // 栈帧管理 - 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 live_in_map; - std::map live_out_map; + RISCv64ISel* ISel; - // 干扰图 - InterferenceGraph interference_graph; - - // 图着色结果 - std::map color_map; // vreg -> preg - std::set spilled_vregs; // 被溢出的vreg集合 - - // 可用的物理寄存器池 + // --- 算法数据结构 --- + // 寄存器池 std::vector allocable_int_regs; std::vector allocable_fp_regs; + int K_int; // 整数寄存器数量 + int K_fp; // 浮点寄存器数量 - // 存储vreg到IR Value*的反向映射 - // 这个map将在run()函数开始时被填充，并在rewriteFunction()中使用。 - std::map vreg_to_value_map; - std::map 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 coalescedMoves; + std::set constrainedMoves; + std::set frozenMoves; + std::set worklistMoves; + std::set activeMoves; + + // 数据结构 + InterferenceGraph adjSet; + std::map adjList; // 邻接表 + std::map degree; + MoveList moveList; + AliasMap alias; + ColorMap color_map; + + // 活跃性分析结果 + std::map live_in_map; + std::map live_out_map; + // VReg -> Value* 和 VReg -> Type* 的映射 + const std::map& vreg_to_value_map; + const std::map& vreg_type_map; }; } // namespace sysy diff --git a/src/sysyc.cpp b/src/sysyc.cpp index 04da485..747eb89 100644 --- a/src/sysyc.cpp +++ b/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; From 19a433c94f679d0c3faa8c5030fdddc865a119df Mon Sep 17 00:00:00 2001 From: Lixuanwang Date: Sun, 3 Aug 2025 15:41:29 +0800 Subject: [PATCH 17/55] =?UTF-8?q?[midend]=E4=B8=BA=E8=84=9A=E6=9C=AC?= =?UTF-8?q?=E6=B7=BB=E5=8A=A0=E4=BA=86-O1=E5=8F=82=E6=95=B0=EF=BC=8C?= =?UTF-8?q?=E6=94=AF=E6=8C=81=E6=B5=8B=E8=AF=95=E6=80=A7=E8=83=BD?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- script/runit-single.sh | 20 ++++++++------------ script/runit.sh | 20 ++++++++------------ 2 files changed, 16 insertions(+), 24 deletions(-) diff --git a/script/runit-single.sh b/script/runit-single.sh index ed32181..31ad66a 100644 --- a/script/runit-single.sh +++ b/script/runit-single.sh @@ -21,6 +21,7 @@ QEMU_RISCV64="qemu-riscv64" # --- 初始化变量 --- EXECUTE_MODE=false CLEAN_MODE=false +OPTIMIZE_FLAG="" # 用于存储 -O1 标志 SYSYC_TIMEOUT=10 # sysyc 编译超时 (秒) GCC_TIMEOUT=10 # gcc 编译超时 (秒) EXEC_TIMEOUT=5 # qemu 自动化执行超时 (秒) @@ -39,6 +40,7 @@ show_help() { echo "选项:" echo " -e, --executable 编译为可执行文件并运行测试 (必须)。" echo " -c, --clean 清理 tmp 临时目录下的所有文件。" + echo " -O1 启用 sysyc 的 -O1 优化。" echo " -sct N 设置 sysyc 编译超时为 N 秒 (默认: 10)。" echo " -gct N 设置 gcc 交叉编译超时为 N 秒 (默认: 10)。" echo " -et N 设置 qemu 自动化执行超时为 N 秒 (默认: 5)。" @@ -80,6 +82,10 @@ while [[ "$#" -gt 0 ]]; do CLEAN_MODE=true shift # 消耗选项 ;; + -O1) + OPTIMIZE_FLAG="-O1" + shift # 消耗选项 + ;; -sct) if [[ -n "$2" && "$2" =~ ^[0-9]+$ ]]; then SYSYC_TIMEOUT="$2"; shift 2; else echo "错误: -sct 需要一个正整数参数。" >&2; exit 1; fi ;; @@ -144,6 +150,7 @@ mkdir -p "${TMP_DIR}" TOTAL_CASES=${#SY_FILES[@]} echo "SysY 单例测试运行器启动..." +if [ -n "$OPTIMIZE_FLAG" ]; then echo "优化等级: ${OPTIMIZE_FLAG}"; fi echo "超时设置: sysyc=${SYSYC_TIMEOUT}s, gcc=${GCC_TIMEOUT}s, qemu=${EXEC_TIMEOUT}s" echo "失败输出最大行数: ${MAX_OUTPUT_LINES}" echo "" @@ -164,19 +171,9 @@ 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}" + timeout -s KILL ${SYSYC_TIMEOUT} "${SYSYC}" -s ir "${sy_file}" ${OPTIMIZE_FLAG} > "${ir_file}" SYSYC_STATUS=$? if [ $SYSYC_STATUS -eq 124 ]; then echo -e "\e[31m错误: SysY 编译 ${sy_file} IR超时\e[0m" @@ -185,7 +182,6 @@ for sy_file in "${SY_FILES[@]}"; do echo -e "\e[31m错误: SysY 编译 ${sy_file} IR失败，退出码: ${SYSYC_STATUS}\e[0m" is_passed=0 fi - timeout -s KILL ${SYSYC_TIMEOUT} "${SYSYC}" -S "${sy_file}" -o "${assembly_file}" if [ $? -ne 0 ]; then echo -e "\e[31m错误: SysY 编译失败或超时。\e[0m" is_passed=0 diff --git a/script/runit.sh b/script/runit.sh index 990cc52..fa413f9 100644 --- a/script/runit.sh +++ b/script/runit.sh @@ -16,8 +16,8 @@ SYSYC="${BUILD_BIN_DIR}/sysyc" GCC_RISCV64="riscv64-linux-gnu-gcc" QEMU_RISCV64="qemu-riscv64" -# --- 新增功能: 初始化变量 --- EXECUTE_MODE=false +OPTIMIZE_FLAG="" # 用于存储 -O1 标志 SYSYC_TIMEOUT=10 # sysyc 编译超时 (秒) GCC_TIMEOUT=10 # gcc 编译超时 (秒) EXEC_TIMEOUT=5 # qemu 执行超时 (秒) @@ -35,6 +35,7 @@ show_help() { echo "选项:" echo " -e, --executable 编译为可执行文件并运行测试。" echo " -c, --clean 清理 'tmp' 目录下的所有生成文件。" + echo " -O1 启用 sysyc 的 -O1 优化。" echo " -set [f|h|p|all]... 指定要运行的测试集 (functional, h_functional, performance)。可多选，默认为 all。" echo " -sct N 设置 sysyc 编译超时为 N 秒 (默认: 10)。" echo " -gct N 设置 gcc 交叉编译超时为 N 秒 (默认: 10)。" @@ -85,9 +86,12 @@ while [[ "$#" -gt 0 ]]; do clean_tmp exit 0 ;; + -O1) + OPTIMIZE_FLAG="-O1" + shift + ;; -set) shift # 移过 '-set' - # 消耗所有后续参数直到遇到下一个选项 while [[ "$#" -gt 0 && ! "$1" =~ ^- ]]; do TEST_SETS+=("$1") shift @@ -125,7 +129,6 @@ SET_MAP[p]="performance" SEARCH_PATHS=() -# 如果未指定测试集，或指定了 'all'，则搜索所有目录 if [ ${#TEST_SETS[@]} -eq 0 ] || [[ " ${TEST_SETS[@]} " =~ " all " ]]; then SEARCH_PATHS+=("${TESTDATA_DIR}") else @@ -138,13 +141,13 @@ else done fi -# 如果没有有效的搜索路径，则退出 if [ ${#SEARCH_PATHS[@]} -eq 0 ]; then echo -e "\e[31m错误: 没有找到有效的测试集目录，测试中止。\e[0m" exit 1 fi echo "SysY 测试运行器启动..." +if [ -n "$OPTIMIZE_FLAG" ]; then echo "优化等级: ${OPTIMIZE_FLAG}"; fi echo "输入目录: ${SEARCH_PATHS[@]}" echo "临时目录: ${TMP_DIR}" echo "执行模式: ${EXECUTE_MODE}" @@ -154,7 +157,6 @@ if ${EXECUTE_MODE}; then fi echo "" -# 使用构建好的路径查找 .sy 文件并排序 sy_files=$(find "${SEARCH_PATHS[@]}" -name "*.sy" | sort -V) if [ -z "$sy_files" ]; then echo "在指定目录中未找到任何 .sy 文件。" @@ -162,7 +164,6 @@ if [ -z "$sy_files" ]; then fi TOTAL_CASES=$(echo "$sy_files" | wc -w) -# --- 修复: 使用 here-string (<<<) 代替管道 (|) 来避免子 shell 问题 --- while IFS= read -r sy_file; do is_passed=1 # 1 表示通过, 0 表示失败 @@ -176,10 +177,8 @@ while IFS= read -r sy_file; do output_actual_file="${TMP_DIR}/${output_base_name}_sysyc_riscv64.actual_out" echo "正在处理: $(basename "$sy_file") (路径: ${relative_path_no_ext}.sy)" - - # 步骤 1: 使用 sysyc 编译 .sy 到 .s echo " 使用 sysyc 编译 (超时 ${SYSYC_TIMEOUT}s)..." - timeout -s KILL ${SYSYC_TIMEOUT} "${SYSYC}" -S "${sy_file}" -o "${assembly_file}" + timeout -s KILL ${SYSYC_TIMEOUT} "${SYSYC}" -S "${sy_file}" -o "${assembly_file}" ${OPTIMIZE_FLAG} SYSYC_STATUS=$? if [ $SYSYC_STATUS -eq 124 ]; then echo -e "\e[31m错误: SysY 编译 ${sy_file} 超时\e[0m" @@ -189,9 +188,7 @@ while IFS= read -r sy_file; do is_passed=0 fi - # 只有当 EXECUTE_MODE 为 true 且上一步成功时才继续 if ${EXECUTE_MODE} && [ "$is_passed" -eq 1 ]; then - # 步骤 2: 使用 riscv64-linux-gnu-gcc 编译 .s 到可执行文件 echo " 使用 gcc 编译 (超时 ${GCC_TIMEOUT}s)..." timeout -s KILL ${GCC_TIMEOUT} "${GCC_RISCV64}" "${assembly_file}" -o "${executable_file}" -L"${LIB_DIR}" -lsysy_riscv -static GCC_STATUS=$? @@ -213,7 +210,6 @@ while IFS= read -r sy_file; do continue fi - # 步骤 3, 4, 5: 只有当编译都成功时才执行 if [ "$is_passed" -eq 1 ]; then echo " 正在执行 (超时 ${EXEC_TIMEOUT}s)..." From 22cf18a1d649a8837161789b317e151863c8f0b5 Mon Sep 17 00:00:00 2001 From: rain2133 <1370973498@qq.com> Date: Sun, 3 Aug 2025 16:14:31 +0800 Subject: [PATCH 18/55] =?UTF-8?q?[midend-BuildCFG]=E4=BF=AE=E5=A4=8D?= =?UTF-8?q?=E9=80=BB=E8=BE=91?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/include/midend/Pass/Optimize/BuildCFG.h | 25 +-- src/midend/CMakeLists.txt | 1 + src/midend/Pass/Optimize/BuildCFG.cpp | 160 ++++++++------------ src/midend/Pass/Pass.cpp | 9 +- 4 files changed, 71 insertions(+), 124 deletions(-) diff --git a/src/include/midend/Pass/Optimize/BuildCFG.h b/src/include/midend/Pass/Optimize/BuildCFG.h index 4054c54..a7fb6cb 100644 --- a/src/include/midend/Pass/Optimize/BuildCFG.h +++ b/src/include/midend/Pass/Optimize/BuildCFG.h @@ -1,33 +1,20 @@ #pragma once -#include "Pass.h" #include "IR.h" -#include "Instruction.h" +#include "Pass.h" #include #include namespace sysy { -class DominatorTreeAnalysisPass; -class LivenessAnalysisPass; - class BuildCFG : public OptimizationPass { public: - // Pass的唯一ID，用于PassRegistry - static char ID; + static void *ID; + BuildCFG() : OptimizationPass("BuildCFG", Granularity::Function) {} + bool runOnFunction(Function *F, AnalysisManager &AM) override; + void getAnalysisUsage(std::set &analysisDependencies, std::set &analysisInvalidations) const override; + void *getPassID() const override { return &ID; } - BuildCFG() : OptimizationPass("BuildCFG", Pass::Granularity::Function, Pass::PassKind::Optimization) {} - - // 重载 runOnFunction 方法，实现具体的优化逻辑 - bool runOnFunction(Function *F, AnalysisManager& AM) override; - - // 提供PassID - void *getPassID() const override { return &ID; } - - // 声明Pass的分析使用 - // BuildCFG不依赖任何分析，但会使其他依赖CFG的分析失效 - void getAnalysisUsage(std::set &analysisDependencies, - std::set &analysisInvalidations) override; }; } // namespace sysy \ No newline at end of file diff --git a/src/midend/CMakeLists.txt b/src/midend/CMakeLists.txt index 3532818..f944a3c 100644 --- a/src/midend/CMakeLists.txt +++ b/src/midend/CMakeLists.txt @@ -11,6 +11,7 @@ add_library(midend_lib STATIC Pass/Optimize/Reg2Mem.cpp Pass/Optimize/SysYIRCFGOpt.cpp Pass/Optimize/SCCP.cpp + Pass/Optimize/BuildCFG.cpp ) # 包含中端模块所需的头文件路径 diff --git a/src/midend/Pass/Optimize/BuildCFG.cpp b/src/midend/Pass/Optimize/BuildCFG.cpp index 823d126..07cdd4e 100644 --- a/src/midend/Pass/Optimize/BuildCFG.cpp +++ b/src/midend/Pass/Optimize/BuildCFG.cpp @@ -1,121 +1,79 @@ #include "BuildCFG.h" -#include "Instruction.h" -#include "IR.h" -#include "Liveness.h" // 包含活跃性分析的头文件以引用其ID -#include "Dom.h" // 包含支配树分析的头文件以引用其ID +#include "Dom.h" +#include "Liveness.h" #include #include #include namespace sysy { -char BuildCFG::ID = 0; +void *BuildCFG::ID = (void *)&BuildCFG::ID; // 定义唯一的 Pass ID // 声明Pass的分析使用 -void BuildCFG::getAnalysisUsage(std::set &analysisDependencies, - std::set &analysisInvalidations) { - // BuildCFG不依赖其他分析 - // analysisDependencies.insert(&DominatorTreeAnalysisPass::ID); // 错误的例子 +void BuildCFG::getAnalysisUsage(std::set &analysisDependencies, std::set &analysisInvalidations) const { + // BuildCFG不依赖其他分析 + // analysisDependencies.insert(&DominatorTreeAnalysisPass::ID); // 错误的例子 - // BuildCFG会使所有依赖于CFG的分析结果失效，所以它必须声明这些失效 - analysisInvalidations.insert(&DominatorTreeAnalysisPass::ID); - analysisInvalidations.insert(&LivenessAnalysisPass::ID); + // BuildCFG会使所有依赖于CFG的分析结果失效，所以它必须声明这些失效 + analysisInvalidations.insert(&DominatorTreeAnalysisPass::ID); + analysisInvalidations.insert(&LivenessAnalysisPass::ID); } -bool BuildCFG::runOnFunction(Function *F, AnalysisManager& AM) { - if (DEBUG) { - std::cout << "Running BuildCFG pass on function: " << F->getName() << std::endl; +bool BuildCFG::runOnFunction(Function *F, AnalysisManager &AM) { + if (DEBUG) { + std::cout << "Running BuildCFG pass on function: " << F->getName() << std::endl; + } + + bool changed = false; + + // 1. 清空所有基本块的前驱和后继列表 + for (auto &bb : F->getBasicBlocks()) { + bb->clearPredecessors(); + bb->clearSuccessors(); + } + + // 2. 遍历每个基本块，重建CFG + for (auto &bb : F->getBasicBlocks()) { + // 获取基本块的最后一条指令 + auto &inst = *bb->terminator(); + Instruction *termInst = inst.get(); + // 确保基本块有终结指令 + if (!termInst) { + continue; } - bool changed = false; + // 根据终结指令类型，建立前驱后继关系 + if (termInst->isBranch()) { + // 无条件跳转 + if (termInst->isUnconditional()) { + auto brInst = dynamic_cast(termInst); + BasicBlock *succ = dynamic_cast(brInst->getBlock()); + assert(succ && "Branch instruction's target must be a BasicBlock"); + bb->addSuccessor(succ); + succ->addPredecessor(bb.get()); + changed = true; - // 1. 清空所有基本块的前驱和后继列表 - for (auto &bb : *F) { - bb->predecessors.clear(); - bb->successors.clear(); + // 条件跳转 + } else if (termInst->isConditional()) { + auto brInst = dynamic_cast(termInst); + BasicBlock *trueSucc = dynamic_cast(brInst->getThenBlock()); + BasicBlock *falseSucc = dynamic_cast(brInst->getElseBlock()); + + assert(trueSucc && falseSucc && "Branch instruction's targets must be BasicBlocks"); + + bb->addSuccessor(trueSucc); + trueSucc->addPredecessor(bb.get()); + bb->addSuccessor(falseSucc); + falseSucc->addPredecessor(bb.get()); + changed = true; + } + } else if (auto retInst = dynamic_cast(termInst)) { + // RetInst没有后继，无需处理 + // ... } + } - // 2. 遍历每个基本块，重建CFG - for (auto &bb : *F) { - // 获取基本块的最后一条指令 - Instruction *termInst = bb->getTerminator(); - - // 确保基本块有终结指令 - if (!termInst) { - continue; - } - - // 根据终结指令类型，建立前驱后继关系 - if (auto brInst = dynamic_cast(termInst)) { - // 无条件跳转 - if (brInst->getNumOperands() == 1) { - BasicBlock *succ = dynamic_cast(brInst->getOperand(0)); - assert(succ && "Branch instruction's target must be a BasicBlock"); - - bb->successors.push_back(succ); - succ->predecessors.push_back(bb.get()); - changed = true; - - // 条件跳转 - } else if (brInst->getNumOperands() == 3) { - BasicBlock *trueSucc = dynamic_cast(brInst->getOperand(1)); - BasicBlock *falseSucc = dynamic_cast(brInst->getOperand(2)); - - assert(trueSucc && falseSucc && "Branch instruction's targets must be BasicBlocks"); - - bb->successors.push_back(trueSucc); - trueSucc->predecessors.push_back(bb.get()); - - bb->successors.push_back(falseSucc); - falseSucc->predecessors.push_back(bb.get()); - changed = true; - } - } else if (auto retInst = dynamic_cast(termInst)) { - // RetInst没有后继，无需处理 - // ... - } - } - - // 3. 额外处理：可达性分析，标记不可达基本块 - std::queue q; - std::set visited; - - // 默认所有块不可达 - for (auto &bb : *F) { - bb->setreachableFalse(); - } - - // 从函数入口基本块开始 - BasicBlock* entryBB = F->getEntryBlock(); - if (entryBB) { - q.push(entryBB); - visited.insert(entryBB); - entryBB->setreachableTrue(); - } - - // 广度优先搜索 (BFS) 遍历所有可达的基本块 - while (!q.empty()) { - BasicBlock* currentBB = q.front(); - q.pop(); - - for (auto& succ : currentBB->successors) { - if (visited.find(succ) == visited.end()) { - q.push(succ); - visited.insert(succ); - succ->setreachableTrue(); - } - } - } - - // 将未访问到的基本块标记为不可达 - for (auto& bb : *F) { - if (visited.find(bb.get()) == visited.end()) { - bb->setreachableFalse(); - changed = true; // 发现不可达块，视为改变 - } - } - - return changed; + return changed; } } // namespace sysy \ No newline at end of file diff --git a/src/midend/Pass/Pass.cpp b/src/midend/Pass/Pass.cpp index c293853..c2c8371 100644 --- a/src/midend/Pass/Pass.cpp +++ b/src/midend/Pass/Pass.cpp @@ -36,11 +36,12 @@ void PassManager::runOptimizationPipeline(Module* moduleIR, IRBuilder* builderIR 3. 添加优化passid */ // 注册分析遍 - registerAnalysisPass(); - registerAnalysisPass(); + registerAnalysisPass(); + registerAnalysisPass(); // 注册优化遍 - registerOptimizationPass(builderIR); + registerOptimizationPass(); + registerOptimizationPass(); registerOptimizationPass(); registerOptimizationPass(); @@ -66,7 +67,7 @@ void PassManager::runOptimizationPipeline(Module* moduleIR, IRBuilder* builderIR } this->clearPasses(); - this->addPass(&&BuildCFG::ID); + this->addPass(&BuildCFG::ID); this->run(); this->clearPasses(); From 92c89f7616a973b4c5882e92f69b0b75ee14f03a Mon Sep 17 00:00:00 2001 From: Lixuanwang Date: Sun, 3 Aug 2025 17:12:39 +0800 Subject: [PATCH 19/55] =?UTF-8?q?[midend]=E4=BF=AE=E6=AD=A3=E4=BA=86?= =?UTF-8?q?=E8=84=9A=E6=9C=AC=E9=94=99=E8=AF=AF?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- script/runit-single.sh | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/script/runit-single.sh b/script/runit-single.sh index 31ad66a..02a34de 100644 --- a/script/runit-single.sh +++ b/script/runit-single.sh @@ -173,7 +173,9 @@ for sy_file in "${SY_FILES[@]}"; do # 步骤 1: sysyc 编译 echo " 使用 sysyc 编译 (超时 ${SYSYC_TIMEOUT}s)..." - timeout -s KILL ${SYSYC_TIMEOUT} "${SYSYC}" -s ir "${sy_file}" ${OPTIMIZE_FLAG} > "${ir_file}" + timeout -s KILL ${SYSYC_TIMEOUT} "${SYSYC}" -S "${sy_file}" ${OPTIMIZE_FLAG} -o "${assembly_file}" + # timeout -s KILL ${SYSYC_TIMEOUT} "${SYSYC}" -s ir "${sy_file}" ${OPTIMIZE_FLAG} > "${ir_file}" + # timeout -s KILL ${SYSYC_TIMEOUT} "${SYSYC}" -s asmd "${sy_file}" > "${assembly_debug_file}" 2>&1 SYSYC_STATUS=$? if [ $SYSYC_STATUS -eq 124 ]; then echo -e "\e[31m错误: SysY 编译 ${sy_file} IR超时\e[0m" @@ -186,7 +188,6 @@ for sy_file in "${SY_FILES[@]}"; do echo -e "\e[31m错误: SysY 编译失败或超时。\e[0m" is_passed=0 fi - # timeout -s KILL ${SYSYC_TIMEOUT} "${SYSYC}" -s asmd "${sy_file}" > "${assembly_debug_file}" 2>&1 # 步骤 2: GCC 编译 if [ "$is_passed" -eq 1 ]; then From 91f755959bd1bb36ff5837cc08299055d53c129a Mon Sep 17 00:00:00 2001 From: rain2133 <1370973498@qq.com> Date: Sun, 3 Aug 2025 17:25:05 +0800 Subject: [PATCH 20/55] =?UTF-8?q?[midend]=E4=BF=AE=E6=94=B9=E4=B8=AD?= =?UTF-8?q?=E7=AB=AF=E6=B5=81=E6=B0=B4=E7=BA=BF?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/midend/Pass/Pass.cpp | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/src/midend/Pass/Pass.cpp b/src/midend/Pass/Pass.cpp index c2c8371..73a4573 100644 --- a/src/midend/Pass/Pass.cpp +++ b/src/midend/Pass/Pass.cpp @@ -79,6 +79,10 @@ void PassManager::runOptimizationPipeline(Module* moduleIR, IRBuilder* builderIR this->addPass(&SysYAddReturnPass::ID); this->run(); + this->clearPasses(); + this->addPass(&BuildCFG::ID); + this->run(); + if(DEBUG) { std::cout << "=== IR After CFGOpt Optimizations ===\n"; printPasses(); @@ -119,7 +123,9 @@ void PassManager::runOptimizationPipeline(Module* moduleIR, IRBuilder* builderIR std::cout << "=== IR After Reg2Mem Optimizations ===\n"; printPasses(); } - + this->clearPasses(); + this->addPass(&BuildCFG::ID); + this->run(); if (DEBUG) std::cout << "--- Custom optimization sequence finished ---\n"; } @@ -134,6 +140,7 @@ void PassManager::runOptimizationPipeline(Module* moduleIR, IRBuilder* builderIR SysYPrinter printer(moduleIR); printer.printIR(); } + } void PassManager::clearPasses() { From ec91a4e259659c205bdaa4ad2a401462f05a1a44 Mon Sep 17 00:00:00 2001 From: Lixuanwang Date: Sun, 3 Aug 2025 17:26:09 +0800 Subject: [PATCH 21/55] =?UTF-8?q?[backend]=E6=9B=B4=E6=96=B0=E8=84=9A?= =?UTF-8?q?=E6=9C=AC=EF=BC=8C=E7=8E=B0=E5=9C=A8=E4=BC=9A=E6=8B=B7=E8=B4=9D?= =?UTF-8?q?.sy=E6=96=87=E4=BB=B6=E5=88=B0tmp=E7=9B=AE=E5=BD=95?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- script/runit-single.sh | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/script/runit-single.sh b/script/runit-single.sh index 02a34de..c6dacee 100644 --- a/script/runit-single.sh +++ b/script/runit-single.sh @@ -171,6 +171,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 "${sy_file}" ${OPTIMIZE_FLAG} -o "${assembly_file}" From e4ad23a1a594a9da6b96655d4256352d5f6d277d Mon Sep 17 00:00:00 2001 From: Lixuanwang Date: Sun, 3 Aug 2025 18:37:08 +0800 Subject: [PATCH 22/55] =?UTF-8?q?[backend]=E4=BF=AE=E5=A4=8D=E4=BA=86?= =?UTF-8?q?=E5=AF=84=E5=AD=98=E5=99=A8=E5=88=86=E9=85=8D=E5=99=A8=E5=9C=A8?= =?UTF-8?q?=E5=A4=84=E7=90=86=E5=85=A8=E7=89=A9=E7=90=86=E5=AF=84=E5=AD=98?= =?UTF-8?q?=E5=99=A8=E6=93=8D=E4=BD=9C=E6=95=B0=E6=97=B6=E7=9A=84bug?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- script/runit-single.sh | 2 +- src/backend/RISCv64/RISCv64RegAlloc.cpp | 11 +++++++++++ 2 files changed, 12 insertions(+), 1 deletion(-) diff --git a/script/runit-single.sh b/script/runit-single.sh index c6dacee..3cc47aa 100644 --- a/script/runit-single.sh +++ b/script/runit-single.sh @@ -184,7 +184,7 @@ for sy_file in "${SY_FILES[@]}"; do # 步骤 1: sysyc 编译 echo " 使用 sysyc 编译 (超时 ${SYSYC_TIMEOUT}s)..." timeout -s KILL ${SYSYC_TIMEOUT} "${SYSYC}" -S "${sy_file}" ${OPTIMIZE_FLAG} -o "${assembly_file}" - # timeout -s KILL ${SYSYC_TIMEOUT} "${SYSYC}" -s ir "${sy_file}" ${OPTIMIZE_FLAG} > "${ir_file}" + timeout -s KILL ${SYSYC_TIMEOUT} "${SYSYC}" -s ir "${sy_file}" ${OPTIMIZE_FLAG} > "${ir_file}" # timeout -s KILL ${SYSYC_TIMEOUT} "${SYSYC}" -s asmd "${sy_file}" > "${assembly_debug_file}" 2>&1 SYSYC_STATUS=$? if [ $SYSYC_STATUS -eq 124 ]; then diff --git a/src/backend/RISCv64/RISCv64RegAlloc.cpp b/src/backend/RISCv64/RISCv64RegAlloc.cpp index a1cd77c..87f276f 100644 --- a/src/backend/RISCv64/RISCv64RegAlloc.cpp +++ b/src/backend/RISCv64/RISCv64RegAlloc.cpp @@ -461,6 +461,17 @@ void RISCv64RegAlloc::coalesce() { unsigned y = getAlias(*use.begin()); unsigned u, v; if (precolored.count(y)) { u = y; v = x; } else { u = x; v = y; } + + // 防御性检查，处理物理寄存器之间的传送指令 + if (precolored.count(u) && precolored.count(v)) { + // 如果 u 和 v 都是物理寄存器，我们不能合并它们。 + // 这通常是一条寄存器拷贝指令，例如 `mv a2, a1`。 + // 把它加入 constrainedMoves 列表，然后直接返回，不再处理。 + constrainedMoves.insert(move); + // addWorklist(u) 和 addWorklist(v) 在这里也不需要调用， + // 因为它们只对虚拟寄存器有意义。 + return; + } if (DEEPERDEBUG) std::cerr << "[Coalesce] Processing move between " << regIdToString(x) << " and " << regIdToString(y) << " (aliases " << regIdToString(u) From d8b004e5e58fdd3ac52b942ff1a46e65169b6449 Mon Sep 17 00:00:00 2001 From: rain2133 <1370973498@qq.com> Date: Sun, 3 Aug 2025 22:16:40 +0800 Subject: [PATCH 23/55] =?UTF-8?q?[midend]=E4=BF=AE=E6=94=B9use=E5=85=B3?= =?UTF-8?q?=E7=B3=BB=E7=9B=B8=E5=85=B3=E7=9A=84=E5=87=BD=E6=95=B0=EF=BC=8C?= =?UTF-8?q?=E4=BD=BF=E5=85=B6=E8=83=BD=E8=87=AA=E5=8A=A8=E7=9A=84=E6=AD=A3?= =?UTF-8?q?=E7=A1=AE=E7=BB=B4=E6=8A=A4=EF=BC=8C=E4=BF=AE=E6=94=B9=E4=BA=86?= =?UTF-8?q?phi=E6=8C=87=E4=BB=A4=E7=9A=84=E5=90=84=E7=A7=8D=E6=8E=A5?= =?UTF-8?q?=E5=8F=A3?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/include/midend/IR.h | 98 ++-- .../midend/Pass/Optimize/SysYIROptUtils.h | 11 +- src/midend/IR.cpp | 499 ++++-------------- 3 files changed, 135 insertions(+), 473 deletions(-) diff --git a/src/include/midend/IR.h b/src/include/midend/IR.h index 14433e4..2920ccd 100644 --- a/src/include/midend/IR.h +++ b/src/include/midend/IR.h @@ -202,6 +202,7 @@ class Use { public: unsigned getIndex() const { return index; } ///< 返回value在User操作数中的位置 + void setIndex(int newIndex) { index = newIndex; } ///< 设置value在User操作数中的位置 User* getUser() const { return user; } ///< 返回使用者 Value* getValue() const { return value; } ///< 返回被使用的值 void setValue(Value *newValue) { value = newValue; } ///< 将被使用的值设置为newValue @@ -229,7 +230,14 @@ class Value { std::list>& getUses() { return uses; } ///< 获取使用关系列表 void addUse(const std::shared_ptr &use) { uses.push_back(use); } ///< 添加使用关系 void replaceAllUsesWith(Value *value); ///< 将原来使用该value的使用者全变为使用给定参数value并修改相应use关系 - void removeUse(const std::shared_ptr &use) { uses.remove(use); } ///< 删除使用关系use + void removeUse(const std::shared_ptr &use) { + assert(use != nullptr && "Use cannot be null"); + assert(use->getValue() != this && "Use does not belong to this Value"); + auto it = std::find(uses.begin(), uses.end(), use); + assert(it != uses.end() && "Use not found in Value's uses"); + uses.remove(use); + } ///< 删除使用关系use + void removeAllUses(); }; /** @@ -633,21 +641,6 @@ class User : public Value { explicit User(Type *type, const std::string &name = "") : Value(type, name) {} public: - // ~User() override { - // // 当 User 对象被销毁时（例如，LoadInst 或 StoreInst 被删除时）， - // // 它必须通知它所使用的所有 Value，将对应的 Use 关系从它们的 uses 列表中移除。 - // // 这样可以防止 Value 的 uses 列表中出现悬空的 Use 对象。 - // for (const auto &use_ptr : operands) { - // // 确保 use_ptr 非空，并且其内部指向的 Value* 也非空 - // // (虽然通常情况下不会为空，但为了健壮性考虑) - // if (use_ptr && use_ptr->getValue()) { - // use_ptr->getValue()->removeUse(use_ptr); - // } - // } - // // operands 向量本身是 std::vector>， - // // 在此析构函数结束后，operands 向量会被销毁，其内部的 shared_ptr 也会被释放， - // // 如果 shared_ptr 引用计数降为0，Use 对象本身也会被销毁。 - // } unsigned getNumOperands() const { return operands.size(); } ///< 获取操作数数量 auto operand_begin() const { return operands.begin(); } ///< 返回操作数列表的开头迭代器 auto operand_end() const { return operands.end(); } ///< 返回操作数列表的结尾迭代器 @@ -657,11 +650,7 @@ class User : public Value { operands.emplace_back(std::make_shared(operands.size(), this, value)); value->addUse(operands.back()); } ///< 增加操作数 - void removeOperand(unsigned index) { - auto value = getOperand(index); - value->removeUse(operands[index]); - operands.erase(operands.begin() + index); - } ///< 移除操作数 + void removeOperand(unsigned index); template void addOperands(const ContainerT &newoperands) { for (auto value : newoperands) { @@ -919,57 +908,48 @@ class PhiInst : public Instruction { const std::string &name = "") : Instruction(Kind::kPhi, type, parent, name), vsize(rhs.size()) { assert(rhs.size() == Blocks.size() && "PhiInst: rhs and Blocks must have the same size"); - for(size_t i = 0; i < rhs.size(); ++i) { + for(size_t i = 0; i < vsize; ++i) { addOperand(rhs[i]); + addOperand(Blocks[i]); blk2val[Blocks[i]] = rhs[i]; } } public: - Value* getValue(unsigned k) const {return getOperand(2 * k);} ///< 获取位置为k的值 - BasicBlock* getBlock(unsigned k) const {return dynamic_cast(getOperand(2 * k + 1));} - //增加llvm同名方法实现获取value和block - Value* getIncomingValue(unsigned k) const {return getOperand(2 * k);} ///< 获取位置为k的值 - BasicBlock* getIncomingBlock(unsigned k) const {return dynamic_cast(getOperand(2 * k + 1));} - - Value* getIncomingValue(BasicBlock* blk) const { - return getvalfromBlk(blk); - } ///< 获取指定基本块的传入值 - - BasicBlock* getIncomingBlock(Value* val) const { - return getBlkfromVal(val); - } ///< 获取指定值的传入基本块 - - void replaceIncoming(BasicBlock *oldBlock, BasicBlock *newBlock, Value *newValue){ - delBlk(oldBlock); - addIncoming(newValue, newBlock); - } - - auto& getincomings() const {return blk2val;} ///< 获取所有的基本块和对应的值 - - Value* getvalfromBlk(BasicBlock* blk) const ; - BasicBlock* getBlkfromVal(Value* val) const ; - unsigned getNumIncomingValues() const { return vsize; } ///< 获取传入值的数量 + Value *getIncomingValue(unsigned Idx) const { return getOperand(Idx * 2); } ///< 获取指定位置的传入值 + BasicBlock *getIncomingBlock(unsigned Idx) const {return dynamic_cast(getOperand(Idx * 2 + 1)); } ///< 获取指定位置的传入基本块 + + Value* getvalfromBlk(BasicBlock* block); + BasicBlock* getBlkfromVal(Value* value); + void addIncoming(Value *value, BasicBlock *block) { - assert(value && block && "PhiInst: value and block must not be null"); + assert(value && block && "PhiInst: value and block cannot be null"); addOperand(value); addOperand(block); blk2val[block] = value; vsize++; } ///< 添加传入值和对应的基本块 - - void removeIncoming(BasicBlock *block){ - delBlk(block); - } - - void delValue(Value* val); - void delBlk(BasicBlock* blk); - - void replaceBlk(BasicBlock* newBlk, unsigned k); - void replaceold2new(BasicBlock* oldBlk, BasicBlock* newBlk); - void refreshB2VMap(); - + void removeIncoming(unsigned Idx) { + assert(Idx < vsize && "PhiInst: Index out of bounds"); + auto blk = getIncomingBlock(Idx); + removeOperand(Idx * 2); // Remove value + removeOperand(Idx * 2 + 1); // Remove block + blk2val.erase(blk); + vsize--; + } ///< 移除指定位置的传入值和对应的基本块 + void removeIncomingValue(Value *value); + void removeIncomingBlock(BasicBlock *block); + void setIncomingValue(unsigned Idx, Value *value); + void setIncomingBlock(unsigned Idx, BasicBlock *block); + void replaceIncomingValue(Value *oldValue, Value *newValue); + void replaceIncomingBlock(BasicBlock *oldBlock, BasicBlock *newBlock); + void refreshMap() { + blk2val.clear(); + for (unsigned i = 0; i < vsize; ++i) { + blk2val[getIncomingBlock(i)] = getIncomingValue(i); + } + } ///< 刷新块到值的映射关系 auto getValues() { return make_range(std::next(operand_begin()), operand_end()); } }; diff --git a/src/include/midend/Pass/Optimize/SysYIROptUtils.h b/src/include/midend/Pass/Optimize/SysYIROptUtils.h index 1265059..00a4db5 100644 --- a/src/include/midend/Pass/Optimize/SysYIROptUtils.h +++ b/src/include/midend/Pass/Optimize/SysYIROptUtils.h @@ -48,13 +48,6 @@ public: } } } - // 清空 User 的 operands 向量。这会递减 User 持有的 shared_ptr 的引用计数。 - // 当引用计数降为 0 时，Use 对象本身将被销毁。 - // User::operands.clear(); // 这个步骤会在 Instruction 的析构函数中自动完成，因为它是 vector 成员 - // 或者我们可以在 User::removeOperand 方法中确保 Use 对象从 operands 中移除。 - // 实际上，只要 Value::removeUse(use_ptr) 被调用了， - // 当 Instruction 所在的 unique_ptr 销毁时，它的 operands vector 也会被销毁。 - // 所以这里不需要显式 clear() } static void usedelete(Instruction *inst) { assert(inst && "Instruction to delete cannot be null."); @@ -75,7 +68,7 @@ public: // 步骤3: 物理删除指令 // 这会导致 Instruction 对象的 unique_ptr 销毁，从而调用其析构函数链。 parentBlock->removeInst(inst); -} +} static BasicBlock::iterator usedelete(BasicBlock::iterator inst_it) { Instruction *inst_to_delete = inst_it->get(); @@ -92,7 +85,7 @@ public: // 步骤3: 物理删除指令并返回下一个迭代器 return parentBlock->removeInst(inst_it); -} + } // 判断是否是全局变量 static bool isGlobal(Value *val) { diff --git a/src/midend/IR.cpp b/src/midend/IR.cpp index b61a766..636f38f 100644 --- a/src/midend/IR.cpp +++ b/src/midend/IR.cpp @@ -182,377 +182,45 @@ auto Function::getCalleesWithNoExternalAndSelf() -> std::set { } return result; } -// 函数克隆，后续函数级优化（内联等）需要用到 -Function * Function::clone(const std::string &suffix) const { - std::stringstream ss; - std::map oldNewBlockMap; - IRBuilder builder; - auto newFunction = new Function(parent, type, name); - newFunction->getEntryBlock()->setName(blocks.front()->getName()); - oldNewBlockMap.emplace(blocks.front().get(), newFunction->getEntryBlock()); - auto oldBlockListIter = std::next(blocks.begin()); - while (oldBlockListIter != blocks.end()) { - auto newBlock = newFunction->addBasicBlock(oldBlockListIter->get()->getName()); - oldNewBlockMap.emplace(oldBlockListIter->get(), newBlock); - oldBlockListIter++; - } - for (const auto &oldNewBlockItem : oldNewBlockMap) { - auto oldBlock = oldNewBlockItem.first; - auto newBlock = oldNewBlockItem.second; - for (const auto &oldPred : oldBlock->getPredecessors()) { - newBlock->addPredecessor(oldNewBlockMap.at(oldPred)); - } - for (const auto &oldSucc : oldBlock->getSuccessors()) { - newBlock->addSuccessor(oldNewBlockMap.at(oldSucc)); +void Value::removeAllUses() { + while (!uses.empty()) { + auto use = uses.back(); + uses.pop_back(); + if (use && use->getUser()) { + auto user = use->getUser(); + int index = use->getIndex(); + user->removeOperand(index); ///< 从User中移除该操作数 + } else { + // 如果use或user为null，输出警告信息 + assert(use != nullptr && "Use cannot be null"); + assert(use->getUser() != nullptr && "Use's user cannot be null"); } } - - std::map oldNewValueMap; - std::map isAddedToCreate; - std::map isCreated; - std::queue toCreate; - - for (const auto &oldBlock : blocks) { - for (const auto &inst : oldBlock->getInstructions()) { - isAddedToCreate.emplace(inst.get(), false); - isCreated.emplace(inst.get(), false); - } - } - for (const auto &oldBlock : blocks) { - for (const auto &inst : oldBlock->getInstructions()) { - for (const auto &valueUse : inst->getOperands()) { - auto value = valueUse->getValue(); - if (oldNewValueMap.find(value) == oldNewValueMap.end()) { - auto oldAllocInst = dynamic_cast(value); - if (oldAllocInst != nullptr) { - std::vector dims; - // TODO: 这里的dims用type推断 - // for (const auto &dim : oldAllocInst->getDims()) { - // dims.emplace_back(dim->getValue()); - // } - ss << oldAllocInst->getName() << suffix; - auto newAllocInst = - new AllocaInst(oldAllocInst->getType(), oldNewBlockMap.at(oldAllocInst->getParent()), ss.str()); - ss.str(""); - oldNewValueMap.emplace(oldAllocInst, newAllocInst); - if (isAddedToCreate.find(oldAllocInst) == isAddedToCreate.end()) { - isAddedToCreate.emplace(oldAllocInst, true); - } else { - isAddedToCreate.at(oldAllocInst) = true; - } - if (isCreated.find(oldAllocInst) == isCreated.end()) { - isCreated.emplace(oldAllocInst, true); - } else { - isCreated.at(oldAllocInst) = true; - } - } - } - } - if (inst->getKind() == Instruction::kAlloca) { - if (oldNewValueMap.find(inst.get()) == oldNewValueMap.end()) { - auto oldAllocInst = dynamic_cast(inst.get()); - std::vector dims; - // TODO: 这里的dims用type推断 - // for (const auto &dim : oldAllocInst->getDims()) { - // dims.emplace_back(dim->getValue()); - // } - ss << oldAllocInst->getName() << suffix; - auto newAllocInst = - new AllocaInst(oldAllocInst->getType(), oldNewBlockMap.at(oldAllocInst->getParent()), ss.str()); - ss.str(""); - oldNewValueMap.emplace(oldAllocInst, newAllocInst); - if (isAddedToCreate.find(oldAllocInst) == isAddedToCreate.end()) { - isAddedToCreate.emplace(oldAllocInst, true); - } else { - isAddedToCreate.at(oldAllocInst) = true; - } - if (isCreated.find(oldAllocInst) == isCreated.end()) { - isCreated.emplace(oldAllocInst, true); - } else { - isCreated.at(oldAllocInst) = true; - } - } - } - } - } - for (const auto &oldBlock : blocks) { - for (const auto &inst : oldBlock->getInstructions()) { - for (const auto &valueUse : inst->getOperands()) { - auto value = valueUse->getValue(); - if (oldNewValueMap.find(value) == oldNewValueMap.end()) { - auto globalValue = dynamic_cast(value); - auto constVariable = dynamic_cast(value); - auto constantValue = dynamic_cast(value); - auto functionValue = dynamic_cast(value); - if (globalValue != nullptr || constantValue != nullptr || constVariable != nullptr || - functionValue != nullptr) { - if (functionValue == this) { - oldNewValueMap.emplace(value, newFunction); - } else { - oldNewValueMap.emplace(value, value); - } - isCreated.emplace(value, true); - isAddedToCreate.emplace(value, true); - } - } - } - } - } - for (const auto &oldBlock : blocks) { - for (const auto &inst : oldBlock->getInstructions()) { - if (inst->getKind() != Instruction::kAlloca) { - bool isReady = true; - for (const auto &use : inst->getOperands()) { - auto value = use->getValue(); - if (dynamic_cast(value) == nullptr && !isCreated.at(value)) { - isReady = false; - break; - } - } - if (isReady) { - toCreate.push(inst.get()); - isAddedToCreate.at(inst.get()) = true; - } - } - } - } - - while (!toCreate.empty()) { - auto inst = dynamic_cast(toCreate.front()); - toCreate.pop(); - - bool isReady = true; - for (const auto &valueUse : inst->getOperands()) { - auto value = dynamic_cast(valueUse->getValue()); - if (value != nullptr && !isCreated.at(value)) { - isReady = false; - break; - } - } - - if (!isReady) { - toCreate.push(inst); - continue; - } - isCreated.at(inst) = true; - switch (inst->getKind()) { - case Instruction::kAdd: - case Instruction::kSub: - case Instruction::kMul: - case Instruction::kDiv: - case Instruction::kRem: - case Instruction::kICmpEQ: - case Instruction::kICmpNE: - case Instruction::kICmpLT: - case Instruction::kICmpGT: - case Instruction::kICmpLE: - case Instruction::kICmpGE: - case Instruction::kAnd: - case Instruction::kOr: - case Instruction::kFAdd: - case Instruction::kFSub: - case Instruction::kFMul: - case Instruction::kFDiv: - case Instruction::kFCmpEQ: - case Instruction::kFCmpNE: - case Instruction::kFCmpLT: - case Instruction::kFCmpGT: - case Instruction::kFCmpLE: - case Instruction::kFCmpGE: { - auto oldBinaryInst = dynamic_cast(inst); - auto lhs = oldBinaryInst->getLhs(); - auto rhs = oldBinaryInst->getRhs(); - Value *newLhs; - Value *newRhs; - newLhs = oldNewValueMap[lhs]; - newRhs = oldNewValueMap[rhs]; - ss << oldBinaryInst->getName() << suffix; - auto newBinaryInst = new BinaryInst(oldBinaryInst->getKind(), oldBinaryInst->getType(), newLhs, newRhs, - oldNewBlockMap.at(oldBinaryInst->getParent()), ss.str()); - ss.str(""); - oldNewValueMap.emplace(oldBinaryInst, newBinaryInst); - break; - } - - case Instruction::kNeg: - case Instruction::kNot: - case Instruction::kFNeg: - case Instruction::kFNot: - case Instruction::kItoF: - case Instruction::kFtoI: { - auto oldUnaryInst = dynamic_cast(inst); - auto hs = oldUnaryInst->getOperand(); - Value *newHs; - newHs = oldNewValueMap.at(hs); - ss << oldUnaryInst->getName() << suffix; - auto newUnaryInst = new UnaryInst(oldUnaryInst->getKind(), oldUnaryInst->getType(), newHs, - oldNewBlockMap.at(oldUnaryInst->getParent()), ss.str()); - ss.str(""); - oldNewValueMap.emplace(oldUnaryInst, newUnaryInst); - break; - } - - case Instruction::kCall: { - auto oldCallInst = dynamic_cast(inst); - std::vector newArgumnts; - for (const auto &arg : oldCallInst->getArguments()) { - newArgumnts.emplace_back(oldNewValueMap.at(arg->getValue())); - } - - ss << oldCallInst->getName() << suffix; - CallInst *newCallInst; - newCallInst = - new CallInst(oldCallInst->getCallee(), newArgumnts, oldNewBlockMap.at(oldCallInst->getParent()), ss.str()); - ss.str(""); - // if (oldCallInst->getCallee() != this) { - // newCallInst = new CallInst(oldCallInst->getCallee(), newArgumnts, - // oldNewBlockMap.at(oldCallInst->getParent()), - // oldCallInst->getName()); - // } else { - // newCallInst = new CallInst(newFunction, newArgumnts, oldNewBlockMap.at(oldCallInst->getParent()), - // oldCallInst->getName()); - // } - - oldNewValueMap.emplace(oldCallInst, newCallInst); - break; - } - - case Instruction::kCondBr: { - auto oldCondBrInst = dynamic_cast(inst); - auto oldCond = oldCondBrInst->getCondition(); - Value *newCond; - newCond = oldNewValueMap.at(oldCond); - auto newCondBrInst = new CondBrInst(newCond, oldNewBlockMap.at(oldCondBrInst->getThenBlock()), - oldNewBlockMap.at(oldCondBrInst->getElseBlock()), - oldNewBlockMap.at(oldCondBrInst->getParent())); - oldNewValueMap.emplace(oldCondBrInst, newCondBrInst); - break; - } - - case Instruction::kBr: { - auto oldBrInst = dynamic_cast(inst); - auto newBrInst = - new UncondBrInst(oldNewBlockMap.at(oldBrInst->getBlock()), oldNewBlockMap.at(oldBrInst->getParent())); - oldNewValueMap.emplace(oldBrInst, newBrInst); - break; - } - - case Instruction::kReturn: { - auto oldReturnInst = dynamic_cast(inst); - auto oldRval = oldReturnInst->getReturnValue(); - Value *newRval = nullptr; - if (oldRval != nullptr) { - newRval = oldNewValueMap.at(oldRval); - } - auto newReturnInst = - new ReturnInst(newRval, oldNewBlockMap.at(oldReturnInst->getParent()), oldReturnInst->getName()); - oldNewValueMap.emplace(oldReturnInst, newReturnInst); - break; - } - - case Instruction::kAlloca: { - assert(false); - } - - case Instruction::kLoad: { - auto oldLoadInst = dynamic_cast(inst); - auto oldPointer = oldLoadInst->getPointer(); - Value *newPointer; - newPointer = oldNewValueMap.at(oldPointer); - - std::vector newIndices; - // for (const auto &index : oldLoadInst->getIndices()) { - // newIndices.emplace_back(oldNewValueMap.at(index->getValue())); - // } - ss << oldLoadInst->getName() << suffix; - // TODO : 这里的newLoadInst的类型需要根据oldLoadInst的类型来推断 - auto newLoadInst = new LoadInst(newPointer, oldNewBlockMap.at(oldLoadInst->getParent()), ss.str()); - ss.str(""); - oldNewValueMap.emplace(oldLoadInst, newLoadInst); - break; - } - - case Instruction::kStore: { - auto oldStoreInst = dynamic_cast(inst); - auto oldPointer = oldStoreInst->getPointer(); - auto oldValue = oldStoreInst->getValue(); - Value *newPointer; - Value *newValue; - std::vector newIndices; - newPointer = oldNewValueMap.at(oldPointer); - newValue = oldNewValueMap.at(oldValue); - // TODO: 这里的newIndices需要根据oldStoreInst的类型来推断 - // for (const auto &index : oldStoreInst->getIndices()) { - // newIndices.emplace_back(oldNewValueMap.at(index->getValue())); - // } - auto newStoreInst = new StoreInst(newValue, newPointer, - oldNewBlockMap.at(oldStoreInst->getParent()), oldStoreInst->getName()); - oldNewValueMap.emplace(oldStoreInst, newStoreInst); - break; - } - - // TODO：复制GEP指令 - - case Instruction::kMemset: { - auto oldMemsetInst = dynamic_cast(inst); - auto oldPointer = oldMemsetInst->getPointer(); - auto oldValue = oldMemsetInst->getValue(); - Value *newPointer; - Value *newValue; - newPointer = oldNewValueMap.at(oldPointer); - newValue = oldNewValueMap.at(oldValue); - - auto newMemsetInst = new MemsetInst(newPointer, oldMemsetInst->getBegin(), oldMemsetInst->getSize(), newValue, - oldNewBlockMap.at(oldMemsetInst->getParent()), oldMemsetInst->getName()); - oldNewValueMap.emplace(oldMemsetInst, newMemsetInst); - break; - } - - case Instruction::kInvalid: - case Instruction::kPhi: { - break; - } - - default: - assert(false); - } - for (const auto &userUse : inst->getUses()) { - auto user = userUse->getUser(); - if (!isAddedToCreate.at(user)) { - toCreate.push(user); - isAddedToCreate.at(user) = true; - } - } - } - - for (const auto &oldBlock : blocks) { - auto newBlock = oldNewBlockMap.at(oldBlock.get()); - builder.setPosition(newBlock, newBlock->end()); - for (const auto &inst : oldBlock->getInstructions()) { - builder.insertInst(dynamic_cast(oldNewValueMap.at(inst.get()))); - } - } - - // for (const auto ¶m : blocks.front()->getArguments()) { - // newFunction->getEntryBlock()->insertArgument(dynamic_cast(oldNewValueMap.at(param))); - // } - for (const auto &arg : arguments) { - auto newArg = dynamic_cast(oldNewValueMap.at(arg)); - if (newArg != nullptr) { - newFunction->insertArgument(newArg); - } - } - - return newFunction; + uses.clear(); } + /** * 设置操作数 */ -void User::setOperand(unsigned index, Value *value) { - assert(index < getNumOperands()); - operands[index]->setValue(value); - value->addUse(operands[index]); +void User::setOperand(unsigned index, Value *newvalue) { + if (index >= operands.size()) { + std::cerr << "index=" << index << ", but mOperands max size=" << operands.size() << std::endl; + assert(index < operands.size()); + } + std::shared_ptr olduse = operands[index]; + Value *oldValue = olduse->getValue(); + if (oldValue != newvalue) { + // 如果新值和旧值不同，先移除旧值的使用关系 + oldValue->removeUse(olduse); + // 设置新的操作数 + operands[index] = std::make_shared(index, this, newvalue); + newvalue->addUse(operands[index]); + } + else { + // 如果新值和旧值相同，直接更新use的索引 + operands[index]->setValue(newvalue); + } } /** * 替换操作数 @@ -565,29 +233,50 @@ void User::replaceOperand(unsigned index, Value *value) { value->addUse(use); } +/** + * 移除操作数 + */ +void User::removeOperand(unsigned index) { + assert(index < getNumOperands() && "Index out of range in removeOperand"); + std::shared_ptr useToRemove = operands.at(index); + Value *valueToRemove = useToRemove->getValue(); + if(valueToRemove) { + if(valueToRemove == this) { + std::cerr << "Cannot remove operand that is the same as the User itself." << std::endl; + } + valueToRemove->removeUse(useToRemove); + } + operands.erase(operands.begin() + index); + unsigned newIndex = 0; + for(auto it = operands.begin(); it != operands.end(); ++it, ++newIndex) { + (*it)->setIndex(newIndex); // 更新剩余操作数的索引 + } +} + + /** * phi相关函数 */ -Value* PhiInst::getvalfromBlk(BasicBlock* blk) const { - // refreshB2VMap(); +Value* PhiInst::getvalfromBlk(BasicBlock* blk) { + refreshMap(); if( blk2val.find(blk) != blk2val.end()) { return blk2val.at(blk); } return nullptr; } -BasicBlock* PhiInst::getBlkfromVal(Value* val) const { +BasicBlock* PhiInst::getBlkfromVal(Value* val) { // 返回第一个值对应的基本块 for(unsigned i = 0; i < vsize; i++) { - if(getValue(i) == val) { - return getBlock(i); + if(getIncomingValue(i) == val) { + return getIncomingBlock(i); } } return nullptr; } -void PhiInst::delValue(Value* val){ +void PhiInst::removeIncomingValue(Value* val){ //根据value删除对应的基本块和值 unsigned i = 0; BasicBlock* blk = getBlkfromVal(val); @@ -595,17 +284,14 @@ void PhiInst::delValue(Value* val){ return; // 如果val没有对应的基本块，直接返回 } for(i = 0; i < vsize; i++) { - if(getValue(i) == val) { + if(getIncomingValue(i) == val) { break; } } - removeOperand(2 * i + 1); // 删除blk - removeOperand(2 * i); // 删除val - vsize--; - blk2val.erase(blk); // 删除blk2val映射 + removeIncoming(i); } -void PhiInst::delBlk(BasicBlock* blk){ +void PhiInst::removeIncomingBlock(BasicBlock* blk){ //根据Blk删除对应的基本块和值 unsigned i = 0; Value* val = getvalfromBlk(blk); @@ -613,45 +299,48 @@ void PhiInst::delBlk(BasicBlock* blk){ return; // 如果blk没有对应的值，直接返回 } for(i = 0; i < vsize; i++) { - if(getBlock(i) == blk) { + if(getIncomingBlock(i) == blk) { break; } } - removeOperand(2 * i + 1); // 删除blk - removeOperand(2 * i); // 删除val - vsize--; - blk2val.erase(blk); // 删除blk2val映射 + removeIncoming(i); } -void PhiInst::replaceBlk(BasicBlock* newBlk, unsigned k){ - // refreshB2VMap(); - BasicBlock* oldBlk = getBlock(k); - Value* val = blk2val.at(oldBlk); - if(newBlk == oldBlk || oldBlk == nullptr) { - return; // 如果新旧基本块相同，直接返回 - } - // Value* val = blk2val.at(getBlock(k)); - // 替换基本块 - setOperand(2 * k + 1, newBlk); - // 替换blk2val映射 - blk2val.erase(oldBlk); - blk2val.emplace(newBlk, val); +void PhiInst::setIncomingValue(unsigned k, Value* val) { + assert(k < vsize && "PhiInst: index out of range"); + assert(val != nullptr && "PhiInst: value cannot be null"); + refreshMap(); + blk2val.erase(getIncomingBlock(k)); + setOperand(2 * k, val); + blk2val[getIncomingBlock(k)] = val; } -void PhiInst::replaceold2new(BasicBlock* oldBlk, BasicBlock* newBlk){ - // refreshB2VMap(); - Value* val = blk2val.at(oldBlk); - // 替换基本块 - delBlk(oldBlk); +void PhiInst::setIncomingBlock(unsigned k, BasicBlock* blk) { + assert(k < vsize && "PhiInst: index out of range"); + assert(blk != nullptr && "PhiInst: block cannot be null"); + refreshMap(); + auto oldVal = getIncomingValue(k); + blk2val.erase(getIncomingBlock(k)); + setOperand(2 * k + 1, blk); + blk2val[blk] = oldVal; +} + +void PhiInst::replaceIncomingValue(Value* newVal, Value* oldVal) { + refreshMap(); + assert(blk2val.find(getBlkfromVal(oldVal)) != blk2val.end() && "PhiInst: oldVal not found in blk2val"); + auto blk = getBlkfromVal(oldVal); + removeIncomingValue(oldVal); + addIncoming(newVal, blk); +} + +void PhiInst::replaceIncomingBlock(BasicBlock* newBlk, BasicBlock* oldBlk) { + refreshMap(); + assert(blk2val.find(oldBlk) != blk2val.end() && "PhiInst: oldBlk not found in blk2val"); + auto val = blk2val[oldBlk]; + removeIncomingBlock(oldBlk); addIncoming(val, newBlk); } -void PhiInst::refreshB2VMap(){ - blk2val.clear(); - for(unsigned i = 0; i < vsize; i++) { - blk2val.emplace(getBlock(i), getValue(i)); - } -} CallInst::CallInst(Function *callee, const std::vector &args, BasicBlock *parent, const std::string &name) : Instruction(kCall, callee->getReturnType(), parent, name) { From 446a6a6fcbb61fcd02d50ef05484129618ccadc6 Mon Sep 17 00:00:00 2001 From: rain2133 <1370973498@qq.com> Date: Sun, 3 Aug 2025 22:18:00 +0800 Subject: [PATCH 24/55] =?UTF-8?q?[midend]=E4=BF=AE=E5=A4=8Dphi=E6=8C=87?= =?UTF-8?q?=E4=BB=A4=E6=8E=A5=E5=8F=A3=EF=BC=8C=E4=BC=98=E5=8C=96=E9=81=8D?= =?UTF-8?q?=E9=80=82=E9=85=8D?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/include/midend/IR.h | 10 ++++++-- src/midend/IR.cpp | 19 +++++++++++++-- src/midend/Pass/Optimize/Reg2Mem.cpp | 4 ++-- src/midend/Pass/Optimize/SCCP.cpp | 2 +- src/midend/Pass/Optimize/SysYIRCFGOpt.cpp | 29 +++++++++++++---------- src/midend/SysYIRPrinter.cpp | 4 ++-- 6 files changed, 46 insertions(+), 22 deletions(-) diff --git a/src/include/midend/IR.h b/src/include/midend/IR.h index 2920ccd..5658d9d 100644 --- a/src/include/midend/IR.h +++ b/src/include/midend/IR.h @@ -920,7 +920,7 @@ class PhiInst : public Instruction { Value *getIncomingValue(unsigned Idx) const { return getOperand(Idx * 2); } ///< 获取指定位置的传入值 BasicBlock *getIncomingBlock(unsigned Idx) const {return dynamic_cast(getOperand(Idx * 2 + 1)); } ///< 获取指定位置的传入基本块 - Value* getvalfromBlk(BasicBlock* block); + Value* getValfromBlk(BasicBlock* block); BasicBlock* getBlkfromVal(Value* value); void addIncoming(Value *value, BasicBlock *block) { @@ -933,17 +933,23 @@ class PhiInst : public Instruction { void removeIncoming(unsigned Idx) { assert(Idx < vsize && "PhiInst: Index out of bounds"); auto blk = getIncomingBlock(Idx); - removeOperand(Idx * 2); // Remove value removeOperand(Idx * 2 + 1); // Remove block + removeOperand(Idx * 2); // Remove value blk2val.erase(blk); vsize--; } ///< 移除指定位置的传入值和对应的基本块 + // 移除指定的传入值或基本块 void removeIncomingValue(Value *value); void removeIncomingBlock(BasicBlock *block); + // 设置指定位置的传入值或基本块 void setIncomingValue(unsigned Idx, Value *value); void setIncomingBlock(unsigned Idx, BasicBlock *block); + // 替换指定位置的传入值或基本块（原理是删除再添加）保留旧块或者旧值 void replaceIncomingValue(Value *oldValue, Value *newValue); void replaceIncomingBlock(BasicBlock *oldBlock, BasicBlock *newBlock); + // 替换指定位置的传入值或基本块（原理是删除再添加） + void replaceIncomingValue(Value *oldValue, Value *newValue, BasicBlock *newBlock); + void replaceIncomingBlock(BasicBlock *oldBlock, BasicBlock *newBlock, Value *newValue); void refreshMap() { blk2val.clear(); for (unsigned i = 0; i < vsize; ++i) { diff --git a/src/midend/IR.cpp b/src/midend/IR.cpp index 636f38f..10b133f 100644 --- a/src/midend/IR.cpp +++ b/src/midend/IR.cpp @@ -258,7 +258,7 @@ void User::removeOperand(unsigned index) { * phi相关函数 */ -Value* PhiInst::getvalfromBlk(BasicBlock* blk) { +Value* PhiInst::getValfromBlk(BasicBlock* blk) { refreshMap(); if( blk2val.find(blk) != blk2val.end()) { return blk2val.at(blk); @@ -294,7 +294,7 @@ void PhiInst::removeIncomingValue(Value* val){ void PhiInst::removeIncomingBlock(BasicBlock* blk){ //根据Blk删除对应的基本块和值 unsigned i = 0; - Value* val = getvalfromBlk(blk); + Value* val = getValfromBlk(blk); if(val == nullptr) { return; // 如果blk没有对应的值，直接返回 } @@ -341,6 +341,21 @@ void PhiInst::replaceIncomingBlock(BasicBlock* newBlk, BasicBlock* oldBlk) { addIncoming(val, newBlk); } +void PhiInst::replaceIncomingValue(Value *oldValue, Value *newValue, BasicBlock *newBlock) { + refreshMap(); + assert(blk2val.find(getBlkfromVal(oldValue)) != blk2val.end() && "PhiInst: oldValue not found in blk2val"); + auto oldBlock = getBlkfromVal(oldValue); + removeIncomingValue(oldValue); + addIncoming(newValue, newBlock); +} + +void PhiInst::replaceIncomingBlock(BasicBlock *oldBlock, BasicBlock *newBlock, Value *newValue) { + refreshMap(); + assert(blk2val.find(oldBlock) != blk2val.end() && "PhiInst: oldBlock not found in blk2val"); + auto oldValue = blk2val[oldBlock]; + removeIncomingBlock(oldBlock); + addIncoming(newValue, newBlock); +} CallInst::CallInst(Function *callee, const std::vector &args, BasicBlock *parent, const std::string &name) : Instruction(kCall, callee->getReturnType(), parent, name) { diff --git a/src/midend/Pass/Optimize/Reg2Mem.cpp b/src/midend/Pass/Optimize/Reg2Mem.cpp index 199153b..cd52f51 100644 --- a/src/midend/Pass/Optimize/Reg2Mem.cpp +++ b/src/midend/Pass/Optimize/Reg2Mem.cpp @@ -148,8 +148,8 @@ void Reg2MemContext::rewritePhis(Function *func) { // 1. 为 Phi 指令的每个入边，在前驱块的末尾插入 Store 指令 // PhiInst 假设有 getIncomingValues() 和 getIncomingBlocks() for (unsigned i = 0; i < phiInst->getNumIncomingValues(); ++i) { // 假设 PhiInst 是通过操作数来管理入边的 - Value *incomingValue = phiInst->getValue(i); // 获取入值 - BasicBlock *incomingBlock = phiInst->getBlock(i); // 获取对应的入块 + Value *incomingValue = phiInst->getIncomingValue(i); // 获取入值 + BasicBlock *incomingBlock = phiInst->getIncomingBlock(i); // 获取对应的入块 // 在入块的跳转指令之前插入 StoreInst // 需要找到 incomingBlock 的终结指令 (Terminator Instruction) diff --git a/src/midend/Pass/Optimize/SCCP.cpp b/src/midend/Pass/Optimize/SCCP.cpp index 33d716f..e83bc31 100644 --- a/src/midend/Pass/Optimize/SCCP.cpp +++ b/src/midend/Pass/Optimize/SCCP.cpp @@ -845,7 +845,7 @@ void SCCPContext::RemovePhiIncoming(BasicBlock *phiParentBB, BasicBlock *removed for (Instruction *inst : insts_to_check) { if (auto phi = dynamic_cast(inst)) { - phi->delBlk(removedPred); + phi->removeIncomingBlock(removedPred); } } } diff --git a/src/midend/Pass/Optimize/SysYIRCFGOpt.cpp b/src/midend/Pass/Optimize/SysYIRCFGOpt.cpp index a4c584b..5e75645 100644 --- a/src/midend/Pass/Optimize/SysYIRCFGOpt.cpp +++ b/src/midend/Pass/Optimize/SysYIRCFGOpt.cpp @@ -189,7 +189,7 @@ bool SysYCFGOptUtils::SysYDelNoPreBLock(Function *func) { break; } // 将这个 Phi 节点中来自不可达前驱（unreachableBlock）的输入参数删除 - dynamic_cast(phiInstPtr.get())->delBlk(unreachableBlock); + dynamic_cast(phiInstPtr.get())->removeIncomingBlock(unreachableBlock); } } } @@ -311,7 +311,7 @@ bool SysYCFGOptUtils::SysYDelEmptyBlock(Function *func, IRBuilder *pBuilder) { // 找到在空块链中导致 currentDefBlock 的那个前驱块 if (emptyBlockRedirectMap.count(incomingBlock) || incomingBlock == currentBlock) { // 递归追溯该传入值 - return getUltimateSourceValue(phi->getIncomingValue(incomingBlock), incomingBlock); + return getUltimateSourceValue(phi->getValfromBlk(incomingBlock), incomingBlock); } } } @@ -354,7 +354,7 @@ bool SysYCFGOptUtils::SysYDelEmptyBlock(Function *func, IRBuilder *pBuilder) { if (actualEmptyPredecessorOfS) { // 获取 Phi 节点原本从 actualEmptyPredecessorOfS 接收的值 - Value *valueFromEmptyPredecessor = phiInst->getIncomingValue(actualEmptyPredecessorOfS); + Value *valueFromEmptyPredecessor = phiInst->getValfromBlk(actualEmptyPredecessorOfS); // 追溯这个值，找到它在非空块中的最终来源 // currentBlock 是 P @@ -364,12 +364,13 @@ bool SysYCFGOptUtils::SysYDelEmptyBlock(Function *func, IRBuilder *pBuilder) { // 替换 Phi 节点的传入块和传入值 if (ultimateSourceValue) { // 确保成功追溯到有效来源 - phiInst->replaceIncoming(actualEmptyPredecessorOfS, currentBlock, ultimateSourceValue); + // phiInst->replaceIncoming(actualEmptyPredecessorOfS, currentBlock, ultimateSourceValue); + phiInst->replaceIncomingBlock(actualEmptyPredecessorOfS, currentBlock, ultimateSourceValue); } else { assert(false && "[DelEmptyBlock] Unable to trace a valid source for Phi instruction"); // 无法追溯到有效来源，这可能是个错误或特殊情况 // 此时可能需要移除该 Phi 项，或者插入一个 undef 值 - phiInst->removeIncoming(actualEmptyPredecessorOfS); + phiInst->getValfromBlk(actualEmptyPredecessorOfS); } } } else { @@ -421,7 +422,7 @@ bool SysYCFGOptUtils::SysYDelEmptyBlock(Function *func, IRBuilder *pBuilder) { if (actualEmptyPredecessorOfS) { // 获取 Phi 节点原本从 actualEmptyPredecessorOfS 接收的值 - Value *valueFromEmptyPredecessor = phiInst->getIncomingValue(actualEmptyPredecessorOfS); + Value *valueFromEmptyPredecessor = phiInst->getValfromBlk(actualEmptyPredecessorOfS); // 追溯这个值，找到它在非空块中的最终来源 // currentBlock 是 P @@ -431,12 +432,13 @@ bool SysYCFGOptUtils::SysYDelEmptyBlock(Function *func, IRBuilder *pBuilder) { // 替换 Phi 节点的传入块和传入值 if (ultimateSourceValue) { // 确保成功追溯到有效来源 - phiInst->replaceIncoming(actualEmptyPredecessorOfS, currentBlock, ultimateSourceValue); + // phiInst->replaceIncoming(actualEmptyPredecessorOfS, currentBlock, ultimateSourceValue); + phiInst->replaceIncomingBlock(actualEmptyPredecessorOfS, currentBlock, ultimateSourceValue); } else { assert(false && "[DelEmptyBlock] Unable to trace a valid source for Phi instruction"); // 无法追溯到有效来源，这可能是个错误或特殊情况 // 此时可能需要移除该 Phi 项，或者插入一个 undef 值 - phiInst->removeIncoming(actualEmptyPredecessorOfS); + phiInst->removeIncomingBlock(actualEmptyPredecessorOfS); } } } else { @@ -481,7 +483,7 @@ bool SysYCFGOptUtils::SysYDelEmptyBlock(Function *func, IRBuilder *pBuilder) { if (actualEmptyPredecessorOfS) { // 获取 Phi 节点原本从 actualEmptyPredecessorOfS 接收的值 - Value *valueFromEmptyPredecessor = phiInst->getIncomingValue(actualEmptyPredecessorOfS); + Value *valueFromEmptyPredecessor = phiInst->getValfromBlk(actualEmptyPredecessorOfS); // 追溯这个值，找到它在非空块中的最终来源 // currentBlock 是 P @@ -491,12 +493,13 @@ bool SysYCFGOptUtils::SysYDelEmptyBlock(Function *func, IRBuilder *pBuilder) { // 替换 Phi 节点的传入块和传入值 if (ultimateSourceValue) { // 确保成功追溯到有效来源 - phiInst->replaceIncoming(actualEmptyPredecessorOfS, currentBlock, ultimateSourceValue); + // phiInst->replaceIncoming(actualEmptyPredecessorOfS, currentBlock, ultimateSourceValue); + phiInst->replaceIncomingBlock(actualEmptyPredecessorOfS, currentBlock, ultimateSourceValue); } else { assert(false && "[DelEmptyBlock] Unable to trace a valid source for Phi instruction"); // 无法追溯到有效来源，这可能是个错误或特殊情况 // 此时可能需要移除该 Phi 项，或者插入一个 undef 值 - phiInst->removeIncoming(actualEmptyPredecessorOfS); + phiInst->removeIncomingBlock(actualEmptyPredecessorOfS); } } } else { @@ -647,7 +650,7 @@ bool SysYCFGOptUtils::SysYCondBr2Br(Function *func, IRBuilder *pBuilder) { break; } // 使用 delBlk 方法删除 basicblock.get() 对应的传入值 - dynamic_cast(phiinst.get())->removeIncoming(basicblock.get()); + dynamic_cast(phiinst.get())->removeIncomingBlock(basicblock.get()); } } else { // cond为false或0 @@ -665,7 +668,7 @@ bool SysYCFGOptUtils::SysYCondBr2Br(Function *func, IRBuilder *pBuilder) { break; } // 使用 delBlk 方法删除 basicblock.get() 对应的传入值 - dynamic_cast(phiinst.get())->removeIncoming(basicblock.get()); + dynamic_cast(phiinst.get())->removeIncomingBlock(basicblock.get()); } } } diff --git a/src/midend/SysYIRPrinter.cpp b/src/midend/SysYIRPrinter.cpp index 9a0f427..3706ff4 100644 --- a/src/midend/SysYIRPrinter.cpp +++ b/src/midend/SysYIRPrinter.cpp @@ -512,9 +512,9 @@ void SysYPrinter::printInst(Instruction *pInst) { if (!firstPair) std::cout << ", "; firstPair = false; std::cout << "[ "; - printValue(phiInst->getValue(i)); + printValue(phiInst->getIncomingValue(i)); std::cout << ", %"; - printBlock(phiInst->getBlock(i)); + printBlock(phiInst->getIncomingBlock(i)); std::cout << " ]"; } std::cout << std::endl; From c8a8bf9a37140f12faa3e9b8ddd6162f4bb2db34 Mon Sep 17 00:00:00 2001 From: Lixuanwang Date: Sun, 3 Aug 2025 23:28:38 +0800 Subject: [PATCH 25/55] =?UTF-8?q?[backend]=E4=BF=AE=E5=A4=8D=E4=BA=86?= =?UTF-8?q?=E6=BA=A2=E5=87=BA=E4=BD=8D=E7=BD=AE=E9=94=99=E8=AF=AF=E7=9A=84?= =?UTF-8?q?=E9=97=AE=E9=A2=98?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/backend/RISCv64/RISCv64RegAlloc.cpp | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/src/backend/RISCv64/RISCv64RegAlloc.cpp b/src/backend/RISCv64/RISCv64RegAlloc.cpp index 87f276f..195ef6c 100644 --- a/src/backend/RISCv64/RISCv64RegAlloc.cpp +++ b/src/backend/RISCv64/RISCv64RegAlloc.cpp @@ -656,7 +656,7 @@ void RISCv64RegAlloc::rewriteProgram() { StackFrameInfo& frame_info = MFunc->getFrameInfo(); // 使用 EFI Pass 确定的 locals_end_offset 作为溢出分配的基准。 // locals_end_offset 本身是负数，代表局部变量区域的下边界地址。 - int spill_current_offset = frame_info.locals_end_offset; + int spill_current_offset = frame_info.locals_end_offset - frame_info.spill_size; // 保存溢出区域的起始点，用于最后计算总的 spill_size const int spill_start_offset = frame_info.locals_end_offset; @@ -787,6 +787,11 @@ void RISCv64RegAlloc::rewriteProgram() { std::make_unique(frame_info.spill_offsets.at(old_vreg)) )); new_instructions.push_back(std::move(store)); + if (DEEPERDEBUG) { + std::cerr << "[Spill] Inserted spill store for %vreg" << old_vreg + << " at offset " << frame_info.spill_offsets.at(old_vreg) + << " with new temp vreg " << regIdToString(new_temp_vreg) << ".\n"; + } } } mbb->getInstructions() = std::move(new_instructions); From f24cc7ec88431dcf4d1252e185d87d7e73fa1bde Mon Sep 17 00:00:00 2001 From: rain2133 <1370973498@qq.com> Date: Mon, 4 Aug 2025 00:59:39 +0800 Subject: [PATCH 26/55] =?UTF-8?q?[midend]=E4=BF=AE=E5=A4=8DreplaceAllUsesW?= =?UTF-8?q?ith=E4=B8=AD=E7=94=B1=E4=BA=8EsetOperand=20=E9=97=B4=E6=8E=A5?= =?UTF-8?q?=E8=B0=83=E7=94=A8=20removeUse=20=E6=88=96=20addUse=E5=AF=BC?= =?UTF-8?q?=E8=87=B4=E7=9A=84=E8=BF=AD=E4=BB=A3=E5=99=A8=E5=A4=B1=E6=95=88?= =?UTF-8?q?=E9=97=AE=E9=A2=98?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/include/midend/IR.h | 2 +- src/midend/IR.cpp | 42 ++++++++++++++++++++++++++++++++++++----- 2 files changed, 38 insertions(+), 6 deletions(-) diff --git a/src/include/midend/IR.h b/src/include/midend/IR.h index 5658d9d..ff30db7 100644 --- a/src/include/midend/IR.h +++ b/src/include/midend/IR.h @@ -232,7 +232,7 @@ class Value { void replaceAllUsesWith(Value *value); ///< 将原来使用该value的使用者全变为使用给定参数value并修改相应use关系 void removeUse(const std::shared_ptr &use) { assert(use != nullptr && "Use cannot be null"); - assert(use->getValue() != this && "Use does not belong to this Value"); + assert(use->getValue() == this && "Use being removed does NOT point to this Value!"); auto it = std::find(uses.begin(), uses.end(), use); assert(it != uses.end() && "Use not found in Value's uses"); uses.remove(use); diff --git a/src/midend/IR.cpp b/src/midend/IR.cpp index 10b133f..ae676f0 100644 --- a/src/midend/IR.cpp +++ b/src/midend/IR.cpp @@ -118,13 +118,45 @@ ArrayType *ArrayType::get(Type *elementType, unsigned numElements) { return result.first->get(); } +// void Value::replaceAllUsesWith(Value *value) { +// for (auto &use : uses) { +// auto user = use->getUser(); +// assert(user && "Use's user cannot be null"); +// user->setOperand(use->getIndex(), value); +// } +// uses.clear(); +// } void Value::replaceAllUsesWith(Value *value) { - for (auto &use : uses) { - use->getUser()->setOperand(use->getIndex(), value); - } - uses.clear(); -} + // 1. 创建 uses 列表的副本进行迭代。 + // 这样做是为了避免在迭代过程中，由于 setOperand 间接调用 removeUse 或 addUse + // 导致原列表被修改，从而引发迭代器失效问题。 + std::list> uses_copy = uses; + for (auto &use_ptr : uses_copy) { // 遍历副本 + // 2. 检查 shared_ptr 本身是否为空。这是最常见的崩溃原因之一。 + if (use_ptr == nullptr) { + std::cerr << "Warning: Encountered a null std::shared_ptr in Value::uses list. Skipping this entry." << std::endl; + // 在一个健康的 IR 中，这种情况不应该发生。如果经常出现，说明你的 Use 创建或管理有问题。 + continue; // 跳过空的智能指针 + } + + // 3. 检查 Use 对象内部的 User* 是否为空。 + User* user_val = use_ptr->getUser(); + if (user_val == nullptr) { + std::cerr << "Warning: Use object (" << use_ptr.get() << ") has a null User* in replaceAllUsesWith. Skipping this entry. This indicates IR corruption." << std::endl; + // 同样，在一个健康的 IR 中，Use 对象的 User* 不应该为空。 + continue; // 跳过用户指针为空的 Use 对象 + } + + // 如果走到这里，use_ptr 和 user_val 都是有效的，可以安全调用 setOperand + user_val->setOperand(use_ptr->getIndex(), value); + } + + // 4. 处理完所有 use 之后，清空原始的 uses 列表。 + // replaceAllUsesWith 的目的就是将所有使用关系从当前 Value 转移走， + // 所以最后清空列表是正确的。 + uses.clear(); +} // Implementations for static members From 6550c8a25b352a08dcfd8dac2614209d05f8359e Mon Sep 17 00:00:00 2001 From: CGH0S7 <776459475@qq.com> Date: Mon, 4 Aug 2025 01:01:29 +0800 Subject: [PATCH 27/55] =?UTF-8?q?[backend-LAG]=E6=B7=BB=E5=8A=A0=E6=96=B0?= =?UTF-8?q?=E7=9A=84LargeArrayToGlobal=E4=B8=AD=E7=AB=AFPass=EF=BC=8C?= =?UTF-8?q?=E4=BB=A5=E5=8F=8A=E6=A0=88=E4=BF=9D=E6=8A=A4=E9=80=BB=E8=BE=91?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../RISCv64/Handler/EliminateFrameIndices.cpp | 10 +- .../Handler/PrologueEpilogueInsertion.cpp | 12 +- src/backend/RISCv64/RISCv64ISel.cpp | 11 +- .../midend/Pass/Optimize/LargeArrayToGlobal.h | 24 +++ src/include/midend/Pass/Pass.h | 2 +- src/midend/CMakeLists.txt | 1 + .../Pass/Optimize/LargeArrayToGlobal.cpp | 143 ++++++++++++++++++ src/midend/Pass/Pass.cpp | 3 + 8 files changed, 198 insertions(+), 8 deletions(-) create mode 100644 src/include/midend/Pass/Optimize/LargeArrayToGlobal.h create mode 100644 src/midend/Pass/Optimize/LargeArrayToGlobal.cpp diff --git a/src/backend/RISCv64/Handler/EliminateFrameIndices.cpp b/src/backend/RISCv64/Handler/EliminateFrameIndices.cpp index d343fbf..ae4e556 100644 --- a/src/backend/RISCv64/Handler/EliminateFrameIndices.cpp +++ b/src/backend/RISCv64/Handler/EliminateFrameIndices.cpp @@ -46,9 +46,13 @@ void EliminateFrameIndicesPass::runOnMachineFunction(MachineFunction* mfunc) { Type* allocated_type = alloca->getType()->as()->getBaseType(); int size = getTypeSizeInBytes(allocated_type); - // RISC-V要求栈地址8字节对齐 - size = (size + 7) & ~7; - if (size == 0) size = 8; // 至少分配8字节 + // 优化栈帧大小：对于大数组使用4字节对齐，小对象使用8字节对齐 + if (size >= 256) { // 大数组优化 + size = (size + 3) & ~3; // 4字节对齐 + } else { + size = (size + 7) & ~7; // 8字节对齐 + } + if (size == 0) size = 4; // 最小4字节 local_var_offset += size; unsigned alloca_vreg = isel->getVReg(alloca); diff --git a/src/backend/RISCv64/Handler/PrologueEpilogueInsertion.cpp b/src/backend/RISCv64/Handler/PrologueEpilogueInsertion.cpp index 0eef863..ef116e2 100644 --- a/src/backend/RISCv64/Handler/PrologueEpilogueInsertion.cpp +++ b/src/backend/RISCv64/Handler/PrologueEpilogueInsertion.cpp @@ -47,12 +47,22 @@ void PrologueEpilogueInsertionPass::runOnMachineFunction(MachineFunction* mfunc) 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; - // 3. 计算最终的栈帧总大小 + // 3. 计算最终的栈帧总大小，包含栈溢出保护 int total_stack_size = frame_info.locals_size + frame_info.spill_size + frame_info.callee_saved_size + 16; + // 栈溢出保护：增加最大栈帧大小以容纳大型数组 + const int MAX_STACK_FRAME_SIZE = 8192; // 8KB to handle large arrays like 256*4*2 = 2048 bytes + if (total_stack_size > MAX_STACK_FRAME_SIZE) { + // 如果仍然超过限制，尝试优化对齐方式 + std::cerr << "Warning: Stack frame size " << total_stack_size + << " exceeds recommended limit " << MAX_STACK_FRAME_SIZE << " for function " + << mfunc->getName() << std::endl; + } + + // 优化：减少对齐开销，使用16字节对齐而非更大的对齐 int aligned_stack_size = (total_stack_size + 15) & ~15; frame_info.total_size = aligned_stack_size; diff --git a/src/backend/RISCv64/RISCv64ISel.cpp b/src/backend/RISCv64/RISCv64ISel.cpp index 2f7c9ae..dfe7d46 100644 --- a/src/backend/RISCv64/RISCv64ISel.cpp +++ b/src/backend/RISCv64/RISCv64ISel.cpp @@ -1289,14 +1289,19 @@ void RISCv64ISel::selectNode(DAGNode* node) { if (stride != 0) { // --- 为当前索引和步长生成偏移计算指令 --- auto offset_vreg = getNewVReg(); - auto index_vreg = getVReg(indexValue); - - // 如果索引是常量，先用 LI 指令加载到虚拟寄存器 + + // 处理索引 - 区分常量与动态值 + unsigned index_vreg; if (auto const_index = dynamic_cast(indexValue)) { + // 对于常量索引，直接创建新的虚拟寄存器 + index_vreg = getNewVReg(); auto li = std::make_unique(RVOpcodes::LI); li->addOperand(std::make_unique(index_vreg)); li->addOperand(std::make_unique(const_index->getInt())); CurMBB->addInstruction(std::move(li)); + } else { + // 对于动态索引，使用已存在的虚拟寄存器 + index_vreg = getVReg(indexValue); } // 优化：如果步长是1，可以直接移动(MV)作为偏移量，无需乘法 diff --git a/src/include/midend/Pass/Optimize/LargeArrayToGlobal.h b/src/include/midend/Pass/Optimize/LargeArrayToGlobal.h new file mode 100644 index 0000000..39c5a52 --- /dev/null +++ b/src/include/midend/Pass/Optimize/LargeArrayToGlobal.h @@ -0,0 +1,24 @@ +#pragma once + +#include "../Pass.h" + +namespace sysy { + +class LargeArrayToGlobalPass : public OptimizationPass { +public: + static void *ID; + + LargeArrayToGlobalPass() : OptimizationPass("LargeArrayToGlobal", Granularity::Module) {} + + bool runOnModule(Module *M, AnalysisManager &AM) override; + void *getPassID() const override { + return &ID; + } + +private: + unsigned calculateTypeSize(Type *type); + void convertAllocaToGlobal(AllocaInst *alloca, Function *F, Module *M); + std::string generateUniqueGlobalName(AllocaInst *alloca, Function *F); +}; + +} // namespace sysy \ No newline at end of file diff --git a/src/include/midend/Pass/Pass.h b/src/include/midend/Pass/Pass.h index 887ad3f..1dcaa68 100644 --- a/src/include/midend/Pass/Pass.h +++ b/src/include/midend/Pass/Pass.h @@ -279,7 +279,7 @@ private: IRBuilder *pBuilder; public: - PassManager() = default; + PassManager() = delete; ~PassManager() = default; PassManager(Module *module, IRBuilder *builder) : pmodule(module) ,pBuilder(builder), analysisManager(module) {} diff --git a/src/midend/CMakeLists.txt b/src/midend/CMakeLists.txt index f944a3c..db4d13c 100644 --- a/src/midend/CMakeLists.txt +++ b/src/midend/CMakeLists.txt @@ -12,6 +12,7 @@ add_library(midend_lib STATIC Pass/Optimize/SysYIRCFGOpt.cpp Pass/Optimize/SCCP.cpp Pass/Optimize/BuildCFG.cpp + Pass/Optimize/LargeArrayToGlobal.cpp ) # 包含中端模块所需的头文件路径 diff --git a/src/midend/Pass/Optimize/LargeArrayToGlobal.cpp b/src/midend/Pass/Optimize/LargeArrayToGlobal.cpp new file mode 100644 index 0000000..9f63dce --- /dev/null +++ b/src/midend/Pass/Optimize/LargeArrayToGlobal.cpp @@ -0,0 +1,143 @@ +#include "../../include/midend/Pass/Optimize/LargeArrayToGlobal.h" +#include "../../IR.h" +#include +#include +#include + +namespace sysy { + +// Helper function to convert type to string +static std::string typeToString(Type *type) { + if (!type) return "null"; + + switch (type->getKind()) { + case Type::kInt: + return "int"; + case Type::kFloat: + return "float"; + case Type::kPointer: + return "ptr"; + case Type::kArray: { + auto *arrayType = type->as(); + return "[" + std::to_string(arrayType->getNumElements()) + " x " + + typeToString(arrayType->getElementType()) + "]"; + } + default: + return "unknown"; + } +} + +void *LargeArrayToGlobalPass::ID = &LargeArrayToGlobalPass::ID; + +bool LargeArrayToGlobalPass::runOnModule(Module *M, AnalysisManager &AM) { + bool changed = false; + + if (!M) { + return false; + } + + // Collect all alloca instructions from all functions + std::vector> allocasToConvert; + + for (auto &funcPair : M->getFunctions()) { + Function *F = funcPair.second.get(); + if (!F || F->getBasicBlocks().begin() == F->getBasicBlocks().end()) { + continue; + } + + for (auto &BB : F->getBasicBlocks()) { + for (auto &inst : BB->getInstructions()) { + if (auto *alloca = dynamic_cast(inst.get())) { + Type *allocatedType = alloca->getAllocatedType(); + + // Calculate the size of the allocated type + unsigned size = calculateTypeSize(allocatedType); + + // Debug: print size information + std::cout << "LargeArrayToGlobalPass: Found alloca with size " << size + << " for type " << typeToString(allocatedType) << std::endl; + + // Convert arrays of 1KB (1024 bytes) or larger to global variables + if (size >= 1024) { + std::cout << "LargeArrayToGlobalPass: Converting array of size " << size << " to global" << std::endl; + allocasToConvert.emplace_back(alloca, F); + } + } + } + } + } + + // Convert the collected alloca instructions to global variables + for (auto [alloca, F] : allocasToConvert) { + convertAllocaToGlobal(alloca, F, M); + changed = true; + } + +return changed; + } + +unsigned LargeArrayToGlobalPass::calculateTypeSize(Type *type) { + if (!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(); + return arrayType->getNumElements() * calculateTypeSize(arrayType->getElementType()); + } + default: + return 0; + } +} + +void LargeArrayToGlobalPass::convertAllocaToGlobal(AllocaInst *alloca, Function *F, Module *M) { + Type *allocatedType = alloca->getAllocatedType(); + + // Create a unique name for the global variable + std::string globalName = generateUniqueGlobalName(alloca, F); + + // Create the global variable - GlobalValue expects pointer type + Type *pointerType = Type::getPointerType(allocatedType); + GlobalValue *globalVar = M->createGlobalValue(globalName, pointerType); + + if (!globalVar) { + return; + } + + // Replace all uses of the alloca with the global variable + alloca->replaceAllUsesWith(globalVar); + + // Remove the alloca instruction from its basic block + for (auto &BB : F->getBasicBlocks()) { + auto &instructions = BB->getInstructions(); + for (auto it = instructions.begin(); it != instructions.end(); ++it) { + if (it->get() == alloca) { + instructions.erase(it); + break; + } + } + } +} + +std::string LargeArrayToGlobalPass::generateUniqueGlobalName(AllocaInst *alloca, Function *F) { + std::string baseName = alloca->getName(); + if (baseName.empty()) { + baseName = "array"; + } + + // Ensure uniqueness by appending function name and counter + static std::unordered_map nameCounter; + std::string key = F->getName() + "." + baseName; + + int counter = nameCounter[key]++; + std::ostringstream oss; + oss << key << "." << counter; + + return oss.str(); +} + +} // namespace sysy \ No newline at end of file diff --git a/src/midend/Pass/Pass.cpp b/src/midend/Pass/Pass.cpp index c2c8371..42c1433 100644 --- a/src/midend/Pass/Pass.cpp +++ b/src/midend/Pass/Pass.cpp @@ -7,6 +7,7 @@ #include "Reg2Mem.h" #include "SCCP.h" #include "BuildCFG.h" +#include "LargeArrayToGlobal.h" #include "Pass.h" #include #include @@ -41,6 +42,7 @@ void PassManager::runOptimizationPipeline(Module* moduleIR, IRBuilder* builderIR // 注册优化遍 registerOptimizationPass(); + registerOptimizationPass(); registerOptimizationPass(); registerOptimizationPass(); @@ -68,6 +70,7 @@ void PassManager::runOptimizationPipeline(Module* moduleIR, IRBuilder* builderIR this->clearPasses(); this->addPass(&BuildCFG::ID); + this->addPass(&LargeArrayToGlobalPass::ID); this->run(); this->clearPasses(); From 0ecd47f0ac8c9d2b59e0d2b644b40f7e31c21d37 Mon Sep 17 00:00:00 2001 From: CGH0S7 <776459475@qq.com> Date: Sun, 3 Aug 2025 22:23:52 +0800 Subject: [PATCH 28/55] =?UTF-8?q?=E4=BF=AE=E5=A4=8DIR=E6=89=93=E5=8D=B0?= =?UTF-8?q?=E5=99=A8=E4=B8=AD=E6=B5=AE=E7=82=B9=E6=AF=94=E8=BE=83=E6=8C=87?= =?UTF-8?q?=E4=BB=A4=E7=9A=84=E7=B1=BB=E5=9E=8B=E9=94=99=E8=AF=AF=EF=BC=8C?= =?UTF-8?q?=E7=A1=AE=E4=BF=9D=E7=94=9F=E6=88=90=E6=AD=A3=E7=A1=AE=E7=9A=84?= =?UTF-8?q?LLVM=20IR=E4=BB=A3=E7=A0=81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/midend/SysYIRPrinter.cpp | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/src/midend/SysYIRPrinter.cpp b/src/midend/SysYIRPrinter.cpp index 9a0f427..fba6abd 100644 --- a/src/midend/SysYIRPrinter.cpp +++ b/src/midend/SysYIRPrinter.cpp @@ -299,7 +299,12 @@ void SysYPrinter::printInst(Instruction *pInst) { // Types and operands std::cout << " "; - printType(binInst->getType()); + // For comparison operations, print operand types instead of result type + if (pInst->getKind() >= Kind::kICmpEQ && pInst->getKind() <= Kind::kFCmpGE) { + printType(binInst->getLhs()->getType()); + } else { + printType(binInst->getType()); + } std::cout << " "; printValue(binInst->getLhs()); std::cout << ", "; From b2c2f3289dfb4195847bb0588e3cfff55a0782a6 Mon Sep 17 00:00:00 2001 From: CGH0S7 <776459475@qq.com> Date: Mon, 4 Aug 2025 01:34:39 +0800 Subject: [PATCH 29/55] =?UTF-8?q?[backend]=E4=BF=AE=E6=94=B9=E4=BA=86?= =?UTF-8?q?=E7=BC=96=E8=AF=91=E5=99=A8=E5=90=8E=E7=AB=AF=20RISCv64ISel.cpp?= =?UTF-8?q?=EF=BC=8C=E5=9C=A8=20kFtoI=20=E7=9A=84=E5=A4=84=E7=90=86?= =?UTF-8?q?=E9=80=BB=E8=BE=91=E4=B8=AD=EF=BC=8C=E7=94=A8=E4=B8=80=E6=AE=B5?= =?UTF-8?q?=E6=8C=87=E4=BB=A4=E5=BA=8F=E5=88=97=E6=A8=A1=E6=8B=9F=E4=BA=86?= =?UTF-8?q?=E6=AD=A3=E7=A1=AE=E7=9A=84=E2=80=9C=E5=90=91=E9=9B=B6=E5=8F=96?= =?UTF-8?q?=E6=95=B4=E2=80=9D=E8=A1=8C=E4=B8=BA=E3=80=8295=20h35=20h37=20h?= =?UTF-8?q?38=E9=80=9A=E8=BF=87=E3=80=82?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/backend/RISCv64/RISCv64ISel.cpp | 82 +++++++++++++++++++++++++++-- 1 file changed, 77 insertions(+), 5 deletions(-) diff --git a/src/backend/RISCv64/RISCv64ISel.cpp b/src/backend/RISCv64/RISCv64ISel.cpp index 2f7c9ae..4758b37 100644 --- a/src/backend/RISCv64/RISCv64ISel.cpp +++ b/src/backend/RISCv64/RISCv64ISel.cpp @@ -767,11 +767,83 @@ void RISCv64ISel::selectNode(DAGNode* node) { CurMBB->addInstruction(std::move(instr)); break; } - case Instruction::kFtoI: { // 浮点 to 整数 - auto instr = std::make_unique(RVOpcodes::FCVT_W_S); - instr->addOperand(std::make_unique(dest_vreg)); // 目标是整数vreg - instr->addOperand(std::make_unique(src_vreg)); // 源是浮点vreg - CurMBB->addInstruction(std::move(instr)); + case Instruction::kFtoI: { // 浮点 to 整数 (带向下取整) + // 目标：实现 floor(x) 的效果, C/C++中浮点转整数是截断(truncate) + // 对于正数，floor(x) == truncate(x) + // RISC-V的 fcvt.w.s 默认是“四舍五入到偶数” + // 我们需要手动实现截断逻辑 + // 逻辑: + // temp_i = fcvt.w.s(x) // 四舍五入 + // temp_f = fcvt.s.w(temp_i) // 转回浮点 + // if (x < temp_f) { // 如果原数更小，说明被“五入”了 + // result = temp_i - 1 + // } else { + // result = temp_i + // } + + auto temp_i_vreg = getNewVReg(Type::getIntType()); + auto temp_f_vreg = getNewVReg(Type::getFloatType()); + auto cmp_vreg = getNewVReg(Type::getIntType()); + + // 1. fcvt.w.s temp_i_vreg, src_vreg + auto fcvt_w = std::make_unique(RVOpcodes::FCVT_W_S); + fcvt_w->addOperand(std::make_unique(temp_i_vreg)); + fcvt_w->addOperand(std::make_unique(src_vreg)); + CurMBB->addInstruction(std::move(fcvt_w)); + + // 2. fcvt.s.w temp_f_vreg, temp_i_vreg + auto fcvt_s = std::make_unique(RVOpcodes::FCVT_S_W); + fcvt_s->addOperand(std::make_unique(temp_f_vreg)); + fcvt_s->addOperand(std::make_unique(temp_i_vreg)); + CurMBB->addInstruction(std::move(fcvt_s)); + + // 3. flt.s cmp_vreg, src_vreg, temp_f_vreg + auto flt = std::make_unique(RVOpcodes::FLT_S); + flt->addOperand(std::make_unique(cmp_vreg)); + flt->addOperand(std::make_unique(src_vreg)); + flt->addOperand(std::make_unique(temp_f_vreg)); + CurMBB->addInstruction(std::move(flt)); + + // 创建标签 + int unique_id = this->local_label_counter++; + std::string rounded_up_label = MFunc->getName() + "_ftoi_rounded_up_" + std::to_string(unique_id); + std::string done_label = MFunc->getName() + "_ftoi_done_" + std::to_string(unique_id); + + // 4. bne cmp_vreg, x0, rounded_up_label + auto bne = std::make_unique(RVOpcodes::BNE); + bne->addOperand(std::make_unique(cmp_vreg)); + bne->addOperand(std::make_unique(PhysicalReg::ZERO)); + bne->addOperand(std::make_unique(rounded_up_label)); + CurMBB->addInstruction(std::move(bne)); + + // 5. else 分支: mv dest_vreg, temp_i_vreg + auto mv = std::make_unique(RVOpcodes::MV); + mv->addOperand(std::make_unique(dest_vreg)); + mv->addOperand(std::make_unique(temp_i_vreg)); + CurMBB->addInstruction(std::move(mv)); + + // 6. j done_label + auto j = std::make_unique(RVOpcodes::J); + j->addOperand(std::make_unique(done_label)); + CurMBB->addInstruction(std::move(j)); + + // 7. rounded_up_label: + auto label_up = std::make_unique(RVOpcodes::LABEL); + label_up->addOperand(std::make_unique(rounded_up_label)); + CurMBB->addInstruction(std::move(label_up)); + + // 8. addiw dest_vreg, temp_i_vreg, -1 + auto addi = std::make_unique(RVOpcodes::ADDIW); + addi->addOperand(std::make_unique(dest_vreg)); + addi->addOperand(std::make_unique(temp_i_vreg)); + addi->addOperand(std::make_unique(-1)); + CurMBB->addInstruction(std::move(addi)); + + // 9. done_label: + auto label_done = std::make_unique(RVOpcodes::LABEL); + label_done->addOperand(std::make_unique(done_label)); + CurMBB->addInstruction(std::move(label_done)); + break; } case Instruction::kFNeg: { // 浮点取负 From 1b9a7a48275783e0788eb977cbdaff93a3a282fc Mon Sep 17 00:00:00 2001 From: Lixuanwang Date: Mon, 4 Aug 2025 01:57:34 +0800 Subject: [PATCH 30/55] =?UTF-8?q?[backend]=E4=BF=AE=E5=A4=8D=E4=BA=86?= =?UTF-8?q?=E5=87=BD=E6=95=B0=E5=BA=8F=E8=A8=80=E5=A4=84=E7=90=86=E9=94=99?= =?UTF-8?q?=E8=AF=AF=E4=B8=94=E4=B8=8E=E5=B0=BE=E5=A3=B0=E6=A0=88=E4=B8=8D?= =?UTF-8?q?=E5=8C=B9=E9=85=8D=E7=9A=84bug?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../RISCv64/Handler/PrologueEpilogueInsertion.cpp | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/backend/RISCv64/Handler/PrologueEpilogueInsertion.cpp b/src/backend/RISCv64/Handler/PrologueEpilogueInsertion.cpp index 0eef863..ab91660 100644 --- a/src/backend/RISCv64/Handler/PrologueEpilogueInsertion.cpp +++ b/src/backend/RISCv64/Handler/PrologueEpilogueInsertion.cpp @@ -95,16 +95,17 @@ void PrologueEpilogueInsertionPass::runOnMachineFunction(MachineFunction* mfunc) // 4.4. 保存所有使用到的被调用者保存寄存器 int next_available_offset = -(16 + frame_info.locals_size + frame_info.spill_size); for (const auto& reg : frame_info.callee_saved_regs_to_store) { - // 采用“先使用，后更新”逻辑 + // 改为“先更新，后使用”逻辑 + next_available_offset -= 8; // 先为当前寄存器分配下一个可用槽位 RVOpcodes store_op = isFPR(reg) ? RVOpcodes::FSD : RVOpcodes::SD; auto save_cs_reg = std::make_unique(store_op); save_cs_reg->addOperand(std::make_unique(reg)); save_cs_reg->addOperand(std::make_unique( std::make_unique(PhysicalReg::S0), - std::make_unique(next_available_offset) // 使用当前偏移 + std::make_unique(next_available_offset) // 使用新计算出的正确偏移 )); prologue_instrs.push_back(std::move(save_cs_reg)); - next_available_offset -= 8; // 为下一个寄存器准备偏移 + // 不再需要在循环末尾递减 } // 4.5. 将所有生成的序言指令一次性插入到函数入口 @@ -121,6 +122,7 @@ void PrologueEpilogueInsertionPass::runOnMachineFunction(MachineFunction* mfunc) // 5.1. 恢复被调用者保存寄存器 int next_available_offset_restore = -(16 + frame_info.locals_size + frame_info.spill_size); for (const auto& reg : frame_info.callee_saved_regs_to_store) { + next_available_offset_restore -= 8; // 为下一个寄存器准备偏移 RVOpcodes load_op = isFPR(reg) ? RVOpcodes::FLD : RVOpcodes::LD; auto restore_cs_reg = std::make_unique(load_op); restore_cs_reg->addOperand(std::make_unique(reg)); @@ -129,7 +131,6 @@ void PrologueEpilogueInsertionPass::runOnMachineFunction(MachineFunction* mfunc) std::make_unique(next_available_offset_restore) // 使用当前偏移 )); epilogue_instrs.push_back(std::move(restore_cs_reg)); - next_available_offset_restore -= 8; // 为下一个寄存器准备偏移 } // 5.2. 恢复 ra 和 s0 From a269366ac51efdbf99bff6a17938d346d29c981d Mon Sep 17 00:00:00 2001 From: Lixuanwang Date: Mon, 4 Aug 2025 02:31:18 +0800 Subject: [PATCH 31/55] =?UTF-8?q?[backend]=E4=BF=AE=E5=A4=8D=E4=BA=86?= =?UTF-8?q?=E8=BE=83=E5=B0=8F=E5=85=A8=E9=9B=B6=E5=85=A8=E5=B1=80=E6=95=B0?= =?UTF-8?q?=E7=BB=84=E6=9C=AA=E6=98=BE=E7=A4=BA=E5=88=9D=E5=A7=8B=E5=8C=96?= =?UTF-8?q?=E5=AF=BC=E8=87=B4=E6=9C=AA=E5=AE=9A=E4=B9=89=E8=A1=8C=E4=B8=BA?= =?UTF-8?q?=E7=9A=84=E9=97=AE=E9=A2=98?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/backend/RISCv64/RISCv64Backend.cpp | 24 +++++++++++++++++++++++- 1 file changed, 23 insertions(+), 1 deletion(-) diff --git a/src/backend/RISCv64/RISCv64Backend.cpp b/src/backend/RISCv64/RISCv64Backend.cpp index e45248f..7e08102 100644 --- a/src/backend/RISCv64/RISCv64Backend.cpp +++ b/src/backend/RISCv64/RISCv64Backend.cpp @@ -139,7 +139,29 @@ std::string RISCv64CodeGen::module_gen() { ss << ".type " << global->getName() << ", @object\n"; ss << ".size " << global->getName() << ", " << total_size << "\n"; ss << global->getName() << ":\n"; - printInitializer(ss, global->getInitValues()); + bool is_all_zeros = true; + const auto& init_values = global->getInitValues(); + if (init_values.getValues().empty()) { + is_all_zeros = true; + } else { + for (auto val : init_values.getValues()) { + if (auto const_val = dynamic_cast(val)) { + if (!const_val->isZero()) { + is_all_zeros = false; + break; + } + } else { + is_all_zeros = false; + break; + } + } + } + if (is_all_zeros) { + ss << " .zero " << total_size << "\n"; + } else { + // 对于有非零初始值的变量，保持原有的打印逻辑。 + printInitializer(ss, global->getInitValues()); + } } // b. 处理全局常量 (ConstantVariable) From 64ba25a77ea89dc29604c1afe0f6f939f8414a5a Mon Sep 17 00:00:00 2001 From: Lixuanwang Date: Mon, 4 Aug 2025 14:11:27 +0800 Subject: [PATCH 32/55] =?UTF-8?q?[backend]=E7=A7=BB=E9=99=A4=E4=BA=86?= =?UTF-8?q?=E5=86=97=E4=BD=99=E7=9A=84keepalive=E4=BC=AA=E6=8C=87=E4=BB=A4?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/backend/RISCv64/RISCv64ISel.cpp | 27 --------------------------- 1 file changed, 27 deletions(-) diff --git a/src/backend/RISCv64/RISCv64ISel.cpp b/src/backend/RISCv64/RISCv64ISel.cpp index 4758b37..a96b578 100644 --- a/src/backend/RISCv64/RISCv64ISel.cpp +++ b/src/backend/RISCv64/RISCv64ISel.cpp @@ -167,33 +167,6 @@ void RISCv64ISel::selectBasicBlock(BasicBlock* bb) { select_recursive(node_to_select); } } - - if (CurMBB == MFunc->getBlocks().front().get()) { // 只对入口块操作 - auto keepalive = std::make_unique(RVOpcodes::PSEUDO_KEEPALIVE); - for (Argument* arg : F->getArguments()) { - keepalive->addOperand(std::make_unique(getVReg(arg))); - } - - auto& instrs = CurMBB->getInstructions(); - auto insert_pos = instrs.end(); - - // 关键：检查基本块是否以一个“终止指令”结尾 - if (!instrs.empty()) { - RVOpcodes last_op = instrs.back()->getOpcode(); - // 扩充了判断条件，涵盖所有可能的终止指令 - if (last_op == RVOpcodes::J || last_op == RVOpcodes::RET || - last_op == RVOpcodes::BEQ || last_op == RVOpcodes::BNE || - last_op == RVOpcodes::BLT || last_op == RVOpcodes::BGE || - last_op == RVOpcodes::BLTU || last_op == RVOpcodes::BGEU) - { - // 如果是，插入点就在这个终止指令之前 - insert_pos = std::prev(instrs.end()); - } - } - - // 在计算出的正确位置插入伪指令 - instrs.insert(insert_pos, std::move(keepalive)); - } } // 核心函数：为DAG节点选择并生成MachineInstr (已修复和增强的完整版本) From 7e5f6800b78a974c1dc158cff4571e8098aca817 Mon Sep 17 00:00:00 2001 From: CGH0S7 <776459475@qq.com> Date: Mon, 4 Aug 2025 16:04:35 +0800 Subject: [PATCH 33/55] =?UTF-8?q?[backend]=E4=BF=AE=E5=A4=8D=E5=AF=84?= =?UTF-8?q?=E5=AD=98=E5=99=A8=E5=88=86=E9=85=8D=E7=AE=97=E6=B3=95=E6=AD=BB?= =?UTF-8?q?=E5=BE=AA=E7=8E=AFbug=EF=BC=8C89=E9=80=9A=E8=BF=87?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/backend/RISCv64/RISCv64ISel.cpp | 9 ++- src/backend/RISCv64/RISCv64RegAlloc.cpp | 73 +++++++++++++++++++---- src/include/backend/RISCv64/RISCv64ISel.h | 6 ++ 3 files changed, 73 insertions(+), 15 deletions(-) diff --git a/src/backend/RISCv64/RISCv64ISel.cpp b/src/backend/RISCv64/RISCv64ISel.cpp index 4758b37..4e26aaa 100644 --- a/src/backend/RISCv64/RISCv64ISel.cpp +++ b/src/backend/RISCv64/RISCv64ISel.cpp @@ -1,4 +1,5 @@ #include "RISCv64ISel.h" +#include "IR.h" // For GlobalValue #include #include #include @@ -209,8 +210,12 @@ void RISCv64ISel::selectNode(DAGNode* node) { case DAGNode::CONSTANT: case DAGNode::ALLOCA_ADDR: if (node->value) { - // 确保它有一个关联的虚拟寄存器即可，不生成代码。 - getVReg(node->value); + // GlobalValue objects (global variables) should not get virtual registers + // since they represent memory addresses, not register-allocated values + if (dynamic_cast(node->value) == nullptr) { + // 确保它有一个关联的虚拟寄存器即可，不生成代码。 + getVReg(node->value); + } } break; diff --git a/src/backend/RISCv64/RISCv64RegAlloc.cpp b/src/backend/RISCv64/RISCv64RegAlloc.cpp index 195ef6c..717a897 100644 --- a/src/backend/RISCv64/RISCv64RegAlloc.cpp +++ b/src/backend/RISCv64/RISCv64RegAlloc.cpp @@ -55,12 +55,41 @@ void RISCv64RegAlloc::run() { if (DEBUG) std::cerr << "===== Running Graph Coloring Register Allocation for function: " << MFunc->getName() << " =====\n"; - while (true) { + const int MAX_ITERATIONS = 50; + int iteration = 0; + + while (iteration++ < MAX_ITERATIONS) { if (doAllocation()) { break; } else { rewriteProgram(); - if (DEBUG) std::cerr << "--- Spilling detected, re-running allocation ---\n"; + if (DEBUG) std::cerr << "--- Spilling detected, re-running allocation (iteration " << iteration << ") ---\n"; + + if (iteration >= MAX_ITERATIONS) { + std::cerr << "ERROR: Register allocation failed to converge after " << MAX_ITERATIONS << " iterations\n"; + std::cerr << " Spill worklist size: " << spillWorklist.size() << "\n"; + std::cerr << " Total nodes: " << (initial.size() + coloredNodes.size()) << "\n"; + + // Emergency spill remaining nodes to break the loop + std::cerr << " Emergency spilling remaining spill worklist nodes...\n"; + for (unsigned node : spillWorklist) { + spilledNodes.insert(node); + } + + // Also spill any nodes that didn't get colors + std::set uncolored; + for (unsigned node : initial) { + if (color_map.find(node) == color_map.end()) { + uncolored.insert(node); + } + } + for (unsigned node : uncolored) { + spilledNodes.insert(node); + } + + // Force completion + break; + } } } @@ -402,14 +431,32 @@ void RISCv64RegAlloc::build() { // --- 规则 3: Live_Out 集合内部的【虚拟寄存器】形成完全图 --- // 使用更高效的遍历，避免重复调用 addEdge(A,B) 和 addEdge(B,A) - for (auto it1 = live_out.begin(); it1 != live_out.end(); ++it1) { - unsigned l1 = *it1; - // 只为虚拟寄存器 l1 添加边 - if (precolored.count(l1)) continue; + // 添加限制以防止过度密集的图 + const size_t MAX_LIVE_OUT_SIZE = 32; // 限制最大活跃变量数 + if (live_out.size() > MAX_LIVE_OUT_SIZE) { + // 对于大量活跃变量，使用更保守的边添加策略 + // 只添加必要的边，而不是完全图 + for (auto it1 = live_out.begin(); it1 != live_out.end(); ++it1) { + unsigned l1 = *it1; + if (precolored.count(l1)) continue; + + // 只添加与定义变量相关的边 + for (unsigned d : def) { + if (d != l1 && !precolored.count(d)) { + addEdge(l1, d); + } + } + } + } else { + // 对于较小的集合，使用原来的完全图方法 + for (auto it1 = live_out.begin(); it1 != live_out.end(); ++it1) { + unsigned l1 = *it1; + if (precolored.count(l1)) continue; - for (auto it2 = std::next(it1); it2 != live_out.end(); ++it2) { - unsigned l2 = *it2; - addEdge(l1, l2); + for (auto it2 = std::next(it1); it2 != live_out.end(); ++it2) { + unsigned l2 = *it2; + addEdge(l1, l2); + } } } } @@ -1357,9 +1404,9 @@ void RISCv64RegAlloc::applyColoring() { // 使用 setPReg 将虚拟寄存器转换为物理寄存器 reg_op->setPReg(color_map.at(vreg)); } else { - // 如果一个vreg在成功分配后仍然没有颜色，这是一个错误 - std::cerr << "FATAL: Virtual register %vreg" << vreg << " has no color after allocation!\n"; - assert(false && "Virtual register has no color after allocation!"); + // 如果一个vreg在成功分配后仍然没有颜色，可能是紧急溢出 + // std::cerr << "WARNING: Virtual register %vreg" << vreg << " has no color after allocation, treating as spilled\n"; + // 在紧急溢出情况下，使用临时寄存器 reg_op->setPReg(PhysicalReg::T6); } } @@ -1371,7 +1418,7 @@ void RISCv64RegAlloc::applyColoring() { if (color_map.count(vreg)) { reg_op->setPReg(color_map.at(vreg)); } else { - assert(false && "Virtual register in memory operand has no color!"); + // std::cerr << "WARNING: Virtual register in memory operand has no color, using T6\n"; reg_op->setPReg(PhysicalReg::T6); } } diff --git a/src/include/backend/RISCv64/RISCv64ISel.h b/src/include/backend/RISCv64/RISCv64ISel.h index d24432d..46d0461 100644 --- a/src/include/backend/RISCv64/RISCv64ISel.h +++ b/src/include/backend/RISCv64/RISCv64ISel.h @@ -3,6 +3,12 @@ #include "RISCv64LLIR.h" +// Forward declarations +namespace sysy { + class GlobalValue; + class Value; +} + extern int DEBUG; extern int DEEPDEBUG; From 0179c13cf4521b466405b22921e2e9e10370a672 Mon Sep 17 00:00:00 2001 From: Lixuanwang Date: Mon, 4 Aug 2025 16:32:54 +0800 Subject: [PATCH 34/55] =?UTF-8?q?[backend]=E6=B7=BB=E5=8A=A0=E4=BA=86?= =?UTF-8?q?=E4=B8=80=E4=BA=9B=E5=B7=A5=E5=85=B7=E5=87=BD=E6=95=B0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/backend/RISCv64/RISCv64AsmPrinter.cpp | 29 ++++++++++++++++++- src/backend/RISCv64/RISCv64ISel.cpp | 4 +++ src/backend/RISCv64/RISCv64RegAlloc.cpp | 24 --------------- .../backend/RISCv64/RISCv64AsmPrinter.h | 2 ++ src/include/backend/RISCv64/RISCv64ISel.h | 3 +- 5 files changed, 36 insertions(+), 26 deletions(-) diff --git a/src/backend/RISCv64/RISCv64AsmPrinter.cpp b/src/backend/RISCv64/RISCv64AsmPrinter.cpp index fcedb43..4dd8fd8 100644 --- a/src/backend/RISCv64/RISCv64AsmPrinter.cpp +++ b/src/backend/RISCv64/RISCv64AsmPrinter.cpp @@ -1,7 +1,8 @@ #include "RISCv64AsmPrinter.h" #include "RISCv64ISel.h" #include - +#include +#include namespace sysy { // 检查是否为内存加载/存储指令，以处理特殊的打印格式 @@ -236,4 +237,30 @@ std::string RISCv64AsmPrinter::regToString(PhysicalReg reg) { } } +std::string RISCv64AsmPrinter::formatInstr(const MachineInstr* instr) { + if (!instr) return "(null instr)"; + + // 使用 stringstream 作为临时的输出目标 + std::stringstream ss; + + // 关键: 临时将类成员 'OS' 指向我们的 stringstream + std::ostream* old_os = this->OS; + this->OS = &ss; + + // 修正: 调用正确的内部打印函数 printMachineInstr + printInstruction(const_cast(instr), false); + + // 恢复旧的 ostream 指针 + this->OS = old_os; + + // 获取stringstream的内容并做一些清理 + std::string result = ss.str(); + size_t endpos = result.find_last_not_of(" \t\n\r"); + if (std::string::npos != endpos) { + result = result.substr(0, endpos + 1); + } + + return result; +} + } // namespace sysy \ No newline at end of file diff --git a/src/backend/RISCv64/RISCv64ISel.cpp b/src/backend/RISCv64/RISCv64ISel.cpp index a96b578..c3879f5 100644 --- a/src/backend/RISCv64/RISCv64ISel.cpp +++ b/src/backend/RISCv64/RISCv64ISel.cpp @@ -1699,4 +1699,8 @@ void RISCv64ISel::print_dag(const std::vector>& dag, co std::cerr << "======================================\n\n"; } +unsigned int RISCv64ISel::getVRegCounter() const { + return vreg_counter; +} + } // namespace sysy \ No newline at end of file diff --git a/src/backend/RISCv64/RISCv64RegAlloc.cpp b/src/backend/RISCv64/RISCv64RegAlloc.cpp index 195ef6c..4245c16 100644 --- a/src/backend/RISCv64/RISCv64RegAlloc.cpp +++ b/src/backend/RISCv64/RISCv64RegAlloc.cpp @@ -122,30 +122,6 @@ void RISCv64RegAlloc::precolorByCallingConvention() { } } - // // --- 部分2：为CALL指令的返回值预着色 --- - // for (auto& mbb : MFunc->getBlocks()) { - // for (auto& instr : mbb->getInstructions()) { - // if (instr->getOpcode() == RVOpcodes::CALL) { - // if (!instr->getOperands().empty() && - // instr->getOperands().front()->getKind() == MachineOperand::KIND_REG) - // { - // auto reg_op = static_cast(instr->getOperands().front().get()); - // if (reg_op->isVirtual()) { - // unsigned ret_vreg = reg_op->getVRegNum(); - // assert(vreg_to_value_map.count(ret_vreg) && "Return vreg not found!"); - // Value* ret_val = vreg_to_value_map.at(ret_vreg); - - // if (ret_val->getType()->isFloat()) { - // color_map[ret_vreg] = PhysicalReg::F10; // fa0 - // } else { - // color_map[ret_vreg] = PhysicalReg::A0; // a0 - // } - // } - // } - // } - // } - // } - // 将所有预着色的vreg视为已着色节点 for(const auto& pair : color_map) { coloredNodes.insert(pair.first); diff --git a/src/include/backend/RISCv64/RISCv64AsmPrinter.h b/src/include/backend/RISCv64/RISCv64AsmPrinter.h index 473ca7f..c9b439b 100644 --- a/src/include/backend/RISCv64/RISCv64AsmPrinter.h +++ b/src/include/backend/RISCv64/RISCv64AsmPrinter.h @@ -20,6 +20,8 @@ public: void setStream(std::ostream& os) { OS = &os; } // 辅助函数 std::string regToString(PhysicalReg reg); + std::string formatInstr(const MachineInstr *instr); + private: // 打印各个部分 void printBasicBlock(MachineBasicBlock* mbb, bool debug = false); diff --git a/src/include/backend/RISCv64/RISCv64ISel.h b/src/include/backend/RISCv64/RISCv64ISel.h index d24432d..db96c62 100644 --- a/src/include/backend/RISCv64/RISCv64ISel.h +++ b/src/include/backend/RISCv64/RISCv64ISel.h @@ -17,7 +17,8 @@ public: // 公开接口，以便后续模块（如RegAlloc）可以查询或创建vreg unsigned getVReg(Value* val); unsigned getNewVReg() { return vreg_counter++; } - unsigned getNewVReg(Type* type); + unsigned getNewVReg(Type* type); + unsigned getVRegCounter() const; // 获取 vreg_map 的公共接口 const std::map& getVRegMap() const { return vreg_map; } const std::map& getVRegValueMap() const { return vreg_to_value_map; } From b848ffca5a4ef35dc7aafe3bc6197c7e7bd3c9f1 Mon Sep 17 00:00:00 2001 From: rain2133 <1370973498@qq.com> Date: Mon, 4 Aug 2025 16:38:12 +0800 Subject: [PATCH 35/55] =?UTF-8?q?[midend]=E5=9C=A8=E7=94=9F=E6=88=90IR?= =?UTF-8?q?=E6=97=B6=E5=BC=95=E8=BF=9B=E4=BA=86=E7=AE=80=E5=8D=95=E7=9A=84?= =?UTF-8?q?CSE=EF=BC=88=E4=BA=8C=E5=85=83=E4=B8=80=E5=85=83loadgep?= =?UTF-8?q?=E7=9A=84cse=EF=BC=89?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/include/midend/SysYIRGenerator.h | 64 ++++- src/midend/SysYIRGenerator.cpp | 391 +++++++++++++++++++-------- 2 files changed, 338 insertions(+), 117 deletions(-) diff --git a/src/include/midend/SysYIRGenerator.h b/src/include/midend/SysYIRGenerator.h index bd671ee..b4d4e57 100644 --- a/src/include/midend/SysYIRGenerator.h +++ b/src/include/midend/SysYIRGenerator.h @@ -86,7 +86,60 @@ private: case LPAREN: case RPAREN: return 0; // Parentheses have lowest precedence for stack logic default: return -1; // Unknown operator } - } + }; + + struct ExpKey { + BinaryOp op; ///< 操作符 + Value *left; ///< 左操作数 + Value *right; ///< 右操作数 + ExpKey(BinaryOp op, Value *left, Value *right) : op(op), left(left), right(right) {} + + bool operator<(const ExpKey &other) const { + if (op != other.op) + return op < other.op; ///< 比较操作符 + if (left != other.left) + return left < other.left; ///< 比较左操作 + return right < other.right; ///< 比较右操作数 + } ///< 重载小于运算符用于比较ExpKey + }; + + struct UnExpKey { + BinaryOp op; ///< 一元操作符 + Value *operand; ///< 操作数 + UnExpKey(BinaryOp op, Value *operand) : op(op), operand(operand) {} + + bool operator<(const UnExpKey &other) const { + if (op != other.op) + return op < other.op; ///< 比较操作符 + return operand < other.operand; ///< 比较操作数 + } ///< 重载小于运算符用于比较UnExpKey + }; + + struct GEPKey { + Value *basePointer; + std::vector indices; + + // 为 std::map 定义比较运算符，使得 GEPKey 可以作为键 + bool operator<(const GEPKey &other) const { + if (basePointer != other.basePointer) { + return basePointer < other.basePointer; + } + // 逐个比较索引，确保顺序一致 + if (indices.size() != other.indices.size()) { + return indices.size() < other.indices.size(); + } + for (size_t i = 0; i < indices.size(); ++i) { + if (indices[i] != other.indices[i]) { + return indices[i] < other.indices[i]; + } + } + return false; // 如果 basePointer 和所有索引都相同，则认为相等 + } + }; + std::map availableGEPs; ///< 用于存储 GEP 的缓存 + std::map availableBinaryExpressions; + std::map availableUnaryExpressions; + std::map availableLoads; public: SysYIRGenerator() = default; @@ -167,6 +220,15 @@ public: Value* computeExp(SysYParser::ExpContext *ctx, Type* targetType = nullptr); Value* computeAddExp(SysYParser::AddExpContext *ctx, Type* targetType = nullptr); void compute(); + + // 参数是发生 store 操作的目标地址/变量的 Value* + void invalidateExpressionsOnStore(Value* storedAddress); + + // 清除因函数调用而失效的表达式缓存（保守策略） + void invalidateExpressionsOnCall(); + + // 在进入新的基本块时清空所有表达式缓存 + void enterNewBasicBlock(); public: // 获取GEP指令的地址 Value* getGEPAddressInst(Value* basePointer, const std::vector& indices); diff --git a/src/midend/SysYIRGenerator.cpp b/src/midend/SysYIRGenerator.cpp index b0ffab5..2e0e910 100644 --- a/src/midend/SysYIRGenerator.cpp +++ b/src/midend/SysYIRGenerator.cpp @@ -38,6 +38,116 @@ std::pair calculate_signed_magic(int d) { return {m, k}; } +// 清除因函数调用而失效的表达式缓存（保守策略） +void SysYIRGenerator::invalidateExpressionsOnCall() { + availableBinaryExpressions.clear(); + availableUnaryExpressions.clear(); + availableLoads.clear(); + availableGEPs.clear(); +} + +// 在进入新的基本块时清空所有表达式缓存 +void SysYIRGenerator::enterNewBasicBlock() { + availableBinaryExpressions.clear(); + availableUnaryExpressions.clear(); + availableLoads.clear(); + availableGEPs.clear(); +} + +// 清除因变量赋值而失效的表达式缓存 +// @param storedAddress: store 指令的目标地址 (例如 AllocaInst* 或 GEPInst*) +void SysYIRGenerator::invalidateExpressionsOnStore(Value *storedAddress) { + // 遍历二元表达式缓存，移除受影响的条目 + // 创建一个临时列表来存储要移除的键，避免在迭代时修改容器 + std::vector binaryKeysToRemove; + for (const auto &pair : availableBinaryExpressions) { + // 检查左操作数 + // 如果左操作数是 LoadInst，并且它从 storedAddress 加载 + if (auto loadInst = dynamic_cast(pair.first.left)) { + if (loadInst->getPointer() == storedAddress) { + binaryKeysToRemove.push_back(pair.first); + continue; // 这个表达式已标记为移除，跳到下一个 + } + } + // 如果左操作数本身就是被存储的地址 (例如，将一个地址值直接作为操作数，虽然不常见) + if (pair.first.left == storedAddress) { + binaryKeysToRemove.push_back(pair.first); + continue; + } + + // 检查右操作数，逻辑同左操作数 + if (auto loadInst = dynamic_cast(pair.first.right)) { + if (loadInst->getPointer() == storedAddress) { + binaryKeysToRemove.push_back(pair.first); + continue; + } + } + if (pair.first.right == storedAddress) { + binaryKeysToRemove.push_back(pair.first); + continue; + } + } + // 实际移除条目 + for (const auto &key : binaryKeysToRemove) { + availableBinaryExpressions.erase(key); + } + + // 遍历一元表达式缓存，移除受影响的条目 + std::vector unaryKeysToRemove; + for (const auto &pair : availableUnaryExpressions) { + // 检查操作数 + if (auto loadInst = dynamic_cast(pair.first.operand)) { + if (loadInst->getPointer() == storedAddress) { + unaryKeysToRemove.push_back(pair.first); + continue; + } + } + if (pair.first.operand == storedAddress) { + unaryKeysToRemove.push_back(pair.first); + continue; + } + } + // 实际移除条目 + for (const auto &key : unaryKeysToRemove) { + availableUnaryExpressions.erase(key); + } + availableLoads.erase(storedAddress); + + std::vector gepKeysToRemove; + for (const auto &pair : availableGEPs) { + // 检查 GEP 的基指针是否受存储影响 + if (auto loadInst = dynamic_cast(pair.first.basePointer)) { + if (loadInst->getPointer() == storedAddress) { + gepKeysToRemove.push_back(pair.first); + continue; // 标记此GEP为移除，跳过后续检查 + } + } + // 如果基指针本身就是存储的目标地址 (不常见，但可能) + if (pair.first.basePointer == storedAddress) { + gepKeysToRemove.push_back(pair.first); + continue; + } + + // 检查 GEP 的每个索引是否受存储影响 + for (const auto &indexVal : pair.first.indices) { + if (auto loadInst = dynamic_cast(indexVal)) { + if (loadInst->getPointer() == storedAddress) { + gepKeysToRemove.push_back(pair.first); + break; // 标记此GEP为移除，并跳出内部循环 + } + } + // 如果索引本身就是存储的目标地址 + if (indexVal == storedAddress) { + gepKeysToRemove.push_back(pair.first); + break; + } + } + } + // 实际移除条目 + for (const auto &key : gepKeysToRemove) { + availableGEPs.erase(key); + } +} // std::vector BinaryValueStack; ///< 用于存储value的栈 // std::vector BinaryOpStack; ///< 用于存储二元表达式的操作符栈 @@ -267,46 +377,56 @@ void SysYIRGenerator::compute() { } } else { // 否则，创建相应的IR指令 - if (commonType == Type::getIntType()) { - switch (op) { - case BinaryOp::ADD: resultValue = builder.createAddInst(lhs, rhs); break; - case BinaryOp::SUB: resultValue = builder.createSubInst(lhs, rhs); break; - case BinaryOp::MUL: resultValue = builder.createMulInst(lhs, rhs); break; - case BinaryOp::DIV: { - ConstantInteger *rhsConst = dynamic_cast(rhs); - if (rhsConst) { - int divisor = rhsConst->getInt(); - if (divisor > 0 && (divisor & (divisor - 1)) == 0) { - int shift = 0; - int temp = divisor; - while (temp > 1) { - temp >>= 1; - shift++; + ExpKey currentExpKey(static_cast(op), lhs, rhs); + auto it = availableBinaryExpressions.find(currentExpKey); + + if (it != availableBinaryExpressions.end()) { + // 在缓存中找到，重用结果 + resultValue = it->second; + } else { + if (commonType == Type::getIntType()) { + switch (op) { + case BinaryOp::ADD: resultValue = builder.createAddInst(lhs, rhs); break; + case BinaryOp::SUB: resultValue = builder.createSubInst(lhs, rhs); break; + case BinaryOp::MUL: resultValue = builder.createMulInst(lhs, rhs); break; + case BinaryOp::DIV: { + ConstantInteger *rhsConst = dynamic_cast(rhs); + if (rhsConst) { + int divisor = rhsConst->getInt(); + if (divisor > 0 && (divisor & (divisor - 1)) == 0) { + int shift = 0; + int temp = divisor; + while (temp > 1) { + temp >>= 1; + shift++; + } + resultValue = builder.createSRAInst(lhs, ConstantInteger::get(shift)); + } else { + resultValue = builder.createDivInst(lhs, rhs); } - resultValue = builder.createSRAInst(lhs, ConstantInteger::get(shift)); } else { resultValue = builder.createDivInst(lhs, rhs); } - } else { - resultValue = builder.createDivInst(lhs, rhs); + break; } - break; - } - case BinaryOp::MOD: resultValue = builder.createRemInst(lhs, rhs); break; - } - } else if (commonType == Type::getFloatType()) { - switch (op) { - case BinaryOp::ADD: resultValue = builder.createFAddInst(lhs, rhs); break; - case BinaryOp::SUB: resultValue = builder.createFSubInst(lhs, rhs); break; - case BinaryOp::MUL: resultValue = builder.createFMulInst(lhs, rhs); break; - case BinaryOp::DIV: resultValue = builder.createFDivInst(lhs, rhs); break; - case BinaryOp::MOD: - std::cerr << "Error: Modulo operator not supported for float types." << std::endl; + case BinaryOp::MOD: resultValue = builder.createRemInst(lhs, rhs); break; + } + } else if (commonType == Type::getFloatType()) { + switch (op) { + case BinaryOp::ADD: resultValue = builder.createFAddInst(lhs, rhs); break; + case BinaryOp::SUB: resultValue = builder.createFSubInst(lhs, rhs); break; + case BinaryOp::MUL: resultValue = builder.createFMulInst(lhs, rhs); break; + case BinaryOp::DIV: resultValue = builder.createFDivInst(lhs, rhs); break; + case BinaryOp::MOD: + std::cerr << "Error: Modulo operator not supported for float types." << std::endl; + return; + } + } else { + std::cerr << "Error: Unsupported type for binary instruction." << std::endl; return; } - } else { - std::cerr << "Error: Unsupported type for binary instruction." << std::endl; - return; + // 将新创建的指令结果添加到缓存 + availableBinaryExpressions[currentExpKey] = resultValue; } } break; @@ -358,36 +478,45 @@ void SysYIRGenerator::compute() { return; } } else { - // 否则，创建相应的IR指令 - switch (op) { - case BinaryOp::PLUS: - resultValue = operand; // 一元加指令通常直接返回操作数 - break; - case BinaryOp::NEG: { - if (commonType == sysy::Type::getIntType()) { - resultValue = builder.createNegInst(operand); - } else if (commonType == sysy::Type::getFloatType()) { - resultValue = builder.createFNegInst(operand); - } else { - std::cerr << "Error: Negation not supported for operand type." << std::endl; - return; + // 否则，创建相应的IR指令 (在这里应用CSE) + UnExpKey currentUnExpKey(static_cast(op), operand); + auto it = availableUnaryExpressions.find(currentUnExpKey); + if (it != availableUnaryExpressions.end()) { + // 在缓存中找到，重用结果 + resultValue = it->second; + } else { + switch (op) { + case BinaryOp::PLUS: + resultValue = operand; // 一元加指令通常直接返回操作数 + break; + case BinaryOp::NEG: { + if (commonType == sysy::Type::getIntType()) { + resultValue = builder.createNegInst(operand); + } else if (commonType == sysy::Type::getFloatType()) { + resultValue = builder.createFNegInst(operand); + } else { + std::cerr << "Error: Negation not supported for operand type." << std::endl; + return; + } + break; + } + case BinaryOp::NOT: + // 逻辑非 + if (commonType == sysy::Type::getIntType()) { + resultValue = builder.createNotInst(operand); + } else if (commonType == sysy::Type::getFloatType()) { + resultValue = builder.createFNotInst(operand); + } else { + std::cerr << "Error: Logical NOT not supported for operand type." << std::endl; + return; + } + break; + default: + std::cerr << "Error: Unknown unary operator for instructions: " << op << std::endl; + return; } - break; - } - case BinaryOp::NOT: - // 逻辑非 - if (commonType == sysy::Type::getIntType()) { - resultValue = builder.createNotInst(operand); - } else if (commonType == sysy::Type::getFloatType()) { - resultValue = builder.createFNotInst(operand); - } else { - std::cerr << "Error: Logical NOT not supported for operand type." << std::endl; - return; - } - break; - default: - std::cerr << "Error: Unknown unary operator for instructions: " << op << std::endl; - return; + // 将新创建的指令结果添加到缓存 + availableUnaryExpressions[currentUnExpKey] = resultValue; } } break; @@ -529,7 +658,19 @@ Value* SysYIRGenerator::getGEPAddressInst(Value* basePointer, const std::vector< // `indices` 向量现在由调用方（如 visitLValue, visitVarDecl, visitAssignStmt）负责完整准备， // 包括是否需要添加初始的 `0` 索引。 // 所以这里直接将其传递给 `builder.createGetElementPtrInst`。 - return builder.createGetElementPtrInst(basePointer, indices); + GEPKey key = {basePointer, indices}; + + // 尝试从缓存中查找 + auto it = availableGEPs.find(key); + if (it != availableGEPs.end()) { + return it->second; // 缓存命中，返回已有的 GEPInst* + } + + // 缓存未命中，创建新的 GEPInst + Value* gepInst = builder.createGetElementPtrInst(basePointer, indices); // 假设 builder 提供了 createGEPInst 方法 + availableGEPs[key] = gepInst; // 将新的 GEPInst* 加入缓存 + + return gepInst; } /* @@ -628,7 +769,13 @@ std::any SysYIRGenerator::visitConstDecl(SysYParser::ConstDeclContext *ctx) { // 显式地为局部常量在栈上分配空间 // alloca 的类型将是指针指向常量类型，例如 `int*` 或 `int[2][3]*` + // 将alloca全部集中到entry中 + auto entry = builder.getBasicBlock()->getParent()->getEntryBlock(); + auto it = builder.getPosition(); + auto nowblk = builder.getBasicBlock(); + builder.setPosition(entry, entry->terminator()); AllocaInst *alloca = builder.createAllocaInst(Type::getPointerType(variableType), name); + builder.setPosition(nowblk, it); ArrayValueTree *root = std::any_cast(constDef->constInitVal()->accept(this)); ValueCounter values; @@ -785,8 +932,12 @@ std::any SysYIRGenerator::visitVarDecl(SysYParser::VarDeclContext *ctx) { // 对于数组，alloca 的类型将是指针指向数组类型，例如 `int[2][3]*` // 对于标量，alloca 的类型将是指针指向标量类型，例如 `int*` - AllocaInst* alloca = - builder.createAllocaInst(Type::getPointerType(variableType), name); + auto entry = builder.getBasicBlock()->getParent()->getEntryBlock(); + auto it = builder.getPosition(); + auto nowblk = builder.getBasicBlock(); + builder.setPosition(entry, entry->terminator()); + AllocaInst *alloca = builder.createAllocaInst(Type::getPointerType(variableType), name); + builder.setPosition(nowblk, it); if (varDef->initVal() != nullptr) { ValueCounter values; @@ -988,6 +1139,8 @@ std::any SysYIRGenerator::visitFuncType(SysYParser::FuncTypeContext *ctx) { std::any SysYIRGenerator::visitFuncDef(SysYParser::FuncDefContext *ctx){ // 更新作用域 module->enterNewScope(); + // 清除CSE缓存 + enterNewBasicBlock(); auto name = ctx->Ident()->getText(); std::vector paramActualTypes; @@ -1143,7 +1296,16 @@ std::any SysYIRGenerator::visitAssignStmt(SysYParser::AssignStmtContext *ctx) { if (AllocaInst *alloc = dynamic_cast(variable)) { Type* allocatedType = alloc->getType()->as()->getBaseType(); if (allocatedType->isPointer()) { - gepBasePointer = builder.createLoadInst(alloc); + // 尝试从缓存中获取 builder.createLoadInst(alloc) 的结果 + auto it = availableLoads.find(alloc); + if (it != availableLoads.end()) { + gepBasePointer = it->second; // 缓存命中，重用 + } else { + gepBasePointer = builder.createLoadInst(alloc); // 缓存未命中，创建新的 LoadInst + availableLoads[alloc] = gepBasePointer; // 将结果加入缓存 + } + // --- CSE 结束 --- + // gepBasePointer = builder.createLoadInst(alloc); gepIndices = indices; } else { gepBasePointer = alloc; @@ -1205,9 +1367,9 @@ std::any SysYIRGenerator::visitAssignStmt(SysYParser::AssignStmtContext *ctx) { } } } - + builder.createStoreInst(RValue, LValue); - + invalidateExpressionsOnStore(LValue); return std::any(); } @@ -1244,7 +1406,9 @@ std::any SysYIRGenerator::visitIfStmt(SysYParser::IfStmtContext *ctx) { labelstring.str(""); function->addBasicBlock(thenBlock); builder.setPosition(thenBlock, thenBlock->end()); - + // CSE清除缓存 + enterNewBasicBlock(); + auto block = dynamic_cast(ctx->stmt(0)); // 如果是块语句，直接访问 // 否则访问语句 @@ -1263,7 +1427,9 @@ std::any SysYIRGenerator::visitIfStmt(SysYParser::IfStmtContext *ctx) { labelstring.str(""); function->addBasicBlock(elseBlock); builder.setPosition(elseBlock, elseBlock->end()); - + // CSE清除缓存 + enterNewBasicBlock(); + block = dynamic_cast(ctx->stmt(1)); if (block != nullptr) { visitBlockStmt(block); @@ -1280,7 +1446,9 @@ std::any SysYIRGenerator::visitIfStmt(SysYParser::IfStmtContext *ctx) { labelstring.str(""); function->addBasicBlock(exitBlock); builder.setPosition(exitBlock, exitBlock->end()); - + // CSE清除缓存 + enterNewBasicBlock(); + } else { builder.pushTrueBlock(thenBlock); builder.pushFalseBlock(exitBlock); @@ -1293,7 +1461,9 @@ std::any SysYIRGenerator::visitIfStmt(SysYParser::IfStmtContext *ctx) { labelstring.str(""); function->addBasicBlock(thenBlock); builder.setPosition(thenBlock, thenBlock->end()); - + // CSE清除缓存 + enterNewBasicBlock(); + auto block = dynamic_cast(ctx->stmt(0)); if (block != nullptr) { visitBlockStmt(block); @@ -1310,6 +1480,9 @@ std::any SysYIRGenerator::visitIfStmt(SysYParser::IfStmtContext *ctx) { labelstring.str(""); function->addBasicBlock(exitBlock); builder.setPosition(exitBlock, exitBlock->end()); + // CSE清除缓存 + enterNewBasicBlock(); + } return std::any(); } @@ -1327,7 +1500,9 @@ std::any SysYIRGenerator::visitWhileStmt(SysYParser::WhileStmtContext *ctx) { builder.createUncondBrInst(headBlock); BasicBlock::conectBlocks(curBlock, headBlock); builder.setPosition(headBlock, headBlock->end()); - + // CSE清除缓存 + enterNewBasicBlock(); + BasicBlock* bodyBlock = new BasicBlock(function); BasicBlock* exitBlock = new BasicBlock(function); @@ -1343,6 +1518,8 @@ std::any SysYIRGenerator::visitWhileStmt(SysYParser::WhileStmtContext *ctx) { labelstring.str(""); function->addBasicBlock(bodyBlock); builder.setPosition(bodyBlock, bodyBlock->end()); + // CSE清除缓存 + enterNewBasicBlock(); builder.pushBreakBlock(exitBlock); builder.pushContinueBlock(headBlock); @@ -1367,7 +1544,9 @@ std::any SysYIRGenerator::visitWhileStmt(SysYParser::WhileStmtContext *ctx) { labelstring.str(""); function->addBasicBlock(exitBlock); builder.setPosition(exitBlock, exitBlock->end()); - + // CSE清除缓存 + enterNewBasicBlock(); + return std::any(); } @@ -1482,62 +1661,34 @@ std::any SysYIRGenerator::visitLValue(SysYParser::LValueContext *ctx) { // 3. 处理可变变量 (AllocaInst/GlobalValue) 或带非常量索引的常量变量 // 这里区分标量访问和数组元素/子数组访问 - + Value *targetAddress = nullptr; // 检查是否是访问标量变量本身（没有索引，且声明维度为0） if (dims.empty() && declaredNumDims == 0) { - // 对于标量变量，直接加载其值。 - // variable 本身就是指向标量的指针 (e.g., int* %a) if (dynamic_cast(variable) || dynamic_cast(variable)) { - value = builder.createLoadInst(variable); + targetAddress = variable; } else { - // 如果走到这里且不是AllocaInst/GlobalValue，但dims为空且declaredNumDims为0， - // 且又不是ConstantVariable (前面已处理)，则可能是错误情况。 assert(false && "Unhandled scalar variable type in LValue access."); return static_cast(nullptr); } } else { - // 访问数组元素或子数组（有索引，或变量本身是数组/多维指针） Value* gepBasePointer = nullptr; - std::vector gepIndices; // 准备传递给 getGEPAddressInst 的索引列表 - // GEP 的基指针就是变量本身（它是一个指向内存的指针） + std::vector gepIndices; if (AllocaInst *alloc = dynamic_cast(variable)) { - // 情况 A: 局部变量 (AllocaInst) - // 获取 AllocaInst 分配的内存的实际类型。 - // 例如：对于 `int b[10][20];`，`allocatedType` 是 `[10 x [20 x i32]]`。 - // 对于 `int b[][20]` 的函数参数，其 AllocaInst 存储的是一个指针， - // 此时 `allocatedType` 是 `[20 x i32]*`。 Type* allocatedType = alloc->getType()->as()->getBaseType(); - if (allocatedType->isPointer()) { - // 如果 AllocaInst 分配的是一个指针类型 (例如，用于存储函数参数的指针，如 int b[][20] 中的 b) - // 即 `allocatedType` 是一个指向数组指针的指针 (e.g., [20 x i32]**) - // 那么 GEP 的基指针是加载这个指针变量的值。 - gepBasePointer = builder.createLoadInst(alloc); // 加载出实际的指针值 (e.g., [20 x i32]*) - // 对于这种参数指针，用户提供的索引直接作用于它。不需要额外的 0。 + gepBasePointer = builder.createLoadInst(alloc); gepIndices = dims; } else { - // 如果 AllocaInst 分配的是实际的数组数据 (例如，int b[10][20] 中的 b) - // 那么 AllocaInst 本身就是 GEP 的基指针。 - // 这里的 `alloc` 是指向数组的指针 (e.g., [10 x [20 x i32]]*) - gepBasePointer = alloc; // 类型是 [10 x [20 x i32]]* - // 对于这种完整的数组分配，GEP 的第一个索引必须是 0，用于“步过”整个数组。 + gepBasePointer = alloc; gepIndices.push_back(ConstantInteger::get(0)); gepIndices.insert(gepIndices.end(), dims.begin(), dims.end()); } } else if (GlobalValue *glob = dynamic_cast(variable)) { - // 情况 B: 全局变量 (GlobalValue) - // GlobalValue 总是指向全局数据的指针。 - gepBasePointer = glob; // 类型是 [61 x [67 x i32]]* - // 对于全局数组，GEP 的第一个索引必须是 0，用于“步过”整个数组。 + gepBasePointer = glob; gepIndices.push_back(ConstantInteger::get(0)); gepIndices.insert(gepIndices.end(), dims.begin(), dims.end()); } else if (ConstantVariable *constV = dynamic_cast(variable)) { - // 情况 C: 常量变量 (ConstantVariable)，如果它代表全局数组常量 - // 假设 ConstantVariable 可以直接作为 GEP 的基指针。 gepBasePointer = constV; - // 对于常量数组，也需要 0 索引来“步过”整个数组。 - // 这里可以进一步检查 constV->getType()->as()->getBaseType()->isArray() - // 但为了简洁，假设所有 ConstantVariable 作为 GEP 基指针时都需要此 0。 gepIndices.push_back(ConstantInteger::get(0)); gepIndices.insert(gepIndices.end(), dims.begin(), dims.end()); } else { @@ -1545,18 +1696,25 @@ std::any SysYIRGenerator::visitLValue(SysYParser::LValueContext *ctx) { return static_cast(nullptr); } - // 现在调用 getGEPAddressInst，传入正确准备的基指针和索引列表 - Value *targetAddress = getGEPAddressInst(gepBasePointer, gepIndices); + targetAddress = getGEPAddressInst(gepBasePointer, gepIndices); - // 如果提供的索引数量少于声明的维度数量，则表示访问的是子数组，返回其地址 - if (dims.size() < declaredNumDims) { - value = targetAddress; + } + + // 如果提供的索引数量少于声明的维度数量，则表示访问的是子数组，返回其地址 (无需加载) + if (dims.size() < declaredNumDims) { + value = targetAddress; + } else { + // value = builder.createLoadInst(targetAddress); + auto it = availableLoads.find(targetAddress); + if (it != availableLoads.end()) { + value = it->second; // 缓存命中，重用已有的 LoadInst 结果 } else { - // 否则，表示访问的是最终的标量元素，加载其值 - // 假设 createLoadInst 接受 Value* pointer - value = builder.createLoadInst(targetAddress); + // 缓存未命中，创建新的 LoadInst + value = builder.createLoadInst(targetAddress); + availableLoads[targetAddress] = value; // 将新的 LoadInst 结果加入缓存 } } + return value; } @@ -1676,6 +1834,7 @@ std::any SysYIRGenerator::visitUnaryExp(SysYParser::UnaryExpContext *ctx) { visitPrimaryExp(ctx->primaryExp()); } else if (ctx->call() != nullptr) { BinaryExpStack.push_back(std::any_cast(visitCall(ctx->call())));BinaryExpLenStack.back()++; + invalidateExpressionsOnCall(); } else if (ctx->unaryOp() != nullptr) { // 遇到一元操作符，将其压入 BinaryExpStack auto opNode = dynamic_cast(ctx->unaryOp()->children[0]); From 5f63554ca36e9ed2f8e066cec02077df849f654b Mon Sep 17 00:00:00 2001 From: rain2133 <1370973498@qq.com> Date: Mon, 4 Aug 2025 18:56:57 +0800 Subject: [PATCH 36/55] =?UTF-8?q?[midend]=E4=BF=AE=E6=AD=A3=E5=90=88?= =?UTF-8?q?=E5=B9=B6=E5=9F=BA=E6=9C=AC=E5=9D=97=E9=93=BE=E4=BC=9A=E5=B0=86?= =?UTF-8?q?entry=E5=9D=97=E7=BA=B3=E5=85=A5=E8=80=83=E8=99=91=E8=8C=83?= =?UTF-8?q?=E5=9B=B4=E7=9A=84=E9=97=AE=E9=A2=98=E3=80=82=E4=B8=8A=E6=AC=A1?= =?UTF-8?q?commit=E5=90=8C=E6=97=B6=E4=BF=AE=E6=94=B9=E4=BA=86alloca?= =?UTF-8?q?=E5=88=9B=E5=BB=BA=E7=9A=84=E9=80=BB=E8=BE=91=E4=BF=9D=E8=AF=81?= =?UTF-8?q?=E4=BA=86alloca=E7=9A=84=E5=A3=B0=E6=98=8E=E5=85=A8=E9=83=A8?= =?UTF-8?q?=E5=9C=A8entry=E5=9D=97=E4=B8=AD?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/midend/Pass/Optimize/SysYIRCFGOpt.cpp | 14 +++++++++----- 1 file changed, 9 insertions(+), 5 deletions(-) diff --git a/src/midend/Pass/Optimize/SysYIRCFGOpt.cpp b/src/midend/Pass/Optimize/SysYIRCFGOpt.cpp index 5e75645..393df63 100644 --- a/src/midend/Pass/Optimize/SysYIRCFGOpt.cpp +++ b/src/midend/Pass/Optimize/SysYIRCFGOpt.cpp @@ -77,6 +77,11 @@ bool SysYCFGOptUtils::SysYBlockMerge(Function *func) { bool changed = false; for (auto blockiter = func->getBasicBlocks().begin(); blockiter != func->getBasicBlocks().end();) { + // 检查当前块是是不是entry块 + if( blockiter->get() == func->getEntryBlock() ) { + blockiter++; + continue; // 跳过入口块 + } if (blockiter->get()->getNumSuccessors() == 1) { // 如果当前块只有一个后继块 // 且后继块只有一个前驱块 @@ -288,13 +293,12 @@ bool SysYCFGOptUtils::SysYDelEmptyBlock(Function *func, IRBuilder *pBuilder) { continue; } - std::function getUltimateSourceValue = [&](Value *val, - BasicBlock *currentDefBlock) -> Value * { - // 如果值不是指令，例如常量或函数参数，则它本身就是最终来源 - if (auto instr = dynamic_cast(val)) { // Assuming Value* has a method to check if it's an instruction + std::function getUltimateSourceValue = [&](Value *val, BasicBlock *currentDefBlock) -> Value * { + + if(!dynamic_cast(val)) { + // 如果 val 不是指令，直接返回它 return val; } - Instruction *inst = dynamic_cast(val); // 如果定义指令不在任何空块中，它就是最终来源 if (!emptyBlockRedirectMap.count(currentDefBlock)) { From 08fcda939b1cc10c61bd56b5d1cedad1dfe07744 Mon Sep 17 00:00:00 2001 From: rain2133 <1370973498@qq.com> Date: Wed, 6 Aug 2025 01:02:11 +0800 Subject: [PATCH 37/55] =?UTF-8?q?[midend-llvmirprint]=E5=AE=9E=E7=8E=B0?= =?UTF-8?q?=E4=BA=86=E5=A4=A7=E9=83=A8=E5=88=86=E5=87=BD=E6=95=B0=E7=9A=84?= =?UTF-8?q?print=E6=96=B9=E6=B3=95=EF=BC=8CTODO=EF=BC=9A=E9=9C=80=E8=A6=81?= =?UTF-8?q?=E5=AE=8C=E5=96=84func=E5=92=8Cmodule=E7=9A=84print=E6=96=B9?= =?UTF-8?q?=E6=B3=95=E4=BB=A5=E5=8F=8A=E9=87=8D=E5=91=BD=E5=90=8D=E7=9A=84?= =?UTF-8?q?=E9=80=BB=E8=BE=91?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/include/midend/IR.h | 129 ++++++++++------- src/midend/IR.cpp | 310 ++++++++++++++++++++++++++++++++++++++-- 2 files changed, 378 insertions(+), 61 deletions(-) diff --git a/src/include/midend/IR.h b/src/include/midend/IR.h index ff30db7..241f28f 100644 --- a/src/include/midend/IR.h +++ b/src/include/midend/IR.h @@ -83,6 +83,7 @@ class Type { auto as() const -> std::enable_if_t, T *> { return dynamic_cast(const_cast(this)); } + virtual void print(std::ostream& os) const; }; class PointerType : public Type { @@ -97,6 +98,7 @@ class PointerType : public Type { public: Type* getBaseType() const { return baseType; } ///< 获取指向的类型 + void print(std::ostream& os) const override; }; class FunctionType : public Type { @@ -116,6 +118,7 @@ class FunctionType : public Type { Type* getReturnType() const { return returnType; } ///< 获取返回值类信息 auto getParamTypes() const { return make_range(paramTypes); } ///< 获取形参类型列表 unsigned getNumParams() const { return paramTypes.size(); } ///< 获取形参数量 + void print(std::ostream& os) const override; }; class ArrayType : public Type { @@ -132,6 +135,7 @@ class ArrayType : public Type { : Type(Kind::kArray), elementType(elementType), numElements(numElements) {} Type *elementType; unsigned numElements; // 当前维度的大小 + void print(std::ostream& os) const override; }; /*! @@ -206,6 +210,7 @@ class Use { User* getUser() const { return user; } ///< 返回使用者 Value* getValue() const { return value; } ///< 返回被使用的值 void setValue(Value *newValue) { value = newValue; } ///< 将被使用的值设置为newValue + void print(std::ostream& os) const; }; //! The base class of all value types @@ -238,6 +243,7 @@ class Value { uses.remove(use); } ///< 删除使用关系use void removeAllUses(); + virtual void print(std::ostream& os) const = 0; ///< 输出值信息到输出流 }; /** @@ -402,6 +408,7 @@ public: virtual bool isZero() const = 0; virtual bool isOne() const = 0; + void print(std::ostream& os) const = 0; }; class ConstantInteger : public ConstantValue { @@ -428,6 +435,7 @@ public: bool isZero() const override { return constVal == 0; } bool isOne() const override { return constVal == 1; } + void print(std::ostream& os) const; }; class ConstantFloating : public ConstantValue { @@ -454,6 +462,7 @@ public: bool isZero() const override { return constFVal == 0.0f; } bool isOne() const override { return constFVal == 1.0f; } + void print(std::ostream& os) const; }; class UndefinedValue : public ConstantValue { @@ -485,6 +494,7 @@ public: bool isZero() const override { return false; } bool isOne() const override { return false; } + void print(std::ostream& os) const; }; // --- End of refactored ConstantValue and related classes --- @@ -625,6 +635,7 @@ public: } } ///< 移除指定位置的指令 iterator moveInst(iterator sourcePos, iterator targetPos, BasicBlock *block); + void print(std::ostream& os) const; }; //! User is the abstract base type of `Value` types which use other `Value` as @@ -736,57 +747,57 @@ public: std::string getKindString() const{ switch (kind) { case kInvalid: - return "Invalid"; + return "invalid"; case kAdd: - return "Add"; + return "add"; case kSub: - return "Sub"; + return "sub"; case kMul: - return "Mul"; + return "mul"; case kDiv: - return "Div"; + return "sdiv"; case kRem: - return "Rem"; + return "srem"; case kICmpEQ: - return "ICmpEQ"; + return "icmp eq"; case kICmpNE: - return "ICmpNE"; + return "icmp ne"; case kICmpLT: - return "ICmpLT"; + return "icmp slt"; case kICmpGT: - return "ICmpGT"; + return "icmp sgt"; case kICmpLE: - return "ICmpLE"; + return "icmp sle"; case kICmpGE: - return "ICmpGE"; + return "icmp sge"; case kFAdd: - return "FAdd"; + return "fadd"; case kFSub: - return "FSub"; + return "fsub"; case kFMul: - return "FMul"; + return "fmul"; case kFDiv: - return "FDiv"; + return "fdiv"; case kFCmpEQ: - return "FCmpEQ"; + return "fcmp oeq"; case kFCmpNE: - return "FCmpNE"; + return "fcmp one"; case kFCmpLT: - return "FCmpLT"; + return "fcmp olt"; case kFCmpGT: - return "FCmpGT"; + return "fcmp ogt"; case kFCmpLE: - return "FCmpLE"; + return "fcmp ole"; case kFCmpGE: - return "FCmpGE"; + return "fcmp oge"; case kAnd: - return "And"; + return "and"; case kOr: - return "Or"; + return "or"; case kNeg: - return "Neg"; + return "neg"; case kNot: - return "Not"; + return "not"; case kFNeg: return "FNeg"; case kFNot: @@ -794,27 +805,29 @@ public: case kFtoI: return "FtoI"; case kItoF: - return "IToF"; + return "iToF"; case kCall: - return "Call"; + return "call"; case kCondBr: - return "CondBr"; + return "condBr"; case kBr: - return "Br"; + return "br"; case kReturn: - return "Return"; + return "return"; + case kUnreachable: + return "unreachable"; case kAlloca: - return "Alloca"; + return "alloca"; case kLoad: - return "Load"; + return "load"; case kStore: - return "Store"; + return "store"; case kGetElementPtr: - return "GetElementPtr"; + return "getElementPtr"; case kMemset: - return "Memset"; + return "memset"; case kPhi: - return "Phi"; + return "phi"; case kBitItoF: return "BitItoF"; case kBitFtoI: @@ -887,6 +900,7 @@ public: static constexpr uint64_t DefineOpMask = kAlloca | kStore | kPhi; return (kind & DefineOpMask) != 0U; } + virtual void print(std::ostream& os) const = 0; }; // class Instruction class Function; @@ -957,6 +971,7 @@ class PhiInst : public Instruction { } } ///< 刷新块到值的映射关系 auto getValues() { return make_range(std::next(operand_begin()), operand_end()); } + void print(std::ostream& os) const override; }; @@ -965,16 +980,20 @@ class CallInst : public Instruction { friend class IRBuilder; protected: - CallInst(Function *callee, const std::vector &args = {}, - BasicBlock *parent = nullptr, const std::string &name = ""); - + CallInst(Function *callee, const std::vector &args, BasicBlock *parent = nullptr, const std::string &name = "") + : Instruction(kCall, callee->getReturnType(), parent, name) { + addOperand(callee); + for (auto arg : args) { + addOperand(arg); + } + } public: - Function* getCallee() const; + Function *getCallee() const { return dynamic_cast(getOperand(0)); } auto getArguments() const { return make_range(std::next(operand_begin()), operand_end()); } - + void print(std::ostream& os) const override; }; // class CallInst //! Unary instruction, includes '!', '-' and type conversion. @@ -992,7 +1011,7 @@ protected: public: Value* getOperand() const { return User::getOperand(0); } - + void print(std::ostream& os) const override; }; // class UnaryInst //! Binary instruction, e.g., arithmatic, relation, logic, etc. @@ -1071,6 +1090,7 @@ public: // 后端处理数组访存操作时需要创建计算地址的指令，需要在外部构造 BinaryInst 对象 return new BinaryInst(kind, type, lhs, rhs, parent, name); } + void print(std::ostream& os) const override; }; // class BinaryInst //! The return statement @@ -1091,6 +1111,7 @@ class ReturnInst : public Instruction { Value* getReturnValue() const { return hasReturnValue() ? getOperand(0) : nullptr; } + void print(std::ostream& os) const override; }; //! Unconditional branch @@ -1120,7 +1141,7 @@ public: } return succs; } - + void print(std::ostream& os) const override; }; // class UncondBrInst //! Conditional branch @@ -1160,7 +1181,7 @@ public: } return succs; } - + void print(std::ostream& os) const override; }; // class CondBrInst class UnreachableInst : public Instruction { @@ -1168,7 +1189,7 @@ public: // 构造函数：设置指令类型为 kUnreachable explicit UnreachableInst(const std::string& name, BasicBlock *parent = nullptr) : Instruction(kUnreachable, Type::getVoidType(), parent, "") {} - + void print(std::ostream& os) const { os << "unreachable"; } }; //! Allocate memory for stack variables, used for non-global variable declartion @@ -1186,7 +1207,7 @@ public: Type* getAllocatedType() const { return getType()->as()->getBaseType(); } ///< 获取分配的类型 - + void print(std::ostream& os) const override; }; // class AllocaInst @@ -1224,6 +1245,7 @@ public: BasicBlock *parent = nullptr, const std::string &name = "") { return new GetElementPtrInst(resultType, basePointer, indices, parent, name); } + void print(std::ostream& os) const override; }; //! Load a value from memory address specified by a pointer value @@ -1241,7 +1263,7 @@ protected: public: Value* getPointer() const { return getOperand(0); } - + void print(std::ostream& os) const override; }; // class LoadInst //! Store a value to memory address specified by a pointer value @@ -1260,7 +1282,7 @@ protected: public: Value* getValue() const { return getOperand(0); } Value* getPointer() const { return getOperand(1); } - + void print(std::ostream& os) const override; }; // class StoreInst //! Memset instruction @@ -1290,7 +1312,7 @@ public: Value* getBegin() const { return getOperand(1); } Value* getSize() const { return getOperand(2); } Value* getValue() const { return getOperand(3); } - + void print(std::ostream& os) const override; }; class GlobalValue; @@ -1308,6 +1330,7 @@ public: public: Function* getParent() const { return func; } int getIndex() const { return index; } + void print(std::ostream& os) const; }; @@ -1385,6 +1408,7 @@ protected: blocks.emplace_front(block); return block; } + void print(std::ostream& os) const; }; //! Global value declared at file scope @@ -1450,6 +1474,7 @@ public: return getByIndex(index); } ///< 通过多维索引indices获取初始值 const ValueCounter& getInitValues() const { return initValues; } + void print(std::ostream& os) const; }; // class GlobalValue @@ -1507,6 +1532,8 @@ class ConstantVariable : public Value { return getByIndex(index); } ///< 通过多维索引indices获取初始值 const ValueCounter& getInitValues() const { return initValues; } ///< 获取初始值 + void print(std::ostream& os) const; + void print_init(std::ostream& os) const; }; using SymbolTableNode = struct SymbolTableNode { @@ -1620,6 +1647,8 @@ class Module { void leaveScope() { variableTable.leaveScope(); } ///< 离开作用域 bool isInGlobalArea() const { return variableTable.isInGlobalScope(); } ///< 是否位于全局作用域 + + void print(std::ostream& os) const; }; /*! diff --git a/src/midend/IR.cpp b/src/midend/IR.cpp index ae676f0..37e1a9a 100644 --- a/src/midend/IR.cpp +++ b/src/midend/IR.cpp @@ -5,9 +5,11 @@ #include #include #include +#include #include #include "IRBuilder.h" +using namespace std; /** * @file IR.cpp * @@ -15,6 +17,64 @@ */ namespace sysy { +/*相关打印函数*/ + +template +ostream &interleave(std::ostream &os, const T &container, const std::string sep = ", ") { + auto b = container.begin(), e = container.end(); + if (b == e) + return os; + os << *b; + for (b = std::next(b); b != e; b = std::next(b)) + os << sep << *b; + return os; +} + +template +ostream &interleave_call(std::ostream &os, const T &container, const std::string sep = ", ") { + auto b = container.begin(), e = container.end(); + b = std::next(b); // Skip the first element + if (b == e) + return os; + os << *b; + for (b = std::next(b); b != e; b = std::next(b)) + os << sep << *b; + return os; +} + +static inline ostream &printVarName(ostream &os, const Value *var) +{ + if (dynamic_cast(var) != nullptr) { + auto globalVal = dynamic_cast(var); + return os << "@" << globalVal->getName(); + } else { + return os << "%" << var->getName(); + } +} +static inline ostream &printBlockName(ostream &os, const BasicBlock *block) { + return os << block->getName(); +} +static inline ostream &printFunctionName(ostream &os, const Function *fn) { + return os << '@' << fn->getName(); +} +static inline ostream &printOperand(ostream &os, const Value *value) { + auto constValue = dynamic_cast(value); + if (constValue != nullptr) { + constValue->print(os); + return os; + } + return printVarName(os, value); +} + +inline std::ostream& operator<<(std::ostream& os, const Type& type) { + type.print(os); + return os; +} + +inline std::ostream& operator<<(std::ostream& os, const Value& value) { + value.print(os); + return os; +} //===----------------------------------------------------------------------===// // Types //===----------------------------------------------------------------------===// @@ -73,6 +133,37 @@ auto Type::getSize() const -> unsigned { return 0; } + +void Type::print(ostream &os) const { + auto kind = getKind(); + switch (kind){ + case kInt: os << "i32"; break; + case kFloat: os << "float"; break; + case kVoid: os << "void"; break; + case kPointer: + static_cast(this)->getBaseType()->print(os); + os << "*"; + break; + case kFunction: + static_cast(this)->getReturnType()->print(os); + os << "("; + interleave(os, static_cast(this)->getParamTypes()); + os << ")"; + break; + case kArray: + os << "["; + os << static_cast(this)->getNumElements(); + os << " x "; + static_cast(this)->getElementType()->print(os); + os << "]"; + break; + case kLabel: + default: + cerr << "error type\n"; + break; + } +} + PointerType* PointerType::get(Type *baseType) { static std::map> pointerTypes; auto iter = pointerTypes.find(baseType); @@ -204,6 +295,214 @@ UndefinedValue* UndefinedValue::get(Type* type) { return newUndef; } +inline std::string getMachineCode(float fval) { + uint32_t mrf = *reinterpret_cast(&fval); + std::stringstream ss; + ss << std::hex << std::uppercase << std::setfill('0') << std::setw(8) << mrf; + return "0x" + ss.str(); +} + +void ConstantValue::print(std::ostream &os) const { + if(dynamic_cast(this)) { + dynamic_cast(this)->print(os); + } else if(dynamic_cast(this)) { + dynamic_cast(this)->print(os); + } else if(dynamic_cast(this)) { + dynamic_cast(this)->print(os); + } else { + os << "unknown constant type"; + } +} + +void ConstantInteger::print(std::ostream &os) const { + os << "i32 " << this->getInt(); +} +void ConstantFloating::print(std::ostream &os) const { + os << "float " << getMachineCode(this->getFloat()); +} +void UndefinedValue::print(std::ostream &os) const { + os << this->getType() << " undef"; +} + +void BasicBlock::print(std::ostream &os) const { + assert(this->getName() != "" && "BasicBlock name cannot be empty"); + os << " "; + printBlockName(os, this); + os << ":\n"; + for (auto &inst : instructions) { + os << " " << *inst << '\n'; + } +} + +void PhiInst::print(std::ostream &os) const { + printVarName(os, this); + os << " = " << getKindString() << " " << *getType() << " "; + for (unsigned i = 0; i < vsize; ++i) { + if (i > 0) { + os << ", "; + } + os << " ["; + printOperand(os, getIncomingValue(i)); + os << ", "; + printBlockName(os, getIncomingBlock(i)); + os << "]"; + } +} + +void CallInst::print(std::ostream &os) const { + if(!getType()->isVoid()) { + printVarName(os, this) << " = "; + } + os << getKindString() << *getType() << " " ; + printFunctionName(os, getCallee()); + os << "("; + interleave_call(os, getOperands()); + os << ")"; +} + +// 情况比较复杂就不用getkindstring了 +void UnaryInst::print(std::ostream &os) const { + printVarName(os, this) << " = "; + switch (getKind()) { + case kNeg: + os << "sub i32 0, "; + printOperand(os, getOperand()); + break; + case kFNeg: + os << "fsub float 0.0, "; + printOperand(os, getOperand()); + break; + case kNot: + os << "xor " << *getOperand()->getType() << " "; + printOperand(os, getOperand()); + os << ", -1"; + return; + case kFNot: + os << "fcmp une " << *getOperand()->getType() << " "; + printOperand(os, getOperand()); + os << ", 0.0"; + return; + case kFtoI: + os << "fptosi " << *getOperand()->getType() << " "; + printOperand(os, getOperand()); + os << " to " << *getType(); + return; + case kItoF: + os << "sitofp " << *getOperand()->getType() << " "; + printOperand(os, getOperand()); + os << " to " << *getType(); + return; + default: + os << "error unary inst"; + return; + } +} + + + +void AllocaInst::print(std::ostream &os) const { + PointerType *ptrType = dynamic_cast(getType()); + Type *baseType = ptrType->getBaseType(); + printVarName(os, this); + os << " = " << getKindString() << " " << *baseType; +} + +void BinaryInst::print(std::ostream &os) const { + printVarName(os, this) << " = "; + + auto kind = getKind(); + + // 检查是否为比较指令 + if (kind == kICmpEQ || kind == kICmpNE || kind == kICmpLT || + kind == kICmpGT || kind == kICmpLE || kind == kICmpGE) { + // 整数比较指令 + os << getKindString() << " " << *getLhs()->getType() << " "; + printOperand(os, getLhs()); + os << ", "; + printOperand(os, getRhs()); + } else if (kind == kFCmpEQ || kind == kFCmpNE || kind == kFCmpLT || + kind == kFCmpGT || kind == kFCmpLE || kind == kFCmpGE) { + // 浮点比较指令 + os << getKindString() << " " << *getLhs()->getType() << " "; + printOperand(os, getLhs()); + os << ", "; + printOperand(os, getRhs()); + } else { + // 算术和逻辑指令 + os << getKindString() << " " << *getType() << " "; + printOperand(os, getLhs()); + os << ", "; + printOperand(os, getRhs()); + } +} + +void ReturnInst::print(std::ostream &os) const { + os << "ret "; + if (hasReturnValue()) { + os << *getReturnValue()->getType() << " "; + printOperand(os, getReturnValue()); + } else { + os << "void"; + } +} + +void UncondBrInst::print(std::ostream &os) const { + os << "br label %"; + printBlockName(os, getBlock()); +} + +void CondBrInst::print(std::ostream &os) const { + os << "br " << *getCondition()->getType() << " "; + printOperand(os, getCondition()); + os << ", label %"; + printBlockName(os, getThenBlock()); + os << ", label %"; + printBlockName(os, getElseBlock()); +} + +void GetElementPtrInst::print(std::ostream &os) const { + printVarName(os, this) << " = getelementptr "; + + // 获取基指针的基类型 + auto basePtr = getBasePointer(); + auto basePtrType = basePtr->getType()->as(); + auto baseType = basePtrType->getBaseType(); + + os << *baseType << ", " << *basePtr->getType() << " "; + printOperand(os, basePtr); + + // 打印索引 - 使用getIndex方法而不是getIndices + for (unsigned i = 0; i < getNumIndices(); ++i) { + auto index = getIndex(i); + os << ", " << *index->getType() << " "; + printOperand(os, index); + } +} + +void LoadInst::print(std::ostream &os) const { + printVarName(os, this) << " = load " << *getType() << ", " << *getPointer()->getType() << " "; + printOperand(os, getPointer()); +} + +void MemsetInst::print(std::ostream &os) const { + os << "call void @llvm.memset.p0i8.i32(i8* "; + printOperand(os, getPointer()); + os << ", i8 "; + printOperand(os, getOperand(3)); // value + os << ", i32 "; + printOperand(os, getOperand(2)); // size + os << ", i1 false)"; +} + +void StoreInst::print(std::ostream &os) const { + os << "store " << *getValue()->getType() << " "; + printOperand(os, getValue()); + os << ", " << *getPointer()->getType() << " "; + printOperand(os, getPointer()); +} + + + auto Function::getCalleesWithNoExternalAndSelf() -> std::set { std::set result; @@ -389,17 +688,6 @@ void PhiInst::replaceIncomingBlock(BasicBlock *oldBlock, BasicBlock *newBlock, V addIncoming(newValue, newBlock); } -CallInst::CallInst(Function *callee, const std::vector &args, BasicBlock *parent, const std::string &name) - : Instruction(kCall, callee->getReturnType(), parent, name) { - addOperand(callee); - for (auto arg : args) { - addOperand(arg); - } -} -/** - * 获取被调用函数的指针 - */ -Function * CallInst::getCallee() const { return dynamic_cast(getOperand(0)); } /** * 获取变量指针 From a4406e011211adcc82acedafd336b9f08aa6bee0 Mon Sep 17 00:00:00 2001 From: rain2133 <1370973498@qq.com> Date: Wed, 6 Aug 2025 01:31:23 +0800 Subject: [PATCH 38/55] =?UTF-8?q?[midend]=E5=A2=9E=E5=8A=A0=E4=BA=86?= =?UTF-8?q?=E6=8C=87=E4=BB=A4=E9=87=8D=E5=91=BD=E5=90=8D=E9=80=BB=E8=BE=91?= =?UTF-8?q?=E3=80=82?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/include/midend/IR.h | 13 +-- src/midend/IR.cpp | 214 +++++++++++++++++++++++++++++++++++++++- 2 files changed, 214 insertions(+), 13 deletions(-) diff --git a/src/include/midend/IR.h b/src/include/midend/IR.h index 241f28f..73a93cc 100644 --- a/src/include/midend/IR.h +++ b/src/include/midend/IR.h @@ -98,7 +98,6 @@ class PointerType : public Type { public: Type* getBaseType() const { return baseType; } ///< 获取指向的类型 - void print(std::ostream& os) const override; }; class FunctionType : public Type { @@ -118,7 +117,6 @@ class FunctionType : public Type { Type* getReturnType() const { return returnType; } ///< 获取返回值类信息 auto getParamTypes() const { return make_range(paramTypes); } ///< 获取形参类型列表 unsigned getNumParams() const { return paramTypes.size(); } ///< 获取形参数量 - void print(std::ostream& os) const override; }; class ArrayType : public Type { @@ -135,7 +133,6 @@ class ArrayType : public Type { : Type(Kind::kArray), elementType(elementType), numElements(numElements) {} Type *elementType; unsigned numElements; // 当前维度的大小 - void print(std::ostream& os) const override; }; /*! @@ -980,16 +977,10 @@ class CallInst : public Instruction { friend class IRBuilder; protected: - CallInst(Function *callee, const std::vector &args, BasicBlock *parent = nullptr, const std::string &name = "") - : Instruction(kCall, callee->getReturnType(), parent, name) { - addOperand(callee); - for (auto arg : args) { - addOperand(arg); - } - } + CallInst(Function *callee, const std::vector &args, BasicBlock *parent = nullptr, const std::string &name = ""); public: - Function *getCallee() const { return dynamic_cast(getOperand(0)); } + Function *getCallee() const; auto getArguments() const { return make_range(std::next(operand_begin()), operand_end()); } diff --git a/src/midend/IR.cpp b/src/midend/IR.cpp index 37e1a9a..c0901cf 100644 --- a/src/midend/IR.cpp +++ b/src/midend/IR.cpp @@ -209,6 +209,62 @@ ArrayType *ArrayType::get(Type *elementType, unsigned numElements) { return result.first->get(); } +void Argument::print(std::ostream& os) const { + os << *getType() << " %" << getName(); +} + +void GlobalValue::print(std::ostream& os) const { + // 输出全局变量的LLVM IR格式 + os << "@" << getName() << " = global "; + + // 输出初始化值 + if (initValues.size() > 0) { + os << *getType()->as()->getBaseType() << " "; + if (initValues.size() == 1) { + // 单个初始值 + initValues.getValue(0)->print(os); + } else { + // 数组初始值 + os << "["; + for (unsigned i = 0; i < initValues.size(); ++i) { + if (i > 0) os << ", "; + auto value = initValues.getValue(i); + os << *value->getType() << " "; + value->print(os); + } + os << "]"; + } + } else { + os << *getType()->as()->getBaseType() << " zeroinitializer"; + } +} + +void ConstantVariable::print(std::ostream& os) const { + // 输出常量的LLVM IR格式 + os << "@" << getName() << " = constant "; + + // 输出初始化值 + if (initValues.size() > 0) { + os << *getType()->as()->getBaseType() << " "; + if (initValues.size() == 1) { + // 单个初始值 + initValues.getValue(0)->print(os); + } else { + // 数组初始值 + os << "["; + for (unsigned i = 0; i < initValues.size(); ++i) { + if (i > 0) os << ", "; + auto value = initValues.getValue(i); + os << *value->getType() << " "; + value->print(os); + } + os << "]"; + } + } else { + os << *getType()->as()->getBaseType() << " zeroinitializer"; + } +} + // void Value::replaceAllUsesWith(Value *value) { // for (auto &use : uses) { // auto user = use->getUser(); @@ -349,6 +405,18 @@ void PhiInst::print(std::ostream &os) const { } } +CallInst::CallInst(Function *callee, const std::vector &args, BasicBlock *parent, const std::string &name) + : Instruction(kCall, callee->getReturnType(), parent, name) { + addOperand(callee); + for (auto arg : args) { + addOperand(arg); + } +} + +Function *CallInst::getCallee() const { + return dynamic_cast(getOperand(0)); +} + void CallInst::print(std::ostream &os) const { if(!getType()->isVoid()) { printVarName(os, this) << " = "; @@ -488,9 +556,9 @@ void MemsetInst::print(std::ostream &os) const { os << "call void @llvm.memset.p0i8.i32(i8* "; printOperand(os, getPointer()); os << ", i8 "; - printOperand(os, getOperand(3)); // value + printOperand(os, getValue()); // value os << ", i32 "; - printOperand(os, getOperand(2)); // size + printOperand(os, getSize()); // size os << ", i1 false)"; } @@ -779,4 +847,146 @@ auto BasicBlock::moveInst(iterator sourcePos, iterator targetPos, BasicBlock *bl return instructions.erase(sourcePos); } +/** + * 为Value重命名以符合LLVM IR格式 + */ +void renameValues(Function* function) { + std::unordered_map valueNames; + unsigned tempCounter = 0; + unsigned labelCounter = 0; + + // 检查名字是否需要重命名（只有纯数字或空名字才需要重命名） + auto needsRename = [](const std::string& name) { + if (name.empty()) return true; + + // 检查是否为纯数字 + for (char c : name) { + if (!std::isdigit(c)) { + return false; // 包含非数字字符，不需要重命名 + } + } + return true; // 纯数字或空字符串，需要重命名 + }; + + // 重命名函数参数 + for (auto arg : function->getArguments()) { + if (needsRename(arg->getName())) { + valueNames[arg] = "%" + std::to_string(tempCounter++); + arg->setName(valueNames[arg].substr(1)); // 去掉%前缀，因为printVarName会加上 + } + } + + // 重命名基本块 + for (auto& block : function->getBasicBlocks()) { + if (needsRename(block->getName())) { + valueNames[block.get()] = "label" + std::to_string(labelCounter++); + block->setName(valueNames[block.get()]); + } + } + + // 重命名指令 + for (auto& block : function->getBasicBlocks()) { + for (auto& inst : block->getInstructions()) { + // 只有产生值的指令需要重命名 + if (!inst->getType()->isVoid() && needsRename(inst->getName())) { + valueNames[inst.get()] = "%" + std::to_string(tempCounter++); + inst->setName(valueNames[inst.get()].substr(1)); // 去掉%前缀 + } + } + } +} + +void Function::print(std::ostream& os) const { + // 重命名所有值 + auto* mutableThis = const_cast(this); + renameValues(mutableThis); + + // 打印函数签名 + os << "define " << *getReturnType() << " "; + printFunctionName(os, this); + os << "("; + + // 打印参数列表 + const auto& args = const_cast(this)->getArguments(); + for (size_t i = 0; i < args.size(); ++i) { + if (i > 0) os << ", "; + os << *args[i]->getType() << " "; + printVarName(os, args[i]); + } + os << ") {\n"; + + // 打印基本块 + for (auto& block : const_cast(this)->getBasicBlocks()) { + block->print(os); + } + + os << "}\n"; +} + +void Module::print(std::ostream& os) const { + // 打印全局变量声明 + for (auto& globalVar : const_cast(this)->getGlobals()) { + printVarName(os, globalVar.get()); + os << " = global " << *globalVar->getType()->as()->getBaseType(); + + // 打印初始值 + const auto& initValues = globalVar->getInitValues(); + if (initValues.size() > 0) { + os << " "; + // 简化处理：只打印第一个初始值 + initValues.getValue(0)->print(os); + } else { + // 默认初始化 + if (globalVar->getType()->as()->getBaseType()->isInt()) { + os << " 0"; + } else if (globalVar->getType()->as()->getBaseType()->isFloat()) { + os << " 0.0"; + } else { + os << " zeroinitializer"; + } + } + os << "\n"; + } + + // 打印常量声明 + for (auto& constVar : getConsts()) { + printVarName(os, constVar.get()); + os << " = constant " << *constVar->getType()->as()->getBaseType(); + os << " "; + const auto& initValues = constVar->getInitValues(); + if (initValues.size() > 0) { + initValues.getValue(0)->print(os); + } else { + os << "0"; + } + os << "\n"; + } + + // 打印外部函数声明 + for (auto& extFunc : getExternalFunctions()) { + os << "declare " << *extFunc.second->getReturnType() << " "; + printFunctionName(os, extFunc.second.get()); + os << "("; + + const auto& paramTypes = extFunc.second->getParamTypes(); + bool first = true; + for (auto paramType : paramTypes) { + if (!first) os << ", "; + os << *paramType; + first = false; + } + os << ")\n"; + } + + if (!getExternalFunctions().empty()) { + os << "\n"; // 外部函数和普通函数之间加空行 + } + + // 打印函数定义 + for (auto& func : const_cast(this)->getFunctions()) { + func.second->print(os); + os << "\n"; // 函数之间加空行 + } +} + } // namespace sysy From 5d343f42a5eb8aaacaeef7af4d4f57c05ccbec89 Mon Sep 17 00:00:00 2001 From: rain2133 <1370973498@qq.com> Date: Wed, 6 Aug 2025 02:02:05 +0800 Subject: [PATCH 39/55] =?UTF-8?q?[midend-llvmirprint]=E6=A3=80=E6=9F=A5?= =?UTF-8?q?=E5=B9=B6=E4=BF=AE=E5=A4=8D=E4=BA=86=E5=88=9D=E5=A7=8B=E5=80=BC?= =?UTF-8?q?=E7=9A=84=E6=89=93=E5=8D=B0=E9=80=BB=E8=BE=91?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/midend/IR.cpp | 191 ++++++++++++++++++++++++++++++++++------------ 1 file changed, 142 insertions(+), 49 deletions(-) diff --git a/src/midend/IR.cpp b/src/midend/IR.cpp index c0901cf..2a41637 100644 --- a/src/midend/IR.cpp +++ b/src/midend/IR.cpp @@ -164,6 +164,21 @@ void Type::print(ostream &os) const { } } +void Use::print(std::ostream& os) const { + os << "Use[" << index << "]: "; + if (value) { + printVarName(os, value); + } else { + os << "null"; + } + os << " used by "; + if (user) { + os << "User@" << user; + } else { + os << "null"; + } +} + PointerType* PointerType::get(Type *baseType) { static std::map> pointerTypes; auto iter = pointerTypes.find(baseType); @@ -217,25 +232,63 @@ void GlobalValue::print(std::ostream& os) const { // 输出全局变量的LLVM IR格式 os << "@" << getName() << " = global "; + auto baseType = getType()->as()->getBaseType(); + os << *baseType << " "; + // 输出初始化值 - if (initValues.size() > 0) { - os << *getType()->as()->getBaseType() << " "; - if (initValues.size() == 1) { - // 单个初始值 - initValues.getValue(0)->print(os); + if (initValues.size() == 0) { + // 没有初始化值，使用zeroinitializer + os << "zeroinitializer"; + } else { + // 检查是否所有值都是零值 + bool allZero = true; + const auto& values = initValues.getValues(); + for (Value* val : values) { + if (auto constVal = dynamic_cast(val)) { + if (!constVal->isZero()) { + allZero = false; + break; + } + } else { + allZero = false; + break; + } + } + + if (allZero) { + // 所有值都是零，使用zeroinitializer + os << "zeroinitializer"; + } else if (initValues.size() == 1) { + // 单个初始值 - 如果是标量零值也考虑使用zeroinitializer + auto singleVal = initValues.getValue(0); + if (auto constVal = dynamic_cast(singleVal)) { + if (constVal->isZero() && (baseType->isInt() || baseType->isFloat())) { + // 标量零值使用zeroinitializer + os << "zeroinitializer"; + } else { + // 非零值或非基本类型，打印实际值 + singleVal->print(os); + } + } else { + // 非常量值，打印实际值 + singleVal->print(os); + } } else { - // 数组初始值 + // 数组初始值 - 需要展开ValueCounter中的压缩表示 os << "["; - for (unsigned i = 0; i < initValues.size(); ++i) { - if (i > 0) os << ", "; - auto value = initValues.getValue(i); - os << *value->getType() << " "; - value->print(os); + bool first = true; + const auto& numbers = initValues.getNumbers(); + + for (size_t i = 0; i < values.size(); ++i) { + for (unsigned j = 0; j < numbers[i]; ++j) { + if (!first) os << ", "; + os << *values[i]->getType() << " "; + values[i]->print(os); + first = false; + } } os << "]"; } - } else { - os << *getType()->as()->getBaseType() << " zeroinitializer"; } } @@ -243,25 +296,91 @@ void ConstantVariable::print(std::ostream& os) const { // 输出常量的LLVM IR格式 os << "@" << getName() << " = constant "; + auto baseType = getType()->as()->getBaseType(); + os << *baseType << " "; + // 输出初始化值 + if (initValues.size() == 0) { + // 没有初始化值，使用zeroinitializer + os << "zeroinitializer"; + } else { + // 检查是否所有值都是零值 + bool allZero = true; + const auto& values = initValues.getValues(); + for (Value* val : values) { + if (auto constVal = dynamic_cast(val)) { + if (!constVal->isZero()) { + allZero = false; + break; + } + } else { + allZero = false; + break; + } + } + + if (allZero) { + // 所有值都是零，使用zeroinitializer + os << "zeroinitializer"; + } else if (initValues.size() == 1) { + // 单个初始值 - 如果是标量零值也考虑使用zeroinitializer + auto singleVal = initValues.getValue(0); + if (auto constVal = dynamic_cast(singleVal)) { + if (constVal->isZero() && (baseType->isInt() || baseType->isFloat())) { + // 标量零值使用zeroinitializer + os << "zeroinitializer"; + } else { + // 非零值或非基本类型，打印实际值 + singleVal->print(os); + } + } else { + // 非常量值，打印实际值 + singleVal->print(os); + } + } else { + // 数组初始值 - 需要展开ValueCounter中的压缩表示 + os << "["; + bool first = true; + const auto& numbers = initValues.getNumbers(); + + for (size_t i = 0; i < values.size(); ++i) { + for (unsigned j = 0; j < numbers[i]; ++j) { + if (!first) os << ", "; + os << *values[i]->getType() << " "; + values[i]->print(os); + first = false; + } + } + os << "]"; + } + } +} + +void ConstantVariable::print_init(std::ostream& os) const { + // 只输出初始化值部分 if (initValues.size() > 0) { - os << *getType()->as()->getBaseType() << " "; if (initValues.size() == 1) { // 单个初始值 initValues.getValue(0)->print(os); } else { - // 数组初始值 + // 数组初始值 - 需要展开ValueCounter中的压缩表示 os << "["; - for (unsigned i = 0; i < initValues.size(); ++i) { - if (i > 0) os << ", "; - auto value = initValues.getValue(i); - os << *value->getType() << " "; - value->print(os); + bool first = true; + const auto& values = initValues.getValues(); + const auto& numbers = initValues.getNumbers(); + + for (size_t i = 0; i < values.size(); ++i) { + for (unsigned j = 0; j < numbers[i]; ++j) { + if (!first) os << ", "; + os << *values[i]->getType() << " "; + values[i]->print(os); + first = false; + } } os << "]"; } } else { - os << *getType()->as()->getBaseType() << " zeroinitializer"; + os << "zeroinitializer"; } } @@ -926,39 +1045,13 @@ void Function::print(std::ostream& os) const { void Module::print(std::ostream& os) const { // 打印全局变量声明 for (auto& globalVar : const_cast(this)->getGlobals()) { - printVarName(os, globalVar.get()); - os << " = global " << *globalVar->getType()->as()->getBaseType(); - - // 打印初始值 - const auto& initValues = globalVar->getInitValues(); - if (initValues.size() > 0) { - os << " "; - // 简化处理：只打印第一个初始值 - initValues.getValue(0)->print(os); - } else { - // 默认初始化 - if (globalVar->getType()->as()->getBaseType()->isInt()) { - os << " 0"; - } else if (globalVar->getType()->as()->getBaseType()->isFloat()) { - os << " 0.0"; - } else { - os << " zeroinitializer"; - } - } + globalVar->print(os); os << "\n"; } // 打印常量声明 for (auto& constVar : getConsts()) { - printVarName(os, constVar.get()); - os << " = constant " << *constVar->getType()->as()->getBaseType(); - os << " "; - const auto& initValues = constVar->getInitValues(); - if (initValues.size() > 0) { - initValues.getValue(0)->print(os); - } else { - os << "0"; - } + constVar->print(os); os << "\n"; } From 37f2a017838c3ec4af475e62524c96b78212254b Mon Sep 17 00:00:00 2001 From: rain2133 <1370973498@qq.com> Date: Wed, 6 Aug 2025 15:28:54 +0800 Subject: [PATCH 40/55] =?UTF-8?q?[midend-llvmirprint]=E4=BF=AE=E5=A4=8D?= =?UTF-8?q?=E4=BA=86gep=E6=8C=87=E4=BB=A4=E5=AF=B9=E4=B8=8D=E5=90=AB?= =?UTF-8?q?=E7=BB=B4=E5=BA=A6=E4=BF=A1=E6=81=AF=E7=9A=84=E6=95=B0=E7=BB=84?= =?UTF-8?q?=E6=8C=87=E9=92=88=E7=9A=84=E5=A4=84=E7=90=86=E9=80=BB=E8=BE=91?= =?UTF-8?q?=EF=BC=8C=E4=BF=AE=E5=A4=8D=E8=8B=A5=E5=B9=B2=E6=89=93=E5=8D=B0?= =?UTF-8?q?bug=EF=BC=8C=E5=9C=A8-s=20ir/ird=20-o=20?= =?UTF-8?q?=E7=9A=84=E5=8F=82=E6=95=B0=E4=B8=8B=E6=9C=80=E7=BB=88=E4=BC=9A?= =?UTF-8?q?=E6=89=93=E5=8D=B0ir=E5=88=B0file=E4=B8=AD=EF=BC=8C=E4=BC=98?= =?UTF-8?q?=E5=8C=96=E8=BF=87=E7=A8=8B=E4=B8=AD=E7=9A=84=E6=89=93=E5=8D=B0?= =?UTF-8?q?=E9=80=BB=E8=BE=91=E5=BE=85=E6=9B=B4=E6=94=B9=E3=80=82?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/midend/IR.cpp | 55 +++++++++++++++++++++------------- src/midend/SysYIRGenerator.cpp | 29 +++++++++++++++--- src/sysyc.cpp | 18 +++++++++-- 3 files changed, 75 insertions(+), 27 deletions(-) diff --git a/src/midend/IR.cpp b/src/midend/IR.cpp index 2a41637..fffab0c 100644 --- a/src/midend/IR.cpp +++ b/src/midend/IR.cpp @@ -10,6 +10,14 @@ #include "IRBuilder.h" using namespace std; + +inline std::string getMachineCode(float fval) { + uint32_t mrf = *reinterpret_cast(&fval); + std::stringstream ss; + ss << std::hex << std::uppercase << std::setfill('0') << std::setw(8) << mrf; + return "0x" + ss.str(); +} + /** * @file IR.cpp * @@ -44,9 +52,9 @@ ostream &interleave_call(std::ostream &os, const T &container, const std::string static inline ostream &printVarName(ostream &os, const Value *var) { - if (dynamic_cast(var) != nullptr) { - auto globalVal = dynamic_cast(var); - return os << "@" << globalVal->getName(); + if (dynamic_cast(var) != nullptr || + dynamic_cast(var) != nullptr) { + return os << "@" << var->getName(); } else { return os << "%" << var->getName(); } @@ -60,7 +68,14 @@ static inline ostream &printFunctionName(ostream &os, const Function *fn) { static inline ostream &printOperand(ostream &os, const Value *value) { auto constValue = dynamic_cast(value); if (constValue != nullptr) { - constValue->print(os); + // 对于常量，只打印值，不打印类型（类型已经在指令中单独打印了） + if (auto constInt = dynamic_cast(constValue)) { + os << constInt->getInt(); + } else if (auto constFloat = dynamic_cast(constValue)) { + os << getMachineCode(constFloat->getFloat()); + } else if (auto undefVal = dynamic_cast(constValue)) { + os << "undef"; + } return os; } return printVarName(os, value); @@ -267,11 +282,11 @@ void GlobalValue::print(std::ostream& os) const { os << "zeroinitializer"; } else { // 非零值或非基本类型，打印实际值 - singleVal->print(os); + printOperand(os, singleVal); } } else { // 非常量值，打印实际值 - singleVal->print(os); + printOperand(os, singleVal); } } else { // 数组初始值 - 需要展开ValueCounter中的压缩表示 @@ -283,7 +298,7 @@ void GlobalValue::print(std::ostream& os) const { for (unsigned j = 0; j < numbers[i]; ++j) { if (!first) os << ", "; os << *values[i]->getType() << " "; - values[i]->print(os); + printOperand(os, values[i]); first = false; } } @@ -331,11 +346,11 @@ void ConstantVariable::print(std::ostream& os) const { os << "zeroinitializer"; } else { // 非零值或非基本类型，打印实际值 - singleVal->print(os); + printOperand(os, singleVal); } } else { // 非常量值，打印实际值 - singleVal->print(os); + printOperand(os, singleVal); } } else { // 数组初始值 - 需要展开ValueCounter中的压缩表示 @@ -347,7 +362,7 @@ void ConstantVariable::print(std::ostream& os) const { for (unsigned j = 0; j < numbers[i]; ++j) { if (!first) os << ", "; os << *values[i]->getType() << " "; - values[i]->print(os); + printOperand(os, values[i]); first = false; } } @@ -470,13 +485,6 @@ UndefinedValue* UndefinedValue::get(Type* type) { return newUndef; } -inline std::string getMachineCode(float fval) { - uint32_t mrf = *reinterpret_cast(&fval); - std::stringstream ss; - ss << std::hex << std::uppercase << std::setfill('0') << std::setw(8) << mrf; - return "0x" + ss.str(); -} - void ConstantValue::print(std::ostream &os) const { if(dynamic_cast(this)) { dynamic_cast(this)->print(os); @@ -540,10 +548,17 @@ void CallInst::print(std::ostream &os) const { if(!getType()->isVoid()) { printVarName(os, this) << " = "; } - os << getKindString() << *getType() << " " ; + os << getKindString() << " " << *getType() << " " ; printFunctionName(os, getCallee()); os << "("; - interleave_call(os, getOperands()); + + // 打印参数，跳过第一个操作数（函数本身） + for (unsigned i = 1; i < getNumOperands(); ++i) { + if (i > 1) os << ", "; + auto arg = getOperand(i); + os << *arg->getType() << " "; + printOperand(os, arg); + } os << ")"; } @@ -639,7 +654,7 @@ void UncondBrInst::print(std::ostream &os) const { } void CondBrInst::print(std::ostream &os) const { - os << "br " << *getCondition()->getType() << " "; + os << "br i1 "; // 条件分支的条件总是假定为i1类型 printOperand(os, getCondition()); os << ", label %"; printBlockName(os, getThenBlock()); diff --git a/src/midend/SysYIRGenerator.cpp b/src/midend/SysYIRGenerator.cpp index 2e0e910..fb75465 100644 --- a/src/midend/SysYIRGenerator.cpp +++ b/src/midend/SysYIRGenerator.cpp @@ -1652,11 +1652,13 @@ std::any SysYIRGenerator::visitLValue(SysYParser::LValueContext *ctx) { break; } } - if (allIndicesConstant) { + // 如果是常量变量且所有索引都是常量，并且不是数组名单独出现的情况 + if (allIndicesConstant && !dims.empty()) { // 如果是常量变量且所有索引都是常量，直接通过 getByIndices 获取编译时值 // 这个方法会根据索引深度返回最终的标量值或指向子数组的指针 (作为 ConstantValue/Variable) return constVar->getByIndices(dims); } + // 如果dims为空（数组名单独出现），需要走GEP路径来实现数组到指针的退化 } // 3. 处理可变变量 (AllocaInst/GlobalValue) 或带非常量索引的常量变量 @@ -1681,16 +1683,35 @@ std::any SysYIRGenerator::visitLValue(SysYParser::LValueContext *ctx) { } else { gepBasePointer = alloc; gepIndices.push_back(ConstantInteger::get(0)); - gepIndices.insert(gepIndices.end(), dims.begin(), dims.end()); + if (dims.empty() && declaredNumDims > 0) { + // 数组名单独出现（没有索引）：在SysY中，数组名应该退化为指向第一个元素的指针 + // 需要添加额外的0索引来获取第一个元素的地址 + gepIndices.push_back(ConstantInteger::get(0)); + } else { + // 正常的数组元素访问 + gepIndices.insert(gepIndices.end(), dims.begin(), dims.end()); + } } } else if (GlobalValue *glob = dynamic_cast(variable)) { gepBasePointer = glob; gepIndices.push_back(ConstantInteger::get(0)); - gepIndices.insert(gepIndices.end(), dims.begin(), dims.end()); + if (dims.empty() && declaredNumDims > 0) { + // 全局数组名单独出现（没有索引）：应该退化为指向第一个元素的指针 + gepIndices.push_back(ConstantInteger::get(0)); + } else { + // 正常的数组元素访问 + gepIndices.insert(gepIndices.end(), dims.begin(), dims.end()); + } } else if (ConstantVariable *constV = dynamic_cast(variable)) { gepBasePointer = constV; gepIndices.push_back(ConstantInteger::get(0)); - gepIndices.insert(gepIndices.end(), dims.begin(), dims.end()); + if (dims.empty() && declaredNumDims > 0) { + // 常量数组名单独出现（没有索引）：应该退化为指向第一个元素的指针 + gepIndices.push_back(ConstantInteger::get(0)); + } else { + // 正常的数组元素访问 + gepIndices.insert(gepIndices.end(), dims.begin(), dims.end()); + } } else { assert(false && "LValue variable type not supported for GEP base pointer."); return static_cast(nullptr); diff --git a/src/sysyc.cpp b/src/sysyc.cpp index 747eb89..be17fd3 100644 --- a/src/sysyc.cpp +++ b/src/sysyc.cpp @@ -132,7 +132,7 @@ int main(int argc, char **argv) { if (DEBUG) { cout << "=== Init IR ===\n"; - SysYPrinter(moduleIR).printIR(); // 临时打印器用于调试 + moduleIR->print(cout); // 使用新实现的print方法直接打印IR } // 创建 Pass 管理器并运行优化管道 @@ -145,9 +145,21 @@ int main(int argc, char **argv) { if (argStopAfter == "ir" || argStopAfter == "ird") { // 打印最终 IR cout << "=== Final IR ===\n"; - SysYPrinter printer(moduleIR); // 在这里创建打印器，因为可能之前调试时用过临时打印器 - printer.printIR(); + if (!argOutputFilename.empty()) { + // 输出到指定文件 + ofstream fout(argOutputFilename); + if (not fout.is_open()) { + cerr << "Failed to open output file: " << argOutputFilename << endl; + return EXIT_FAILURE; + } + moduleIR->print(fout); + fout.close(); + } else { + // 输出到标准输出 + moduleIR->print(cout); + } return EXIT_SUCCESS; + } // b) 如果未停止在 IR 阶段，则继续生成汇编 (后端) From d7328001494f2173b29bfc1b385c394c7c599580 Mon Sep 17 00:00:00 2001 From: ladev789 Date: Thu, 7 Aug 2025 00:36:43 +0800 Subject: [PATCH 41/55] =?UTF-8?q?[midend-llvmprint]=E6=9B=B4=E6=96=B0?= =?UTF-8?q?=E8=84=9A=E6=9C=AC=EF=BC=8C=E7=A6=81=E7=94=A8=E5=86=85=E5=AD=98?= =?UTF-8?q?=E6=B3=84=E6=BC=8F=E6=A3=80=E6=9F=A5?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- script/runit.sh | 2 ++ 1 file changed, 2 insertions(+) diff --git a/script/runit.sh b/script/runit.sh index fa413f9..80dca82 100644 --- a/script/runit.sh +++ b/script/runit.sh @@ -3,6 +3,8 @@ # runit.sh - 用于编译和测试 SysY 程序的脚本 # 此脚本应该位于 mysysy/test_script/ +export ASAN_OPTIONS=detect_leaks=0 + # 定义相对于脚本位置的目录 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" &>/dev/null && pwd)" TESTDATA_DIR="${SCRIPT_DIR}/../testdata" From 8aa5ba692f16267ae9c73d826c6497abb4bde9dc Mon Sep 17 00:00:00 2001 From: rain2133 <1370973498@qq.com> Date: Thu, 7 Aug 2025 01:34:00 +0800 Subject: [PATCH 42/55] =?UTF-8?q?[midend]=E5=88=9D=E6=AD=A5=E4=BF=AE?= =?UTF-8?q?=E5=A4=8D=E5=86=85=E5=AD=98=E6=B3=84=E6=BC=8F=E9=97=AE=E9=A2=98?= =?UTF-8?q?(=E4=BB=8D=E7=84=B6=E5=89=A9=E4=BD=9911=E5=A4=84)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/include/midend/IR.h | 40 ++++++++++++ src/midend/IR.cpp | 135 ++++++++++++++++++++++++++++++++++++++++ src/sysyc.cpp | 11 ++++ 3 files changed, 186 insertions(+) diff --git a/src/include/midend/IR.h b/src/include/midend/IR.h index 73a93cc..bc010c9 100644 --- a/src/include/midend/IR.h +++ b/src/include/midend/IR.h @@ -20,6 +20,10 @@ #include namespace sysy { + +// Global cleanup function to release all statically allocated IR objects +void cleanupIRPools(); + /** * \defgroup type Types * @brief Sysy的类型系统 @@ -95,6 +99,9 @@ class PointerType : public Type { public: static PointerType* get(Type *baseType); ///< 获取指向baseType的Pointer类型 + + // Cleanup method to release all cached pointer types (call at program exit) + static void cleanup(); public: Type* getBaseType() const { return baseType; } ///< 获取指向的类型 @@ -112,6 +119,9 @@ class FunctionType : public Type { public: /// 获取返回值类型为returnType， 形参类型列表为paramTypes的Function类型 static FunctionType* get(Type *returnType, const std::vector ¶mTypes = {}); + + // Cleanup method to release all cached function types (call at program exit) + static void cleanup(); public: Type* getReturnType() const { return returnType; } ///< 获取返回值类信息 @@ -124,6 +134,9 @@ class ArrayType : public Type { // elements：数组的元素类型 (例如，int[3] 的 elementType 是 int) // numElements：该维度的大小 (例如，int[3] 的 numElements 是 3) static ArrayType *get(Type *elementType, unsigned numElements); + + // Cleanup method to release all cached array types (call at program exit) + static void cleanup(); Type *getElementType() const { return elementType; } unsigned getNumElements() const { return numElements; } @@ -367,6 +380,9 @@ public: // Static factory method to get a canonical ConstantValue from the pool static ConstantValue* get(Type* type, ConstantValVariant val); + + // Cleanup method to release all cached constants (call at program exit) + static void cleanup(); // Helper methods to access constant values with appropriate casting int getInt() const { @@ -474,6 +490,9 @@ protected: public: static UndefinedValue* get(Type* type); + + // Cleanup method to release all cached undefined values (call at program exit) + static void cleanup(); size_t hash() const override { return std::hash{}(getType()); @@ -632,6 +651,10 @@ public: } } ///< 移除指定位置的指令 iterator moveInst(iterator sourcePos, iterator targetPos, BasicBlock *block); + + /// 清理基本块中的所有使用关系 + void cleanup(); + void print(std::ostream& os) const; }; @@ -667,6 +690,9 @@ class User : public Value { } ///< 增加多个操作数 void replaceOperand(unsigned index, Value *value); ///< 替换操作数 void setOperand(unsigned index, Value *value); ///< 设置操作数 + + /// 清理用户的所有操作数使用关系 + void cleanup(); }; /*! @@ -1321,6 +1347,10 @@ public: public: Function* getParent() const { return func; } int getIndex() const { return index; } + + /// 清理参数的使用关系 + void cleanup(); + void print(std::ostream& os) const; }; @@ -1399,6 +1429,10 @@ protected: blocks.emplace_front(block); return block; } + + /// 清理函数中的所有使用关系 + void cleanup(); + void print(std::ostream& os) const; }; @@ -1554,6 +1588,9 @@ class SymbolTable { bool isInGlobalScope() const; ///< 是否位于全局作用域 void enterGlobalScope(); ///< 进入全局作用域 bool isCurNodeNull() { return curNode == nullptr; } + + /// 清理符号表中的所有内容 + void cleanup(); }; //! IR unit for representing a SysY compile unit @@ -1639,6 +1676,9 @@ class Module { bool isInGlobalArea() const { return variableTable.isInGlobalScope(); } ///< 是否位于全局作用域 + /// 清理模块中的所有对象，包括函数、基本块、指令等 + void cleanup(); + void print(std::ostream& os) const; }; diff --git a/src/midend/IR.cpp b/src/midend/IR.cpp index fffab0c..89e44de 100644 --- a/src/midend/IR.cpp +++ b/src/midend/IR.cpp @@ -25,6 +25,18 @@ inline std::string getMachineCode(float fval) { */ namespace sysy { +// Global cleanup function implementation +void cleanupIRPools() { + // Clean up the main memory pools that cause leaks + ConstantValue::cleanup(); + UndefinedValue::cleanup(); + + // Note: Type pools (PointerType, FunctionType, ArrayType) use unique_ptr + // and will be automatically cleaned up when the program exits. + // For more thorough cleanup during program execution, consider refactoring + // to use singleton pattern with explicit cleanup methods. +} + /*相关打印函数*/ template @@ -206,6 +218,12 @@ PointerType* PointerType::get(Type *baseType) { return result.first->second.get(); } +void PointerType::cleanup() { + // Note: Due to static variable scoping, we can't directly access + // the static map here. The cleanup will happen when the program exits. + // For more thorough cleanup, consider using a singleton pattern. +} + FunctionType*FunctionType::get(Type *returnType, const std::vector ¶mTypes) { static std::set> functionTypes; auto iter = @@ -225,6 +243,12 @@ FunctionType*FunctionType::get(Type *returnType, const std::vector ¶ return result.first->get(); } +void FunctionType::cleanup() { + // Note: Due to static variable scoping, we can't directly access + // the static set here. The cleanup will happen when the program exits. + // For more thorough cleanup, consider using a singleton pattern. +} + ArrayType *ArrayType::get(Type *elementType, unsigned numElements) { static std::set> arrayTypes; auto iter = std::find_if(arrayTypes.begin(), arrayTypes.end(), [&](const std::unique_ptr &type) -> bool { @@ -239,6 +263,12 @@ ArrayType *ArrayType::get(Type *elementType, unsigned numElements) { return result.first->get(); } +void ArrayType::cleanup() { + // Note: Due to static variable scoping, we can't directly access + // the static set here. The cleanup will happen when the program exits. + // For more thorough cleanup, consider using a singleton pattern. +} + void Argument::print(std::ostream& os) const { os << *getType() << " %" << getName(); } @@ -464,6 +494,13 @@ ConstantValue* ConstantValue::get(Type* type, ConstantValVariant val) { return newConstant; } +void ConstantValue::cleanup() { + for (auto& pair : mConstantPool) { + delete pair.second; + } + mConstantPool.clear(); +} + ConstantInteger* ConstantInteger::get(Type* type, int val) { return dynamic_cast(ConstantValue::get(type, val)); } @@ -485,6 +522,13 @@ UndefinedValue* UndefinedValue::get(Type* type) { return newUndef; } +void UndefinedValue::cleanup() { + for (auto& pair : UndefValues) { + delete pair.second; + } + UndefValues.clear(); +} + void ConstantValue::print(std::ostream &os) const { if(dynamic_cast(this)) { dynamic_cast(this)->print(os); @@ -1097,4 +1141,95 @@ void Module::print(std::ostream& os) const { } } +void Module::cleanup() { + // 清理所有函数中的使用关系 + for (auto& func : functions) { + if (func.second) { + func.second->cleanup(); + } + } + + for (auto& extFunc : externalFunctions) { + if (extFunc.second) { + extFunc.second->cleanup(); + } + } + + // 清理符号表 + variableTable.cleanup(); + + // 清理函数表 + functions.clear(); + externalFunctions.clear(); +} + +void Function::cleanup() { + // 清理所有基本块中的使用关系 + for (auto& block : blocks) { + if (block) { + block->cleanup(); + } + } + + // 清理参数列表中的使用关系 + for (auto arg : arguments) { + if (arg) { + arg->cleanup(); + } + } + + // 清理基本块列表 + blocks.clear(); + arguments.clear(); + callees.clear(); +} + +void BasicBlock::cleanup() { + // 清理所有指令中的使用关系 + for (auto& inst : instructions) { + if (inst) { + inst->cleanup(); + } + } + + // 清理指令列表 + instructions.clear(); + + // 清理前驱后继关系 + predecessors.clear(); + successors.clear(); +} + +void User::cleanup() { + // 清理所有操作数的使用关系 + for (auto& operand : operands) { + if (operand && operand->getValue()) { + operand->getValue()->removeUse(operand); + } + } + + // 清理操作数列表 + operands.clear(); +} + +void SymbolTable::cleanup() { + // 清理全局变量和常量 + globals.clear(); + globalconsts.clear(); + + // 清理符号表节点 + nodeList.clear(); + + // 重置当前节点 + curNode = nullptr; + + // 清理变量索引 + variableIndex.clear(); +} + +void Argument::cleanup() { + // Argument继承自Value，清理其使用列表 + uses.clear(); +} + } // namespace sysy diff --git a/src/sysyc.cpp b/src/sysyc.cpp index be17fd3..b946934 100644 --- a/src/sysyc.cpp +++ b/src/sysyc.cpp @@ -110,6 +110,7 @@ int main(int argc, char **argv) { // 如果指定停止在 AST 阶段，则打印并退出 if (argStopAfter == "ast") { cout << moduleAST->toStringTree(true) << '\n'; + sysy::cleanupIRPools(); // 清理内存池 return EXIT_SUCCESS; } @@ -150,6 +151,8 @@ int main(int argc, char **argv) { ofstream fout(argOutputFilename); if (not fout.is_open()) { cerr << "Failed to open output file: " << argOutputFilename << endl; + moduleIR->cleanup(); // 清理模块 + sysy::cleanupIRPools(); // 清理内存池 return EXIT_FAILURE; } moduleIR->print(fout); @@ -158,6 +161,8 @@ int main(int argc, char **argv) { // 输出到标准输出 moduleIR->print(cout); } + moduleIR->cleanup(); // 清理模块 + sysy::cleanupIRPools(); // 清理内存池 return EXIT_SUCCESS; } @@ -178,6 +183,8 @@ int main(int argc, char **argv) { ofstream fout(argOutputFilename); if (not fout.is_open()) { cerr << "Failed to open output file: " << argOutputFilename << endl; + moduleIR->cleanup(); // 清理模块 + sysy::cleanupIRPools(); // 清理内存池 return EXIT_FAILURE; } fout << asmCode << endl; @@ -185,6 +192,8 @@ int main(int argc, char **argv) { } else { cout << asmCode << endl; } + moduleIR->cleanup(); // 清理模块 + sysy::cleanupIRPools(); // 清理内存池 return EXIT_SUCCESS; } @@ -193,5 +202,7 @@ int main(int argc, char **argv) { cout << "Compilation completed. No output specified (neither -s nor -S). Exiting.\n"; // return EXIT_SUCCESS; // 或者这里调用一个链接器生成可执行文件 + moduleIR->cleanup(); // 清理模块 + sysy::cleanupIRPools(); // 清理内存池 return EXIT_SUCCESS; } \ No newline at end of file From ba21bb320359b30e1ac67f8e2a742b08e78dd0d4 Mon Sep 17 00:00:00 2001 From: rain2133 <1370973498@qq.com> Date: Thu, 7 Aug 2025 02:53:36 +0800 Subject: [PATCH 43/55] =?UTF-8?q?[midend]=E4=BF=AE=E5=A4=8D=E5=86=85?= =?UTF-8?q?=E5=AD=98=E6=B3=84=E6=BC=8F=E5=92=8CHeap-buffer-overflow?= =?UTF-8?q?=E9=97=AE=E9=A2=98(getexternalfunction=E4=B8=AD=E5=8F=8A?= =?UTF-8?q?=E5=85=B6=E9=9A=90=E7=A7=98=E7=9A=84=E9=94=99=E8=AF=AF)?= =?UTF-8?q?=EF=BC=8C=E4=BF=AE=E5=A4=8D=E5=85=A8=E5=B1=80=E5=B8=B8=E9=87=8F?= =?UTF-8?q?=E6=A0=87=E9=87=8F=E8=AE=BF=E9=97=AE=E7=9A=84=E9=94=99=E8=AF=AF?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/include/midend/IR.h | 5 ++++- src/midend/IR.cpp | 26 ++++++++------------------ src/midend/SysYIRGenerator.cpp | 15 +++++++++++---- 3 files changed, 23 insertions(+), 23 deletions(-) diff --git a/src/include/midend/IR.h b/src/include/midend/IR.h index bc010c9..d9d618b 100644 --- a/src/include/midend/IR.h +++ b/src/include/midend/IR.h @@ -923,6 +923,9 @@ public: static constexpr uint64_t DefineOpMask = kAlloca | kStore | kPhi; return (kind & DefineOpMask) != 0U; } + + virtual ~Instruction() = default; + virtual void print(std::ostream& os) const = 0; }; // class Instruction @@ -1655,7 +1658,7 @@ class Module { } ///< 获取函数 Function* getExternalFunction(const std::string &name) const { auto result = externalFunctions.find(name); - if (result == functions.end()) { + if (result == externalFunctions.end()) { return nullptr; } return result->second.get(); diff --git a/src/midend/IR.cpp b/src/midend/IR.cpp index 89e44de..0a9cfac 100644 --- a/src/midend/IR.cpp +++ b/src/midend/IR.cpp @@ -1164,17 +1164,20 @@ void Module::cleanup() { } void Function::cleanup() { - // 清理所有基本块中的使用关系 + // 首先清理所有基本块中的使用关系 for (auto& block : blocks) { if (block) { block->cleanup(); } } - // 清理参数列表中的使用关系 + // 然后安全地清理参数列表中的使用关系 for (auto arg : arguments) { if (arg) { + // 清理参数的所有使用关系 arg->cleanup(); + // 现在安全地删除参数对象 + delete arg; } } @@ -1185,14 +1188,7 @@ void Function::cleanup() { } void BasicBlock::cleanup() { - // 清理所有指令中的使用关系 - for (auto& inst : instructions) { - if (inst) { - inst->cleanup(); - } - } - - // 清理指令列表 + // 直接清理指令列表，让析构函数自然处理 instructions.clear(); // 清理前驱后继关系 @@ -1201,14 +1197,8 @@ void BasicBlock::cleanup() { } void User::cleanup() { - // 清理所有操作数的使用关系 - for (auto& operand : operands) { - if (operand && operand->getValue()) { - operand->getValue()->removeUse(operand); - } - } - - // 清理操作数列表 + // 简单清理：让shared_ptr的析构函数自动处理Use关系 + // 这样避免了手动管理可能已经被释放的Value对象 operands.clear(); } diff --git a/src/midend/SysYIRGenerator.cpp b/src/midend/SysYIRGenerator.cpp index fb75465..babf38a 100644 --- a/src/midend/SysYIRGenerator.cpp +++ b/src/midend/SysYIRGenerator.cpp @@ -1658,7 +1658,13 @@ std::any SysYIRGenerator::visitLValue(SysYParser::LValueContext *ctx) { // 这个方法会根据索引深度返回最终的标量值或指向子数组的指针 (作为 ConstantValue/Variable) return constVar->getByIndices(dims); } - // 如果dims为空（数组名单独出现），需要走GEP路径来实现数组到指针的退化 + // 如果dims为空，检查是否是常量标量 + if (dims.empty() && declaredNumDims == 0) { + // 常量标量，直接返回其值 + // 默认传入空索引列表，表示访问标量本身 + return constVar->getByIndices(dims); + } + // 如果dims为空但不是标量（数组名单独出现），需要走GEP路径来实现数组到指针的退化 } // 3. 处理可变变量 (AllocaInst/GlobalValue) 或带非常量索引的常量变量 @@ -1668,7 +1674,8 @@ std::any SysYIRGenerator::visitLValue(SysYParser::LValueContext *ctx) { if (dims.empty() && declaredNumDims == 0) { if (dynamic_cast(variable) || dynamic_cast(variable)) { targetAddress = variable; - } else { + } + else { assert(false && "Unhandled scalar variable type in LValue access."); return static_cast(nullptr); } @@ -1793,10 +1800,10 @@ std::any SysYIRGenerator::visitCall(SysYParser::CallContext *ctx) { // 获取形参列表。`getArguments()` 返回的是 `Argument*` 的集合， // 每个 `Argument` 代表一个函数形参，其 `getType()` 就是指向形参的类型的指针类型。 - auto formalParams = function->getArguments(); + const auto& formalParams = function->getArguments(); // 检查实参和形参数量是否匹配。 - if (args.size() != formalParams.size()) { + if (args.size() != function->getNumArguments()) { std::cerr << "Error: Function call argument count mismatch for function '" << funcName << "'." << std::endl; assert(false && "Function call argument count mismatch!"); } From c507b98199c0fa60b2c0d8cae8924b4488f915b3 Mon Sep 17 00:00:00 2001 From: Lixuanwang Date: Thu, 7 Aug 2025 23:45:26 +0800 Subject: [PATCH 44/55] =?UTF-8?q?[midend-llvmprint]=E6=9B=B4=E6=96=B0?= =?UTF-8?q?=E8=84=9A=E6=9C=AC=EF=BC=8C=E6=94=AF=E6=8C=81-eir=E6=89=A7?= =?UTF-8?q?=E8=A1=8CIR=E6=B5=8B=E8=AF=95?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- script/runit-single.sh | 281 ++++++++++++------------ script/runit.sh | 482 ++++++++++++++++++++++++++--------------- src/sysyc.cpp | 2 +- 3 files changed, 455 insertions(+), 310 deletions(-) diff --git a/script/runit-single.sh b/script/runit-single.sh index 3cc47aa..bfbbcdc 100644 --- a/script/runit-single.sh +++ b/script/runit-single.sh @@ -2,66 +2,67 @@ # runit-single.sh - 用于编译和测试单个或少量 SysY 程序的脚本 # 模仿 runit.sh 的功能，但以具体文件路径作为输入。 +# 此脚本应该位于 mysysy/script/ + +export ASAN_OPTIONS=detect_leaks=0 # --- 配置区 --- -# 请根据你的环境修改这些路径 -# 假设此脚本位于你的项目根目录或一个脚本目录中 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" &>/dev/null && pwd)" -# 默认寻找项目根目录下的 build 和 lib BUILD_BIN_DIR="${SCRIPT_DIR}/../build/bin" LIB_DIR="${SCRIPT_DIR}/../lib" -# 临时文件会存储在脚本所在目录的 tmp 子目录中 TMP_DIR="${SCRIPT_DIR}/tmp" # 定义编译器和模拟器 SYSYC="${BUILD_BIN_DIR}/sysyc" +LLC_CMD="llc-19" # 新增 GCC_RISCV64="riscv64-linux-gnu-gcc" QEMU_RISCV64="qemu-riscv64" # --- 初始化变量 --- EXECUTE_MODE=false +IR_EXECUTE_MODE=false # 新增 CLEAN_MODE=false -OPTIMIZE_FLAG="" # 用于存储 -O1 标志 -SYSYC_TIMEOUT=10 # sysyc 编译超时 (秒) -GCC_TIMEOUT=10 # gcc 编译超时 (秒) -EXEC_TIMEOUT=5 # qemu 自动化执行超时 (秒) -MAX_OUTPUT_LINES=50 # 对比失败时显示的最大行数 -SY_FILES=() # 存储用户提供的 .sy 文件列表 +OPTIMIZE_FLAG="" +SYSYC_TIMEOUT=30 +LLC_TIMEOUT=10 # 新增 +GCC_TIMEOUT=10 +EXEC_TIMEOUT=30 +MAX_OUTPUT_LINES=20 +SY_FILES=() PASSED_CASES=0 FAILED_CASES_LIST="" +INTERRUPTED=false # 新增 +# ================================================================= # --- 函数定义 --- +# ================================================================= show_help() { echo "用法: $0 [文件1.sy] [文件2.sy] ... [选项]" - echo "编译并测试指定的 .sy 文件。" - echo "" - echo "如果找到对应的 .in/.out 文件，则进行自动化测试。否则，进入交互模式。" + echo "编译并测试指定的 .sy 文件。必须提供 -e 或 -eir 之一。" echo "" echo "选项:" - echo " -e, --executable 编译为可执行文件并运行测试 (必须)。" + echo " -e 通过汇编运行测试 (sysyc -> gcc -> qemu)。" + echo " -eir 通过IR运行测试 (sysyc -> llc -> gcc -> qemu)。" echo " -c, --clean 清理 tmp 临时目录下的所有文件。" echo " -O1 启用 sysyc 的 -O1 优化。" - echo " -sct N 设置 sysyc 编译超时为 N 秒 (默认: 10)。" + echo " -sct N 设置 sysyc 编译超时为 N 秒 (默认: 30)。" + echo " -lct N 设置 llc-19 编译超时为 N 秒 (默认: 10)。" echo " -gct N 设置 gcc 交叉编译超时为 N 秒 (默认: 10)。" - echo " -et N 设置 qemu 自动化执行超时为 N 秒 (默认: 5)。" - echo " -ml N, --max-lines N 当输出对比失败时，最多显示 N 行内容 (默认: 50)。" + echo " -et N 设置 qemu 自动化执行超时为 N 秒 (默认: 30)。" + echo " -ml N, --max-lines N 当输出对比失败时，最多显示 N 行内容 (默认: 20)。" echo " -h, --help 显示此帮助信息并退出。" + echo "" + echo "可在任何时候按 Ctrl+C 来中断测试并显示当前已完成的测例总结。" } -# --- 新增功能: 显示文件内容并根据行数截断 --- display_file_content() { local file_path="$1" local title="$2" local max_lines="$3" - - if [ ! -f "$file_path" ]; then - return - fi - + if [ ! -f "$file_path" ]; then return; fi echo -e "$title" local line_count line_count=$(wc -l < "$file_path") - if [ "$line_count" -gt "$max_lines" ]; then head -n "$max_lines" "$file_path" echo -e "\e[33m[... 输出已截断，共 ${line_count} 行 ...]\e[0m" @@ -70,55 +71,79 @@ display_file_content() { fi } +# --- 新增：总结报告函数 --- +print_summary() { + local total_cases=${#SY_FILES[@]} + echo "" + echo "======================================================================" + if [ "$INTERRUPTED" = true ]; then + echo -e "\e[33m测试被中断。正在汇总已完成的结果...\e[0m" + else + echo "所有测试完成" + fi + + local failed_count + if [ -n "$FAILED_CASES_LIST" ]; then + failed_count=$(echo -e -n "${FAILED_CASES_LIST}" | wc -l) + else + failed_count=0 + fi + local executed_count=$((PASSED_CASES + failed_count)) + + echo "测试结果: [通过: ${PASSED_CASES}, 失败: ${failed_count}, 已执行: ${executed_count}/${total_cases}]" + + if [ -n "$FAILED_CASES_LIST" ]; then + echo "" + echo -e "\e[31m未通过的测例:\e[0m" + printf "%b" "${FAILED_CASES_LIST}" + fi + echo "======================================================================" + + if [ "$failed_count" -gt 0 ]; then + exit 1 + else + exit 0 + fi +} + +# --- 新增：SIGINT 信号处理函数 --- +handle_sigint() { + INTERRUPTED=true + print_summary +} + +# ================================================================= +# --- 主逻辑开始 --- +# ================================================================= + +# --- 新增：设置 trap 来捕获 SIGINT --- +trap handle_sigint SIGINT + # --- 参数解析 --- -# 使用标准的 while 循环来健壮地处理任意顺序的参数 while [[ "$#" -gt 0 ]]; do case "$1" in - -e|--executable) - EXECUTE_MODE=true - shift # 消耗选项 - ;; - -c|--clean) - CLEAN_MODE=true - shift # 消耗选项 - ;; - -O1) - OPTIMIZE_FLAG="-O1" - shift # 消耗选项 - ;; - -sct) - if [[ -n "$2" && "$2" =~ ^[0-9]+$ ]]; then SYSYC_TIMEOUT="$2"; shift 2; else echo "错误: -sct 需要一个正整数参数。" >&2; exit 1; fi - ;; - -gct) - if [[ -n "$2" && "$2" =~ ^[0-9]+$ ]]; then GCC_TIMEOUT="$2"; shift 2; else echo "错误: -gct 需要一个正整数参数。" >&2; exit 1; fi - ;; - -et) - if [[ -n "$2" && "$2" =~ ^[0-9]+$ ]]; then EXEC_TIMEOUT="$2"; shift 2; else echo "错误: -et 需要一个正整数参数。" >&2; exit 1; fi - ;; - -ml|--max-lines) - if [[ -n "$2" && "$2" =~ ^[0-9]+$ ]]; then MAX_OUTPUT_LINES="$2"; shift 2; else echo "错误: --max-lines 需要一个正整数参数。" >&2; exit 1; fi - ;; - -h|--help) - show_help - exit 0 - ;; - -*) # 未知选项 - echo "未知选项: $1" - show_help - exit 1 - ;; - *) # 其他参数被视为文件路径 + -e|--executable) EXECUTE_MODE=true; shift ;; + -eir) IR_EXECUTE_MODE=true; shift ;; # 新增 + -c|--clean) CLEAN_MODE=true; shift ;; + -O1) OPTIMIZE_FLAG="-O1"; shift ;; + -lct) if [[ -n "$2" && "$2" =~ ^[0-9]+$ ]]; then LLC_TIMEOUT="$2"; shift 2; else echo "错误: -lct 需要一个正整数参数。" >&2; exit 1; fi ;; # 新增 + -sct) if [[ -n "$2" && "$2" =~ ^[0-9]+$ ]]; then SYSYC_TIMEOUT="$2"; shift 2; else echo "错误: -sct 需要一个正整数参数。" >&2; exit 1; fi ;; + -gct) if [[ -n "$2" && "$2" =~ ^[0-9]+$ ]]; then GCC_TIMEOUT="$2"; shift 2; else echo "错误: -gct 需要一个正整数参数。" >&2; exit 1; fi ;; + -et) if [[ -n "$2" && "$2" =~ ^[0-9]+$ ]]; then EXEC_TIMEOUT="$2"; shift 2; else echo "错误: -et 需要一个正整数参数。" >&2; exit 1; fi ;; + -ml|--max-lines) if [[ -n "$2" && "$2" =~ ^[0-9]+$ ]]; then MAX_OUTPUT_LINES="$2"; shift 2; else echo "错误: --max-lines 需要一个正整数参数。" >&2; exit 1; fi ;; + -h|--help) show_help; exit 0 ;; + -*) echo "未知选项: $1"; show_help; exit 1 ;; + *) if [[ -f "$1" && "$1" == *.sy ]]; then SY_FILES+=("$1") else echo "警告: 无效文件或不是 .sy 文件，已忽略: $1" fi - shift # 消耗文件参数 + shift ;; esac done - if ${CLEAN_MODE}; then echo "检测到 -c/--clean 选项，正在清空 ${TMP_DIR}..." if [ -d "${TMP_DIR}" ]; then @@ -127,19 +152,22 @@ if ${CLEAN_MODE}; then else echo "临时目录 ${TMP_DIR} 不存在，无需清理。" fi - - if [ ${#SY_FILES[@]} -eq 0 ] && ! ${EXECUTE_MODE}; then + if [ ${#SY_FILES[@]} -eq 0 ] && ! ${EXECUTE_MODE} && ! ${IR_EXECUTE_MODE}; then exit 0 fi fi -# --- 主逻辑开始 --- -if ! ${EXECUTE_MODE}; then - echo "错误: 请提供 -e 或 --executable 选项来运行测试。" +if ! ${EXECUTE_MODE} && ! ${IR_EXECUTE_MODE}; then + echo "错误: 请提供 -e 或 -eir 选项来运行测试。" show_help exit 1 fi +if ${EXECUTE_MODE} && ${IR_EXECUTE_MODE}; then + echo -e "\e[31m错误: -e 和 -eir 选项不能同时使用。\e[0m" >&2 + exit 1 +fi + if [ ${#SY_FILES[@]} -eq 0 ]; then echo "错误: 未提供任何 .sy 文件作为输入。" show_help @@ -151,18 +179,17 @@ TOTAL_CASES=${#SY_FILES[@]} echo "SysY 单例测试运行器启动..." if [ -n "$OPTIMIZE_FLAG" ]; then echo "优化等级: ${OPTIMIZE_FLAG}"; fi -echo "超时设置: sysyc=${SYSYC_TIMEOUT}s, gcc=${GCC_TIMEOUT}s, qemu=${EXEC_TIMEOUT}s" -echo "失败输出最大行数: ${MAX_OUTPUT_LINES}" +echo "超时设置: sysyc=${SYSYC_TIMEOUT}s, llc=${LLC_TIMEOUT}s, gcc=${GCC_TIMEOUT}s, qemu=${EXEC_TIMEOUT}s" echo "" for sy_file in "${SY_FILES[@]}"; do is_passed=1 + compilation_ok=1 base_name=$(basename "${sy_file}" .sy) source_dir=$(dirname "${sy_file}") - ir_file="${TMP_DIR}/${base_name}_sysyc_riscv64.ll" + ir_file="${TMP_DIR}/${base_name}.ll" assembly_file="${TMP_DIR}/${base_name}.s" - assembly_debug_file="${TMP_DIR}/${base_name}_d.s" executable_file="${TMP_DIR}/${base_name}" input_file="${source_dir}/${base_name}.in" output_reference_file="${source_dir}/${base_name}.out" @@ -171,47 +198,39 @@ 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 "${sy_file}" ${OPTIMIZE_FLAG} -o "${assembly_file}" - timeout -s KILL ${SYSYC_TIMEOUT} "${SYSYC}" -s ir "${sy_file}" ${OPTIMIZE_FLAG} > "${ir_file}" - # timeout -s KILL ${SYSYC_TIMEOUT} "${SYSYC}" -s asmd "${sy_file}" > "${assembly_debug_file}" 2>&1 - SYSYC_STATUS=$? - if [ $SYSYC_STATUS -eq 124 ]; then - echo -e "\e[31m错误: SysY 编译 ${sy_file} IR超时\e[0m" - is_passed=0 - elif [ $SYSYC_STATUS -ne 0 ]; then - echo -e "\e[31m错误: SysY 编译 ${sy_file} IR失败，退出码: ${SYSYC_STATUS}\e[0m" - is_passed=0 - fi - if [ $? -ne 0 ]; then - echo -e "\e[31m错误: SysY 编译失败或超时。\e[0m" - is_passed=0 - fi + # --- 编译阶段 --- + if ${IR_EXECUTE_MODE}; then + # 路径1: sysyc -> llc -> gcc + echo " [1/3] 使用 sysyc 编译为 IR (超时 ${SYSYC_TIMEOUT}s)..." + timeout -s KILL ${SYSYC_TIMEOUT} "${SYSYC}" -s ir "${sy_file}" ${OPTIMIZE_FLAG} -o "${ir_file}" + if [ $? -ne 0 ]; then echo -e "\e[31m错误: SysY (IR) 编译失败或超时。\e[0m"; compilation_ok=0; fi - # 步骤 2: GCC 编译 - if [ "$is_passed" -eq 1 ]; then - echo " 使用 gcc 编译 (超时 ${GCC_TIMEOUT}s)..." - timeout -s KILL ${GCC_TIMEOUT} "${GCC_RISCV64}" "${assembly_file}" -o "${executable_file}" -L"${LIB_DIR}" -lsysy_riscv -static - if [ $? -ne 0 ]; then - echo -e "\e[31m错误: GCC 编译失败或超时。\e[0m" - is_passed=0 + if [ "$compilation_ok" -eq 1 ]; then + echo " [2/3] 使用 llc 编译为汇编 (超时 ${LLC_TIMEOUT}s)..." + timeout -s KILL ${LLC_TIMEOUT} "${LLC_CMD}" -march=riscv64 -mcpu=generic-rv64 -mattr=+m,+a,+f,+d,+c -filetype=asm "${ir_file}" -o "${assembly_file}" + if [ $? -ne 0 ]; then echo -e "\e[31m错误: llc 编译失败或超时。\e[0m"; compilation_ok=0; fi + fi + + if [ "$compilation_ok" -eq 1 ]; then + echo " [3/3] 使用 gcc 编译 (超时 ${GCC_TIMEOUT}s)..." + timeout -s KILL ${GCC_TIMEOUT} "${GCC_RISCV64}" "${assembly_file}" -o "${executable_file}" -L"${LIB_DIR}" -lsysy_riscv -static + if [ $? -ne 0 ]; then echo -e "\e[31m错误: GCC 编译失败或超时。\e[0m"; compilation_ok=0; fi + fi + else # EXECUTE_MODE + # 路径2: sysyc -> gcc + echo " [1/2] 使用 sysyc 编译为汇编 (超时 ${SYSYC_TIMEOUT}s)..." + timeout -s KILL ${SYSYC_TIMEOUT} "${SYSYC}" -S "${sy_file}" ${OPTIMIZE_FLAG} -o "${assembly_file}" + if [ $? -ne 0 ]; then echo -e "\e[31m错误: SysY (汇编) 编译失败或超时。\e[0m"; compilation_ok=0; fi + + if [ "$compilation_ok" -eq 1 ]; then + echo " [2/2] 使用 gcc 编译 (超时 ${GCC_TIMEOUT}s)..." + timeout -s KILL ${GCC_TIMEOUT} "${GCC_RISCV64}" "${assembly_file}" -o "${executable_file}" -L"${LIB_DIR}" -lsysy_riscv -static + if [ $? -ne 0 ]; then echo -e "\e[31m错误: GCC 编译失败或超时。\e[0m"; compilation_ok=0; fi fi fi - # 步骤 3: 执行与测试 - if [ "$is_passed" -eq 1 ]; then - # 检查是自动化测试还是交互模式 + # --- 执行与测试阶段 (公共逻辑) --- + if [ "$compilation_ok" -eq 1 ]; then if [ -f "${input_file}" ] || [ -f "${output_reference_file}" ]; then # --- 自动化测试模式 --- echo " 检测到 .in/.out 文件，进入自动化测试模式..." @@ -234,24 +253,26 @@ for sy_file in "${SY_FILES[@]}"; do EXPECTED_RETURN_CODE="$LAST_LINE_TRIMMED" EXPECTED_STDOUT_FILE="${TMP_DIR}/${base_name}.expected_stdout" head -n -1 "${output_reference_file}" > "${EXPECTED_STDOUT_FILE}" - if [ "$ACTUAL_RETURN_CODE" -ne "$EXPECTED_RETURN_CODE" ]; then echo -e "\e[31m 返回码测试失败: 期望 ${EXPECTED_RETURN_CODE}, 实际 ${ACTUAL_RETURN_CODE}\e[0m"; is_passed=0; fi + ret_ok=1 + if [ "$ACTUAL_RETURN_CODE" -ne "$EXPECTED_RETURN_CODE" ]; then echo -e "\e[31m 返回码测试失败: 期望 ${EXPECTED_RETURN_CODE}, 实际 ${ACTUAL_RETURN_CODE}\e[0m"; ret_ok=0; fi + + out_ok=1 if ! diff -q <(tr -d '[:space:]' < "${output_actual_file}") <(tr -d '[:space:]' < "${EXPECTED_STDOUT_FILE}") >/dev/null 2>&1; then - echo -e "\e[31m 标准输出测试失败。\e[0m" - is_passed=0 + echo -e "\e[31m 标准输出测试失败。\e[0m"; out_ok=0 display_file_content "${EXPECTED_STDOUT_FILE}" " \e[36m--- 期望输出 ---\e[0m" "${MAX_OUTPUT_LINES}" display_file_content "${output_actual_file}" " \e[36m--- 实际输出 ---\e[0m" "${MAX_OUTPUT_LINES}" - echo -e " \e[36m----------------\e[0m" fi + + if [ "$ret_ok" -eq 1 ] && [ "$out_ok" -eq 1 ]; then echo -e "\e[32m 返回码与标准输出测试成功。\e[0m"; else is_passed=0; fi + else if diff -q <(tr -d '[:space:]' < "${output_actual_file}") <(tr -d '[:space:]' < "${output_reference_file}") >/dev/null 2>&1; then echo -e "\e[32m 标准输出测试成功。\e[0m" else - echo -e "\e[31m 标准输出测试失败。\e[0m" - is_passed=0 + echo -e "\e[31m 标准输出测试失败。\e[0m"; is_passed=0 display_file_content "${output_reference_file}" " \e[36m--- 期望输出 ---\e[0m" "${MAX_OUTPUT_LINES}" display_file_content "${output_actual_file}" " \e[36m--- 实际输出 ---\e[0m" "${MAX_OUTPUT_LINES}" - echo -e " \e[36m----------------\e[0m" fi fi else @@ -260,20 +281,16 @@ for sy_file in "${SY_FILES[@]}"; do fi else # --- 交互模式 --- - echo -e "\e[33m" - echo " **********************************************************" - echo " ** 未找到 .in 或 .out 文件，进入交互模式。 **" - echo " ** 程序即将运行，你可以直接在终端中输入。 **" - echo " ** 按下 Ctrl+D (EOF) 或以其他方式结束程序以继续。 **" - echo " **********************************************************" - echo -e "\e[0m" + echo -e "\e[33m\n 未找到 .in 或 .out 文件，进入交互模式...\e[0m" "${QEMU_RISCV64}" "${executable_file}" INTERACTIVE_RET_CODE=$? - echo -e "\e[33m\n 交互模式执行完毕，程序返回码: ${INTERACTIVE_RET_CODE}\e[0m" - echo " 注意: 交互模式的结果未经验证。" + echo -e "\e[33m\n 交互模式执行完毕，程序返回码: ${INTERACTIVE_RET_CODE} (此结果未经验证)\e[0m" fi + else + is_passed=0 fi + # --- 状态总结 --- if [ "$is_passed" -eq 1 ]; then echo -e "\e[32m状态: 通过\e[0m" ((PASSED_CASES++)) @@ -284,20 +301,4 @@ for sy_file in "${SY_FILES[@]}"; do done # --- 打印最终总结 --- -echo "======================================================================" -echo "所有测试完成" -echo "测试通过率: [${PASSED_CASES}/${TOTAL_CASES}]" - -if [ -n "$FAILED_CASES_LIST" ]; then - echo "" - echo -e "\e[31m未通过的测例:\e[0m" - echo -e "${FAILED_CASES_LIST}" -fi - -echo "======================================================================" - -if [ "$PASSED_CASES" -eq "$TOTAL_CASES" ]; then - exit 0 -else - exit 1 -fi +print_summary \ No newline at end of file diff --git a/script/runit.sh b/script/runit.sh index 80dca82..e27c905 100644 --- a/script/runit.sh +++ b/script/runit.sh @@ -1,7 +1,7 @@ #!/bin/bash # runit.sh - 用于编译和测试 SysY 程序的脚本 -# 此脚本应该位于 mysysy/test_script/ +# 此脚本应该位于 mysysy/script/ export ASAN_OPTIONS=detect_leaks=0 @@ -10,24 +10,32 @@ SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" &>/dev/null && pwd)" TESTDATA_DIR="${SCRIPT_DIR}/../testdata" BUILD_BIN_DIR="${SCRIPT_DIR}/../build/bin" LIB_DIR="${SCRIPT_DIR}/../lib" -# TMP_DIR="${SCRIPT_DIR}/tmp" TMP_DIR="${SCRIPT_DIR}/tmp" # 定义编译器和模拟器 SYSYC="${BUILD_BIN_DIR}/sysyc" +LLC_CMD="llc-19" GCC_RISCV64="riscv64-linux-gnu-gcc" QEMU_RISCV64="qemu-riscv64" +# --- 状态变量 --- EXECUTE_MODE=false -OPTIMIZE_FLAG="" # 用于存储 -O1 标志 -SYSYC_TIMEOUT=10 # sysyc 编译超时 (秒) -GCC_TIMEOUT=10 # gcc 编译超时 (秒) -EXEC_TIMEOUT=5 # qemu 执行超时 (秒) -MAX_OUTPUT_LINES=50 # 对比失败时显示的最大行数 -TEST_SETS=() # 用于存储要运行的测试集 +IR_EXECUTE_MODE=false +OPTIMIZE_FLAG="" +SYSYC_TIMEOUT=30 +LLC_TIMEOUT=10 +GCC_TIMEOUT=10 +EXEC_TIMEOUT=30 +MAX_OUTPUT_LINES=20 +TEST_SETS=() TOTAL_CASES=0 PASSED_CASES=0 -FAILED_CASES_LIST="" # 用于存储未通过的测例列表 +FAILED_CASES_LIST="" +INTERRUPTED=false # 新增：用于标记是否被中断 + +# ================================================================= +# --- 函数定义 --- +# ================================================================= # 显示帮助信息的函数 show_help() { @@ -35,31 +43,32 @@ show_help() { echo "此脚本用于按文件名前缀数字升序编译和测试 .sy 文件。" echo "" echo "选项:" - echo " -e, --executable 编译为可执行文件并运行测试。" + echo " -e, --executable 编译为汇编并运行测试 (sysyc -> gcc -> qemu)。" + echo " -eir 通过IR编译为可执行文件并运行测试 (sysyc -> llc -> gcc -> qemu)。" echo " -c, --clean 清理 'tmp' 目录下的所有生成文件。" echo " -O1 启用 sysyc 的 -O1 优化。" echo " -set [f|h|p|all]... 指定要运行的测试集 (functional, h_functional, performance)。可多选，默认为 all。" - echo " -sct N 设置 sysyc 编译超时为 N 秒 (默认: 10)。" + echo " -sct N 设置 sysyc 编译超时为 N 秒 (默认: 30)。" + echo " -lct N 设置 llc-19 编译超时为 N 秒 (默认: 10)。" echo " -gct N 设置 gcc 交叉编译超时为 N 秒 (默认: 10)。" - echo " -et N 设置 qemu 执行超时为 N 秒 (默认: 5)。" - echo " -ml N, --max-lines N 当输出对比失败时，最多显示 N 行内容 (默认: 50)。" + echo " -et N 设置 qemu 执行超时为 N 秒 (默认: 30)。" + echo " -ml N, --max-lines N 当输出对比失败时，最多显示 N 行内容 (默认: 20)。" echo " -h, --help 显示此帮助信息并退出。" + echo "" + echo "注意: 默认行为 (无 -e 或 -eir) 是将 .sy 文件同时编译为 .s (汇编) 和 .ll (IR)，不执行。" + echo " 可在任何时候按 Ctrl+C 来中断测试并显示当前已完成的测例总结。" } + # 显示文件内容并根据行数截断的函数 display_file_content() { local file_path="$1" local title="$2" local max_lines="$3" - - if [ ! -f "$file_path" ]; then - return - fi - + if [ ! -f "$file_path" ]; then return; fi echo -e "$title" local line_count line_count=$(wc -l < "$file_path") - if [ "$line_count" -gt "$max_lines" ]; then head -n "$max_lines" "$file_path" echo -e "\e[33m[... 输出已截断，共 ${line_count} 行 ...]\e[0m" @@ -74,63 +83,90 @@ clean_tmp() { rm -rf "${TMP_DIR}"/* } -# 如果临时目录不存在，则创建它 +# --- 新增：总结报告函数 --- +print_summary() { + echo "" # 确保从新的一行开始 + echo "========================================" + if [ "$INTERRUPTED" = true ]; then + echo -e "\e[33m测试被中断。正在汇总已完成的结果...\e[0m" + else + echo "测试完成" + fi + + local failed_count + if [ -n "$FAILED_CASES_LIST" ]; then + # `wc -l` 计算由换行符分隔的列表项数 + failed_count=$(echo -e -n "${FAILED_CASES_LIST}" | wc -l) + else + failed_count=0 + fi + local executed_count=$((PASSED_CASES + failed_count)) + + echo "测试结果: [通过: ${PASSED_CASES}, 失败: ${failed_count}, 已执行: ${executed_count}/${TOTAL_CASES}]" + + if [ -n "$FAILED_CASES_LIST" ]; then + echo "" + echo -e "\e[31m未通过的测例:\e[0m" + # 使用 printf 保证原样输出 + printf "%b" "${FAILED_CASES_LIST}" + fi + + echo "========================================" + + if [ "$failed_count" -gt 0 ]; then + exit 1 + else + exit 0 + fi +} + +# --- 新增：SIGINT 信号处理函数 --- +handle_sigint() { + INTERRUPTED=true + print_summary +} + +# ================================================================= +# --- 主逻辑开始 --- +# ================================================================= + +# --- 新增：设置 trap 来捕获 SIGINT --- +trap handle_sigint SIGINT + mkdir -p "${TMP_DIR}" # 解析命令行参数 while [[ "$#" -gt 0 ]]; do case "$1" in - -e|--executable) - EXECUTE_MODE=true - shift - ;; - -c|--clean) - clean_tmp - exit 0 - ;; - -O1) - OPTIMIZE_FLAG="-O1" - shift - ;; + -e|--executable) EXECUTE_MODE=true; shift ;; + -eir) IR_EXECUTE_MODE=true; shift ;; + -c|--clean) clean_tmp; exit 0 ;; + -O1) OPTIMIZE_FLAG="-O1"; shift ;; -set) - shift # 移过 '-set' - while [[ "$#" -gt 0 && ! "$1" =~ ^- ]]; do - TEST_SETS+=("$1") - shift - done - ;; - -sct) - if [[ -n "$2" && "$2" =~ ^[0-9]+$ ]]; then SYSYC_TIMEOUT="$2"; shift 2; else echo "错误: -sct 需要一个正整数参数。" >&2; exit 1; fi - ;; - -gct) - if [[ -n "$2" && "$2" =~ ^[0-9]+$ ]]; then GCC_TIMEOUT="$2"; shift 2; else echo "错误: -gct 需要一个正整数参数。" >&2; exit 1; fi - ;; - -et) - if [[ -n "$2" && "$2" =~ ^[0-9]+$ ]]; then EXEC_TIMEOUT="$2"; shift 2; else echo "错误: -et 需要一个正整数参数。" >&2; exit 1; fi - ;; - -ml|--max-lines) - if [[ -n "$2" && "$2" =~ ^[0-9]+$ ]]; then MAX_OUTPUT_LINES="$2"; shift 2; else echo "错误: --max-lines 需要一个正整数参数。" >&2; exit 1; fi - ;; - -h|--help) - show_help - exit 0 - ;; - *) - echo "未知选项: $1" - show_help - exit 1 + shift + while [[ "$#" -gt 0 && ! "$1" =~ ^- ]]; do TEST_SETS+=("$1"); shift; done ;; + -sct) if [[ -n "$2" && "$2" =~ ^[0-9]+$ ]]; then SYSYC_TIMEOUT="$2"; shift 2; else echo "错误: -sct 需要一个正整数参数。" >&2; exit 1; fi ;; + -lct) if [[ -n "$2" && "$2" =~ ^[0-9]+$ ]]; then LLC_TIMEOUT="$2"; shift 2; else echo "错误: -lct 需要一个正整数参数。" >&2; exit 1; fi ;; + -gct) if [[ -n "$2" && "$2" =~ ^[0-9]+$ ]]; then GCC_TIMEOUT="$2"; shift 2; else echo "错误: -gct 需要一个正整数参数。" >&2; exit 1; fi ;; + -et) if [[ -n "$2" && "$2" =~ ^[0-9]+$ ]]; then EXEC_TIMEOUT="$2"; shift 2; else echo "错误: -et 需要一个正整数参数。" >&2; exit 1; fi ;; + -ml|--max-lines) if [[ -n "$2" && "$2" =~ ^[0-9]+$ ]]; then MAX_OUTPUT_LINES="$2"; shift 2; else echo "错误: --max-lines 需要一个正整数参数。" >&2; exit 1; fi ;; + -h|--help) show_help; exit 0 ;; + *) echo "未知选项: $1"; show_help; exit 1 ;; esac done -# --- 本次修改点: 根据 -set 参数构建查找路径 --- +if ${EXECUTE_MODE} && ${IR_EXECUTE_MODE}; then + echo -e "\e[31m错误: -e 和 -eir 选项不能同时使用。\e[0m" >&2 + exit 1 +fi + declare -A SET_MAP SET_MAP[f]="functional" SET_MAP[h]="h_functional" SET_MAP[p]="performance" SEARCH_PATHS=() - if [ ${#TEST_SETS[@]} -eq 0 ] || [[ " ${TEST_SETS[@]} " =~ " all " ]]; then SEARCH_PATHS+=("${TESTDATA_DIR}") else @@ -152,9 +188,21 @@ echo "SysY 测试运行器启动..." if [ -n "$OPTIMIZE_FLAG" ]; then echo "优化等级: ${OPTIMIZE_FLAG}"; fi echo "输入目录: ${SEARCH_PATHS[@]}" echo "临时目录: ${TMP_DIR}" -echo "执行模式: ${EXECUTE_MODE}" -if ${EXECUTE_MODE}; then - echo "超时设置: sysyc=${SYSYC_TIMEOUT}s, gcc=${GCC_TIMEOUT}s, qemu=${EXEC_TIMEOUT}s" + +RUN_MODE_INFO="" +if ${IR_EXECUTE_MODE}; then + RUN_MODE_INFO="IR执行模式 (-eir)" + TIMEOUT_INFO="超时设置: sysyc=${SYSYC_TIMEOUT}s, llc=${LLC_TIMEOUT}s, gcc=${GCC_TIMEOUT}s, qemu=${EXEC_TIMEOUT}s" +elif ${EXECUTE_MODE}; then + RUN_MODE_INFO="直接执行模式 (-e)" + TIMEOUT_INFO="超时设置: sysyc=${SYSYC_TIMEOUT}s, gcc=${GCC_TIMEOUT}s, qemu=${EXEC_TIMEOUT}s" +else + RUN_MODE_INFO="编译模式 (默认)" + TIMEOUT_INFO="超时设置: sysyc=${SYSYC_TIMEOUT}s" +fi +echo "运行模式: ${RUN_MODE_INFO}" +echo "${TIMEOUT_INFO}" +if ${EXECUTE_MODE} || ${IR_EXECUTE_MODE}; then echo "失败输出最大行数: ${MAX_OUTPUT_LINES}" fi echo "" @@ -167,132 +215,228 @@ fi TOTAL_CASES=$(echo "$sy_files" | wc -w) while IFS= read -r sy_file; do - is_passed=1 # 1 表示通过, 0 表示失败 + is_passed=0 # 0 表示失败, 1 表示通过 relative_path_no_ext=$(realpath --relative-to="${TESTDATA_DIR}" "${sy_file%.*}") output_base_name=$(echo "${relative_path_no_ext}" | tr '/' '_') - assembly_file="${TMP_DIR}/${output_base_name}_sysyc_riscv64.s" - executable_file="${TMP_DIR}/${output_base_name}_sysyc_riscv64" + assembly_file_S="${TMP_DIR}/${output_base_name}_sysyc_S.s" + executable_file_S="${TMP_DIR}/${output_base_name}_sysyc_S" + output_actual_file_S="${TMP_DIR}/${output_base_name}_sysyc_S.actual_out" + + ir_file="${TMP_DIR}/${output_base_name}_sysyc_ir.ll" + assembly_file_from_ir="${TMP_DIR}/${output_base_name}_from_ir.s" + executable_file_from_ir="${TMP_DIR}/${output_base_name}_from_ir" + output_actual_file_from_ir="${TMP_DIR}/${output_base_name}_from_ir.actual_out" + input_file="${sy_file%.*}.in" output_reference_file="${sy_file%.*}.out" - output_actual_file="${TMP_DIR}/${output_base_name}_sysyc_riscv64.actual_out" echo "正在处理: $(basename "$sy_file") (路径: ${relative_path_no_ext}.sy)" - echo " 使用 sysyc 编译 (超时 ${SYSYC_TIMEOUT}s)..." - timeout -s KILL ${SYSYC_TIMEOUT} "${SYSYC}" -S "${sy_file}" -o "${assembly_file}" ${OPTIMIZE_FLAG} - SYSYC_STATUS=$? - if [ $SYSYC_STATUS -eq 124 ]; then - echo -e "\e[31m错误: SysY 编译 ${sy_file} 超时\e[0m" - is_passed=0 - elif [ $SYSYC_STATUS -ne 0 ]; then - echo -e "\e[31m错误: SysY 编译 ${sy_file} 失败，退出码: ${SYSYC_STATUS}\e[0m" - is_passed=0 - fi - if ${EXECUTE_MODE} && [ "$is_passed" -eq 1 ]; then - echo " 使用 gcc 编译 (超时 ${GCC_TIMEOUT}s)..." - timeout -s KILL ${GCC_TIMEOUT} "${GCC_RISCV64}" "${assembly_file}" -o "${executable_file}" -L"${LIB_DIR}" -lsysy_riscv -static - GCC_STATUS=$? - if [ $GCC_STATUS -eq 124 ]; then - echo -e "\e[31m错误: GCC 编译 ${assembly_file} 超时\e[0m" - is_passed=0 - elif [ $GCC_STATUS -ne 0 ]; then - echo -e "\e[31m错误: GCC 编译 ${assembly_file} 失败，退出码: ${GCC_STATUS}\e[0m" - is_passed=0 + # --- 模式 1: IR 执行模式 (-eir) --- + if ${IR_EXECUTE_MODE}; then + step_failed=0 + test_logic_passed=0 + + echo " [1/4] 使用 sysyc 编译为 IR (超时 ${SYSYC_TIMEOUT}s)..." + timeout -s KILL ${SYSYC_TIMEOUT} "${SYSYC}" -s ir "${sy_file}" -o "${ir_file}" ${OPTIMIZE_FLAG} + SYSYC_STATUS=$? + if [ $SYSYC_STATUS -ne 0 ]; then + [ $SYSYC_STATUS -eq 124 ] && echo -e "\e[31m错误: SysY (IR) 编译超时\e[0m" || echo -e "\e[31m错误: SysY (IR) 编译失败，退出码: ${SYSYC_STATUS}\e[0m" + step_failed=1 fi - elif ! ${EXECUTE_MODE}; then - echo " 跳过执行模式。仅生成汇编文件。" - if [ "$is_passed" -eq 1 ]; then - ((PASSED_CASES++)) - else - FAILED_CASES_LIST+="${relative_path_no_ext}.sy\n" - fi - echo "" - continue - fi - if [ "$is_passed" -eq 1 ]; then - echo " 正在执行 (超时 ${EXEC_TIMEOUT}s)..." - - exec_cmd="${QEMU_RISCV64} \"${executable_file}\"" - if [ -f "${input_file}" ]; then - exec_cmd+=" < \"${input_file}\"" - fi - exec_cmd+=" > \"${output_actual_file}\"" - - eval "timeout -s KILL ${EXEC_TIMEOUT} ${exec_cmd}" - ACTUAL_RETURN_CODE=$? - - if [ "$ACTUAL_RETURN_CODE" -eq 124 ]; then - echo -e "\e[31m 执行超时: ${sy_file} 运行超过 ${EXEC_TIMEOUT} 秒\e[0m" - is_passed=0 - else - if [ -f "${output_reference_file}" ]; then - LAST_LINE_TRIMMED=$(tail -n 1 "${output_reference_file}" | tr -d '[:space:]') - - if [[ "$LAST_LINE_TRIMMED" =~ ^[-+]?[0-9]+$ ]]; then - EXPECTED_RETURN_CODE="$LAST_LINE_TRIMMED" - EXPECTED_STDOUT_FILE="${TMP_DIR}/${output_base_name}_sysyc_riscv64.expected_stdout" - head -n -1 "${output_reference_file}" > "${EXPECTED_STDOUT_FILE}" - - if [ "$ACTUAL_RETURN_CODE" -eq "$EXPECTED_RETURN_CODE" ]; then - echo -e "\e[32m 返回码测试成功: (${ACTUAL_RETURN_CODE}) 与期望值 (${EXPECTED_RETURN_CODE}) 匹配\e[0m" - else - echo -e "\e[31m 返回码测试失败: 期望: ${EXPECTED_RETURN_CODE}, 实际: ${ACTUAL_RETURN_CODE}\e[0m" - is_passed=0 - fi - - if ! diff -q <(tr -d '[:space:]' < "${output_actual_file}") <(tr -d '[:space:]' < "${EXPECTED_STDOUT_FILE}") >/dev/null 2>&1; then - echo -e "\e[31m 标准输出测试失败\e[0m" - is_passed=0 - display_file_content "${EXPECTED_STDOUT_FILE}" " \e[36m---------- 期望输出 ----------\e[0m" "${MAX_OUTPUT_LINES}" - display_file_content "${output_actual_file}" " \e[36m---------- 实际输出 ----------\e[0m" "${MAX_OUTPUT_LINES}" - echo -e " \e[36m------------------------------\e[0m" - fi - else - if [ $ACTUAL_RETURN_CODE -ne 0 ]; then - echo -e "\e[33m警告: 程序以非零状态 ${ACTUAL_RETURN_CODE} 退出 (纯输出比较模式)。\e[0m" - fi - - if diff -q <(tr -d '[:space:]' < "${output_actual_file}") <(tr -d '[:space:]' < "${output_reference_file}") >/dev/null 2>&1; then - echo -e "\e[32m 成功: 输出与参考输出匹配\e[0m" - else - echo -e "\e[31m 失败: 输出不匹配\e[0m" - is_passed=0 - display_file_content "${output_reference_file}" " \e[36m---------- 期望输出 ----------\e[0m" "${MAX_OUTPUT_LINES}" - display_file_content "${output_actual_file}" " \e[36m---------- 实际输出 ----------\e[0m" "${MAX_OUTPUT_LINES}" - echo -e " \e[36m------------------------------\e[0m" - fi - fi - else - echo " 无参考输出文件。程序返回码: ${ACTUAL_RETURN_CODE}" + if [ "$step_failed" -eq 0 ]; then + echo " [2/4] 使用 llc-19 编译为汇编 (超时 ${LLC_TIMEOUT}s)..." + timeout -s KILL ${LLC_TIMEOUT} "${LLC_CMD}" -march=riscv64 -mcpu=generic-rv64 -mattr=+m,+a,+f,+d,+c -filetype=asm "${ir_file}" -o "${assembly_file_from_ir}" + LLC_STATUS=$? + if [ $LLC_STATUS -ne 0 ]; then + [ $LLC_STATUS -eq 124 ] && echo -e "\e[31m错误: llc-19 编译超时\e[0m" || echo -e "\e[31m错误: llc-19 编译失败，退出码: ${LLC_STATUS}\e[0m" + step_failed=1 fi fi + + if [ "$step_failed" -eq 0 ]; then + echo " [3/4] 使用 gcc 编译 (超时 ${GCC_TIMEOUT}s)..." + timeout -s KILL ${GCC_TIMEOUT} "${GCC_RISCV64}" "${assembly_file_from_ir}" -o "${executable_file_from_ir}" -L"${LIB_DIR}" -lsysy_riscv -static + GCC_STATUS=$? + if [ $GCC_STATUS -ne 0 ]; then + [ $GCC_STATUS -eq 124 ] && echo -e "\e[31m错误: GCC 编译超时\e[0m" || echo -e "\e[31m错误: GCC 编译失败，退出码: ${GCC_STATUS}\e[0m" + step_failed=1 + fi + fi + + if [ "$step_failed" -eq 0 ]; then + echo " [4/4] 正在执行 (超时 ${EXEC_TIMEOUT}s)..." + exec_cmd="${QEMU_RISCV64} \"${executable_file_from_ir}\"" + [ -f "${input_file}" ] && exec_cmd+=" < \"${input_file}\"" + exec_cmd+=" > \"${output_actual_file_from_ir}\"" + + eval "timeout -s KILL ${EXEC_TIMEOUT} ${exec_cmd}" + ACTUAL_RETURN_CODE=$? + + if [ "$ACTUAL_RETURN_CODE" -eq 124 ]; then + echo -e "\e[31m 执行超时: 运行超过 ${EXEC_TIMEOUT} 秒\e[0m" + else + if [ -f "${output_reference_file}" ]; then + LAST_LINE_TRIMMED=$(tail -n 1 "${output_reference_file}" | tr -d '[:space:]') + test_logic_passed=1 + if [[ "$LAST_LINE_TRIMMED" =~ ^[-+]?[0-9]+$ ]]; then + EXPECTED_RETURN_CODE="$LAST_LINE_TRIMMED" + EXPECTED_STDOUT_FILE="${TMP_DIR}/${output_base_name}_from_ir.expected_stdout" + head -n -1 "${output_reference_file}" > "${EXPECTED_STDOUT_FILE}" + + if [ "$ACTUAL_RETURN_CODE" -eq "$EXPECTED_RETURN_CODE" ]; then + echo -e "\e[32m 返回码测试成功: (${ACTUAL_RETURN_CODE}) 与期望值 (${EXPECTED_RETURN_CODE}) 匹配\e[0m" + else + echo -e "\e[31m 返回码测试失败: 期望: ${EXPECTED_RETURN_CODE}, 实际: ${ACTUAL_RETURN_CODE}\e[0m" + test_logic_passed=0 + fi + + if diff -q <(tr -d '[:space:]' < "${output_actual_file_from_ir}") <(tr -d '[:space:]' < "${EXPECTED_STDOUT_FILE}") >/dev/null 2>&1; then + [ "$test_logic_passed" -eq 1 ] && echo -e "\e[32m 标准输出测试成功\e[0m" + else + echo -e "\e[31m 标准输出测试失败\e[0m" + display_file_content "${EXPECTED_STDOUT_FILE}" " \e[36m---------- 期望输出 ----------\e[0m" "${MAX_OUTPUT_LINES}" + display_file_content "${output_actual_file_from_ir}" " \e[36m---------- 实际输出 ----------\e[0m" "${MAX_OUTPUT_LINES}" + test_logic_passed=0 + fi + else + if [ $ACTUAL_RETURN_CODE -ne 0 ]; then echo -e "\e[33m警告: 程序以非零状态 ${ACTUAL_RETURN_CODE} 退出 (纯输出比较模式)。\e[0m"; fi + if diff -q <(tr -d '[:space:]' < "${output_actual_file_from_ir}") <(tr -d '[:space:]' < "${output_reference_file}") >/dev/null 2>&1; then + echo -e "\e[32m 成功: 输出与参考输出匹配\e[0m" + else + echo -e "\e[31m 失败: 输出不匹配\e[0m" + display_file_content "${output_reference_file}" " \e[36m---------- 期望输出 ----------\e[0m" "${MAX_OUTPUT_LINES}" + display_file_content "${output_actual_file_from_ir}" " \e[36m---------- 实际输出 ----------\e[0m" "${MAX_OUTPUT_LINES}" + test_logic_passed=0 + fi + fi + else + echo " 无参考输出文件。程序返回码: ${ACTUAL_RETURN_CODE}" + test_logic_passed=1 + fi + fi + fi + [ "$step_failed" -eq 0 ] && [ "$test_logic_passed" -eq 1 ] && is_passed=1 + + # --- 模式 2: 直接执行模式 (-e) --- + elif ${EXECUTE_MODE}; then + step_failed=0 + test_logic_passed=0 + + echo " [1/3] 使用 sysyc 编译为汇编 (超时 ${SYSYC_TIMEOUT}s)..." + timeout -s KILL ${SYSYC_TIMEOUT} "${SYSYC}" -S "${sy_file}" -o "${assembly_file_S}" ${OPTIMIZE_FLAG} + SYSYC_STATUS=$? + if [ $SYSYC_STATUS -ne 0 ]; then + [ $SYSYC_STATUS -eq 124 ] && echo -e "\e[31m错误: SysY (汇编) 编译超时\e[0m" || echo -e "\e[31m错误: SysY (汇编) 编译失败，退出码: ${SYSYC_STATUS}\e[0m" + step_failed=1 + fi + + if [ "$step_failed" -eq 0 ]; then + echo " [2/3] 使用 gcc 编译 (超时 ${GCC_TIMEOUT}s)..." + timeout -s KILL ${GCC_TIMEOUT} "${GCC_RISCV64}" "${assembly_file_S}" -o "${executable_file_S}" -L"${LIB_DIR}" -lsysy_riscv -static + GCC_STATUS=$? + if [ $GCC_STATUS -ne 0 ]; then + [ $GCC_STATUS -eq 124 ] && echo -e "\e[31m错误: GCC 编译超时\e[0m" || echo -e "\e[31m错误: GCC 编译失败，退出码: ${GCC_STATUS}\e[0m" + step_failed=1 + fi + fi + + if [ "$step_failed" -eq 0 ]; then + echo " [3/3] 正在执行 (超时 ${EXEC_TIMEOUT}s)..." + exec_cmd="${QEMU_RISCV64} \"${executable_file_S}\"" + [ -f "${input_file}" ] && exec_cmd+=" < \"${input_file}\"" + exec_cmd+=" > \"${output_actual_file_S}\"" + + eval "timeout -s KILL ${EXEC_TIMEOUT} ${exec_cmd}" + ACTUAL_RETURN_CODE=$? + + if [ "$ACTUAL_RETURN_CODE" -eq 124 ]; then + echo -e "\e[31m 执行超时: 运行超过 ${EXEC_TIMEOUT} 秒\e[0m" + else + if [ -f "${output_reference_file}" ]; then + LAST_LINE_TRIMMED=$(tail -n 1 "${output_reference_file}" | tr -d '[:space:]') + test_logic_passed=1 + if [[ "$LAST_LINE_TRIMMED" =~ ^[-+]?[0-9]+$ ]]; then + EXPECTED_RETURN_CODE="$LAST_LINE_TRIMMED" + EXPECTED_STDOUT_FILE="${TMP_DIR}/${output_base_name}_sysyc_S.expected_stdout" + head -n -1 "${output_reference_file}" > "${EXPECTED_STDOUT_FILE}" + + if [ "$ACTUAL_RETURN_CODE" -eq "$EXPECTED_RETURN_CODE" ]; then + echo -e "\e[32m 返回码测试成功: (${ACTUAL_RETURN_CODE}) 与期望值 (${EXPECTED_RETURN_CODE}) 匹配\e[0m" + else + echo -e "\e[31m 返回码测试失败: 期望: ${EXPECTED_RETURN_CODE}, 实际: ${ACTUAL_RETURN_CODE}\e[0m" + test_logic_passed=0 + fi + + if diff -q <(tr -d '[:space:]' < "${output_actual_file_S}") <(tr -d '[:space:]' < "${EXPECTED_STDOUT_FILE}") >/dev/null 2>&1; then + [ "$test_logic_passed" -eq 1 ] && echo -e "\e[32m 标准输出测试成功\e[0m" + else + echo -e "\e[31m 标准输出测试失败\e[0m" + display_file_content "${EXPECTED_STDOUT_FILE}" " \e[36m---------- 期望输出 ----------\e[0m" "${MAX_OUTPUT_LINES}" + display_file_content "${output_actual_file_S}" " \e[36m---------- 实际输出 ----------\e[0m" "${MAX_OUTPUT_LINES}" + test_logic_passed=0 + fi + else + if [ $ACTUAL_RETURN_CODE -ne 0 ]; then echo -e "\e[33m警告: 程序以非零状态 ${ACTUAL_RETURN_CODE} 退出 (纯输出比较模式)。\e[0m"; fi + if diff -q <(tr -d '[:space:]' < "${output_actual_file_S}") <(tr -d '[:space:]' < "${output_reference_file}") >/dev/null 2>&1; then + echo -e "\e[32m 成功: 输出与参考输出匹配\e[0m" + else + echo -e "\e[31m 失败: 输出不匹配\e[0m" + display_file_content "${output_reference_file}" " \e[36m---------- 期望输出 ----------\e[0m" "${MAX_OUTPUT_LINES}" + display_file_content "${output_actual_file_S}" " \e[36m---------- 实际输出 ----------\e[0m" "${MAX_OUTPUT_LINES}" + test_logic_passed=0 + fi + fi + else + echo " 无参考输出文件。程序返回码: ${ACTUAL_RETURN_CODE}" + test_logic_passed=1 + fi + fi + fi + [ "$step_failed" -eq 0 ] && [ "$test_logic_passed" -eq 1 ] && is_passed=1 + + # --- 模式 3: 默认编译模式 --- + else + s_compile_ok=0 + ir_compile_ok=0 + + echo " [1/2] 使用 sysyc 编译为汇编 (超时 ${SYSYC_TIMEOUT}s)..." + timeout -s KILL ${SYSYC_TIMEOUT} "${SYSYC}" -S "${sy_file}" -o "${assembly_file_S}" ${OPTIMIZE_FLAG} + SYSYC_S_STATUS=$? + if [ $SYSYC_S_STATUS -eq 0 ]; then + s_compile_ok=1 + echo -e " \e[32m-> ${assembly_file_S} [成功]\e[0m" + else + [ $SYSYC_S_STATUS -eq 124 ] && echo -e " \e[31m-> [编译超时]\e[0m" || echo -e " \e[31m-> [编译失败, 退出码: ${SYSYC_S_STATUS}]\e[0m" + fi + + echo " [2/2] 使用 sysyc 编译为 IR (超时 ${SYSYC_TIMEOUT}s)..." + timeout -s KILL ${SYSYC_TIMEOUT} "${SYSYC}" -s ir "${sy_file}" -o "${ir_file}" ${OPTIMIZE_FLAG} + SYSYC_IR_STATUS=$? + if [ $SYSYC_IR_STATUS -eq 0 ]; then + ir_compile_ok=1 + echo -e " \e[32m-> ${ir_file} [成功]\e[0m" + else + [ $SYSYC_IR_STATUS -eq 124 ] && echo -e " \e[31m-> [编译超时]\e[0m" || echo -e " \e[31m-> [编译失败, 退出码: ${SYSYC_IR_STATUS}]\e[0m" + fi + + if [ "$s_compile_ok" -eq 1 ] && [ "$ir_compile_ok" -eq 1 ]; then + is_passed=1 + fi fi + # --- 统计结果 --- if [ "$is_passed" -eq 1 ]; then ((PASSED_CASES++)) else + # 确保 FAILED_CASES_LIST 的每一项都以换行符结尾 FAILED_CASES_LIST+="${relative_path_no_ext}.sy\n" fi echo "" done <<< "$sy_files" -echo "========================================" -echo "测试完成" -echo "测试通过率: [${PASSED_CASES}/${TOTAL_CASES}]" - -if [ -n "$FAILED_CASES_LIST" ]; then - echo "" - echo -e "\e[31m未通过的测例:\e[0m" - echo -e "${FAILED_CASES_LIST}" -fi - -echo "========================================" - -if [ "$PASSED_CASES" -eq "$TOTAL_CASES" ]; then - exit 0 -else - exit 1 -fi +# --- 修改：调用总结函数 --- +print_summary \ No newline at end of file diff --git a/src/sysyc.cpp b/src/sysyc.cpp index b946934..cbb553c 100644 --- a/src/sysyc.cpp +++ b/src/sysyc.cpp @@ -145,7 +145,7 @@ int main(int argc, char **argv) { // a) 如果指定停止在 IR 阶段，则打印最终 IR 并退出 if (argStopAfter == "ir" || argStopAfter == "ird") { // 打印最终 IR - cout << "=== Final IR ===\n"; + if (DEBUG) cerr << "=== Final IR ===\n"; if (!argOutputFilename.empty()) { // 输出到指定文件 ofstream fout(argOutputFilename); From 6b9ad0566d54a9cb5231f1f610f33f9552e97148 Mon Sep 17 00:00:00 2001 From: rain2133 <1370973498@qq.com> Date: Sat, 9 Aug 2025 21:28:44 +0800 Subject: [PATCH 45/55] =?UTF-8?q?[midend-llvmirprint]=E4=BF=AE=E5=A4=8D?= =?UTF-8?q?=E8=BF=9B=E5=BA=A6=EF=BC=88162/199=EF=BC=89=EF=BC=8C=E4=BF=AE?= =?UTF-8?q?=E5=A4=8D=E8=8B=A5=E5=B9=B2=E6=89=93=E5=8D=B0=E9=97=AE=E9=A2=98?= =?UTF-8?q?=EF=BC=8C=E4=BF=AE=E5=A4=8D=E8=8B=A5=E5=B9=B2ir=E7=94=9F?= =?UTF-8?q?=E6=88=90=E9=80=BB=E8=BE=91=E9=97=AE=E9=A2=98?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/include/midend/IR.h | 2 +- src/include/midend/IRBuilder.h | 47 +++++++-------- src/midend/IR.cpp | 106 ++++++++++++++++++++++++++++++--- src/midend/SysYIRGenerator.cpp | 59 ++++++++++++------ 4 files changed, 160 insertions(+), 54 deletions(-) diff --git a/src/include/midend/IR.h b/src/include/midend/IR.h index d9d618b..b05b2ee 100644 --- a/src/include/midend/IR.h +++ b/src/include/midend/IR.h @@ -856,7 +856,7 @@ public: case kBitFtoI: return "BitFtoI"; case kSRA: - return "SRA"; + return "ashr"; default: return "Unknown"; } diff --git a/src/include/midend/IRBuilder.h b/src/include/midend/IRBuilder.h index cc26bbe..a59b5a0 100644 --- a/src/include/midend/IRBuilder.h +++ b/src/include/midend/IRBuilder.h @@ -350,38 +350,31 @@ class IRBuilder { Type *currentWalkType = pointerType->as()->getBaseType(); // 遍历所有索引来深入类型层次结构。 - // `indices` 向量包含了所有 GEP 索引，包括由 `visitLValue` 等函数添加的初始 `0` 索引。 + // 重要：第一个索引总是用于"解引用"指针，后续索引才用于数组/结构体的索引 for (int i = 0; i < indices.size(); ++i) { - if (currentWalkType->isArray()) { - // 情况一：当前遍历类型是 `ArrayType`。 - // 索引用于选择数组元素，`currentWalkType` 更新为数组的元素类型。 - currentWalkType = currentWalkType->as()->getElementType(); - } else if (currentWalkType->isPointer()) { - // 情况二：当前遍历类型是 `PointerType`。 - // 这意味着我们正在通过一个指针来访问其指向的内存。 - // 索引用于选择该指针所指向的“数组”的元素。 - // `currentWalkType` 更新为该指针所指向的基础类型。 - // 例如：如果 `currentWalkType` 是 `i32*`，它将变为 `i32`。 - // 如果 `currentWalkType` 是 `[10 x i32]*`，它将变为 `[10 x i32]`。 - currentWalkType = currentWalkType->as()->getBaseType(); + if (i == 0) { + // 第一个索引：总是用于"解引用"基指针，不改变currentWalkType + // 例如：对于 `[4 x i32]* ptr, i32 0`，第一个0只是说"访问ptr指向的对象" + // currentWalkType 保持为 `[4 x i32]` + continue; } else { - // 情况三：当前遍历类型是标量类型 (例如 `i32`, `float` 等非聚合、非指针类型)。 - // - // 如果 `currentWalkType` 是标量，并且当前索引 `i` **不是** `indices` 向量中的最后一个索引， - // 这意味着尝试对一个标量类型进行进一步的结构性索引，这是**无效的**。 - // 例如：`int x; x[0];` 对应的 GEP 链中，`x` 的类型是 `i32`，再加 `[0]` 索引就是错误。 - // - // 如果 `currentWalkType` 是标量，且这是**最后一个索引** (`i == indices.size() - 1`)， - // 那么 GEP 是合法的，它只是计算一个偏移地址，最终的类型就是这个标量类型。 - // 此时 `currentWalkType` 保持不变，循环结束。 - if (i < indices.size() - 1) { - assert(false && "Invalid GEP indexing: attempting to index into a non-aggregate/non-pointer type with further indices."); - return nullptr; // 返回空指针表示类型推断失败 + // 后续索引：用于实际的数组/结构体索引 + if (currentWalkType->isArray()) { + // 数组索引：选择数组中的元素 + currentWalkType = currentWalkType->as()->getElementType(); + } else if (currentWalkType->isPointer()) { + // 指针索引：解引用指针并继续 + currentWalkType = currentWalkType->as()->getBaseType(); + } else { + // 标量类型：不能进一步索引 + if (i < indices.size() - 1) { + assert(false && "Invalid GEP indexing: attempting to index into a non-aggregate/non-pointer type with further indices."); + return nullptr; + } } - // 如果是最后一个索引，且当前类型是标量，则类型保持不变，这是合法的。 - // 循环会自然结束，返回正确的 `currentWalkType`。 } } + // 所有索引处理完毕后，`currentWalkType` 就是 GEP 指令最终计算出的地址所指向的元素的类型。 return currentWalkType; } diff --git a/src/midend/IR.cpp b/src/midend/IR.cpp index 0a9cfac..290b95a 100644 --- a/src/midend/IR.cpp +++ b/src/midend/IR.cpp @@ -556,8 +556,41 @@ void BasicBlock::print(std::ostream &os) const { os << " "; printBlockName(os, this); os << ":\n"; + + bool reachedTerminator = false; for (auto &inst : instructions) { - os << " " << *inst << '\n'; + // 跳过终结指令后的死代码 + if (reachedTerminator) { + continue; + } + + os << " "; + + // 特殊处理逻辑非指令 + if (auto* unaryInst = dynamic_cast(inst.get())) { + if (unaryInst->getKind() == Instruction::kNot && unaryInst->getType()->isInt()) { + // 生成两行：先比较，再扩展 + os << "%tmp_not_" << unaryInst->getName() << " = icmp eq " + << *unaryInst->getOperand()->getType() << " "; + printOperand(os, unaryInst->getOperand()); + os << ", 0\n %"; + os << unaryInst->getName() << " = zext i1 %tmp_not_" << unaryInst->getName() << " to i32"; + os << '\n'; + + // 检查当前指令是否是终结指令 + if (inst->isTerminator()) { + reachedTerminator = true; + } + continue; + } + } + + os << *inst << '\n'; + + // 检查当前指令是否是终结指令 + if (inst->isTerminator()) { + reachedTerminator = true; + } } } @@ -619,10 +652,11 @@ void UnaryInst::print(std::ostream &os) const { printOperand(os, getOperand()); break; case kNot: + // 在BasicBlock::print中特殊处理整数逻辑非，这里不应该执行到 os << "xor " << *getOperand()->getType() << " "; printOperand(os, getOperand()); os << ", -1"; - return; + break; case kFNot: os << "fcmp une " << *getOperand()->getType() << " "; printOperand(os, getOperand()); @@ -698,8 +732,41 @@ void UncondBrInst::print(std::ostream &os) const { } void CondBrInst::print(std::ostream &os) const { - os << "br i1 "; // 条件分支的条件总是假定为i1类型 - printOperand(os, getCondition()); + Value* condition = getCondition(); + + // 检查条件是否来自比较指令 + if (auto* binaryInst = dynamic_cast(condition)) { + auto kind = binaryInst->getKind(); + if (kind == kICmpEQ || kind == kICmpNE || kind == kICmpLT || + kind == kICmpGT || kind == kICmpLE || kind == kICmpGE || + kind == kFCmpEQ || kind == kFCmpNE || kind == kFCmpLT || + kind == kFCmpGT || kind == kFCmpLE || kind == kFCmpGE) { + // 比较指令返回i1类型，直接使用 + os << "br i1 "; + printOperand(os, condition); + } else { + // 其他指令返回i32，需要转换 + static int tmpCondCounter = 0; + std::string condName = condition->getName(); + if (condName.empty()) { + condName = "const" + std::to_string(++tmpCondCounter); + } + os << "%tmp_cond_" << condName << " = icmp ne i32 "; + printOperand(os, condition); + os << ", 0\n br i1 %tmp_cond_" << condName; + } + } else { + // 对于非BinaryInst的条件（如变量），假设是i32需要转换 + static int tmpCondCounter = 0; + std::string condName = condition->getName(); + if (condName.empty()) { + condName = "const" + std::to_string(++tmpCondCounter); + } + os << "%tmp_cond_" << condName << " = icmp ne i32 "; + printOperand(os, condition); + os << ", 0\n br i1 %tmp_cond_" << condName; + } + os << ", label %"; printBlockName(os, getThenBlock()); os << ", label %"; @@ -731,12 +798,19 @@ void LoadInst::print(std::ostream &os) const { } void MemsetInst::print(std::ostream &os) const { - os << "call void @llvm.memset.p0i8.i32(i8* "; - printOperand(os, getPointer()); - os << ", i8 "; - printOperand(os, getValue()); // value + Value* ptr = getPointer(); + + // Generate a temporary bitcast instruction before the memset call + // This is done at print time to avoid modifying the IR structure + os << "%tmp_bitcast_" << ptr->getName() << " = bitcast " << *ptr->getType() << " "; + printOperand(os, ptr); + os << " to i8*\n "; + + // Now call memset with the bitcast result + os << "call void @llvm.memset.p0i8.i32(i8* %tmp_bitcast_" << ptr->getName() << ", i8 "; + printOperand(os, getValue()); os << ", i32 "; - printOperand(os, getSize()); // size + printOperand(os, getSize()); os << ", i1 false)"; } @@ -1064,7 +1138,18 @@ void renameValues(Function* function) { // 重命名指令 for (auto& block : function->getBasicBlocks()) { + bool reachedTerminator = false; for (auto& inst : block->getInstructions()) { + // 跳过终结指令后的死代码 + if (reachedTerminator) { + continue; + } + + // 检查当前指令是否是终结指令 + if (inst->isTerminator()) { + reachedTerminator = true; + } + // 只有产生值的指令需要重命名 if (!inst->getType()->isVoid() && needsRename(inst->getName())) { valueNames[inst.get()] = "%" + std::to_string(tempCounter++); @@ -1130,6 +1215,9 @@ void Module::print(std::ostream& os) const { os << ")\n"; } + // Always declare memset intrinsic when needed + os << "declare void @llvm.memset.p0i8.i32(i8*, i8, i32, i1)\n"; + if (!getExternalFunctions().empty()) { os << "\n"; // 外部函数和普通函数之间加空行 } diff --git a/src/midend/SysYIRGenerator.cpp b/src/midend/SysYIRGenerator.cpp index babf38a..a31aae9 100644 --- a/src/midend/SysYIRGenerator.cpp +++ b/src/midend/SysYIRGenerator.cpp @@ -1360,11 +1360,12 @@ std::any SysYIRGenerator::visitAssignStmt(SysYParser::AssignStmtContext *ctx) { } } } else { - if (LType == Type::getFloatType()) { + if (LType == Type::getFloatType() && RType != Type::getFloatType()) { RValue = builder.createItoFInst(RValue); - } else { // 假设如果不是浮点型，就是整型 + } else if (LType != Type::getFloatType() && RType == Type::getFloatType()) { RValue = builder.createFtoIInst(RValue); } + // 如果两者都是同一类型，就不需要转换 } } @@ -1691,8 +1692,10 @@ std::any SysYIRGenerator::visitLValue(SysYParser::LValueContext *ctx) { gepBasePointer = alloc; gepIndices.push_back(ConstantInteger::get(0)); if (dims.empty() && declaredNumDims > 0) { - // 数组名单独出现（没有索引）：在SysY中，数组名应该退化为指向第一个元素的指针 - // 需要添加额外的0索引来获取第一个元素的地址 + // 数组名单独出现（没有索引）：在SysY中，多维数组名应该退化为指向第一行的指针 + // 对于二维数组 T[M][N]，退化为 T(*)[N]，需要GEP: getelementptr T[M][N], T[M][N]* ptr, i32 0, i32 0 + // 第一个i32 0: 选择数组本身，第二个i32 0: 选择第0行 + // 结果类型: T[N]* gepIndices.push_back(ConstantInteger::get(0)); } else { // 正常的数组元素访问 @@ -1703,7 +1706,8 @@ std::any SysYIRGenerator::visitLValue(SysYParser::LValueContext *ctx) { gepBasePointer = glob; gepIndices.push_back(ConstantInteger::get(0)); if (dims.empty() && declaredNumDims > 0) { - // 全局数组名单独出现（没有索引）：应该退化为指向第一个元素的指针 + // 全局数组名单独出现（没有索引）：应该退化为指向第一行的指针 + // 需要添加一个额外的i32 0索引 gepIndices.push_back(ConstantInteger::get(0)); } else { // 正常的数组元素访问 @@ -1713,7 +1717,8 @@ std::any SysYIRGenerator::visitLValue(SysYParser::LValueContext *ctx) { gepBasePointer = constV; gepIndices.push_back(ConstantInteger::get(0)); if (dims.empty() && declaredNumDims > 0) { - // 常量数组名单独出现（没有索引）：应该退化为指向第一个元素的指针 + // 常量数组名单独出现（没有索引）：应该退化为指向第一行的指针 + // 需要添加一个额外的i32 0索引 gepIndices.push_back(ConstantInteger::get(0)); } else { // 正常的数组元素访问 @@ -1835,15 +1840,27 @@ std::any SysYIRGenerator::visitCall(SysYParser::CallContext *ctx) { } else if (formalParamExpectedValueType->isFloat() && actualArgType->isInt()) { args[i] = builder.createItoFInst(args[i]); } - // 2. 指针类型转换 (例如数组退化：`[N x T]*` 到 `T*`，或兼容指针类型之间) TODO：不清楚有没有这种样例 + // 2. 指针类型转换 (例如数组退化：`[N x T]*` 到 `T*`，或兼容指针类型之间) // 这种情况常见于数组参数，实参可能是一个更具体的数组指针类型， - // 而形参是其退化后的基础指针类型。LLVM 的 `bitcast` 指令可以用于 - // 在相同大小的指针类型之间进行转换，这对于数组退化至关重要。 - // else if (formalParamType->isPointer() && actualArgType->isPointer()) { - // 检查指针基类型是否兼容，或者是否是数组退化导致的类型不同。 - // 使用 bitcast， - // args[i] = builder.createBitCastInst(args[i], formalParamType); - // } + // 而形参是其退化后的基础指针类型。 + else if (formalParamExpectedValueType->isPointer() && actualArgType->isPointer()) { + // 检查是否是数组指针到元素指针的decay + // 例如：[N x T]* -> T* + auto formalPtrType = formalParamExpectedValueType->as(); + auto actualPtrType = actualArgType->as(); + + if (formalPtrType && actualPtrType && actualPtrType->getBaseType()->isArray()) { + auto actualArrayType = actualPtrType->getBaseType()->as(); + if (actualArrayType && + formalPtrType->getBaseType() == actualArrayType->getElementType()) { + // 这是数组decay的情况，添加GEP来获取数组的第一个元素 + std::vector indices; + indices.push_back(ConstantInteger::get(0)); // 第一个索引：解引用指针 + indices.push_back(ConstantInteger::get(0)); // 第二个索引：获取数组第一个元素 + args[i] = getGEPAddressInst(args[i], indices); + } + } + } // 3. 其他未预期的类型不匹配 // 如果代码执行到这里，说明存在编译器前端未处理的类型不兼容或错误。 else { @@ -2227,15 +2244,23 @@ void Utils::createExternalFunction( const std::vector ¶mNames, const std::vector> ¶mDims, Type *returnType, const std::string &funcName, Module *pModule, IRBuilder *pBuilder) { - auto funcType = Type::getFunctionType(returnType, paramTypes); + // 根据paramDims调整参数类型，数组参数需要转换为指针类型 + std::vector adjustedParamTypes = paramTypes; + for (int i = 0; i < paramTypes.size() && i < paramDims.size(); ++i) { + if (!paramDims[i].empty()) { + // 如果参数有维度信息，说明是数组参数，转换为指针类型 + adjustedParamTypes[i] = Type::getPointerType(paramTypes[i]); + } + } + auto funcType = Type::getFunctionType(returnType, adjustedParamTypes); auto function = pModule->createExternalFunction(funcName, funcType); auto entry = function->getEntryBlock(); pBuilder->setPosition(entry, entry->end()); for (int i = 0; i < paramTypes.size(); ++i) { - auto arg = new Argument(paramTypes[i], function, i, paramNames[i]); + auto arg = new Argument(adjustedParamTypes[i], function, i, paramNames[i]); auto alloca = pBuilder->createAllocaInst( - Type::getPointerType(paramTypes[i]), paramNames[i]); + Type::getPointerType(adjustedParamTypes[i]), paramNames[i]); function->insertArgument(arg); auto store = pBuilder->createStoreInst(arg, alloca); pModule->addVariable(paramNames[i], alloca); From c867bda9b4de4af4d4a90821269342ea06972d33 Mon Sep 17 00:00:00 2001 From: rain2133 <1370973498@qq.com> Date: Sat, 9 Aug 2025 22:30:09 +0800 Subject: [PATCH 46/55] =?UTF-8?q?[midend]=E8=A7=A3=E5=86=B3=E9=83=A8?= =?UTF-8?q?=E5=88=86=E5=8F=98=E9=87=8F=E9=87=8D=E5=91=BD=E5=90=8D=E9=97=AE?= =?UTF-8?q?=E9=A2=98?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/include/midend/IR.h | 8 +++++ src/midend/IR.cpp | 57 ++++++++++++++++++++++++++++++++-- src/midend/SysYIRGenerator.cpp | 14 +++++++-- 3 files changed, 75 insertions(+), 4 deletions(-) diff --git a/src/include/midend/IR.h b/src/include/midend/IR.h index b05b2ee..e6364a2 100644 --- a/src/include/midend/IR.h +++ b/src/include/midend/IR.h @@ -1584,6 +1584,8 @@ class SymbolTable { Value* getVariable(const std::string &name) const; ///< 根据名字name以及当前作用域获取变量 Value* addVariable(const std::string &name, Value *variable); ///< 添加变量 + void registerParameterName(const std::string &name); ///< 注册函数参数名字，避免alloca重名 + void addVariableDirectly(const std::string &name, Value *variable); ///< 直接添加变量到当前作用域，不重命名 std::vector>& getGlobals(); ///< 获取全局变量列表 const std::vector>& getConsts() const; ///< 获取全局常量列表 void enterNewScope(); ///< 进入新的作用域 @@ -1646,6 +1648,12 @@ class Module { void addVariable(const std::string &name, AllocaInst *variable) { variableTable.addVariable(name, variable); } ///< 添加变量 + void addVariableDirectly(const std::string &name, AllocaInst *variable) { + variableTable.addVariableDirectly(name, variable); + } ///< 直接添加变量到当前作用域，不重命名 + void registerParameterName(const std::string &name) { + variableTable.registerParameterName(name); + } ///< 注册函数参数名字，避免alloca重名 Value* getVariable(const std::string &name) { return variableTable.getVariable(name); } ///< 根据名字name和当前作用域获取变量 diff --git a/src/midend/IR.cpp b/src/midend/IR.cpp index 290b95a..d7a796a 100644 --- a/src/midend/IR.cpp +++ b/src/midend/IR.cpp @@ -1,6 +1,7 @@ #include "IR.h" #include #include +#include #include #include #include @@ -1033,12 +1034,23 @@ auto SymbolTable::addVariable(const std::string &name, Value *variable) -> Value if (curNode != nullptr) { std::stringstream ss; auto iter = variableIndex.find(name); + + // 处理超长变量名（超过100字符） + std::string displayName = name; + if (name.length() > 100) { + // 计算简单哈希 + std::hash hasher; + size_t hash = hasher(name); + // 截断到前100个字符 + 哈希后缀 + displayName = name.substr(0, 100) + "_hash_" + std::to_string(hash); + } + if (iter != variableIndex.end()) { - ss << name << iter->second ; + ss << displayName << iter->second ; iter->second += 1; } else { variableIndex.emplace(name, 1); - ss << name << 0 ; + ss << displayName << 0 ; } variable->setName(ss.str()); @@ -1056,6 +1068,47 @@ auto SymbolTable::addVariable(const std::string &name, Value *variable) -> Value return result; } + +/** + * 注册函数参数名字到符号表，确保后续的alloca变量不会使用相同的名字 + */ +void SymbolTable::registerParameterName(const std::string &name) { + if (curNode != nullptr) { + // 为当前函数作用域创建一个唯一的参数名标识 + std::string scopedName = name + "_param_" + std::to_string(reinterpret_cast(curNode)); + auto iter = variableIndex.find(scopedName); + if (iter != variableIndex.end()) { + iter->second += 1; + } else { + // 注册带作用域的参数名，确保在本作用域中后续的addVariable会避免冲突 + variableIndex.emplace(scopedName, 1); + } + // 同时确保原名字也有一个索引，这样addVariable会为alloca生成不同的名字 + auto iter2 = variableIndex.find(name); + if (iter2 == variableIndex.end()) { + variableIndex.emplace(name, 1); // 设置为1，这样addVariable会生成name1而不是name0 + } else { + iter2->second += 1; + } + } +} + +/** + * 直接添加变量到当前作用域，不进行重命名 + */ +void SymbolTable::addVariableDirectly(const std::string &name, Value *variable) { + if (curNode != nullptr) { + curNode->varList.emplace(name, variable); + auto global = dynamic_cast(variable); + auto constvar = dynamic_cast(variable); + if (global != nullptr) { + globals.emplace_back(global); + } else if (constvar != nullptr) { + globalconsts.emplace_back(constvar); + } + } +} + /** * 获取全局变量 */ diff --git a/src/midend/SysYIRGenerator.cpp b/src/midend/SysYIRGenerator.cpp index a31aae9..03e80e6 100644 --- a/src/midend/SysYIRGenerator.cpp +++ b/src/midend/SysYIRGenerator.cpp @@ -1210,15 +1210,25 @@ std::any SysYIRGenerator::visitFuncDef(SysYParser::FuncDefContext *ctx){ for(int i = 0; i < paramActualTypes.size(); ++i) { Argument* arg = new Argument(paramActualTypes[i], function, i, paramNames[i]); function->insertArgument(arg); + } + // 先将所有参数名字注册到符号表中，确保alloca不会使用相同的名字 + for (int i = 0; i < paramNames.size(); ++i) { + // 预先注册参数名字，这样addVariable就会使用不同的后缀 + module->registerParameterName(paramNames[i]); } auto funcArgs = function->getArguments(); std::vector allocas; for (int i = 0; i < paramActualTypes.size(); ++i) { - AllocaInst *alloca = builder.createAllocaInst(Type::getPointerType(paramActualTypes[i]), paramNames[i]); + // 使用函数特定的前缀来确保参数alloca名字唯一 + std::string allocaName = name + "_param_" + paramNames[i]; + AllocaInst *alloca = builder.createAllocaInst(Type::getPointerType(paramActualTypes[i]), allocaName); + // 直接设置唯一名字，不依赖addVariable的命名逻辑 + alloca->setName(allocaName); allocas.push_back(alloca); - module->addVariable(paramNames[i], alloca); + // 直接添加到符号表，使用原参数名作为查找键 + module->addVariableDirectly(paramNames[i], alloca); } for(int i = 0; i < paramActualTypes.size(); ++i) { From 6b92020bc40f273e8aa8b3fa8af10bf683d91cdd Mon Sep 17 00:00:00 2001 From: rain2133 <1370973498@qq.com> Date: Sat, 9 Aug 2025 22:41:32 +0800 Subject: [PATCH 47/55] =?UTF-8?q?[midend-llvmirprint]=E4=BF=AE=E5=A4=8D?= =?UTF-8?q?=E5=85=A8=E5=B1=80=E6=95=B0=E7=BB=84=E6=89=93=E5=8D=B0=E6=A0=BC?= =?UTF-8?q?=E5=BC=8F=E9=97=AE=E9=A2=98?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/midend/IR.cpp | 114 ++++++++++++++++++++++++++++++---------------- 1 file changed, 74 insertions(+), 40 deletions(-) diff --git a/src/midend/IR.cpp b/src/midend/IR.cpp index d7a796a..0c105cf 100644 --- a/src/midend/IR.cpp +++ b/src/midend/IR.cpp @@ -274,6 +274,55 @@ void Argument::print(std::ostream& os) const { os << *getType() << " %" << getName(); } +// 辅助函数：递归生成多维数组的初始化格式 +static void printArrayInitializer(std::ostream& os, Type* arrayType, const ValueCounter& initValues, size_t& valueIndex) { + if (auto arrType = arrayType->as()) { + auto elementType = arrType->getElementType(); + auto numElements = arrType->getNumElements(); + + os << "["; + for (unsigned i = 0; i < numElements; ++i) { + if (i > 0) os << ", "; + + if (elementType->isArray()) { + // 嵌套数组，递归处理 + os << *elementType << " "; + printArrayInitializer(os, elementType, initValues, valueIndex); + } else { + // 基础类型元素 + os << *elementType << " "; + if (valueIndex < initValues.size()) { + const auto& values = initValues.getValues(); + const auto& numbers = initValues.getNumbers(); + + // 找到当前应该使用的值 + size_t currentValueIdx = 0; + size_t currentCount = 0; + for (size_t j = 0; j < values.size(); ++j) { + if (currentCount + numbers[j] > valueIndex) { + currentValueIdx = j; + break; + } + currentCount += numbers[j]; + } + + printOperand(os, values[currentValueIdx]); + valueIndex++; + } else { + // 没有更多初始化值，使用默认值 + if (elementType->isInt()) { + os << "0"; + } else if (elementType->isFloat()) { + os << "0.0"; + } + valueIndex++; + } + } + } + os << "]"; + } +} + void GlobalValue::print(std::ostream& os) const { // 输出全局变量的LLVM IR格式 os << "@" << getName() << " = global "; @@ -320,20 +369,15 @@ void GlobalValue::print(std::ostream& os) const { printOperand(os, singleVal); } } else { - // 数组初始值 - 需要展开ValueCounter中的压缩表示 - os << "["; - bool first = true; - const auto& numbers = initValues.getNumbers(); - - for (size_t i = 0; i < values.size(); ++i) { - for (unsigned j = 0; j < numbers[i]; ++j) { - if (!first) os << ", "; - os << *values[i]->getType() << " "; - printOperand(os, values[i]); - first = false; - } + // 数组初始值 - 根据数组维度生成正确的初始化格式 + if (baseType->isArray()) { + size_t valueIndex = 0; + printArrayInitializer(os, baseType, initValues, valueIndex); + } else { + // 单个非零标量值 + auto singleVal = initValues.getValue(0); + printOperand(os, singleVal); } - os << "]"; } } } @@ -384,20 +428,15 @@ void ConstantVariable::print(std::ostream& os) const { printOperand(os, singleVal); } } else { - // 数组初始值 - 需要展开ValueCounter中的压缩表示 - os << "["; - bool first = true; - const auto& numbers = initValues.getNumbers(); - - for (size_t i = 0; i < values.size(); ++i) { - for (unsigned j = 0; j < numbers[i]; ++j) { - if (!first) os << ", "; - os << *values[i]->getType() << " "; - printOperand(os, values[i]); - first = false; - } + // 数组初始值 - 根据数组维度生成正确的初始化格式 + if (baseType->isArray()) { + size_t valueIndex = 0; + printArrayInitializer(os, baseType, initValues, valueIndex); + } else { + // 单个非零标量值 + auto singleVal = initValues.getValue(0); + printOperand(os, singleVal); } - os << "]"; } } } @@ -409,21 +448,16 @@ void ConstantVariable::print_init(std::ostream& os) const { // 单个初始值 initValues.getValue(0)->print(os); } else { - // 数组初始值 - 需要展开ValueCounter中的压缩表示 - os << "["; - bool first = true; - const auto& values = initValues.getValues(); - const auto& numbers = initValues.getNumbers(); - - for (size_t i = 0; i < values.size(); ++i) { - for (unsigned j = 0; j < numbers[i]; ++j) { - if (!first) os << ", "; - os << *values[i]->getType() << " "; - values[i]->print(os); - first = false; - } + // 数组初始值 - 根据数组维度生成正确的初始化格式 + auto baseType = getType()->as()->getBaseType(); + if (baseType->isArray()) { + size_t valueIndex = 0; + printArrayInitializer(os, baseType, initValues, valueIndex); + } else { + // 单个非零标量值 + auto singleVal = initValues.getValue(0); + singleVal->print(os); } - os << "]"; } } else { os << "zeroinitializer"; From 2c5e4cead1f716474c99a83ca52e882a9e8d0b78 Mon Sep 17 00:00:00 2001 From: rain2133 <1370973498@qq.com> Date: Sun, 10 Aug 2025 15:19:24 +0800 Subject: [PATCH 48/55] =?UTF-8?q?[midend-llvmirprint]=E4=BF=AE=E5=A4=8D?= =?UTF-8?q?=E9=83=A8=E5=88=86=E6=89=93=E5=8D=B0=E9=80=BB=E8=BE=91=EF=BC=8C?= =?UTF-8?q?=E4=BF=AE=E5=A4=8D=E7=94=9F=E6=88=90IR=E6=97=B6=E7=9A=84?= =?UTF-8?q?=E5=9F=BA=E6=9C=AC=E5=9D=97=E9=94=99=E8=AF=AF=E7=9A=84=E5=89=8D?= =?UTF-8?q?=E5=90=8E=E9=A9=B1=E5=85=B3=E7=B3=BB=E9=93=BE=E6=8E=A5?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/midend/IR.cpp | 113 +++++++++++++++------------------ src/midend/SysYIRGenerator.cpp | 2 +- 2 files changed, 52 insertions(+), 63 deletions(-) diff --git a/src/midend/IR.cpp b/src/midend/IR.cpp index 0c105cf..c6a2ce5 100644 --- a/src/midend/IR.cpp +++ b/src/midend/IR.cpp @@ -13,10 +13,19 @@ using namespace std; inline std::string getMachineCode(float fval) { - uint32_t mrf = *reinterpret_cast(&fval); + // LLVM IR要求float也使用64位十六进制表示 + // 将float扩展为double精度格式 + double dval = static_cast(fval); + uint64_t bits = *reinterpret_cast(&dval); + + // 如果是0，直接返回 + if (bits == 0 || fval == 0.0f) { + return "0x0000000000000000"; + } + std::stringstream ss; - ss << std::hex << std::uppercase << std::setfill('0') << std::setw(8) << mrf; - return "0x" + ss.str(); + ss << "0x" << std::hex << std::uppercase << std::setfill('0') << std::setw(16) << bits; + return ss.str(); } /** @@ -638,7 +647,7 @@ void PhiInst::print(std::ostream &os) const { } os << " ["; printOperand(os, getIncomingValue(i)); - os << ", "; + os << ", %"; printBlockName(os, getIncomingBlock(i)); os << "]"; } @@ -723,27 +732,34 @@ void AllocaInst::print(std::ostream &os) const { } void BinaryInst::print(std::ostream &os) const { - printVarName(os, this) << " = "; - auto kind = getKind(); // 检查是否为比较指令 if (kind == kICmpEQ || kind == kICmpNE || kind == kICmpLT || kind == kICmpGT || kind == kICmpLE || kind == kICmpGE) { - // 整数比较指令 - os << getKindString() << " " << *getLhs()->getType() << " "; + // 整数比较指令 - 生成临时i1结果然后转换为i32 + static int tmpCmpCounter = 0; + std::string tmpName = "tmp_icmp_" + std::to_string(++tmpCmpCounter); + os << "%" << tmpName << " = " << getKindString() << " " << *getLhs()->getType() << " "; printOperand(os, getLhs()); os << ", "; printOperand(os, getRhs()); + os << "\n "; + printVarName(os, this) << " = zext i1 %" << tmpName << " to i32"; } else if (kind == kFCmpEQ || kind == kFCmpNE || kind == kFCmpLT || kind == kFCmpGT || kind == kFCmpLE || kind == kFCmpGE) { - // 浮点比较指令 - os << getKindString() << " " << *getLhs()->getType() << " "; + // 浮点比较指令 - 生成临时i1结果然后转换为i32 + static int tmpCmpCounter = 0; + std::string tmpName = "tmp_fcmp_" + std::to_string(++tmpCmpCounter); + os << "%" << tmpName << " = " << getKindString() << " " << *getLhs()->getType() << " "; printOperand(os, getLhs()); os << ", "; printOperand(os, getRhs()); + os << "\n "; + printVarName(os, this) << " = zext i1 %" << tmpName << " to i32"; } else { // 算术和逻辑指令 + printVarName(os, this) << " = "; os << getKindString() << " " << *getType() << " "; printOperand(os, getLhs()); os << ", "; @@ -769,38 +785,15 @@ void UncondBrInst::print(std::ostream &os) const { void CondBrInst::print(std::ostream &os) const { Value* condition = getCondition(); - // 检查条件是否来自比较指令 - if (auto* binaryInst = dynamic_cast(condition)) { - auto kind = binaryInst->getKind(); - if (kind == kICmpEQ || kind == kICmpNE || kind == kICmpLT || - kind == kICmpGT || kind == kICmpLE || kind == kICmpGE || - kind == kFCmpEQ || kind == kFCmpNE || kind == kFCmpLT || - kind == kFCmpGT || kind == kFCmpLE || kind == kFCmpGE) { - // 比较指令返回i1类型，直接使用 - os << "br i1 "; - printOperand(os, condition); - } else { - // 其他指令返回i32，需要转换 - static int tmpCondCounter = 0; - std::string condName = condition->getName(); - if (condName.empty()) { - condName = "const" + std::to_string(++tmpCondCounter); - } - os << "%tmp_cond_" << condName << " = icmp ne i32 "; - printOperand(os, condition); - os << ", 0\n br i1 %tmp_cond_" << condName; - } - } else { - // 对于非BinaryInst的条件（如变量），假设是i32需要转换 - static int tmpCondCounter = 0; - std::string condName = condition->getName(); - if (condName.empty()) { - condName = "const" + std::to_string(++tmpCondCounter); - } - os << "%tmp_cond_" << condName << " = icmp ne i32 "; - printOperand(os, condition); - os << ", 0\n br i1 %tmp_cond_" << condName; + // 由于所有条件都是i32类型（包括比较结果），统一转换为i1 + static int tmpCondCounter = 0; + std::string condName = condition->getName(); + if (condName.empty()) { + condName = "const" + std::to_string(++tmpCondCounter); } + os << "%tmp_cond_" << condName << " = icmp ne i32 "; + printOperand(os, condition); + os << ", 0\n br i1 %tmp_cond_" << condName; os << ", label %"; printBlockName(os, getThenBlock()); @@ -1079,14 +1072,26 @@ auto SymbolTable::addVariable(const std::string &name, Value *variable) -> Value displayName = name.substr(0, 100) + "_hash_" + std::to_string(hash); } + // 区分全局变量和局部变量的命名 + bool isGlobalVariable = (dynamic_cast(variable) != nullptr) || + (dynamic_cast(variable) != nullptr); + + int index = 0; if (iter != variableIndex.end()) { - ss << displayName << iter->second ; + index = iter->second; iter->second += 1; } else { variableIndex.emplace(name, 1); - ss << displayName << 0 ; } - + + if (isGlobalVariable) { + // 全局变量不使用 local_ 前缀 + ss << displayName << index; + } else { + // 局部变量使用 "local_" 前缀确保不会和函数参数名冲突 + ss << "local_" << displayName << index; + } + variable->setName(ss.str()); curNode->varList.emplace(name, variable); auto global = dynamic_cast(variable); @@ -1107,24 +1112,8 @@ auto SymbolTable::addVariable(const std::string &name, Value *variable) -> Value * 注册函数参数名字到符号表，确保后续的alloca变量不会使用相同的名字 */ void SymbolTable::registerParameterName(const std::string &name) { - if (curNode != nullptr) { - // 为当前函数作用域创建一个唯一的参数名标识 - std::string scopedName = name + "_param_" + std::to_string(reinterpret_cast(curNode)); - auto iter = variableIndex.find(scopedName); - if (iter != variableIndex.end()) { - iter->second += 1; - } else { - // 注册带作用域的参数名，确保在本作用域中后续的addVariable会避免冲突 - variableIndex.emplace(scopedName, 1); - } - // 同时确保原名字也有一个索引，这样addVariable会为alloca生成不同的名字 - auto iter2 = variableIndex.find(name); - if (iter2 == variableIndex.end()) { - variableIndex.emplace(name, 1); // 设置为1，这样addVariable会生成name1而不是name0 - } else { - iter2->second += 1; - } - } + // 由于局部变量现在使用 "local_" 前缀，不需要复杂的冲突避免逻辑 + // 这个方法现在主要用于参数相关的记录，可以简化 } /** diff --git a/src/midend/SysYIRGenerator.cpp b/src/midend/SysYIRGenerator.cpp index 03e80e6..a0cd6af 100644 --- a/src/midend/SysYIRGenerator.cpp +++ b/src/midend/SysYIRGenerator.cpp @@ -1546,7 +1546,7 @@ std::any SysYIRGenerator::visitWhileStmt(SysYParser::WhileStmtContext *ctx) { } builder.createUncondBrInst(headBlock); - BasicBlock::conectBlocks(builder.getBasicBlock(), exitBlock); + BasicBlock::conectBlocks(builder.getBasicBlock(), headBlock); builder.popBreakBlock(); builder.popContinueBlock(); From d1ba140657eb7500d9cb35bb7978bd4c0c9a7565 Mon Sep 17 00:00:00 2001 From: rain2133 <1370973498@qq.com> Date: Sun, 10 Aug 2025 16:12:09 +0800 Subject: [PATCH 49/55] =?UTF-8?q?[midend-llvnirprint]=E4=BF=AE=E6=94=B9?= =?UTF-8?q?=E6=B5=AE=E7=82=B9=E4=B8=BA=E5=AD=97=E9=9D=A2=E5=80=BC=E6=89=93?= =?UTF-8?q?=E5=8D=B0=EF=BC=8C=E4=BF=AE=E5=A4=8Dassign=E7=9A=84=E7=B1=BB?= =?UTF-8?q?=E5=9E=8B=E6=8E=A8=E6=96=AD?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/midend/IR.cpp | 34 +++++++--- src/midend/SysYIRGenerator.cpp | 114 +++++++++++++++++++++------------ 2 files changed, 98 insertions(+), 50 deletions(-) diff --git a/src/midend/IR.cpp b/src/midend/IR.cpp index c6a2ce5..b301d82 100644 --- a/src/midend/IR.cpp +++ b/src/midend/IR.cpp @@ -13,16 +13,15 @@ using namespace std; inline std::string getMachineCode(float fval) { - // LLVM IR要求float也使用64位十六进制表示 - // 将float扩展为double精度格式 - double dval = static_cast(fval); - uint64_t bits = *reinterpret_cast(&dval); - // 如果是0，直接返回 - if (bits == 0 || fval == 0.0f) { + if (fval == 0.0f) { return "0x0000000000000000"; } + // 正确的float到double扩展：先转换值，再获取double的位表示 + double dval = static_cast(fval); + uint64_t bits = *reinterpret_cast(&dval); + std::stringstream ss; ss << "0x" << std::hex << std::uppercase << std::setfill('0') << std::setw(16) << bits; return ss.str(); @@ -90,11 +89,18 @@ static inline ostream &printFunctionName(ostream &os, const Function *fn) { static inline ostream &printOperand(ostream &os, const Value *value) { auto constValue = dynamic_cast(value); if (constValue != nullptr) { - // 对于常量，只打印值，不打印类型（类型已经在指令中单独打印了） if (auto constInt = dynamic_cast(constValue)) { os << constInt->getInt(); } else if (auto constFloat = dynamic_cast(constValue)) { - os << getMachineCode(constFloat->getFloat()); + float f = constFloat->getFloat(); + char buffer[64]; + snprintf(buffer, sizeof(buffer), "%.17g", f); + std::string str(buffer); + if (str.find('.') == std::string::npos && str.find('e') == std::string::npos) { + str += ".0"; + } + os << str; + } else if (auto undefVal = dynamic_cast(constValue)) { os << "undef"; } @@ -586,10 +592,18 @@ void ConstantValue::print(std::ostream &os) const { } void ConstantInteger::print(std::ostream &os) const { - os << "i32 " << this->getInt(); + os << this->getInt(); } void ConstantFloating::print(std::ostream &os) const { - os << "float " << getMachineCode(this->getFloat()); + float f = this->getFloat(); + + char buffer[64]; + snprintf(buffer, sizeof(buffer), "%.17g", f); + std::string str(buffer); + if (str.find('.') == std::string::npos && str.find('e') == std::string::npos) { + str += ".0"; + } + os << str; } void UndefinedValue::print(std::ostream &os) const { os << this->getType() << " undef"; diff --git a/src/midend/SysYIRGenerator.cpp b/src/midend/SysYIRGenerator.cpp index a0cd6af..7ff316a 100644 --- a/src/midend/SysYIRGenerator.cpp +++ b/src/midend/SysYIRGenerator.cpp @@ -1297,6 +1297,45 @@ std::any SysYIRGenerator::visitAssignStmt(SysYParser::AssignStmtContext *ctx) { if (dynamic_cast(variable) || dynamic_cast(variable)) { LValue = variable; } + + // 标量变量的类型推断 + Type* LType = builder.getIndexedType(variable->getType(), indices); + + Value* RValue = computeExp(ctx->exp(), LType); // 右值计算 + Type* RType = RValue->getType(); + + // TODO:computeExp处理了类型转换，可以考虑删除判断逻辑 + if (LType != RType) { + ConstantValue *constValue = dynamic_cast(RValue); + if (constValue != nullptr) { + if (LType == Type::getFloatType()) { + if(dynamic_cast(constValue)) { + // 如果是整型常量，转换为浮点型 + RValue = ConstantFloating::get(static_cast(constValue->getInt())); + } else if (dynamic_cast(constValue)) { + // 如果是浮点型常量，直接使用 + RValue = ConstantFloating::get(static_cast(constValue->getFloat())); + } + } else { // 假设如果不是浮点型，就是整型 + if(dynamic_cast(constValue)) { + // 如果是浮点型常量，转换为整型 + RValue = ConstantInteger::get(static_cast(constValue->getFloat())); + } else if (dynamic_cast(constValue)) { + // 如果是整型常量，直接使用 + RValue = ConstantInteger::get(static_cast(constValue->getInt())); + } + } + } else { + if (LType == Type::getFloatType() && RType != Type::getFloatType()) { + RValue = builder.createItoFInst(RValue); + } else if (LType != Type::getFloatType() && RType == Type::getFloatType()) { + RValue = builder.createFtoIInst(RValue); + } + // 如果两者都是同一类型，就不需要转换 + } + } + + builder.createStoreInst(RValue, LValue); } else { // 对于数组或多维数组的左值处理 @@ -1334,52 +1373,47 @@ std::any SysYIRGenerator::visitAssignStmt(SysYParser::AssignStmtContext *ctx) { } // 左值为地址 LValue = getGEPAddressInst(gepBasePointer, gepIndices); - } + + // 数组变量的类型推断，使用gepIndices和gepBasePointer的类型 + Type* LType = builder.getIndexedType(gepBasePointer->getType(), gepIndices); + + Value* RValue = computeExp(ctx->exp(), LType); // 右值计算 + Type* RType = RValue->getType(); - // Value* RValue = std::any_cast(visitExp(ctx->exp())); // 右值 - - // 先推断 LValue 的类型 - // 如果 LValue 是指向数组的指针，则需要根据 indices 获取正确的类型 - // 如果 LValue 是标量，则直接使用其类型 - // 注意：LValue 的类型可能是指向数组的指针 (e.g., int(*)[3]) 或者指向标量的指针 (e.g., int*) 也能推断 - Type* LType = builder.getIndexedType(variable->getType(), indices); - - Value* RValue = computeExp(ctx->exp(), LType); // 右值计算 - Type* RType = RValue->getType(); - - // TODO:computeExp处理了类型转换，可以考虑删除判断逻辑 - if (LType != RType) { - ConstantValue *constValue = dynamic_cast(RValue); - if (constValue != nullptr) { - if (LType == Type::getFloatType()) { - if(dynamic_cast(constValue)) { - // 如果是整型常量，转换为浮点型 - RValue = ConstantFloating::get(static_cast(constValue->getInt())); - } else if (dynamic_cast(constValue)) { - // 如果是浮点型常量，直接使用 - RValue = ConstantFloating::get(static_cast(constValue->getFloat())); + // TODO:computeExp处理了类型转换，可以考虑删除判断逻辑 + if (LType != RType) { + ConstantValue *constValue = dynamic_cast(RValue); + if (constValue != nullptr) { + if (LType == Type::getFloatType()) { + if(dynamic_cast(constValue)) { + // 如果是整型常量，转换为浮点型 + RValue = ConstantFloating::get(static_cast(constValue->getInt())); + } else if (dynamic_cast(constValue)) { + // 如果是浮点型常量，直接使用 + RValue = ConstantFloating::get(static_cast(constValue->getFloat())); + } + } else { // 假设如果不是浮点型，就是整型 + if(dynamic_cast(constValue)) { + // 如果是浮点型常量，转换为整型 + RValue = ConstantInteger::get(static_cast(constValue->getFloat())); + } else if (dynamic_cast(constValue)) { + // 如果是整型常量，直接使用 + RValue = ConstantInteger::get(static_cast(constValue->getInt())); + } } - } else { // 假设如果不是浮点型，就是整型 - if(dynamic_cast(constValue)) { - // 如果是浮点型常量，转换为整型 - RValue = ConstantInteger::get(static_cast(constValue->getFloat())); - } else if (dynamic_cast(constValue)) { - // 如果是整型常量，直接使用 - RValue = ConstantInteger::get(static_cast(constValue->getInt())); - + } else { + if (LType == Type::getFloatType() && RType != Type::getFloatType()) { + RValue = builder.createItoFInst(RValue); + } else if (LType != Type::getFloatType() && RType == Type::getFloatType()) { + RValue = builder.createFtoIInst(RValue); } + // 如果两者都是同一类型，就不需要转换 } - } else { - if (LType == Type::getFloatType() && RType != Type::getFloatType()) { - RValue = builder.createItoFInst(RValue); - } else if (LType != Type::getFloatType() && RType == Type::getFloatType()) { - RValue = builder.createFtoIInst(RValue); - } - // 如果两者都是同一类型，就不需要转换 } + + builder.createStoreInst(RValue, LValue); } - - builder.createStoreInst(RValue, LValue); + invalidateExpressionsOnStore(LValue); return std::any(); } From ad19a6715f88914eb18e1b8a5b3f1521516794a5 Mon Sep 17 00:00:00 2001 From: rain2133 <1370973498@qq.com> Date: Sun, 10 Aug 2025 16:57:40 +0800 Subject: [PATCH 50/55] =?UTF-8?q?[midend]=E5=88=A0=E9=99=A4=E4=BA=86?= =?UTF-8?q?=E9=94=99=E8=AF=AF=E7=9A=84sra=E6=8C=87=E4=BB=A4=E7=94=9F?= =?UTF-8?q?=E6=88=90=E9=80=BB=E8=BE=91?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/midend/SysYIRGenerator.cpp | 21 +-------------------- 1 file changed, 1 insertion(+), 20 deletions(-) diff --git a/src/midend/SysYIRGenerator.cpp b/src/midend/SysYIRGenerator.cpp index 7ff316a..541c976 100644 --- a/src/midend/SysYIRGenerator.cpp +++ b/src/midend/SysYIRGenerator.cpp @@ -389,26 +389,7 @@ void SysYIRGenerator::compute() { case BinaryOp::ADD: resultValue = builder.createAddInst(lhs, rhs); break; case BinaryOp::SUB: resultValue = builder.createSubInst(lhs, rhs); break; case BinaryOp::MUL: resultValue = builder.createMulInst(lhs, rhs); break; - case BinaryOp::DIV: { - ConstantInteger *rhsConst = dynamic_cast(rhs); - if (rhsConst) { - int divisor = rhsConst->getInt(); - if (divisor > 0 && (divisor & (divisor - 1)) == 0) { - int shift = 0; - int temp = divisor; - while (temp > 1) { - temp >>= 1; - shift++; - } - resultValue = builder.createSRAInst(lhs, ConstantInteger::get(shift)); - } else { - resultValue = builder.createDivInst(lhs, rhs); - } - } else { - resultValue = builder.createDivInst(lhs, rhs); - } - break; - } + case BinaryOp::DIV: resultValue = builder.createDivInst(lhs, rhs); break; case BinaryOp::MOD: resultValue = builder.createRemInst(lhs, rhs); break; } } else if (commonType == Type::getFloatType()) { From 4d0e2d73ea442d6bcd96f1d4d2a3445ff33352e0 Mon Sep 17 00:00:00 2001 From: rain2133 <1370973498@qq.com> Date: Sun, 10 Aug 2025 17:32:45 +0800 Subject: [PATCH 51/55] =?UTF-8?q?[midend-LATG]=E5=B0=86=E8=B0=83=E8=AF=95?= =?UTF-8?q?=E4=BF=A1=E6=81=AF=E6=94=B9=E4=B8=BADEBUG=E7=94=9F=E6=95=88?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/midend/Pass/Optimize/LargeArrayToGlobal.cpp | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/src/midend/Pass/Optimize/LargeArrayToGlobal.cpp b/src/midend/Pass/Optimize/LargeArrayToGlobal.cpp index 9f63dce..12f380e 100644 --- a/src/midend/Pass/Optimize/LargeArrayToGlobal.cpp +++ b/src/midend/Pass/Optimize/LargeArrayToGlobal.cpp @@ -52,14 +52,16 @@ bool LargeArrayToGlobalPass::runOnModule(Module *M, AnalysisManager &AM) { // Calculate the size of the allocated type unsigned size = calculateTypeSize(allocatedType); - - // Debug: print size information - std::cout << "LargeArrayToGlobalPass: Found alloca with size " << size + if(DEBUG){ + // Debug: print size information + std::cout << "LargeArrayToGlobalPass: Found alloca with size " << size << " for type " << typeToString(allocatedType) << std::endl; + } // Convert arrays of 1KB (1024 bytes) or larger to global variables if (size >= 1024) { - std::cout << "LargeArrayToGlobalPass: Converting array of size " << size << " to global" << std::endl; + if(DEBUG) + std::cout << "LargeArrayToGlobalPass: Converting array of size " << size << " to global" << std::endl; allocasToConvert.emplace_back(alloca, F); } } From 038552f58b2506dc97272e6b840cdb8ea2e99f65 Mon Sep 17 00:00:00 2001 From: rain2133 <1370973498@qq.com> Date: Mon, 11 Aug 2025 16:47:03 +0800 Subject: [PATCH 52/55] =?UTF-8?q?[midend-SCCP]=E4=BF=AE=E5=A4=8D=E4=BA=86?= =?UTF-8?q?=E5=87=BD=E6=95=B0=E5=8F=82=E6=95=B0=E6=B2=A1=E6=9C=89=E6=AD=A3?= =?UTF-8?q?=E7=A1=AE=E5=88=9D=E5=A7=8B=E5=8C=96=E4=B8=BABottom=E7=9A=84?= =?UTF-8?q?=E9=97=AE=E9=A2=98=EF=BC=8C=E7=8E=B0=E5=9C=A8f/64=E6=A0=B7?= =?UTF-8?q?=E4=BE=8B=E5=8F=AF=E4=BB=A5-O1=E9=80=9A=E8=BF=87?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/midend/Pass/Optimize/SCCP.cpp | 132 ++++++++++++++++++++++++++---- 1 file changed, 118 insertions(+), 14 deletions(-) diff --git a/src/midend/Pass/Optimize/SCCP.cpp b/src/midend/Pass/Optimize/SCCP.cpp index e83bc31..e8ef384 100644 --- a/src/midend/Pass/Optimize/SCCP.cpp +++ b/src/midend/Pass/Optimize/SCCP.cpp @@ -280,6 +280,22 @@ void SCCPContext::ProcessInstruction(Instruction *inst) { return; // 不处理不可达块中的指令的实际值 } + if(DEBUG) { + std::cout << "Processing instruction: " << inst->getName() << " in block " << inst->getParent()->getName() << std::endl; + std::cout << "Old state: "; + if (oldState.state == LatticeVal::Top) { + std::cout << "Top"; + } else if (oldState.state == LatticeVal::Constant) { + if (oldState.constant_type == ValueType::Integer) { + std::cout << "Const(" << std::get(oldState.constantVal) << ")"; + } else { + std::cout << "Const(" << std::get(oldState.constantVal) << ")"; + } + } else { + std::cout << "Bottom"; + } + } + switch (inst->getKind()) { case Instruction::kAdd: case Instruction::kSub: @@ -398,6 +414,7 @@ void SCCPContext::ProcessInstruction(Instruction *inst) { newState = SSAPValue(); // 保持 Top break; case Instruction::kCall: + // TODO: 处理 Call 指令根据副作用分析可以推断的常量 // 大多数 Call 指令都假定为 Bottom，除非是纯函数且所有参数都是常量 newState = SSAPValue(LatticeVal::Bottom); break; @@ -417,19 +434,71 @@ void SCCPContext::ProcessInstruction(Instruction *inst) { } case Instruction::kPhi: { PhiInst *phi = static_cast(inst); + if(DEBUG) { + std::cout << "Processing Phi node: " << phi->getName() << std::endl; + } + // 标准SCCP的phi节点处理： + // 只考虑可执行前驱，但要保证单调性 + SSAPValue currentPhiState = GetValueState(phi); SSAPValue phiResult = SSAPValue(); // 初始为 Top - + bool hasAnyExecutablePred = false; + for (unsigned i = 0; i < phi->getNumIncomingValues(); ++i) { - Value *incomingVal = phi->getIncomingValue(i); BasicBlock *incomingBlock = phi->getIncomingBlock(i); - - if (executableBlocks.count(incomingBlock)) { // 仅考虑可执行前驱 - phiResult = Meet(phiResult, GetValueState(incomingVal)); - if (phiResult.state == LatticeVal::Bottom) - break; // 如果已经 Bottom，则提前退出 + + if (executableBlocks.count(incomingBlock)) { + hasAnyExecutablePred = true; + Value *incomingVal = phi->getIncomingValue(i); + SSAPValue incomingState = GetValueState(incomingVal); + if(DEBUG) { + std::cout << " Incoming from block " << incomingBlock->getName() + << " with value " << incomingVal->getName() << " state: "; + if (incomingState.state == LatticeVal::Top) + std::cout << "Top"; + else if (incomingState.state == LatticeVal::Constant) { + if (incomingState.constant_type == ValueType::Integer) + std::cout << "Const(" << std::get(incomingState.constantVal) << ")"; + else + std::cout << "Const(" << std::get(incomingState.constantVal) << ")"; + } else + std::cout << "Bottom"; + std::cout << std::endl; + } + phiResult = Meet(phiResult, incomingState); + + if (phiResult.state == LatticeVal::Bottom) { + break; // 提前退出优化 + } + } + // 不可执行前驱暂时被忽略 + // 这是标准SCCP的做法，依赖于单调性保证正确性 + } + + if (!hasAnyExecutablePred) { + // 没有可执行前驱，保持Top状态 + newState = SSAPValue(); + } else { + // 关键修复：使用严格的单调性 + // 确保phi的值只能从Top -> Constant -> Bottom单向变化 + if (currentPhiState.state == LatticeVal::Top) { + // 从Top状态，可以变为任何计算结果 + newState = phiResult; + } else if (currentPhiState.state == LatticeVal::Constant) { + // 从Constant状态，只能保持相同常量或变为Bottom + if (phiResult.state == LatticeVal::Constant && + currentPhiState.constantVal == phiResult.constantVal && + currentPhiState.constant_type == phiResult.constant_type) { + // 保持相同的常量 + newState = currentPhiState; + } else { + // 不同的值，必须变为Bottom + newState = SSAPValue(LatticeVal::Bottom); + } + } else { + // 已经是Bottom，保持Bottom + newState = currentPhiState; } } - newState = phiResult; break; } case Instruction::kAlloca: // 对应 kAlloca @@ -486,6 +555,22 @@ void SCCPContext::ProcessInstruction(Instruction *inst) { } } } + + if (DEBUG) { + std::cout << "New state: "; + if (newState.state == LatticeVal::Top) { + std::cout << "Top"; + } else if (newState.state == LatticeVal::Constant) { + if (newState.constant_type == ValueType::Integer) { + std::cout << "Const(" << std::get(newState.constantVal) << ")"; + } else { + std::cout << "Const(" << std::get(newState.constantVal) << ")"; + } + } else { + std::cout << "Bottom"; + } + std::cout << std::endl; + } } // 辅助函数：处理单条控制流边 @@ -493,14 +578,22 @@ void SCCPContext::ProcessEdge(const std::pair &edge) BasicBlock *fromBB = edge.first; BasicBlock *toBB = edge.second; + // 检查目标块是否已经可执行 + bool wasAlreadyExecutable = executableBlocks.count(toBB) > 0; + + // 标记目标块为可执行（如果还不是的话） MarkBlockExecutable(toBB); - - // 对于目标块中的所有 Phi 指令，重新评估其值，因为可能有新的前驱被激活 - for (auto &inst_ptr : toBB->getInstructions()) { - if (dynamic_cast(inst_ptr.get())) { - instWorkList.push(inst_ptr.get()); + + // 如果目标块之前就已经可执行，那么需要重新处理其中的phi节点 + // 因为现在有新的前驱变为可执行，phi节点的值可能需要更新 + if (wasAlreadyExecutable) { + for (auto &inst_ptr : toBB->getInstructions()) { + if (dynamic_cast(inst_ptr.get())) { + instWorkList.push(inst_ptr.get()); + } } } + // 如果目标块是新变为可执行的，MarkBlockExecutable已经添加了所有指令 } // 阶段1: 常量传播与折叠 @@ -515,18 +608,29 @@ bool SCCPContext::PropagateConstants(Function *func) { } } + // 初始化函数参数为Bottom（因为它们在编译时是未知的） + for (auto arg : func->getArguments()) { + valueState[arg] = SSAPValue(LatticeVal::Bottom); + if (DEBUG) { + std::cout << "Initializing function argument " << arg->getName() << " to Bottom" << std::endl; + } + } + // 标记入口块为可执行 if (!func->getBasicBlocks().empty()) { MarkBlockExecutable(func->getEntryBlock()); } - // 主循环：处理工作列表直到不动点 + // 主循环：标准的SCCP工作列表算法 + // 交替处理边工作列表和指令工作列表直到不动点 while (!instWorkList.empty() || !edgeWorkList.empty()) { + // 处理所有待处理的CFG边 while (!edgeWorkList.empty()) { ProcessEdge(edgeWorkList.front()); edgeWorkList.pop(); } + // 处理所有待处理的指令 while (!instWorkList.empty()) { Instruction *inst = instWorkList.front(); instWorkList.pop(); From 46179e38662c9f56c238f3aed1269aed8718830a Mon Sep 17 00:00:00 2001 From: rain2133 <1370973498@qq.com> Date: Mon, 11 Aug 2025 18:40:58 +0800 Subject: [PATCH 53/55] =?UTF-8?q?[midend-CFGOpt]=E4=BF=AE=E5=A4=8D?= =?UTF-8?q?=E9=83=A8=E5=88=86=E6=8C=87=E4=BB=A4=E5=88=A0=E9=99=A4=E9=80=BB?= =?UTF-8?q?=E8=BE=91=E9=94=99=E8=AF=AF?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/midend/Pass/Optimize/SysYIRCFGOpt.cpp | 16 +++++++++++----- 1 file changed, 11 insertions(+), 5 deletions(-) diff --git a/src/midend/Pass/Optimize/SysYIRCFGOpt.cpp b/src/midend/Pass/Optimize/SysYIRCFGOpt.cpp index 393df63..3477864 100644 --- a/src/midend/Pass/Optimize/SysYIRCFGOpt.cpp +++ b/src/midend/Pass/Optimize/SysYIRCFGOpt.cpp @@ -42,7 +42,7 @@ bool SysYCFGOptUtils::SysYDelInstAfterBr(Function *func) { ++Branchiter; while (Branchiter != instructions.end()) { changed = true; - Branchiter = instructions.erase(Branchiter); + Branchiter = SysYIROptUtils::usedelete(Branchiter); // 删除指令 } if (Branch) { // 更新前驱后继关系 @@ -91,7 +91,7 @@ bool SysYCFGOptUtils::SysYBlockMerge(Function *func) { BasicBlock *block = blockiter->get(); BasicBlock *nextBlock = blockiter->get()->getSuccessors()[0]; // auto nextarguments = nextBlock->getArguments(); - // 删除br指令 + // 删除block的br指令 if (block->getNumInstructions() != 0) { auto thelastinstinst = block->terminator(); if (thelastinstinst->get()->isUnconditional()) { @@ -103,14 +103,20 @@ bool SysYCFGOptUtils::SysYBlockMerge(Function *func) { if (brinst->getThenBlock() == brinst->getElseBlock()) { thelastinstinst = SysYIROptUtils::usedelete(thelastinstinst); } + else{ + assert(false && "SysYBlockMerge: unexpected conditional branch with different then and else blocks"); + } } } // 将后继块的指令移动到当前块 // 并将后继块的父指针改为当前块 for (auto institer = nextBlock->begin(); institer != nextBlock->end();) { - institer->get()->setParent(block); - block->getInstructions().emplace_back(institer->release()); - institer = nextBlock->getInstructions().erase(institer); + // institer->get()->setParent(block); + // block->getInstructions().emplace_back(institer->release()); + // 用usedelete删除会导致use关系被删除我只希望移动指令到当前块 + // institer = SysYIROptUtils::usedelete(institer); + // institer = nextBlock->getInstructions().erase(institer); + nextBlock->moveInst(institer, block->getInstructions().end(), block); } // 更新前驱后继关系，类似树节点操作 block->removeSuccessor(nextBlock); From 1361156b0df5f2782dd545d129c806cf57345513 Mon Sep 17 00:00:00 2001 From: rain2133 <1370973498@qq.com> Date: Mon, 11 Aug 2025 18:46:07 +0800 Subject: [PATCH 54/55] =?UTF-8?q?[midend-CFGOpt]=E4=BF=AE=E5=A4=8D?= =?UTF-8?q?=E4=B8=8A=E4=B8=80=E6=AC=A1=E6=8F=90=E4=BA=A4=E7=9A=84=E6=BC=8F?= =?UTF-8?q?=E6=B4=9E?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/midend/Pass/Optimize/SysYIRCFGOpt.cpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/midend/Pass/Optimize/SysYIRCFGOpt.cpp b/src/midend/Pass/Optimize/SysYIRCFGOpt.cpp index 3477864..3f9ffe1 100644 --- a/src/midend/Pass/Optimize/SysYIRCFGOpt.cpp +++ b/src/midend/Pass/Optimize/SysYIRCFGOpt.cpp @@ -116,7 +116,8 @@ bool SysYCFGOptUtils::SysYBlockMerge(Function *func) { // 用usedelete删除会导致use关系被删除我只希望移动指令到当前块 // institer = SysYIROptUtils::usedelete(institer); // institer = nextBlock->getInstructions().erase(institer); - nextBlock->moveInst(institer, block->getInstructions().end(), block); + institer = nextBlock->moveInst(institer, block->getInstructions().end(), block); + } // 更新前驱后继关系，类似树节点操作 block->removeSuccessor(nextBlock); From a1cca3c95a5e3a0f05cc4563a474f5911daaa389 Mon Sep 17 00:00:00 2001 From: rain2133 <1370973498@qq.com> Date: Mon, 11 Aug 2025 19:10:11 +0800 Subject: [PATCH 55/55] =?UTF-8?q?[midend-llvmirprint]=E4=BF=AE=E6=94=B9i1?= =?UTF-8?q?=E7=B1=BB=E5=9E=8B=E4=B8=8D=E5=AD=98=E5=9C=A8=E5=BC=95=E5=85=A5?= =?UTF-8?q?=E7=9A=84=E4=B8=B4=E6=97=B6=E5=AF=84=E5=AD=98=E5=99=A8=E4=BF=9D?= =?UTF-8?q?=E5=AD=98=E6=AF=94=E8=BE=83=E7=BB=93=E6=9E=9C=E9=87=8D=E5=91=BD?= =?UTF-8?q?=E5=90=8D=E7=9A=84=E9=80=BB=E8=BE=91=EF=BC=8C=E5=87=8F=E5=B0=91?= =?UTF-8?q?=E5=86=B2=E7=AA=81=E7=9A=84=E5=8F=AF=E8=83=BD=E6=80=A7?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/midend/IR.cpp | 36 +++++++++++++++++++++++++++--------- 1 file changed, 27 insertions(+), 9 deletions(-) diff --git a/src/midend/IR.cpp b/src/midend/IR.cpp index b301d82..7879816 100644 --- a/src/midend/IR.cpp +++ b/src/midend/IR.cpp @@ -752,8 +752,12 @@ void BinaryInst::print(std::ostream &os) const { if (kind == kICmpEQ || kind == kICmpNE || kind == kICmpLT || kind == kICmpGT || kind == kICmpLE || kind == kICmpGE) { // 整数比较指令 - 生成临时i1结果然后转换为i32 - static int tmpCmpCounter = 0; - std::string tmpName = "tmp_icmp_" + std::to_string(++tmpCmpCounter); + // 使用指令地址和操作数地址的组合哈希来确保唯一性 + auto inst_hash = std::hash{}(static_cast(this)); + auto lhs_hash = std::hash{}(static_cast(getLhs())); + auto rhs_hash = std::hash{}(static_cast(getRhs())); + size_t combined_hash = inst_hash ^ (lhs_hash << 1) ^ (rhs_hash << 2); + std::string tmpName = "tmp_icmp_" + std::to_string(combined_hash % 1000000); os << "%" << tmpName << " = " << getKindString() << " " << *getLhs()->getType() << " "; printOperand(os, getLhs()); os << ", "; @@ -763,8 +767,12 @@ void BinaryInst::print(std::ostream &os) const { } else if (kind == kFCmpEQ || kind == kFCmpNE || kind == kFCmpLT || kind == kFCmpGT || kind == kFCmpLE || kind == kFCmpGE) { // 浮点比较指令 - 生成临时i1结果然后转换为i32 - static int tmpCmpCounter = 0; - std::string tmpName = "tmp_fcmp_" + std::to_string(++tmpCmpCounter); + // 使用指令地址和操作数地址的组合哈希来确保唯一性 + auto inst_hash = std::hash{}(static_cast(this)); + auto lhs_hash = std::hash{}(static_cast(getLhs())); + auto rhs_hash = std::hash{}(static_cast(getRhs())); + size_t combined_hash = inst_hash ^ (lhs_hash << 1) ^ (rhs_hash << 2); + std::string tmpName = "tmp_fcmp_" + std::to_string(combined_hash % 1000000); os << "%" << tmpName << " = " << getKindString() << " " << *getLhs()->getType() << " "; printOperand(os, getLhs()); os << ", "; @@ -799,15 +807,25 @@ void UncondBrInst::print(std::ostream &os) const { void CondBrInst::print(std::ostream &os) const { Value* condition = getCondition(); - // 由于所有条件都是i32类型（包括比较结果），统一转换为i1 - static int tmpCondCounter = 0; + // 使用多个因素的组合哈希来确保唯一性 std::string condName = condition->getName(); if (condName.empty()) { - condName = "const" + std::to_string(++tmpCondCounter); + // 使用条件值地址的哈希值作为唯一标识 + auto ptr_hash = std::hash{}(static_cast(condition)); + condName = "const_" + std::to_string(ptr_hash % 100000); } - os << "%tmp_cond_" << condName << " = icmp ne i32 "; + + // 组合指令地址、条件地址和目标块地址的哈希来确保唯一性 + auto inst_hash = std::hash{}(static_cast(this)); + auto cond_hash = std::hash{}(static_cast(condition)); + auto then_hash = std::hash{}(static_cast(getThenBlock())); + auto else_hash = std::hash{}(static_cast(getElseBlock())); + size_t combined_hash = inst_hash ^ (cond_hash << 1) ^ (then_hash << 2) ^ (else_hash << 3); + std::string uniqueSuffix = std::to_string(combined_hash % 1000000); + + os << "%tmp_cond_" << condName << "_" << uniqueSuffix << " = icmp ne i32 "; printOperand(os, condition); - os << ", 0\n br i1 %tmp_cond_" << condName; + os << ", 0\n br i1 %tmp_cond_" << condName << "_" << uniqueSuffix; os << ", label %"; printBlockName(os, getThenBlock());