#include "RISCv32Backend.h"
#include <sstream>
#include <algorithm>
#include <stdexcept>
#include <regex>
#include <iomanip>
#include <functional> // For std::function

namespace sysy {

// 可用于分配的通用寄存器
const std::vector<RISCv32CodeGen::PhysicalReg> RISCv32CodeGen::allocable_regs = {
    PhysicalReg::T0, PhysicalReg::T1, PhysicalReg::T2, PhysicalReg::T3,
    PhysicalReg::T4, PhysicalReg::T5, PhysicalReg::T6,
    PhysicalReg::A0, PhysicalReg::A1, PhysicalReg::A2, PhysicalReg::A3,
    PhysicalReg::A4, PhysicalReg::A5, PhysicalReg::A6, PhysicalReg::A7,
    PhysicalReg::S0, PhysicalReg::S1, PhysicalReg::S2, PhysicalReg::S3,
    PhysicalReg::S4, PhysicalReg::S5, PhysicalReg::S6, PhysicalReg::S7,
    PhysicalReg::S8, PhysicalReg::S9, PhysicalReg::S10, PhysicalReg::S11
};

// 将物理寄存器枚举转换为字符串
std::string RISCv32CodeGen::reg_to_string(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"; // 临时寄存器
        default: return "UNKNOWN_REG";
    }
}

// 总体代码生成入口
std::string RISCv32CodeGen::code_gen() {
    std::stringstream ss;
    ss << module_gen();
    return ss.str();
}

// 模块级代码生成 (处理全局变量和函数)
std::string RISCv32CodeGen::module_gen() {
    std::stringstream ss;
    bool has_globals = !module->getGlobals().empty();
    if (has_globals) {
        ss << ".data\n"; // 数据段
        for (const auto& global : module->getGlobals()) {
            ss << ".globl " << global->getName() << "\n"; // 声明全局符号
            ss << global->getName() << ":\n"; // 标签
            const auto& init_values = global->getInitValues();
            for (size_t i = 0; i < init_values.getValues().size(); ++i) {
                auto val = init_values.getValues()[i];
                auto count = init_values.getNumbers()[i];
                if (auto constant = dynamic_cast<ConstantValue*>(val)) {
                    for (unsigned j = 0; j < count; ++j) {
                        if (constant->isInt()) {
                            ss << "    .word " << constant->getInt() << "\n"; // 整数常量
                        } else {
                            float f = constant->getFloat();
                            uint32_t float_bits = *(uint32_t*)&f;
                            ss << "    .word " << float_bits << "\n"; // 浮点常量 (按位存储)
                        }
                    }
                }
            }
        }
    }
    if (!module->getFunctions().empty()) {
        ss << ".text\n"; // 代码段
        for (const auto& func : module->getFunctions()) {
            ss << function_gen(func.second.get());
        }
    }
    return ss.str();
}

// 函数级代码生成
std::string RISCv32CodeGen::function_gen(Function* func) {
    std::stringstream ss;
    ss << ".globl " << func->getName() << "\n"; // 声明函数为全局符号
    ss << func->getName() << ":\n"; // 函数入口标签

    // 执行寄存器分配
    auto alloc = register_allocation(func);
    int stack_size = alloc.stack_size;

    // 函数序言 (Prologue)
    // 保存 ra 和 s0, 调整栈指针
    // s0 指向当前帧的底部（分配局部变量/溢出空间后的 sp）
    // 栈布局:
    // +------------+ 高地址
    // |  参数溢出  | (如果参数超过 8 个)
    // +------------+
    // |   保存的 RA | (stack_size - 4)(sp)
    // +------------+
    // |   保存的 S0 | (stack_size - 8)(sp)
    // +------------+
    // | 局部变量/溢出 | 0(sp) 到 (stack_size - 8 - 局部变量大小)(sp)
    // +------------+ 低地址
    // 确保栈大小 16 字节对齐
    int aligned_stack_size = (stack_size + 15) & ~15;

    // 只有当需要栈空间时才生成序言
    if (aligned_stack_size > 0) {
        ss << "    addi sp, sp, -" << aligned_stack_size << "\n"; // 调整栈指针
        ss << "    sw ra, " << (aligned_stack_size - 4) << "(sp)\n"; // 保存返回地址
        ss << "    sw s0, " << (aligned_stack_size - 8) << "(sp)\n"; // 保存帧指针
        ss << "    mv s0, sp\n"; // 设置新的帧指针
    }

    // 生成每个基本块的代码
    int block_idx = 0; // 用于生成默认 entry 标签的索引
    for (const auto& bb : func->getBasicBlocks()) {
        ss << basicBlock_gen(bb.get(), alloc, block_idx++);
    }

    // 函数尾声 (Epilogue) 由 RETURN DAGNode 的指令选择处理，确保正确恢复栈和寄存器
    return ss.str();
}

