#include "mir/MIR.h"

#include <stdexcept>
#include <unordered_map>
#include <cstring>

#include "ir/IR.h"
#include "utils/Log.h"

#define DEBUG_Lower

#ifdef DEBUG_Lower
#include <iostream>
#define DEBUG_MSG(msg) std::cerr << "[Lower Debug] " << msg << std::endl
#else
#define DEBUG_MSG(msg)
#endif

namespace mir {
namespace {

using ValueSlotMap = std::unordered_map<const ir::Value*, int>;

static uint32_t FloatToBits(float f) {
  uint32_t bits;
  memcpy(&bits, &f, sizeof(bits));
  return bits;
}

// 获取类型大小（字节）
int GetTypeSize(const ir::Type* type) {
  if (!type) return 4;
  size_t size = type->Size();
  return size > 0 ? static_cast<int>(size) : 4;
}

// 将 IR 整数比较谓词转换为 ARMv8 条件码
CondCode IcmpToCondCode(ir::IcmpInst::Predicate pred) {
  switch (pred) {
    case ir::IcmpInst::Predicate::EQ: return CondCode::EQ;
    case ir::IcmpInst::Predicate::NE: return CondCode::NE;
    case ir::IcmpInst::Predicate::LT: return CondCode::LT;
    case ir::IcmpInst::Predicate::GT: return CondCode::GT;
    case ir::IcmpInst::Predicate::LE: return CondCode::LE;
    case ir::IcmpInst::Predicate::GE: return CondCode::GE;
    default: return CondCode::AL;
  }
}

// 将 IR 浮点比较谓词转换为 ARMv8 条件码
CondCode FcmpToCondCode(ir::FcmpInst::Predicate pred, bool& isOrdered) {
  isOrdered = true;
  switch (pred) {
    case ir::FcmpInst::Predicate::OEQ: return CondCode::EQ;
    case ir::FcmpInst::Predicate::ONE: return CondCode::NE;
    case ir::FcmpInst::Predicate::OLT: return CondCode::LT;
    case ir::FcmpInst::Predicate::OGT: return CondCode::GT;
    case ir::FcmpInst::Predicate::OLE: return CondCode::LE;
    case ir::FcmpInst::Predicate::OGE: return CondCode::GE;
    case ir::FcmpInst::Predicate::UEQ: isOrdered = false; return CondCode::EQ;
    case ir::FcmpInst::Predicate::UNE: isOrdered = false; return CondCode::NE;
    case ir::FcmpInst::Predicate::ULT: isOrdered = false; return CondCode::LT;
    case ir::FcmpInst::Predicate::UGT: isOrdered = false; return CondCode::GT;
    case ir::FcmpInst::Predicate::ULE: isOrdered = false; return CondCode::LE;
    case ir::FcmpInst::Predicate::UGE: isOrdered = false; return CondCode::GE;
    default: return CondCode::AL;
  }
}

// 获取基本块的标签名（用于汇编输出）
std::string GetBlockLabel(const ir::BasicBlock* bb) {
  if (!bb || !bb->GetParent()) {
    return ".Lunknown";
  }
  // 格式：.L函数名_基本块名
  std::string funcName = bb->GetParent()->GetName();
  std::string blockName = bb->GetName();
  
  // 如果基本块没有名字，使用地址作为标识
  if (blockName.empty()) {
    blockName = std::to_string(reinterpret_cast<uintptr_t>(bb));
  }
  
  return ".L" + funcName + "_" + blockName;
}

// 获取数组类型的维度信息
static const ir::ArrayType* GetArrayType(const ir::Type* type) {
  if (type->IsArray()) {
    return static_cast<const ir::ArrayType*>(type);
  }
  return nullptr;
}

static std::vector<int> GetArrayStrides(const ir::ArrayType* arrayType) {
  std::vector<int> strides;
  const std::vector<int>& dims = arrayType->GetDimensions();
  int stride = 4;  // 元素大小（int/float 是 4 字节）
  
  // 从最后一维向前计算步长
  for (int i = dims.size() - 1; i >= 0; --i) {
    strides.insert(strides.begin(), stride);
    stride *= dims[i];
  }
  return strides;
}

// 在 Lowering.cpp 中添加辅助函数
const ir::Value* GetOperand(const ir::Instruction& inst, size_t index) {
    if (index < inst.GetNumOperands()) {
        return inst.GetOperand(index);
    }
    return nullptr;
}

const ir::BasicBlock* GetBasicBlockOperand(const ir::Instruction& inst, size_t index) {
    const ir::Value* operand = GetOperand(inst, index);
    if (operand) {
        return dynamic_cast<const ir::BasicBlock*>(operand);
    }
    return nullptr;
}

void EmitValueToReg(const ir::Value* value, PhysReg target,
                    const ValueSlotMap& slots, MachineBasicBlock& block,
                    MachineFunction& function) {
  // 处理整数常量
  if (auto* constant = dynamic_cast<const ir::ConstantInt*>(value)) {
    block.Append(Opcode::MovImm,
                 {Operand::Reg(target), Operand::Imm(constant->GetValue())});
    return;
  }
  // 处理浮点常量
  if (auto* fconstant = dynamic_cast<const ir::ConstantFloat*>(value)) {
    // 检查是否已经为这个常量分配了栈槽
    auto it = slots.find(value);
    int slot;
    if (it == slots.end()) {
        DEBUG_MSG("Value not found: " << value->GetName());
        // 输出所有 slots 的键名用于调试
        for (auto& p : slots) {
            DEBUG_MSG("  Slot key: " << p.first->GetName());
        }
        // 分配新的栈槽
        slot = function.CreateFrameIndex(4);
        // 将浮点常量存储到栈槽
        float fval = fconstant->GetValue();
        uint32_t int_val = FloatToBits(fval);
        
        // 使用临时寄存器加载常量并存储
        block.Append(Opcode::MovImm, {Operand::Reg(PhysReg::W8), Operand::Imm(static_cast<int>(int_val))});
        block.Append(Opcode::StoreStack, {Operand::Reg(PhysReg::W8), Operand::FrameIndex(slot)});
        const_cast<ValueSlotMap&>(slots).emplace(value, slot);
    } else {
        slot = it->second;
    }

    // 从栈槽加载到目标寄存器
    block.Append(Opcode::LoadStack, {Operand::Reg(target), Operand::FrameIndex(slot)});
    return;
  }
  // 处理全局变量
  if (auto* global = dynamic_cast<const ir::GlobalValue*>(value)) {
      // 全局变量：需要加载其地址
      // 在 ARM64 中，使用 ADRP + ADD 指令获取全局变量地址
      // 简化版本：先为全局变量分配一个栈槽，然后加载地址到该栈槽
      
      // 检查是否已经为这个全局变量分配了栈槽
      auto it = slots.find(value);
      if (it == slots.end()) {
          // 为全局变量创建栈槽
          const_cast<ValueSlotMap&>(slots).emplace(value, 
              const_cast<MachineFunction&>(function).CreateFrameIndex(8));
          it = slots.find(value);
      }
      
      // 从栈槽加载地址到目标寄存器
      block.Append(Opcode::LoadStack,
                  {Operand::Reg(target), Operand::FrameIndex(it->second)});
      return;
  } 
  // 处理零常量
  if (dynamic_cast<const ir::ConstantZero*>(value) ||
      dynamic_cast<const ir::ConstantAggregateZero*>(value)) {
    // 零常量：直接加载 0
    block.Append(Opcode::MovImm,
                 {Operand::Reg(target), Operand::Imm(0)});
    return;
  }

  auto it = slots.find(value);
  if (it == slots.end()) {
    // 使用值的地址作为调试信息
    std::string valueName = value->GetName();
    if (valueName.empty()) {
        valueName = "(anonymous at " + std::to_string(reinterpret_cast<uintptr_t>(value)) + ")";
    }
    DEBUG_MSG("Value not found: " << valueName);
    // 输出所有 slots 的键名用于调试
    for (auto& p : slots) {
      std::string slotName = p.first->GetName();
          if (slotName.empty()) {
              slotName = "(anonymous at " + std::to_string(reinterpret_cast<uintptr_t>(p.first)) + ")";
          }
      DEBUG_MSG("  Slot key: " << slotName);
    }
    throw std::runtime_error(
        FormatError("mir", "找不到值对应的栈槽: " + valueName));
  }

  block.Append(Opcode::LoadStack,
               {Operand::Reg(target), Operand::FrameIndex(it->second)});
}

void LowerInstruction(const ir::Instruction& inst, MachineFunction& function,
                      ValueSlotMap& slots, MachineBasicBlock& block,
                      std::unordered_map<const ir::BasicBlock*, 
                      MachineBasicBlock*>& blockMap) {
  //auto& block = function.GetEntry();
  DEBUG_MSG("Processing instruction: " << inst.GetName() 
              << " (opcode: " << static_cast<int>(inst.GetOpcode()) << ")");

  switch (inst.GetOpcode()) {
    case ir::Opcode::Alloca: {
      slots.emplace(&inst, function.CreateFrameIndex(GetTypeSize(inst.GetType().get())));
      return;
    }
    case ir::Opcode::Store: {
      auto& store = static_cast<const ir::StoreInst&>(inst);
      auto dst = slots.find(store.GetPtr());
      if (dst == slots.end()) {
        //throw std::runtime_error(
        //    FormatError("mir", "暂不支持对非栈变量地址进行写入"));
        EmitValueToReg(store.GetPtr(), PhysReg::X8, slots, block, function);
        // 加载值到 w9
        EmitValueToReg(store.GetValue(), PhysReg::W9, slots, block, function);
        // 存储值到地址
        block.Append(Opcode::StoreStack,
                    {Operand::Reg(PhysReg::W9), Operand::Reg(PhysReg::X8)});
        return;
      }
      EmitValueToReg(store.GetValue(), PhysReg::W8, slots, block, function);
      block.Append(Opcode::StoreStack,
                   {Operand::Reg(PhysReg::W8), Operand::FrameIndex(dst->second)});
      return;
    }
    case ir::Opcode::Load: {
      auto& load = static_cast<const ir::LoadInst&>(inst);
      auto src = slots.find(load.GetPtr());
      if (src == slots.end()) {
        //throw std::runtime_error(
        //    FormatError("mir", "暂不支持对非栈变量地址进行读取"));
        // 对于非栈变量地址（如 GEP 结果），地址本身在栈槽中
        // 需要先加载地址，然后从该地址加载值
        int dst_slot = function.CreateFrameIndex(GetTypeSize(inst.GetType().get()));
        // 加载地址到 x8
        EmitValueToReg(load.GetPtr(), PhysReg::X8, slots, block, function);
        // 从地址加载值到 w9
        block.Append(Opcode::LoadStack,
                    {Operand::Reg(PhysReg::W9), Operand::Reg(PhysReg::X8)});
        // 存储值到结果栈槽
        block.Append(Opcode::StoreStack,
                    {Operand::Reg(PhysReg::W9), Operand::FrameIndex(dst_slot)});
        slots.emplace(&inst, dst_slot);
        return;
      }
      int dst_slot = function.CreateFrameIndex(GetTypeSize(inst.GetType().get())); // 分配结果槽
      block.Append(Opcode::LoadStack,
                   {Operand::Reg(PhysReg::W8), Operand::FrameIndex(src->second)});
      block.Append(Opcode::StoreStack,
                   {Operand::Reg(PhysReg::W8), Operand::FrameIndex(dst_slot)});
      slots.emplace(&inst, dst_slot);
      return;
    }
    case ir::Opcode::Add: {
      auto& bin = static_cast<const ir::BinaryInst&>(inst);
      int dst_slot = function.CreateFrameIndex(GetTypeSize(inst.GetType().get()));
      EmitValueToReg(bin.GetLhs(), PhysReg::W8, slots, block, function);
      EmitValueToReg(bin.GetRhs(), PhysReg::W9, slots, block, function);
      block.Append(Opcode::AddRR, {Operand::Reg(PhysReg::W8),
                                   Operand::Reg(PhysReg::W8),
                                   Operand::Reg(PhysReg::W9)});
      block.Append(Opcode::StoreStack,
                   {Operand::Reg(PhysReg::W8), Operand::FrameIndex(dst_slot)});
      slots.emplace(&inst, dst_slot);
      return;
    }
    case ir::Opcode::Sub: {
      auto& bin = static_cast<const ir::BinaryInst&>(inst);
      int dst_slot = function.CreateFrameIndex(GetTypeSize(inst.GetType().get()));  // 分配结果栈槽
      EmitValueToReg(bin.GetLhs(), PhysReg::W8, slots, block, function);
      EmitValueToReg(bin.GetRhs(), PhysReg::W9, slots, block, function);
      block.Append(Opcode::SubRR, {Operand::Reg(PhysReg::W8),
                                   Operand::Reg(PhysReg::W8),
                                   Operand::Reg(PhysReg::W9)});
      block.Append(Opcode::StoreStack,
                   {Operand::Reg(PhysReg::W8), Operand::FrameIndex(dst_slot)});
      slots.emplace(&inst, dst_slot);
      return;
    }
    case ir::Opcode::Mul: {
      auto& bin = static_cast<const ir::BinaryInst&>(inst);
      int dst_slot = function.CreateFrameIndex(GetTypeSize(inst.GetType().get()));  // 分配结果栈槽
      EmitValueToReg(bin.GetLhs(), PhysReg::W8, slots, block, function);
      EmitValueToReg(bin.GetRhs(), PhysReg::W9, slots, block, function);
      block.Append(Opcode::MulRR, {Operand::Reg(PhysReg::W8),
                                   Operand::Reg(PhysReg::W8),
                                   Operand::Reg(PhysReg::W9)});
      block.Append(Opcode::StoreStack,
                   {Operand::Reg(PhysReg::W8), Operand::FrameIndex(dst_slot)});
      slots.emplace(&inst, dst_slot);
      return;
    }
    case ir::Opcode::Div: {
      auto& bin = static_cast<const ir::BinaryInst&>(inst);
      int dst_slot = function.CreateFrameIndex(GetTypeSize(inst.GetType().get()));  // 分配结果栈槽
      EmitValueToReg(bin.GetLhs(), PhysReg::W8, slots, block, function);
      EmitValueToReg(bin.GetRhs(), PhysReg::W9, slots, block, function);
      block.Append(Opcode::SDivRR, {Operand::Reg(PhysReg::W8),
                                    Operand::Reg(PhysReg::W8),
                                    Operand::Reg(PhysReg::W9)});
      block.Append(Opcode::StoreStack,
                   {Operand::Reg(PhysReg::W8), Operand::FrameIndex(dst_slot)});
      slots.emplace(&inst, dst_slot);
      return;
    }
    case ir::Opcode::Ret: {
      auto& ret = static_cast<const ir::ReturnInst&>(inst);
      EmitValueToReg(ret.GetValue(), PhysReg::W0, slots, block, function);
      block.Append(Opcode::Ret);
      return;
    }
    case ir::Opcode::FAdd: {
      auto& bin = static_cast<const ir::BinaryInst&>(inst);
      int dst_slot = function.CreateFrameIndex(GetTypeSize(inst.GetType().get()));  // 分配结果栈槽
      // 浮点值加载到 S0, S1（使用浮点寄存器）
      EmitValueToReg(bin.GetLhs(), PhysReg::S0, slots, block, function);
      EmitValueToReg(bin.GetRhs(), PhysReg::S1, slots, block, function);
      block.Append(Opcode::FAddRR, {Operand::Reg(PhysReg::S0),
                                    Operand::Reg(PhysReg::S0),
                                    Operand::Reg(PhysReg::S1)});
      block.Append(Opcode::StoreStack,
                  {Operand::Reg(PhysReg::S0), Operand::FrameIndex(dst_slot)});
      slots.emplace(&inst, dst_slot);
      return;
    }
    case ir::Opcode::FSub: {
      auto& bin = static_cast<const ir::BinaryInst&>(inst);
      int dst_slot = function.CreateFrameIndex(GetTypeSize(inst.GetType().get()));  // 分配结果栈槽
      // 浮点值加载到 S0, S1（使用浮点寄存器）
      EmitValueToReg(bin.GetLhs(), PhysReg::S0, slots, block, function);
      EmitValueToReg(bin.GetRhs(), PhysReg::S1, slots, block, function);
      block.Append(Opcode::FSubRR, {Operand::Reg(PhysReg::S0),
                                    Operand::Reg(PhysReg::S0),
                                    Operand::Reg(PhysReg::S1)});
      block.Append(Opcode::StoreStack,
                  {Operand::Reg(PhysReg::S0), Operand::FrameIndex(dst_slot)});
      slots.emplace(&inst, dst_slot);
      return;
    }
    case ir::Opcode::FMul: {
      auto& bin = static_cast<const ir::BinaryInst&>(inst);
      int dst_slot = function.CreateFrameIndex(GetTypeSize(inst.GetType().get()));  // 分配结果栈槽
      // 浮点值加载到 S0, S1（使用浮点寄存器）
      EmitValueToReg(bin.GetLhs(), PhysReg::S0, slots, block, function);
      EmitValueToReg(bin.GetRhs(), PhysReg::S1, slots, block, function);
      block.Append(Opcode::FMulRR, {Operand::Reg(PhysReg::S0),
                                    Operand::Reg(PhysReg::S0),
                                    Operand::Reg(PhysReg::S1)});
      block.Append(Opcode::StoreStack,
                  {Operand::Reg(PhysReg::S0), Operand::FrameIndex(dst_slot)});
      slots.emplace(&inst, dst_slot);
      return;
    }
    case ir::Opcode::FDiv: {
      auto& bin = static_cast<const ir::BinaryInst&>(inst);
      int dst_slot = function.CreateFrameIndex(GetTypeSize(inst.GetType().get()));  // 分配结果栈槽
      // 浮点值加载到 S0, S1（使用浮点寄存器）
      EmitValueToReg(bin.GetLhs(), PhysReg::S0, slots, block, function);
      EmitValueToReg(bin.GetRhs(), PhysReg::S1, slots, block, function);
      block.Append(Opcode::FDivRR, {Operand::Reg(PhysReg::S0),
                                    Operand::Reg(PhysReg::S0),
                                    Operand::Reg(PhysReg::S1)});
      block.Append(Opcode::StoreStack,
                  {Operand::Reg(PhysReg::S0), Operand::FrameIndex(dst_slot)});
      slots.emplace(&inst, dst_slot);
      return;
    }
    // ========== 整数比较指令（修正版）==========
    case ir::Opcode::Icmp: {
      auto& icmp = static_cast<const ir::IcmpInst&>(inst);
      int dst_slot = function.CreateFrameIndex(GetTypeSize(inst.GetType().get()));
      
      EmitValueToReg(icmp.GetLhs(), PhysReg::W8, slots, block, function);
      EmitValueToReg(icmp.GetRhs(), PhysReg::W9, slots, block, function);
      
      block.Append(Opcode::CmpRR, {Operand::Reg(PhysReg::W8), Operand::Reg(PhysReg::W9)});
      CondCode cc = IcmpToCondCode(icmp.GetPredicate());
      
      // 使用 CSET 模式
      block.Append(Opcode::MovImm, {Operand::Reg(PhysReg::W8), Operand::Imm(1)});
      block.Append(Opcode::MovImm, {Operand::Reg(PhysReg::W9), Operand::Imm(0)});
      
      std::string true_label = ".L_cset_true_" + std::to_string(reinterpret_cast<uintptr_t>(&icmp));
      std::string end_label = ".L_cset_end_" + std::to_string(reinterpret_cast<uintptr_t>(&icmp));
      
      block.Append(Opcode::BCond, {Operand::Cond(cc), Operand::Label(true_label)});
      block.Append(Opcode::MovReg, {Operand::Reg(PhysReg::W8), Operand::Reg(PhysReg::W9)});
      block.Append(Opcode::B, {Operand::Label(end_label)});
      block.Append(Opcode::Label, {Operand::Label(true_label)});
      block.Append(Opcode::Label, {Operand::Label(end_label)});
      
      block.Append(Opcode::StoreStack,
                  {Operand::Reg(PhysReg::W8), Operand::FrameIndex(dst_slot)});
      slots.emplace(&inst, dst_slot);
      return;
    }
    // ========== 浮点比较指令 ==========
    case ir::Opcode::FCmp: {
      auto& fcmp = static_cast<const ir::FcmpInst&>(inst);
      int dst_slot = function.CreateFrameIndex(GetTypeSize(inst.GetType().get()));
      
      // 加载浮点操作数到 s0, s1
      EmitValueToReg(fcmp.GetLhs(), PhysReg::S0, slots, block, function);
      EmitValueToReg(fcmp.GetRhs(), PhysReg::S1, slots, block, function);
      
      // 生成浮点比较指令
      block.Append(Opcode::FCmpRR, {Operand::Reg(PhysReg::S0), Operand::Reg(PhysReg::S1)});
      
      // 简化实现：存储 1 作为结果
      block.Append(Opcode::MovImm, {Operand::Reg(PhysReg::W8), Operand::Imm(1)});
      block.Append(Opcode::StoreStack,
                   {Operand::Reg(PhysReg::W8), Operand::FrameIndex(dst_slot)});
      slots.emplace(&inst, dst_slot);
      return;
    }
    // ========== 跳转指令（使用标签操作数）==========
    case ir::Opcode::Br: {
        DEBUG_MSG("Processing Br");
        auto& br = static_cast<const ir::BranchInst&>(inst);
        
        if (br.IsConditional()) {
            // 条件跳转
            EmitValueToReg(br.GetCondition(), PhysReg::W8, slots, block, function);
            block.Append(Opcode::CmpRI, {Operand::Reg(PhysReg::W8), Operand::Imm(0)});
            
            std::string trueLabel = GetBlockLabel(br.GetTrueTarget());
            std::string falseLabel = GetBlockLabel(br.GetFalseTarget());
            
            block.Append(Opcode::BCond, {Operand::Cond(CondCode::NE), Operand::Label(trueLabel)});
            block.Append(Opcode::B, {Operand::Label(falseLabel)});
        } else {
            // 无条件跳转
            std::string targetLabel = GetBlockLabel(br.GetTarget());
            block.Append(Opcode::B, {Operand::Label(targetLabel)});
        }
        return;
    }
    case ir::Opcode::CondBr: {
        DEBUG_MSG("Processing CondBr");
        auto& br = static_cast<const ir::BranchInst&>(inst);
        
        // 条件跳转处理
        EmitValueToReg(br.GetCondition(), PhysReg::W8, slots, block, function);
        block.Append(Opcode::CmpRI, {Operand::Reg(PhysReg::W8), Operand::Imm(0)});
        
        std::string trueLabel = GetBlockLabel(br.GetTrueTarget());
        std::string falseLabel = GetBlockLabel(br.GetFalseTarget());
        
        block.Append(Opcode::BCond, {Operand::Cond(CondCode::NE), Operand::Label(trueLabel)});
        block.Append(Opcode::B, {Operand::Label(falseLabel)});
        return;
    }
    // ========== 函数调用 ==========
    case ir::Opcode::Call: {
      auto& call = static_cast<const ir::CallInst&>(inst);
      const ir::Function* callee = call.GetCallee();
      const std::string& calleeName = callee->GetName();
      
      // 分配结果栈槽（如果有返回值）
      int dst_slot = -1;
      if (!inst.GetType()->IsVoid()) {
        dst_slot = function.CreateFrameIndex(GetTypeSize(inst.GetType().get()));
      }
      
      // 按照 ARM64 调用约定传递参数
      const auto& args = call.GetArgs();
      size_t intArgCount = 0;
      size_t fpArgCount = 0;
      
      for (size_t i = 0; i < args.size(); ++i) {
        const auto* arg = args[i];
        const ir::Type* argType = arg->GetType().get();
        
        if (argType->IsFloat()) {
          // 浮点参数
          PhysReg reg = static_cast<PhysReg>(static_cast<int>(PhysReg::S0) + fpArgCount);
          EmitValueToReg(arg, reg, slots, block, function);
          fpArgCount++;
        } else {
          // 整数参数
          PhysReg reg = static_cast<PhysReg>(static_cast<int>(PhysReg::W0) + intArgCount);
          EmitValueToReg(arg, reg, slots, block, function);
          intArgCount++;
        }
      }
      
      // 生成调用指令
      //block.Append(Opcode::Call, {Operand::Imm(0)});  // 实际需要传递函数名
      block.Append(Opcode::Call, {Operand::Label(calleeName)});
      // 保存返回值
      if (dst_slot != -1) {
        if (inst.GetType()->IsFloat()) {
          block.Append(Opcode::StoreStack,
                       {Operand::Reg(PhysReg::S0), Operand::FrameIndex(dst_slot)});
        } else {
          block.Append(Opcode::StoreStack,
                       {Operand::Reg(PhysReg::W0), Operand::FrameIndex(dst_slot)});
        }
        slots.emplace(&inst, dst_slot);
      }
      return;
    }
    // ========== 类型转换指令 ==========
    case ir::Opcode::ZExt: {
      auto& zext = static_cast<const ir::ZExtInst&>(inst);
      int dst_slot = function.CreateFrameIndex(GetTypeSize(inst.GetType().get()));
      
      // 加载源值到 w8
      EmitValueToReg(zext.GetValue(), PhysReg::W8, slots, block, function);
      
      // 零扩展：i1 -> i32，直接存储即可（因为 i1 已经是 0 或 1）
      block.Append(Opcode::StoreStack,
                   {Operand::Reg(PhysReg::W8), Operand::FrameIndex(dst_slot)});
      slots.emplace(&inst, dst_slot);
      return;
    }
    case ir::Opcode::SIToFP: {
      auto& sitofp = static_cast<const ir::SIToFPInst&>(inst);
      int dst_slot = function.CreateFrameIndex(GetTypeSize(inst.GetType().get()));
      
      // 加载整数到 w8
      EmitValueToReg(sitofp.GetValue(), PhysReg::W8, slots, block, function);
      
      // 整数转浮点：SCVTF s0, w8
      block.Append(Opcode::SIToFP, {Operand::Reg(PhysReg::S0), Operand::Reg(PhysReg::W8)});
      block.Append(Opcode::StoreStack,
                   {Operand::Reg(PhysReg::S0), Operand::FrameIndex(dst_slot)});
      slots.emplace(&inst, dst_slot);
      return;
    }
    case ir::Opcode::FPToSI: {
      auto& fptosi = static_cast<const ir::FPToSIInst&>(inst);
      int dst_slot = function.CreateFrameIndex(GetTypeSize(inst.GetType().get()));
      
      // 加载浮点数到 s0
      EmitValueToReg(fptosi.GetValue(), PhysReg::S0, slots, block, function);
      
      // 浮点转整数：FCVTZS w8, s0
      block.Append(Opcode::FPToSI, {Operand::Reg(PhysReg::W8), Operand::Reg(PhysReg::S0)});
      block.Append(Opcode::StoreStack,
                   {Operand::Reg(PhysReg::W8), Operand::FrameIndex(dst_slot)});
      slots.emplace(&inst, dst_slot);
      return;
    }
    // ========== GEP 指令（计算数组元素地址）==========
    case ir::Opcode::GEP: {
      auto& gep = static_cast<const ir::GEPInst&>(inst);
      
      // GEP 返回指针类型，在 ARM64 上指针是 8 字节
      int dst_slot = function.CreateFrameIndex(8);
      
      // 获取基地址（数组的起始地址）
      ir::Value* base = gep.GetBase();
      const auto& indices = gep.GetIndices();
      
      // 加载基地址到 x8（使用 64 位寄存器存储地址）
      EmitValueToReg(base, PhysReg::X8, slots, block, function);
      
      if (indices.empty()) {
        // 没有索引，直接返回基地址
        block.Append(Opcode::StoreStack,
                    {Operand::Reg(PhysReg::X8), Operand::FrameIndex(dst_slot)});
        slots.emplace(&inst, dst_slot);
        return;
      }
      
      // 获取数组类型信息，计算每个维度的步长
      const ir::Type* baseType = base->GetType().get();
      
      // 如果基地址是指针类型，需要解引用获取元素类型
      if (baseType->IsPtrInt32() || baseType->IsPtrFloat() || baseType->IsPtrInt1()) {
        // 对于指针类型，第一个索引是偏移量（以元素为单位）
        // 例如：int* p; p[1] 的 GEP 中 indices[0] = 1
        if (indices.size() >= 1) {
          // 加载索引到 x9
          EmitValueToReg(indices[0], PhysReg::X9, slots, block, function);
          
          // 乘以元素大小（int/float 是 4 字节）
          block.Append(Opcode::MovImm, {Operand::Reg(PhysReg::X10), Operand::Imm(4)});
          block.Append(Opcode::MulRR, {Operand::Reg(PhysReg::X9),
                                      Operand::Reg(PhysReg::X9),
                                      Operand::Reg(PhysReg::X10)});
          
          // 地址 = base + index * 4
          block.Append(Opcode::AddRR, {Operand::Reg(PhysReg::X8),
                                      Operand::Reg(PhysReg::X8),
                                      Operand::Reg(PhysReg::X9)});
        }
        
        // 存储计算出的地址
        block.Append(Opcode::StoreStack,
                    {Operand::Reg(PhysReg::X8), Operand::FrameIndex(dst_slot)});
        slots.emplace(&inst, dst_slot);
        return;
      }
      
      // 如果基地址是数组类型，需要处理多维数组
      if (baseType->IsArray()) {
        const ir::ArrayType* arrayType = static_cast<const ir::ArrayType*>(baseType);
        const std::vector<int>& dims = arrayType->GetDimensions();
        
        // 计算每个维度的步长
        std::vector<int> strides(dims.size());
        int stride = 4;  // 元素大小（int/float 是 4 字节）
        for (int i = dims.size() - 1; i >= 0; --i) {
          strides[i] = stride;
          stride *= dims[i];
        }
        
        // 计算总偏移量
        // 地址 = base + index0 * stride0 + index1 * stride1 + ...
        size_t numIndices = indices.size();
        
        // 限制索引数量（不能超过维度数）
        if (numIndices > dims.size()) {
          numIndices = dims.size();
        }
        
        // 加载当前地址到 x9 作为偏移量累加器
        block.Append(Opcode::MovImm, {Operand::Reg(PhysReg::X9), Operand::Imm(0)});
        
        for (size_t i = 0; i < numIndices; ++i) {
          // 加载当前索引到 x10
          EmitValueToReg(indices[i], PhysReg::X10, slots, block, function);
          
          // 乘以步长
          block.Append(Opcode::MovImm, {Operand::Reg(PhysReg::X11), Operand::Imm(strides[i])});
          block.Append(Opcode::MulRR, {Operand::Reg(PhysReg::X10),
                                      Operand::Reg(PhysReg::X10),
                                      Operand::Reg(PhysReg::X11)});
          
          // 累加到偏移量
          block.Append(Opcode::AddRR, {Operand::Reg(PhysReg::X9),
                                      Operand::Reg(PhysReg::X9),
                                      Operand::Reg(PhysReg::X10)});
        }
        
        // 最终地址 = base + offset
        block.Append(Opcode::AddRR, {Operand::Reg(PhysReg::X8),
                                    Operand::Reg(PhysReg::X8),
                                    Operand::Reg(PhysReg::X9)});
        
        // 存储计算出的地址
        block.Append(Opcode::StoreStack,
                    {Operand::Reg(PhysReg::X8), Operand::FrameIndex(dst_slot)});
        slots.emplace(&inst, dst_slot);
        return;
      }
      
      // 其他情况：简单处理
      // 只处理第一个索引
      if (indices.size() >= 1) {
        EmitValueToReg(indices[0], PhysReg::X9, slots, block, function);
        
        // 乘以元素大小（默认 4 字节）
        block.Append(Opcode::MovImm, {Operand::Reg(PhysReg::X10), Operand::Imm(4)});
        block.Append(Opcode::MulRR, {Operand::Reg(PhysReg::X9),
                                    Operand::Reg(PhysReg::X9),
                                    Operand::Reg(PhysReg::X10)});
        
        block.Append(Opcode::AddRR, {Operand::Reg(PhysReg::X8),
                                    Operand::Reg(PhysReg::X8),
                                    Operand::Reg(PhysReg::X9)});
      }
      
      // 存储计算出的地址
      block.Append(Opcode::StoreStack,
                  {Operand::Reg(PhysReg::X8), Operand::FrameIndex(dst_slot)});
      slots.emplace(&inst, dst_slot);
      return;
    }
    // 处理 Trunc 指令
    case ir::Opcode::Trunc: {
        auto& inst_ref = static_cast<const ir::Instruction&>(inst);
        int dst_slot = function.CreateFrameIndex(GetTypeSize(inst.GetType().get()));
        
        // 假设 Trunc 指令有 GetValue() 方法
        // 如果没有，需要通过操作数列表获取
        const ir::Value* src_val = nullptr;
        if (inst.GetNumOperands() > 0) {
            src_val = inst.GetOperand(0);
        }
        if (src_val) {
            EmitValueToReg(src_val, PhysReg::W8, slots, block, function);
        }
        
        block.Append(Opcode::StoreStack,
                    {Operand::Reg(PhysReg::W8), Operand::FrameIndex(dst_slot)});
        slots.emplace(&inst, dst_slot);
        return;
    }
    // 处理 Mod 指令
    case ir::Opcode::Mod: {
        int dst_slot = function.CreateFrameIndex(GetTypeSize(inst.GetType().get()));
        
        // 通过操作数获取左右值
        const ir::Value* lhs = nullptr;
        const ir::Value* rhs = nullptr;
        if (inst.GetNumOperands() >= 2) {
            lhs = inst.GetOperand(0);
            rhs = inst.GetOperand(1);
        }
        
        if (lhs && rhs) {
            EmitValueToReg(lhs, PhysReg::W8, slots, block, function);
            EmitValueToReg(rhs, PhysReg::W9, slots, block, function);
            
            // a % b = a - (a / b) * b
            block.Append(Opcode::SDivRR, {Operand::Reg(PhysReg::W10),
                                          Operand::Reg(PhysReg::W8),
                                          Operand::Reg(PhysReg::W9)});
            block.Append(Opcode::MulRR, {Operand::Reg(PhysReg::W10),
                                        Operand::Reg(PhysReg::W10),
                                        Operand::Reg(PhysReg::W9)});
            block.Append(Opcode::SubRR, {Operand::Reg(PhysReg::W8),
                                        Operand::Reg(PhysReg::W8),
                                        Operand::Reg(PhysReg::W10)});
        }
        
        block.Append(Opcode::StoreStack,
                    {Operand::Reg(PhysReg::W8), Operand::FrameIndex(dst_slot)});
        slots.emplace(&inst, dst_slot);
        return;
    }
    // 处理 And 指令
    case ir::Opcode::And: {
        int dst_slot = function.CreateFrameIndex(GetTypeSize(inst.GetType().get()));
        
        const ir::Value* lhs = nullptr;
        const ir::Value* rhs = nullptr;
        if (inst.GetNumOperands() >= 2) {
            lhs = inst.GetOperand(0);
            rhs = inst.GetOperand(1);
        }
        
        if (lhs && rhs) {
            EmitValueToReg(lhs, PhysReg::W8, slots, block, function);
            EmitValueToReg(rhs, PhysReg::W9, slots, block, function);
            block.Append(Opcode::AndRR, {Operand::Reg(PhysReg::W8),
                                        Operand::Reg(PhysReg::W8),
                                        Operand::Reg(PhysReg::W9)});
        }
        
        block.Append(Opcode::StoreStack,
                    {Operand::Reg(PhysReg::W8), Operand::FrameIndex(dst_slot)});
        slots.emplace(&inst, dst_slot);
        return;
    }
    // 处理 Or 指令
    case ir::Opcode::Or: {
        int dst_slot = function.CreateFrameIndex(GetTypeSize(inst.GetType().get()));
        
        const ir::Value* lhs = nullptr;
        const ir::Value* rhs = nullptr;
        if (inst.GetNumOperands() >= 2) {
            lhs = inst.GetOperand(0);
            rhs = inst.GetOperand(1);
        }
        
        if (lhs && rhs) {
            EmitValueToReg(lhs, PhysReg::W8, slots, block, function);
            EmitValueToReg(rhs, PhysReg::W9, slots, block, function);
            block.Append(Opcode::OrRR, {Operand::Reg(PhysReg::W8),
                                        Operand::Reg(PhysReg::W8),
                                        Operand::Reg(PhysReg::W9)});
        }
        
        block.Append(Opcode::StoreStack,
                    {Operand::Reg(PhysReg::W8), Operand::FrameIndex(dst_slot)});
        slots.emplace(&inst, dst_slot);
        return;
    }
    // 处理 Not 指令
    case ir::Opcode::Not: {
        int dst_slot = function.CreateFrameIndex(GetTypeSize(inst.GetType().get()));
        
        const ir::Value* src_val = nullptr;
        if (inst.GetNumOperands() > 0) {
            src_val = inst.GetOperand(0);
        }
        
        if (src_val) {
            EmitValueToReg(src_val, PhysReg::W8, slots, block, function);
            // NOT  = XOR with -1
            block.Append(Opcode::MovImm, {Operand::Reg(PhysReg::W9), Operand::Imm(-1)});
            block.Append(Opcode::EorRR, {Operand::Reg(PhysReg::W8),
                                        Operand::Reg(PhysReg::W8),
                                        Operand::Reg(PhysReg::W9)});
        }
        
        block.Append(Opcode::StoreStack,
                    {Operand::Reg(PhysReg::W8), Operand::FrameIndex(dst_slot)});
        slots.emplace(&inst, dst_slot);
        return;
    }
    // 处理 FPExt（浮点扩展）
    case ir::Opcode::FPExt: {
        int dst_slot = function.CreateFrameIndex(GetTypeSize(inst.GetType().get()));
        
        const ir::Value* src_val = nullptr;
        if (inst.GetNumOperands() > 0) {
            src_val = inst.GetOperand(0);
        }
        
        if (src_val) {
            EmitValueToReg(src_val, PhysReg::S0, slots, block, function);
        }
        
        block.Append(Opcode::StoreStack,
                    {Operand::Reg(PhysReg::S0), Operand::FrameIndex(dst_slot)});
        slots.emplace(&inst, dst_slot);
        return;
    }
    // 处理 FPTrunc（浮点截断）
    case ir::Opcode::FPTrunc: {
        int dst_slot = function.CreateFrameIndex(GetTypeSize(inst.GetType().get()));
        
        const ir::Value* src_val = nullptr;
        if (inst.GetNumOperands() > 0) {
            src_val = inst.GetOperand(0);
        }
        
        if (src_val) {
            EmitValueToReg(src_val, PhysReg::S0, slots, block, function);
        }
        
        block.Append(Opcode::StoreStack,
                    {Operand::Reg(PhysReg::S0), Operand::FrameIndex(dst_slot)});
        slots.emplace(&inst, dst_slot);
        return;
    }
    default:
      DEBUG_MSG("Unhandled opcode: " << static_cast<int>(inst.GetOpcode()) 
                << " for instruction: " << inst.GetName());
      throw std::runtime_error(FormatError("mir", "暂不支持该 IR 指令，opcode: " 
                            + std::to_string(static_cast<int>(inst.GetOpcode()))));
    //throw std::runtime_error(FormatError("mir", "暂不支持该 IR 指令"));
    //throw std::runtime_error(FormatError("mir", "暂不支持该 IR 指令，opcode: " 
    //                    + std::to_string(static_cast<int>(inst.GetOpcode()))));
  }
}

} // namespace

// 辅助函数，将单个 IR 函数转换为 MachineFunction
std::unique_ptr<MachineFunction> LowerFunction(const ir::Function& func) {
  auto machine_func = std::make_unique<MachineFunction>(func.GetName());
  ValueSlotMap slots;

  // 存储参数信息，稍后处理
  struct ParamInfo {
      const ir::Value* arg;
      int slot;
      bool isFloat;
  };
  std::vector<ParamInfo> paramInfos;
  
  // 为函数参数分配栈槽
  for (const auto& arg : func.GetArguments()) {
    int slot = machine_func->CreateFrameIndex(GetTypeSize(arg->GetType().get()));
    slots.emplace(arg.get(), slot);
    bool isFloat = arg->GetType()->IsFloat();
    paramInfos.push_back({arg.get(), slot, isFloat});
  }
  
  // IR 基本块到 MIR 基本块的映射
  std::unordered_map<const ir::BasicBlock*, MachineBasicBlock*> blockMap;
  
  // 第一遍：为每个 IR 基本块创建 MIR 基本块
  std::string func_name = func.GetName(); 
  for (const auto& bb : func.GetBlocks()) {
    // 格式: .L函数名_基本块名
    auto mirBB = std::make_unique<MachineBasicBlock>(".L" + func_name + "_" + bb->GetName());
    blockMap[bb.get()] = mirBB.get();
    machine_func->AddBasicBlock(std::move(mirBB));
  }
  
  // 在入口基本块的开头添加参数加载指令
  if (!func.GetBlocks().empty()) {
    MachineBasicBlock* entryBB = blockMap[func.GetEntry()];
    if (entryBB) {
        size_t intArgIdx = 0;
        size_t fpArgIdx = 0;
        
        for (const auto& param : paramInfos) {
            if (param.isFloat) {
                if (fpArgIdx < 8) {
                    PhysReg reg = static_cast<PhysReg>(static_cast<int>(PhysReg::S0) + fpArgIdx);
                    entryBB->Append(Opcode::StoreStack,
                                   {Operand::Reg(reg), Operand::FrameIndex(param.slot)});
                }
                fpArgIdx++;
            } else {
                if (intArgIdx < 8) {
                    PhysReg reg = static_cast<PhysReg>(static_cast<int>(PhysReg::W0) + intArgIdx);
                    entryBB->Append(Opcode::StoreStack,
                                   {Operand::Reg(reg), Operand::FrameIndex(param.slot)});
                }
                intArgIdx++;
            }
        }
    }
  }
  
  // 第二遍：遍历每个基本块，转换指令
  for (const auto& bb : func.GetBlocks()) {
    MachineBasicBlock* mirBB = blockMap[bb.get()];
    if (!mirBB) {
      throw std::runtime_error(FormatError("mir", "找不到基本块对应的 MIR 基本块"));
    }
    
    for (const auto& inst : bb->GetInstructions()) {
      LowerInstruction(*inst, *machine_func, slots, *mirBB, blockMap);
    }
  }
  
  return machine_func;
}

std::unique_ptr<MachineModule> LowerToMIR(const ir::Module& module) {
  DefaultContext();
  
  auto machine_module = std::make_unique<MachineModule>();

  std::vector<const ir::GlobalValue*> globals;
  // 处理全局变量
  for (const auto& global : module.GetGlobals()) {
      // 为全局变量在数据段分配空间
      // 这里需要扩展 MachineModule 来支持全局变量
      DEBUG_MSG("Global variable: " << global->GetName());
      globals.push_back(global.get());
  }
  
  // 遍历模块中的所有函数
  for (const auto& func : module.GetFunctions()) {
    try {
      auto machine_func = LowerFunction(*func);
      machine_module->AddFunction(std::move(machine_func));
    } catch (const std::runtime_error& e) {
      // 记录错误但继续处理其他函数
      throw std::runtime_error(FormatError("mir", "转换函数失败: " + func->GetName() + " - " + e.what()));
    }
  }
  
  if (machine_module->GetFunctions().empty()) {
    throw std::runtime_error(FormatError("mir", "模块中没有成功转换的函数"));
  }
  
  return machine_module;
}

}  // namespace mir