// 基本块代码生成
std::string RISCv32CodeGen::basicBlock_gen(BasicBlock* bb, const RegAllocResult& alloc, int block_idx) {
    std::stringstream ss;

    // 修复空标签问题：如果块名为空，使用伪名称 (例如 entry_block_0)
    std::string bb_name = bb->getName();
    if (bb_name.empty()) {
        bb_name = ENTRY_BLOCK_PSEUDO_NAME + std::to_string(block_idx);
        // 如果是第一个块，且没有名称，则通常是函数入口块，可以考虑直接使用 "entry"
        // 但为了通用性，伪名称更安全
        if (block_idx == 0) { // 第一个块通常是 entry 块
            bb_name = "entry";
        }
    }
    ss << bb_name << ":\n"; // 基本块标签

    // 为每个基本块重置虚拟寄存器映射和计数器，因为 DAG 是按块构建的
    // 注意：这里的重置可能会影响跨块的活跃性分析，如果 DAG 构建是跨块的，则不能在这里重置
    // 但目前 DAG 是按块构建，所以在此重置是合理的。
    value_vreg_map.clear();
    vreg_counter = 0; // 为每个块重置虚拟寄存器计数器

    // 构建当前基本块的 DAG
    // 注意：DAGNode 的唯一性在当前函数范围内是重要的，
    // 所以 build_dag 应该返回一个完整的 DAG 节点列表，而不是每次都创建新的。
    // 为了简化，这里仍然按块构建，但需要注意跨块值的使用。
    auto dag_nodes_for_bb = build_dag(bb);
    print_dag(dag_nodes_for_bb, bb_name); // 打印 DAG 调试信息

    // 存储最终生成的指令
    std::set<DAGNode*> emitted_nodes; // 跟踪已发射的节点，防止重复
    std::vector<std::string> ordered_insts; // 用于收集指令并按序排列

    // 在 DAG 中遍历并生成指令。由于 select_instructions 可能会递归地为操作数选择指令，
    // 并且 emit_instructions 也会递归地发射，我们需要一个机制来确保指令的正确顺序和唯一性。
    // 最简单的方法是逆拓扑序遍历所有节点，确保其操作数先被处理。
    // 但是目前的 DAG 构建方式可能不支持直接的拓扑排序，
    // 我们将依赖 emit_instructions 的递归特性来处理依赖。

    // 遍历 DAG 的根节点（没有用户的节点，或者 Store/Return/Branch 节点）
    // 从这些节点开始递归发射指令。
    // NOTE: 这种发射方式可能不总是产生最优的代码顺序，但可以确保依赖关系。
    for (auto it = dag_nodes_for_bb.rbegin(); it != dag_nodes_for_bb.rend(); ++it) {
        DAGNode* node = it->get();
        // 只有那些没有用户（或者代表副作用，如STORE, RETURN, BRANCH）的节点才需要作为发射的“根”
        // 否则，它们会被其用户节点递归地发射
        // 然而，为了确保所有指令都被发射，我们通常从所有节点（或者至少是副作用节点）开始发射
        // 并且利用 emitted_nodes 集合防止重复
        // 这里简化为对所有 DAG 节点进行一次 select_instructions 和 emit_instructions 调用。
        // emit_instructions 会通过递归处理其操作数来保证依赖顺序。
        select_instructions(node, alloc); // 为当前节点选择指令
    }

    // 收集所有指令到一个临时的 vector 中，然后进行排序
    // 注意：这里的发射逻辑需要重新设计，目前的 emit_instructions 是直接添加到 std::vector<std::string>& insts 中
    // 并且期望是按顺序添加的，这在递归时难以保证。
    // 更好的方法是让 emit_instructions 直接输出到 stringstream，并控制递归顺序。
    // 但是为了最小化改动，我们先保持 emit_instructions 的现有签名，
    // 然后在它内部处理指令的收集和去重。

    // 重新设计 emit_instructions 的调用方式
    // 这里的思路是，每个 DAGNode 都存储了自己及其依赖（如果未被其他节点引用）的指令。
    // 最终，我们遍历 BasicBlock 中的所有原始 IR 指令，找到它们对应的 DAGNode，然后发射。
    // 这是因为 IR 指令的顺序决定了代码的逻辑顺序。

    // 遍历 IR 指令，并找到对应的 DAGNode 进行发射
    // 由于 build_dag 是从 IR 指令顺序构建的，我们应该按照 IR 指令的顺序来发射。
    emitted_nodes.clear(); // 再次清空已发射节点集合
    // 临时存储每个 IR 指令对应的 DAGNode，因为 DAGNode 列表是平铺的
    std::map<Instruction*, DAGNode*> inst_to_dag_node;
    for (const auto& dag_node_ptr : dag_nodes_for_bb) {
        if (dag_node_ptr->value && dynamic_cast<Instruction*>(dag_node_ptr->value)) {
            inst_to_dag_node[dynamic_cast<Instruction*>(dag_node_ptr->value)] = dag_node_ptr.get();
        }
    }

    for (const auto& inst_ptr : bb->getInstructions()) {
        DAGNode* node_to_emit = nullptr;
        // 查找当前 IR 指令在 DAG 中对应的节点。
        // 注意：不是所有 IR 指令都会直接映射到一个“根”DAGNode (例如，某些值可能只作为操作数存在)
        // 但终结符（如 Branch, Return）和 Store 指令总是重要的。
        // 对于 load/binary 等，我们应该在 build_dag 中确保它们有一个结果 vreg，并被后续指令使用。
        // 如果一个 IR 指令是某个 DAGNode 的 value，那么我们就发射那个 DAGNode。
        if (inst_to_dag_node.count(inst_ptr.get())) {
            node_to_emit = inst_to_dag_node.at(inst_ptr.get());
        }

        if (node_to_emit) {
            // 注意：select_instructions 已经在上面统一调用过，这里只需要 emit。
            // 但如果 select_instructions 没有递归地为所有依赖选择指令，这里可能需要重新考虑。
            // 为了简化，我们假定 select_instructions 在第一次被调用时（通常在 emit 之前）已经递归地为所有操作数选择了指令。

            // 直接将指令添加到 ss 中，而不是通过 vector 中转
            emit_instructions(node_to_emit, ss, alloc, emitted_nodes);
        }
    }

    return ss.str();
}

// DAG 构建
std::vector<std::unique_ptr<RISCv32CodeGen::DAGNode>> RISCv32CodeGen::build_dag(BasicBlock* bb) {
    std::vector<std::unique_ptr<DAGNode>> nodes_storage; // 存储所有 unique_ptr
    std::map<Value*, DAGNode*> value_to_node; // 将 IR Value* 映射到原始 DAGNode*，用于快速查找

    // 辅助函数，用于创建 DAGNode 并管理其所有权
    auto create_node = [&](DAGNode::NodeKind kind, Value* val = nullptr) -> DAGNode* {
        // 优化：如果一个值已经有节点并且它不是控制流/存储/Alloca地址，则重用它 (CSE)
        // 对于 AllocaInst，我们想创建一个代表其地址的节点，但不一定直接为 AllocaInst 本身分配虚拟寄存器。
        if (val && value_to_node.count(val) && kind != DAGNode::STORE && kind != DAGNode::RETURN && kind != DAGNode::BRANCH && kind != DAGNode::ALLOCA_ADDR) {
            return value_to_node[val];
        }

        auto node = std::make_unique<DAGNode>(kind);
        node->value = val;

        // 为产生结果的值分配虚拟寄存器
        if (val && kind != DAGNode::STORE && kind != DAGNode::RETURN && kind != DAGNode::BRANCH && kind != DAGNode::ALLOCA_ADDR) {
            node->result_vreg = "v" + std::to_string(vreg_counter++);
            value_vreg_map[val] = node->result_vreg; // 将 IR Value 映射到其虚拟寄存器
        } else if (kind == DAGNode::ALLOCA_ADDR) {
            // 对于 AllocaInst 的地址，我们将虚拟寄存器分配给 DAGNode 本身，
            // 而不是直接在 value_vreg_map 中分配给 AllocaInst (因为 AllocaInst 是内存位置)。
            node->result_vreg = "v" + std::to_string(vreg_counter++);
            // 考虑是否需要将 AllocaInst 映射到其虚拟寄存器，如果它被视为指针值
            // value_vreg_map[val] = node->result_vreg; // 考虑这是否需要/正确
        }

        DAGNode* raw_node_ptr = node.get();
        nodes_storage.push_back(std::move(node)); // 存储 unique_ptr

        // 仅当 IR Value 表示一个计算值时，才将其映射到创建的 DAGNode
        if (val && kind != DAGNode::STORE && kind != DAGNode::RETURN && kind != DAGNode::BRANCH) {
             value_to_node[val] = raw_node_ptr;
        }
        return raw_node_ptr;
    };


    for (const auto& inst_ptr : bb->getInstructions()) {
        auto inst = inst_ptr.get();

        if (auto alloca = dynamic_cast<AllocaInst*>(inst)) {
            // AllocaInst 本身不产生寄存器中的值，但其地址将被 load/store 使用。
            // 创建一个节点来表示分配内存的地址。
            // 这个地址将是 s0 (帧指针) 的偏移量。
            // 我们将 AllocaInst 指针存储在 DAGNode 的 `value` 字段中。
            auto alloca_addr_node = create_node(DAGNode::ALLOCA_ADDR, alloca);
            // 此节点将有一个 result_vreg，表示计算出的地址 (s0 + 偏移量)
            // 实际偏移量将在寄存器分配阶段 (stack_map) 确定。
        } else if (auto store = dynamic_cast<StoreInst*>(inst)) {
            auto store_node = create_node(DAGNode::STORE, store); // 将 store inst 绑定到 node

            // 获取要存储的值
            Value* val_to_store_ir = store->getValue();
            DAGNode* val_node = nullptr;
            if (value_to_node.count(val_to_store_ir)) {
                val_node = value_to_node[val_to_store_ir];
            } else if (auto constant = dynamic_cast<ConstantValue*>(val_to_store_ir)) {
                val_node = create_node(DAGNode::CONSTANT, constant);
            } else { // 这是一个尚未在此块中计算的值，假设它需要加载 (从内存或参数)
                val_node = create_node(DAGNode::LOAD, val_to_store_ir);
            }

            // 获取内存位置的指针
            Value* ptr_ir = store->getPointer();
            DAGNode* ptr_node = nullptr;
            if (value_to_node.count(ptr_ir)) {
                ptr_node = value_to_node[ptr_ir];
            } else if (auto alloca = dynamic_cast<AllocaInst*>(ptr_ir)) {
                ptr_node = create_node(DAGNode::ALLOCA_ADDR, alloca);
            } else if (auto global = dynamic_cast<GlobalValue*>(ptr_ir)) {
                 ptr_node = create_node(DAGNode::CONSTANT, global); // 全局地址将被加载
            } else { // 必须是存储在虚拟寄存器中的指针
                ptr_node = create_node(DAGNode::LOAD, ptr_ir); // 这是一个产生指针的指令
            }

            store_node->operands.push_back(val_node);
            store_node->operands.push_back(ptr_node);
            val_node->users.push_back(store_node);
            ptr_node->users.push_back(store_node);
        } else if (auto load = dynamic_cast<LoadInst*>(inst)) {
            if (value_to_node.count(load)) continue; // 共同子表达式消除 (CSE)

            auto load_node = create_node(DAGNode::LOAD, load); // 为 load_node 分配 result_vreg 并映射 load

            Value* ptr_ir = load->getPointer();
            DAGNode* ptr_node = nullptr;
            if (value_to_node.count(ptr_ir)) {
                ptr_node = value_to_node[ptr_ir];
            } else if (auto alloca = dynamic_cast<AllocaInst*>(ptr_ir)) {
                ptr_node = create_node(DAGNode::ALLOCA_ADDR, alloca);
            } else if (auto global = dynamic_cast<GlobalValue*>(ptr_ir)) {
                ptr_node = create_node(DAGNode::CONSTANT, global); // 全局地址将被加载
            } else { // 必须是存储在虚拟寄存器中的指针
                ptr_node = create_node(DAGNode::LOAD, ptr_ir); // 这是一个产生指针的指令
            }

            load_node->operands.push_back(ptr_node);
            ptr_node->users.push_back(load_node);
        } else if (auto bin = dynamic_cast<BinaryInst*>(inst)) {
            if (value_to_node.count(bin)) continue; // CSE

            auto bin_node = create_node(DAGNode::BINARY, bin);

            auto get_operand_node = [&](Value* operand_ir) -> DAGNode* {
                if (value_to_node.count(operand_ir)) {
                    return value_to_node[operand_ir];
                } else if (auto constant = dynamic_cast<ConstantValue*>(operand_ir)) {
                    return create_node(DAGNode::CONSTANT, constant);
                } else {
                    // 这是一个由另一个指令或参数产生的值，如果不在 map 中，则假设需要加载
                    return create_node(DAGNode::LOAD, operand_ir);
                }
            };

            DAGNode* lhs_node = get_operand_node(bin->getLhs());
            DAGNode* rhs_node = get_operand_node(bin->getRhs());

            bin_node->operands.push_back(lhs_node);
            bin_node->operands.push_back(rhs_node);
            lhs_node->users.push_back(bin_node);
            rhs_node->users.push_back(bin_node);
        } else if (auto call = dynamic_cast<CallInst*>(inst)) {
            if (value_to_node.count(call)) continue; // CSE (如果结果被重用)

            auto call_node = create_node(DAGNode::CALL, call); // 如果调用返回一个值，则分配 result_vreg

            for (auto arg : call->getArguments()) {
                auto arg_val_ir = arg->getValue();
                DAGNode* arg_node = nullptr;
                if (value_to_node.count(arg_val_ir)) {
                    arg_node = value_to_node[arg_val_ir];
                } else if (auto constant = dynamic_cast<ConstantValue*>(arg_val_ir)) {
                    arg_node = create_node(DAGNode::CONSTANT, constant);
                } else {
                    arg_node = create_node(DAGNode::LOAD, arg_val_ir);
                }
                call_node->operands.push_back(arg_node);
                arg_node->users.push_back(call_node);
            }
        } else if (auto ret = dynamic_cast<ReturnInst*>(inst)) {
            auto ret_node = create_node(DAGNode::RETURN, ret); // 将 return inst 绑定到 node
            if (ret->hasReturnValue()) {
                auto val_ir = ret->getReturnValue();
                DAGNode* val_node = nullptr;
                if (value_to_node.count(val_ir)) {
                    val_node = value_to_node[val_ir];
                } else if (auto constant = dynamic_cast<ConstantValue*>(val_ir)) {
                    val_node = create_node(DAGNode::CONSTANT, constant);
                } else {
                    val_node = create_node(DAGNode::LOAD, val_ir);
                }
                ret_node->operands.push_back(val_node);
                val_node->users.push_back(ret_node);
            }
        } else if (auto cond_br = dynamic_cast<CondBrInst*>(inst)) {
            auto br_node = create_node(DAGNode::BRANCH, cond_br); // 将 cond_br inst 绑定到 node
            auto cond_ir = cond_br->getCondition();

            if (auto constant_cond = dynamic_cast<ConstantValue*>(cond_ir)) {
                // 优化常量条件分支为无条件跳转
                br_node->inst = "j " + (constant_cond->getInt() ? cond_br->getThenBlock()->getName() : cond_br->getElseBlock()->getName());
                // 对于直接跳转，不需要操作数
            } else {
                DAGNode* cond_node = nullptr;
                if (value_to_node.count(cond_ir)) {
                    cond_node = value_to_node[cond_ir];
                } else if (auto bin_cond = dynamic_cast<BinaryInst*>(cond_ir)) {
                    cond_node = create_node(DAGNode::BINARY, bin_cond);
                } else { // 必须是一个需要加载的值
                    cond_node = create_node(DAGNode::LOAD, cond_ir);
                }
                br_node->operands.push_back(cond_node);
                cond_node->users.push_back(br_node);
            }
        } else if (auto uncond_br = dynamic_cast<UncondBrInst*>(inst)) {
            auto br_node = create_node(DAGNode::BRANCH, uncond_br); // 将 uncond_br inst 绑定到 node
            br_node->inst = "j " + uncond_br->getBlock()->getName();
        }
    }

    return nodes_storage;
}

// 打印 DAG
void RISCv32CodeGen::print_dag(const std::vector<std::unique_ptr<DAGNode>>& dag, const std::string& bb_name) {
    std::cerr << "=== DAG for Basic Block: " << bb_name << " ===\n";
    std::set<DAGNode*> visited;

    // 辅助映射，用于在打印输出中为节点分配顺序 ID
    std::map<DAGNode*, int> node_to_id;
    int current_id = 0;
    for (const auto& node_ptr : dag) {
        node_to_id[node_ptr.get()] = current_id++;
    }

    std::function<void(DAGNode*, int)> print_node = [&](DAGNode* node, int indent) {
        if (!node) return;

        std::string current_indent(indent, ' ');
        int node_id = node_to_id.count(node) ? node_to_id[node] : -1; // 获取分配的 ID

        std::cerr << current_indent << "Node#" << node_id << ": " << node->getNodeKindString();
        if (!node->result_vreg.empty()) {
            std::cerr << " (vreg: " << node->result_vreg << ")";
        }

        if (node->value) {
            std::cerr << " [";
            if (auto inst = dynamic_cast<Instruction*>(node->value)) {
                std::cerr << inst->getKindString();
                if (!inst->getName().empty()) {
                    std::cerr << "(" << inst->getName() << ")";
                }
            } else if (auto constant = dynamic_cast<ConstantValue*>(node->value)) {
                if (constant->isInt()) {
                    std::cerr << "ConstInt(" << constant->getInt() << ")";
                } else {
                    std::cerr << "ConstFloat(" << constant->getFloat() << ")";
                }
            } else if (auto global = dynamic_cast<GlobalValue*>(node->value)) {
                std::cerr << "Global(" << global->getName() << ")";
            } else if (auto alloca = dynamic_cast<AllocaInst*>(node->value)) {
                std::cerr << "Alloca(" << (alloca->getName().empty() ? ("%" + std::to_string(reinterpret_cast<uintptr_t>(alloca) % 1000)) : alloca->getName()) << ")";
            }
            std::cerr << "]";
        }
        std::cerr << " -> Inst: \"" << node->inst << "\""; // 打印选定的指令
        std::cerr << "\n";

        if (visited.find(node) != visited.end()) {
            std::cerr << current_indent << " (已打印后代)\n";
            return; // 避免循环的无限递归
        }
        visited.insert(node);


        if (!node->operands.empty()) {
            std::cerr << current_indent << "  操作数:\n";
            for (auto operand : node->operands) {
                print_node(operand, indent + 4);
            }
        }
        // 移除了 users 打印，以简化输出并避免 DAG 中的冗余递归。
        // Users 更适用于向上遍历，而不是向下遍历。
    };

    // 遍历 DAG，以尊重依赖的方式打印。
    // 当前实现：遍历所有节点，从作为“根”的节点开始打印（没有用户或副作用节点）。
    // 每次打印新的根时，重置 visited 集合，以允许共享子图被重新打印（尽管这不是最高效的方式）。
    for (const auto& node_ptr : dag) {
        // 只有那些没有用户或者表示副作用（如 store/branch/return）的节点才被视为“根”
        // 这样可以确保所有指令（包括那些没有明确结果的）都被打印
        if (node_ptr->users.empty() || node_ptr->kind == DAGNode::STORE || node_ptr->kind == DAGNode::RETURN || node_ptr->kind == DAGNode::BRANCH) {
            visited.clear(); // 为每个根重置 visited，允许重新打印共享子图
            print_node(node_ptr.get(), 0);
        }
    }
    std::cerr << "=== DAG 结束 ===\n\n";
}


// 指令选择
void RISCv32CodeGen::select_instructions(DAGNode* node, const RegAllocResult& alloc) {
    if (!node) return;
    // ALLOCA_ADDR 节点不直接映射到一条指令，它表示的是地址的计算
    if (!node->inst.empty() && node->kind != DAGNode::ALLOCA_ADDR) return; // 指令已选择

    // 首先递归地为操作数选择指令
    for (auto operand : node->operands) {
        if (operand) {
            select_instructions(operand, alloc);
        }
    }

    std::stringstream ss_inst; // 使用 stringstream 构建指令

    // 获取分配的物理寄存器，如果没有分配，则使用临时寄存器 (T0)
    auto get_preg_or_temp = [&](const std::string& vreg) {
        if (alloc.vreg_to_preg.count(vreg)) {
            return reg_to_string(alloc.vreg_to_preg.at(vreg));
        }
        // 如果虚拟寄存器未分配给物理寄存器，则表示它已溢出或是一个临时值。
        // 为简化，我们使用固定临时寄存器 t0 用于溢出值或需要加载到寄存器中的立即数。
        // 更健壮的后端会在此处显式处理溢出。
        return reg_to_string(PhysicalReg::T0); // 回退到临时寄存器
    };

    // 获取分配的栈变量的内存偏移量
    auto get_stack_offset = [&](Value* val) {
        if (alloc.stack_map.count(val)) {
            return std::to_string(alloc.stack_map.at(val));
        }
        return std::string("0"); // 默认或错误情况
    };

    switch (node->kind) {
        case DAGNode::CONSTANT: {
            if (auto constant = dynamic_cast<ConstantValue*>(node->value)) {
                std::string dest_reg = get_preg_or_temp(node->result_vreg);
                if (constant->isInt()) {
                    ss_inst << "li " << dest_reg << ", " << constant->getInt();
                } else {
                    float f = constant->getFloat();
                    uint32_t float_bits = *(uint32_t*)&f;
                    // 对于浮点数，先加载整数位，然后转换
                    ss_inst << "li " << dest_reg << ", " << float_bits << "\n";
                    ss_inst << "fmv.w.x " << dest_reg << ", " << dest_reg; // 假设 dest_reg 可以同时用于整数和浮点数 (FPU 寄存器并非总是如此)
                }
            } else if (auto global = dynamic_cast<GlobalValue*>(node->value)) {
                std::string dest_reg = get_preg_or_temp(node->result_vreg);
                ss_inst << "la " << dest_reg << ", " << global->getName(); // 加载全局变量地址
            }
            break;
        }
        case DAGNode::ALLOCA_ADDR: {
            // 对于 AllocaInst，我们想计算其地址 (s0 + 偏移量) 并放入 result_vreg
            if (auto alloca_inst = dynamic_cast<AllocaInst*>(node->value)) {
                std::string dest_reg = get_preg_or_temp(node->result_vreg);
                int offset = alloc.stack_map.at(alloca_inst);
                // 帧指针 s0 已经指向当前帧的基地址。
                // 偏移量是相对于 s0 的。
                ss_inst << "addi " << dest_reg << ", s0, " << offset;
            }
            break;
        }
        case DAGNode::LOAD: {
            if (node->operands.empty() || !node->operands[0]) break;
            std::string dest_reg = get_preg_or_temp(node->result_vreg);
            DAGNode* ptr_node = node->operands[0]; // 操作数是指针

            // 检查指针本身是否是 AllocaInst
            if (ptr_node->kind == DAGNode::ALLOCA_ADDR) { // 检查节点类型，而非其值
                if (auto alloca_inst = dynamic_cast<AllocaInst*>(ptr_node->value)) {
                    int offset = alloc.stack_map.at(alloca_inst);
                    ss_inst << "lw " << dest_reg << ", " << offset << "(s0)";
                }
            } else {
                // 指针在寄存器中 (可能是全局地址，或 GEP/其他计算结果)
                std::string ptr_reg = get_preg_or_temp(ptr_node->result_vreg);
                ss_inst << "lw " << dest_reg << ", 0(" << ptr_reg << ")"; // 从 ptr_reg 中的地址加载
            }
            break;
        }
        case DAGNode::STORE: {
            if (node->operands.size() < 2 || !node->operands[0] || !node->operands[1]) break;
            DAGNode* val_node = node->operands[0]; // 要存储的值
            DAGNode* ptr_node = node->operands[1]; // 目标地址

            std::string src_reg;
            if (val_node->kind == DAGNode::CONSTANT) {
                // 如果存储的是常量，先将其加载到临时寄存器 (t0)
                if (auto constant = dynamic_cast<ConstantValue*>(val_node->value)) {
                    src_reg = reg_to_string(PhysicalReg::T0); // 使用临时寄存器用于常量
                    ss_inst << "li " << src_reg << ", " << constant->getInt(); // 这行指令将作为 store 指令的一部分被添加
                } else { // 存储全局地址
                    src_reg = reg_to_string(PhysicalReg::T0); // 使用临时寄存器
                    ss_inst << "la " << src_reg << ", " << dynamic_cast<GlobalValue*>(val_node->value)->getName();
                }
            } else {
                src_reg = get_preg_or_temp(val_node->result_vreg);
            }
            // 将 li/la 指令与 sw 指令放在同一行，用 \n 分隔，emit_instructions 会正确处理
            // 这里将 store 指令放在 li/la 指令的后面
            ss_inst << (ss_inst.str().empty() ? "" : "\n"); // 如果前面有指令，则换行
            
            // 检查指针是否是 AllocaInst (栈变量)
            if (ptr_node->kind == DAGNode::ALLOCA_ADDR) {
                if (auto alloca_inst = dynamic_cast<AllocaInst*>(ptr_node->value)) {
                    int offset = alloc.stack_map.at(alloca_inst);
                    ss_inst << "sw " << src_reg << ", " << offset << "(s0)";
                }
            } else {
                // 指针在寄存器中 (可能是全局地址，或 GEP/其他计算结果)
                std::string ptr_reg = get_preg_or_temp(ptr_node->result_vreg);
                ss_inst << "sw " << src_reg << ", 0(" << ptr_reg << ")";
            }
            break;
        }
        case DAGNode::BINARY: {
            if (node->operands.size() < 2 || !node->operands[0] || !node->operands[1]) break;
            auto bin = dynamic_cast<BinaryInst*>(node->value);
            if (!bin) break;

            std::string dest_reg = get_preg_or_temp(node->result_vreg);
            std::string lhs_reg = get_preg_or_temp(node->operands[0]->result_vreg);
            std::string rhs_reg = get_preg_or_temp(node->operands[1]->result_vreg);

            std::string opcode;
            switch (bin->getKind()) {
                case BinaryInst::kAdd: opcode = "add"; break;
                case BinaryInst::kSub: opcode = "sub"; break;
                case BinaryInst::kMul: opcode = "mul"; break;
                case BinaryInst::kICmpEQ: // 实现 A == B 为 sub A, B; seqz D, (A-B)
                    ss_inst << "sub " << dest_reg << ", " << lhs_reg << ", " << rhs_reg << "\n";
                    ss_inst << "seqz " << dest_reg << ", " << dest_reg; // 如果等于零则设置
                    node->inst = ss_inst.str(); // 设置指令并返回
                    return;
                case Instruction::kDiv: opcode = "div"; break; // 整数除法
                case Instruction::kRem: opcode = "rem"; break; // 整数余数
                case BinaryInst::kICmpGE: // A >= B <=> !(A < B) <=> !(slt D, A, B) <=> slt D, A, B; xori D, D, 1
                    ss_inst << "slt " << dest_reg << ", " << lhs_reg << ", " << rhs_reg << "\n";
                    ss_inst << "xori " << dest_reg << ", " << dest_reg << ", 1";
                    node->inst = ss_inst.str();
                    return;
                case BinaryInst::kICmpGT: // A > B <=> B < A
                    opcode = "slt";
                    ss_inst << opcode << " " << dest_reg << ", " << rhs_reg << ", " << lhs_reg; // slt rd, rs2, rs1 (如果 rs2 < rs1)
                    node->inst = ss_inst.str();
                    return;
                case BinaryInst::kICmpLE: // A <= B <=> !(A > B) <=> !(slt D, B, A) <=> slt D, B, A; xori D, D, 1
                    ss_inst << "slt " << dest_reg << ", " << rhs_reg << ", " << lhs_reg << "\n";
                    ss_inst << "xori " << dest_reg << ", " << dest_reg << ", 1";
                    node->inst = ss_inst.str();
                    return;
                case BinaryInst::kICmpLT: // A < B
                    opcode = "slt";
                    ss_inst << opcode << " " << dest_reg << ", " << lhs_reg << ", " << rhs_reg;
                    node->inst = ss_inst.str();
                    return;
                case BinaryInst::kICmpNE: // A != B <=> ! (A == B) <=> sub D, A, B; snez D, D
                    ss_inst << "sub " << dest_reg << ", " << lhs_reg << ", " << rhs_reg << "\n";
                    ss_inst << "snez " << dest_reg << ", " << dest_reg;
                    node->inst = ss_inst.str();
                    return;
                default:
                    // 处理未知二进制操作或抛出错误
                    throw std::runtime_error("Unsupported binary instruction kind: " + bin->getKindString());
            }
            if (!opcode.empty()) {
                ss_inst << opcode << " " << dest_reg << ", " << lhs_reg << ", " << rhs_reg;
            }
            break;
        }
        case DAGNode::CALL: {
            if (!node->value) break;
            auto call = dynamic_cast<CallInst*>(node->value);
            if (!call) break;

            // 将参数放入 a0-a7
            for (size_t i = 0; i < node->operands.size() && i < 8; ++i) {
                if (node->operands[i] && !node->operands[i]->result_vreg.empty()) {
                    ss_inst << "mv " << reg_to_string(static_cast<PhysicalReg>(static_cast<int>(PhysicalReg::A0) + i))
                            << ", " << get_preg_or_temp(node->operands[i]->result_vreg) << "\n";
                } else if (node->operands[i] && node->operands[i]->kind == DAGNode::CONSTANT) {
                    // 直接将常量参数加载到 A 寄存器
                    if (auto const_val = dynamic_cast<ConstantValue*>(node->operands[i]->value)) {
                        ss_inst << "li " << reg_to_string(static_cast<PhysicalReg>(static_cast<int>(PhysicalReg::A0) + i))
                                << ", " << const_val->getInt() << "\n";
                    } else if (auto global_val = dynamic_cast<GlobalValue*>(node->operands[i]->value)) {
                         ss_inst << "la " << reg_to_string(static_cast<PhysicalReg>(static_cast<int>(PhysicalReg::A0) + i))
                                << ", " << global_val->getName() << "\n";
                    }
                }
            }
            ss_inst << "call " << call->getCallee()->getName(); // 使用 'call' 伪指令

            // 如果函数返回一个值，将其从 a0 移动到结果虚拟寄存器
            if ((call->getType()->isInt() || call->getType()->isFloat()) && !node->result_vreg.empty()) {
                ss_inst << "\nmv " << get_preg_or_temp(node->result_vreg) << ", a0";
            }
            break;
        }
        case DAGNode::RETURN: {
            // 如果有返回值，将其移动到 a0
            if (!node->operands.empty() && node->operands[0]) {
                std::string return_val_reg = get_preg_or_temp(node->operands[0]->result_vreg);
                // 对于返回值，直接将最终结果移动到 a0
                // 确保 load 的结果最终进入 a0，避免不必要的 t0 中转
                ss_inst << "mv a0, " << return_val_reg << "\n";
            }

            // 函数尾声 (Epilogue): 恢复 s0, ra, 并调整 sp
            if (alloc.stack_size > 0) {
                int aligned_stack_size = (alloc.stack_size + 15) & ~15;
                ss_inst << "lw ra, " << (aligned_stack_size - 4) << "(sp)\n"; // 恢复 ra
                ss_inst << "lw s0, " << (aligned_stack_size - 8) << "(sp)\n"; // 恢复 s0
                ss_inst << "addi sp, sp, " << aligned_stack_size << "\n"; // 恢复栈指针
            }
            ss_inst << "ret"; // 返回
            break;
        }
        case DAGNode::BRANCH: {
            auto br = dynamic_cast<CondBrInst*>(node->value);
            auto uncond_br = dynamic_cast<UncondBrInst*>(node->value);

            if (node->inst.empty()) { // 如果不是通过常量传播优化的直接跳转
                if (br) {
                    if (node->operands.empty() || !node->operands[0]) break;
                    std::string cond_reg = get_preg_or_temp(node->operands[0]->result_vreg);
                    std::string then_block = br->getThenBlock()->getName();
                    std::string else_block = br->getElseBlock()->getName();

                    // 修复空标签问题
                    if (then_block.empty()) {
                        then_block = ENTRY_BLOCK_PSEUDO_NAME + "then"; // 临时命名
                    }
                    if (else_block.empty()) {
                        else_block = ENTRY_BLOCK_PSEUDO_NAME + "else"; // 临时命名
                    }

                    ss_inst << "bnez " << cond_reg << ", " << then_block << "\n"; // 如果条件不为零 (真)，则跳转到 then 块
                    ss_inst << "j " << else_block; // 无条件跳转到 else 块
                } else if (uncond_br) {
                    std::string target_block = uncond_br->getBlock()->getName();
                    if (target_block.empty()) { // 修复空标签问题
                        target_block = ENTRY_BLOCK_PSEUDO_NAME + "target"; // 临时命名
                    }
                    ss_inst << "j " << target_block; // 无条件跳转
                }
            } else {
                // 这个分支节点已经被 build_dag 中的常量传播优化为直接跳转。
                // 它的 'inst' 字段已经设置。直接复制它。
                ss_inst << node->inst;
            }
            break;
        }
        default:
            // 对于不直接映射到指令的节点 (例如 `alloca` 本身，其地址由其地址节点处理)
            // 或未处理的指令类型，将 inst 留空。
            break;
    }
    node->inst = ss_inst.str(); // 存储生成的指令
}

// 修改：指令发射，直接输出到 stringstream，处理依赖和去重
void RISCv32CodeGen::emit_instructions(DAGNode* node, std::stringstream& ss, const RegAllocResult& alloc, std::set<DAGNode*>& emitted_nodes) {
    if (!node || emitted_nodes.count(node)) {
        return; // 已发射或为空
    }

    // 递归地发射操作数以确保满足依赖关系
    for (auto operand : node->operands) {
        if (operand) {
            emit_instructions(operand, ss, alloc, emitted_nodes);
        }
    }

    // 标记当前节点为已发射
    emitted_nodes.insert(node);

    // 分割多行指令并处理每一行
    std::stringstream node_inst_ss(node->inst);
    std::string line;

    while (std::getline(node_inst_ss, line, '\n')) {
        // 清除前导/尾随空白并移除行开头的潜在标签
        line = std::regex_replace(line, std::regex("^\\s*[^\\s:]*:\\s*"), ""); // 移除标签（例如 `label: inst`）
        line = std::regex_replace(line, std::regex("^\\s+|\\s+$"), ""); // 清除空白

        if (line.empty()) continue;

        // 处理虚拟寄存器替换和溢出/加载逻辑
        std::string processed_line = line;

        // 如果是 store 或 load，并且操作数是 ALLOCA_ADDR，那么地址计算（addi s0, offset）应该在实际的 sw/lw 之前
        // 但由于 DAG 结构，ALLOCA_ADDR 节点本身会生成一条 addi 指令。
        // 我们需要确保这条 addi 指令在 store/load 之前被发射。
        // emit_instructions 的递归调用已经处理了操作数的发射，所以 `ptr_node->inst` 应该已经生成。

        // 替换结果虚拟寄存器 (如果此行中存在)
        if (!node->result_vreg.empty()) {
            std::string preg = reg_to_string(PhysicalReg::T0); // 默认到 T0
            if (alloc.vreg_to_preg.count(node->result_vreg)) {
                preg = reg_to_string(alloc.vreg_to_preg.at(node->result_vreg));
            }

            // 如果结果需要溢出到栈
            if (node->value && alloc.stack_map.count(node->value) && alloc.vreg_to_preg.find(node->result_vreg) == alloc.vreg_to_preg.end()) {
                // 这意味着此指令的结果将溢出。我们应该在计算后生成一个存储指令。
                // 注意：这是一个简化的溢出方法；真实的溢出策略更复杂。
                int offset = alloc.stack_map.at(node->value);
                std::string spill_reg = reg_to_string(PhysicalReg::T0); // 使用 t0 进行溢出
                // 将结果寄存器替换为 spill_reg
                processed_line = std::regex_replace(processed_line, std::regex("\\b" + node->result_vreg + "\\b"), spill_reg);
                
                // 如果当前节点不是 STORE 本身，则需要添加一个 store 指令
                if (node->kind != DAGNode::STORE) {
                    std::string store_inst = "sw " + spill_reg + ", " + std::to_string(offset) + "(s0)";
                    ss << "    " << store_inst << "\n";
                }
            } else {
                 // 如果结果不溢出或者已经被分配了物理寄存器
                processed_line = std::regex_replace(processed_line, std::regex("\\b" + node->result_vreg + "\\b"), preg);
            }
        }
        
        // 替换操作数虚拟寄存器 (如果此行中存在)
        for (auto operand : node->operands) {
            if (operand && !operand->result_vreg.empty()) {
                std::string operand_preg = reg_to_string(PhysicalReg::T0);
                if (alloc.vreg_to_preg.count(operand->result_vreg)) {
                    operand_preg = reg_to_string(alloc.vreg_to_preg.at(operand->result_vreg));
                } else if (operand->value && alloc.stack_map.count(operand->value)) {
                    // 此操作数已溢出，在使用前将其加载到临时寄存器 (t0)。
                    int offset = alloc.stack_map.at(operand->value);
                    std::string load_inst = "lw " + reg_to_string(PhysicalReg::T0) + ", " + std::to_string(offset) + "(s0)";
                    // 这里直接发射 load 指令
                    ss << "    " << load_inst << "\n";
                    operand_preg = reg_to_string(PhysicalReg::T0); // 使用 t0 作为此指令的源
                }
                processed_line = std::regex_replace(processed_line, std::regex("\\b" + operand->result_vreg + "\\b"), operand_preg);
            }
        }

        // 添加处理后的指令
        ss << "    " << processed_line << "\n";
    }
}


// 活跃性分析 (基本保持不变，因为是通用的数据流分析)
std::map<Instruction*, std::set<std::string>> RISCv32CodeGen::liveness_analysis(Function* func) {
    std::map<Instruction*, std::set<std::string>> live_in, live_out;
    bool changed = true;

    // 初始化所有 live_in/out 集合为空
    for (const auto& bb : func->getBasicBlocks()) {
        for (const auto& inst_ptr : bb->getInstructions()) {
            live_in[inst_ptr.get()] = {};
            live_out[inst_ptr.get()] = {};
        }
    }

    while (changed) {
        changed = false;
        // 逆序遍历基本块
        for (auto it = func->getBasicBlocks_NoRange().rbegin(); it != func->getBasicBlocks_NoRange().rend(); ++it) {
            auto bb = it->get();
            // 在基本块内逆序遍历指令
            for (auto inst_it = bb->getInstructions().rbegin(); inst_it != bb->getInstructions().rend(); ++inst_it) {
                auto inst = inst_it->get();
                std::set<std::string> current_live_in = live_in[inst];
                std::set<std::string> current_live_out = live_out[inst];

                std::set<std::string> new_live_out;
                // 后继的 live_in 集合的并集
                if (inst->isTerminator()) {
                    if (auto br = dynamic_cast<CondBrInst*>(inst)) {
                        new_live_out.insert(live_in[br->getThenBlock()->getInstructions().front().get()].begin(),
                                            live_in[br->getThenBlock()->getInstructions().front().get()].end());
                        new_live_out.insert(live_in[br->getElseBlock()->getInstructions().front().get()].begin(),
                                            live_in[br->getElseBlock()->getInstructions().front().get()].end());
                    } else if (auto uncond = dynamic_cast<UncondBrInst*>(inst)) {
                        new_live_out.insert(live_in[uncond->getBlock()->getInstructions().front().get()].begin(),
                                            live_in[uncond->getBlock()->getInstructions().front().get()].end());
                    }
                    // 返回指令没有后继，所以 new_live_out 保持为空
                } else {
                    auto next_inst_it = std::next(inst_it);
                    if (next_inst_it != bb->getInstructions().rend()) {
                        // 不是终结符，所以块中的下一条指令是后继
                        new_live_out = live_in[next_inst_it->get()];
                    }
                }

                // 计算当前指令的 use 和 def 集合
                std::set<std::string> use_set, def_set;

                // 定义 (Def)
                if (value_vreg_map.count(inst)) {
                    def_set.insert(value_vreg_map.at(inst));
                }

                // 使用 (Use)
                if (auto bin = dynamic_cast<BinaryInst*>(inst)) {
                    if (value_vreg_map.count(bin->getLhs())) use_set.insert(value_vreg_map.at(bin->getLhs()));
                    if (value_vreg_map.count(bin->getRhs())) use_set.insert(value_vreg_map.at(bin->getRhs()));
                } else if (auto call = dynamic_cast<CallInst*>(inst)) {
                    for (auto arg : call->getArguments()) {
                        if (value_vreg_map.count(arg->getValue())) use_set.insert(value_vreg_map.at(arg->getValue()));
                    }
                } else if (auto load = dynamic_cast<LoadInst*>(inst)) {
                    if (value_vreg_map.count(load->getPointer())) use_set.insert(value_vreg_map.at(load->getPointer()));
                } else if (auto store = dynamic_cast<StoreInst*>(inst)) {
                    if (value_vreg_map.count(store->getValue())) use_set.insert(value_vreg_map.at(store->getValue()));
                    if (value_vreg_map.count(store->getPointer())) use_set.insert(value_vreg_map.at(store->getPointer()));
                } else if (auto ret = dynamic_cast<ReturnInst*>(inst)) {
                    if (ret->hasReturnValue() && value_vreg_map.count(ret->getReturnValue()))
                        use_set.insert(value_vreg_map.at(ret->getReturnValue()));
                } else if (auto cond_br = dynamic_cast<CondBrInst*>(inst)) {
                     if (value_vreg_map.count(cond_br->getCondition()))
                        use_set.insert(value_vreg_map.at(cond_br->getCondition()));
                }
                // AllocaInst 不直接“使用”或“定义”虚拟寄存器，其地址是常量。

                // 计算新的 live_in = use U (new_live_out - def)
                std::set<std::string> new_live_in = use_set;
                for (const auto& vreg : new_live_out) {
                    if (def_set.find(vreg) == def_set.end()) {
                        new_live_in.insert(vreg);
                    }
                }

                // 检查收敛
                if (new_live_in != current_live_in || new_live_out != current_live_out) {
                    live_in[inst] = new_live_in;
                    live_out[inst] = new_live_out;
                    changed = true;
                }
            }
        }
    }
    return live_in;
}

// 干扰图构建 (基本保持不变)
std::map<std::string, std::set<std::string>> RISCv32CodeGen::build_interference_graph(
    const std::map<Instruction*, std::set<std::string>>& live_sets) {
    std::map<std::string, std::set<std::string>> graph;

    // 确保 live_sets 中所有存在的虚拟寄存器最初都在图中
    for (const auto& pair : live_sets) {
        for (const auto& vreg : pair.second) {
            graph[vreg] = {}; // 初始化空集合
        }
    }

    for (const auto& pair : live_sets) {
        auto inst = pair.first;
        const auto& live_after_inst = pair.second; // 这实际上是下一条指令/基本块入口的 live_in

        std::string defined_vreg;
        if (value_vreg_map.count(inst)) {
            defined_vreg = value_vreg_map.at(inst);
        }

        // 将从 defined vreg 到此时所有其他活跃 vreg 的边添加
        if (!defined_vreg.empty()) {
            for (const auto& live_vreg : live_after_inst) {
                if (live_vreg != defined_vreg) { // 虚拟寄存器不与其自身干扰
                    graph[defined_vreg].insert(live_vreg);
                    graph[live_vreg].insert(defined_vreg); // 对称边
                }
            }
        }
    }
    return graph;
}

// 图着色 (简化版，贪婪着色) (基本保持不变)
void RISCv32CodeGen::color_graph(std::map<std::string, PhysicalReg>& vreg_to_preg,
                                 const std::map<std::string, std::set<std::string>>& interference_graph) {
    vreg_to_preg.clear(); // 清除之前的映射

    // 按度数（从大到小）对虚拟寄存器排序以改进着色效果
    std::vector<std::pair<std::string, int>> vreg_degrees;
    for (const auto& entry : interference_graph) {
        vreg_degrees.push_back({entry.first, (int)entry.second.size()});
    }
    std::sort(vreg_degrees.begin(), vreg_degrees.end(),
              [](const auto& a, const auto& b) { return a.second > b.second; }); // 按度数降序排序

    for (const auto& vreg_deg_pair : vreg_degrees) {
        const std::string& vreg = vreg_deg_pair.first;
        std::set<PhysicalReg> used_colors; // 邻居使用的物理寄存器

        // 收集干扰邻居的颜色
        if (interference_graph.count(vreg)) {
            for (const auto& neighbor_vreg : interference_graph.at(vreg)) {
                if (vreg_to_preg.count(neighbor_vreg)) {
                    used_colors.insert(vreg_to_preg.at(neighbor_vreg));
                }
            }
        }

        // 查找第一个可用的颜色（物理寄存器）
        bool colored = false;
        for (PhysicalReg preg : allocable_regs) {
            if (used_colors.find(preg) == used_colors.end()) {
                vreg_to_preg[vreg] = preg;
                colored = true;
                break;
            }
        }

        if (!colored) {
            // 溢出 (Spilling): 如果没有可用的物理寄存器，这个虚拟寄存器必须溢出到内存。
            // 对于这个简化示例，我们没有实现完整的溢出。
            // 一个常见的方法是为其分配一个特殊的“溢出”指示符，并在代码生成中处理它。
            // 目前，我们只是不为其分配物理寄存器，`get_preg_or_temp` 将使用默认的 `t0` 或触发栈加载/存储。
            std::cerr << "警告: 无法为 " << vreg << " 分配寄存器。它很可能会溢出到栈。\n";
            // 更完整的编译器会将此虚拟寄存器添加到 `alloc.stack_map` 并在此处管理其栈偏移量。
        }
    }
}

// 寄存器分配
RISCv32CodeGen::RegAllocResult RISCv32CodeGen::register_allocation(Function* func) {
    // 1. Phi 节点消除 (如果 IR 中有 Phi 节点，需要在活跃性分析前消除)
    eliminate_phi(func); // 确保首先调用此函数

    // 为每个函数重置计数器
    alloca_offset_counter = 0;
    vreg_counter = 0;
    value_vreg_map.clear(); // 为每个函数清除

    // 在活跃性分析之前，为 alloca 指令和函数参数分配虚拟寄存器，
    // 并为 allocas 建立初始栈映射。
    RegAllocResult alloc_result;

    // 为所有产生值的指令分配虚拟寄存器。
    // 这部分实际上在 build_dag 中发生。
    // 但是，为了使活跃性分析工作，所有可能使用的 Value* 都必须有一个虚拟寄存器。
    // 我们可以遍历指令 (在 DAG 构建之前) 来填充 `value_vreg_map`。
    // 如果 DAG 分配虚拟寄存器，这有点像先有鸡还是先有蛋的问题。
    // 让我们假设 build_dag 在分配虚拟寄存器时填充 value_vreg_map。

    // 计算 AllocaInst 的栈偏移量
    int current_stack_offset = 0; // 相对于 s0 (帧指针)
    // 参数由 a0-a7 处理，所以除非它们溢出，否则这里不需要直接为它们分配栈空间。

    // 收集函数中所有唯一的 AllocaInst
    std::set<AllocaInst*> allocas_in_func;
    for (const auto& bb_ptr : func->getBasicBlocks()) {
        for (const auto& inst_ptr : bb_ptr->getInstructions()) {
            if (auto alloca = dynamic_cast<AllocaInst*>(inst_ptr.get())) {
                allocas_in_func.insert(alloca);
            }
        }
    }

    // 为 alloca 指令分配栈空间
    for (auto alloca : allocas_in_func) {
        // 为 4 字节整数 (i32) 分配空间
        int size = 4; // 假设 i32，如果存在其他类型则调整
        alloc_result.stack_map[alloca] = current_stack_offset;
        current_stack_offset += size;
    }

    // 确保栈大小是 16 的倍数，并考虑保存的 ra 和 s0
    // ra 在 (stack_size - 4)(sp)
    // s0 在 (stack_size - 8)(sp)
    // 所以最小栈大小必须是 8 + current_stack_offset。
    alloc_result.stack_size = current_stack_offset + 8; // 用于 s0 和 ra
    // 对齐到 16 字节以符合 ABI
    alloc_result.stack_size = (alloc_result.stack_size + 15) & ~15;

    // 2. 活跃性分析
    std::map<Instruction*, std::set<std::string>> live_sets = liveness_analysis(func);

    // 3. 构建干扰图
    std::map<std::string, std::set<std::string>> interference_graph = build_interference_graph(live_sets);

    // 4. 图着色
    color_graph(alloc_result.vreg_to_preg, interference_graph);

    return alloc_result;
}

// Phi 消除 (简化版，将 Phi 的结果直接复制到每个前驱基本块的末尾)
void RISCv32CodeGen::eliminate_phi(Function* func) {
    // 这是一个占位符。适当的 phi 消除将涉及
    // 在每个前驱基本块的末尾插入 `mov` 指令，用于每个 phi 操作数。
    // 对于给定的 IR 示例，没有 phi 节点，所以这可能不是严格必要的，
    // 但如果前端生成 phi 节点，则有此阶段是好的做法。
    // 目前，我们假设没有生成 phi 节点或者它们已在前端处理。
}

} // namespace sysy