|
|
#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) ((void)0)
|
|
|
#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 (value == nullptr) {
|
|
|
DEBUG_MSG( "EmitValueToReg called with null value\n");
|
|
|
}
|
|
|
|
|
|
// 辅助函数：判断32位立即数是否可用单条 movz/movn 编码
|
|
|
auto isLegalMovImm = [](uint32_t imm) -> bool {
|
|
|
// 检查是否可以通过 movz 或 movn 表示（16位立即数，可左移0/16/32/48位）
|
|
|
// 对于32位寄存器，只考虑 lsl 0 或 16
|
|
|
if ((imm & 0xFFFF) == imm) return true; // 低16位，lsl #0
|
|
|
if ((imm & 0xFFFF0000) == imm) return true; // 高16位，lsl #16
|
|
|
// 可选：检查 movn 情况（~imm 满足上述条件），为了简单可不做，直接返回 false
|
|
|
return false;
|
|
|
};
|
|
|
|
|
|
if (auto* constant = dynamic_cast<const ir::ConstantInt*>(value)) {
|
|
|
uint32_t imm = static_cast<uint32_t>(constant->GetValue());
|
|
|
if (isLegalMovImm(imm)) {
|
|
|
block.Append(Opcode::MovImm,
|
|
|
{Operand::Reg(target), Operand::Imm(static_cast<int64_t>(imm))});
|
|
|
} else {
|
|
|
// 分解为 movz (低16位) + movk (高16位)
|
|
|
uint16_t low = imm & 0xFFFF;
|
|
|
uint16_t high = (imm >> 16) & 0xFFFF;
|
|
|
block.Append(Opcode::MovImm,
|
|
|
{Operand::Reg(target), Operand::Imm(low)}); // 先加载低16位
|
|
|
if (high != 0) {
|
|
|
// 使用 Movk 指令写入高16位
|
|
|
block.Append(Opcode::Movk,
|
|
|
{Operand::Reg(target), Operand::Imm(high), Operand::Imm(16)});
|
|
|
}
|
|
|
}
|
|
|
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);
|
|
|
|
|
|
// 同样需要对 int_val 进行大立即数分解
|
|
|
if (isLegalMovImm(int_val)) {
|
|
|
block.Append(Opcode::MovImm, {Operand::Reg(PhysReg::W8), Operand::Imm(static_cast<int64_t>(int_val))});
|
|
|
} else {
|
|
|
uint16_t low = int_val & 0xFFFF;
|
|
|
uint16_t high = (int_val >> 16) & 0xFFFF;
|
|
|
block.Append(Opcode::MovImm, {Operand::Reg(PhysReg::W8), Operand::Imm(low)});
|
|
|
if (high != 0) {
|
|
|
block.Append(Opcode::Movk, {Operand::Reg(PhysReg::W8), Operand::Imm(high), Operand::Imm(16)});
|
|
|
}
|
|
|
}
|
|
|
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 (dynamic_cast<const ir::ConstantZero*>(value) ||
|
|
|
dynamic_cast<const ir::ConstantAggregateZero*>(value)) {
|
|
|
// 零常量：直接加载 0
|
|
|
block.Append(Opcode::MovImm,
|
|
|
{Operand::Reg(target), Operand::Imm(0)});
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
// ========== 处理全局变量 ==========
|
|
|
if (auto* global = dynamic_cast<const ir::GlobalValue*>(value)) {
|
|
|
// 如果目标是 32 位寄存器，升级为对应的 64 位寄存器
|
|
|
PhysReg addrTarget = target;
|
|
|
if (target >= PhysReg::W0 && target <= PhysReg::W30) {
|
|
|
// 映射 Wn → Xn
|
|
|
addrTarget = static_cast<PhysReg>(
|
|
|
static_cast<int>(target) - static_cast<int>(PhysReg::W0) + static_cast<int>(PhysReg::X0));
|
|
|
}
|
|
|
// 现在 addrTarget 一定是 64 位寄存器
|
|
|
block.Append(Opcode::Adrp, {Operand::Reg(addrTarget), Operand::Label(global->GetName())});
|
|
|
block.Append(Opcode::AddLabel, {Operand::Reg(addrTarget), Operand::Reg(addrTarget), Operand::Label(global->GetName())});
|
|
|
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));
|
|
|
}
|
|
|
|
|
|
PhysReg actualTarget = target;
|
|
|
const ir::Type* ty = value->GetType().get();
|
|
|
bool isPointer = ty->IsPtrInt32() || ty->IsPtrFloat() || ty->IsPtrInt1()
|
|
|
|| ty->IsArray(); // 数组类型在地址上下文中视为指针
|
|
|
|
|
|
// 若非指针类型且目标是 64 位寄存器，降级为对应的 32 位寄存器（自动零扩展）
|
|
|
if (!isPointer && target >= PhysReg::X0 && target <= PhysReg::X30) {
|
|
|
actualTarget = static_cast<PhysReg>(
|
|
|
static_cast<int>(target) - static_cast<int>(PhysReg::X0) + static_cast<int>(PhysReg::W0));
|
|
|
}
|
|
|
|
|
|
block.Append(Opcode::LoadStack,
|
|
|
{Operand::Reg(actualTarget), 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: {
|
|
|
// alloca 返回一个指针，我们需要为该指针分配一个栈槽（存放地址值）
|
|
|
int ptrSlot = function.CreateFrameIndex(8); // 指针占8字节
|
|
|
// 为数组数据分配实际栈空间
|
|
|
int arraySlot = function.CreateFrameIndex(GetTypeSize(inst.GetType().get()));
|
|
|
|
|
|
// 将数组基地址（sp + arraySlot_offset）加载到 x8
|
|
|
block.Append(Opcode::LoadStackAddr,
|
|
|
{Operand::Reg(PhysReg::X8), Operand::FrameIndex(arraySlot)});
|
|
|
// 将地址存储到指针槽
|
|
|
block.Append(Opcode::StoreStack,
|
|
|
{Operand::Reg(PhysReg::X8), Operand::FrameIndex(ptrSlot)});
|
|
|
|
|
|
// 将 alloca 指令映射到指针槽，后续使用 alloca 值即获得地址
|
|
|
slots.emplace(&inst, ptrSlot);
|
|
|
return;
|
|
|
}
|
|
|
case ir::Opcode::Store: {
|
|
|
auto& store = static_cast<const ir::StoreInst&>(inst);
|
|
|
const ir::Value* ptr = store.GetPtr();
|
|
|
const ir::Value* val = store.GetValue();
|
|
|
|
|
|
// 处理全局变量作为存储目标
|
|
|
if (auto* global = dynamic_cast<const ir::GlobalValue*>(ptr)) {
|
|
|
// 生成全局变量地址到 x8
|
|
|
block.Append(Opcode::Adrp, {Operand::Reg(PhysReg::X8), Operand::Label(global->GetName())});
|
|
|
block.Append(Opcode::AddLabel, {Operand::Reg(PhysReg::X8), Operand::Reg(PhysReg::X8), Operand::Label(global->GetName())});
|
|
|
// 加载要存储的值到 w9
|
|
|
EmitValueToReg(val, PhysReg::W9, slots, block, function);
|
|
|
// 间接存储：str w9, [x8]
|
|
|
block.Append(Opcode::StoreStack, {Operand::Reg(PhysReg::W9), Operand::Reg(PhysReg::X8)});
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
auto dstIt = slots.find(ptr);
|
|
|
if (dstIt == slots.end()) {
|
|
|
// 指针不在 slots 中（例如直接来自函数参数的指针）
|
|
|
// 计算指针地址到 x8
|
|
|
EmitValueToReg(ptr, PhysReg::X8, slots, block, function);
|
|
|
// 加载要存储的值到 w9
|
|
|
EmitValueToReg(val, PhysReg::W9, slots, block, function);
|
|
|
// 使用 StoreStack 的寄存器间接形式（str w9, [x8]）
|
|
|
block.Append(Opcode::StoreStack,
|
|
|
{Operand::Reg(PhysReg::W9), Operand::Reg(PhysReg::X8)});
|
|
|
} else {
|
|
|
// 指针在 slots 中（alloca 或 gep 的结果），从指针槽加载地址到 x8
|
|
|
block.Append(Opcode::LoadStack,
|
|
|
{Operand::Reg(PhysReg::X8), Operand::FrameIndex(dstIt->second)});
|
|
|
// 加载要存储的值到 w9
|
|
|
EmitValueToReg(val, PhysReg::W9, slots, block, function);
|
|
|
// 间接存储
|
|
|
block.Append(Opcode::StoreStack,
|
|
|
{Operand::Reg(PhysReg::W9), Operand::Reg(PhysReg::X8)});
|
|
|
}
|
|
|
return;
|
|
|
}
|
|
|
case ir::Opcode::Load: {
|
|
|
auto& load = static_cast<const ir::LoadInst&>(inst);
|
|
|
const ir::Value* ptr = load.GetPtr();
|
|
|
int dstSlot = function.CreateFrameIndex(GetTypeSize(inst.GetType().get()));
|
|
|
|
|
|
// 处理全局变量作为加载源
|
|
|
if (auto* global = dynamic_cast<const ir::GlobalValue*>(ptr)) {
|
|
|
// 生成全局变量地址到 x8
|
|
|
block.Append(Opcode::Adrp, {Operand::Reg(PhysReg::X8), Operand::Label(global->GetName())});
|
|
|
block.Append(Opcode::AddLabel, {Operand::Reg(PhysReg::X8), Operand::Reg(PhysReg::X8), Operand::Label(global->GetName())});
|
|
|
// 间接加载到 w9
|
|
|
block.Append(Opcode::LoadStack, {Operand::Reg(PhysReg::W9), Operand::Reg(PhysReg::X8)});
|
|
|
// 存储结果到栈槽
|
|
|
block.Append(Opcode::StoreStack, {Operand::Reg(PhysReg::W9), Operand::FrameIndex(dstSlot)});
|
|
|
slots.emplace(&inst, dstSlot);
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
auto srcIt = slots.find(ptr);
|
|
|
if (srcIt == slots.end()) {
|
|
|
// 指针不在 slots 中，计算地址到 x8
|
|
|
EmitValueToReg(ptr, PhysReg::X8, slots, block, function);
|
|
|
// 间接加载到 w9
|
|
|
block.Append(Opcode::LoadStack,
|
|
|
{Operand::Reg(PhysReg::W9), Operand::Reg(PhysReg::X8)});
|
|
|
} else {
|
|
|
// 从指针槽加载地址到 x8
|
|
|
block.Append(Opcode::LoadStack,
|
|
|
{Operand::Reg(PhysReg::X8), Operand::FrameIndex(srcIt->second)});
|
|
|
// 间接加载到 w9
|
|
|
block.Append(Opcode::LoadStack,
|
|
|
{Operand::Reg(PhysReg::W9), Operand::Reg(PhysReg::X8)});
|
|
|
}
|
|
|
// 将加载的值存入结果槽
|
|
|
block.Append(Opcode::StoreStack,
|
|
|
{Operand::Reg(PhysReg::W9), Operand::FrameIndex(dstSlot)});
|
|
|
slots.emplace(&inst, dstSlot);
|
|
|
return;
|
|
|
}
|
|
|
case ir::Opcode::Add: {
|
|
|
auto& bin = static_cast<const ir::BinaryInst&>(inst);
|
|
|
const ir::Type* lhsTy = bin.GetLhs()->GetType().get();
|
|
|
const ir::Type* rhsTy = bin.GetRhs()->GetType().get();
|
|
|
|
|
|
// 指针判断：指令结果类型是指针，或者任一操作数是指针（指针算术）
|
|
|
bool isPointer = (lhsTy->IsPtrInt32() || lhsTy->IsPtrFloat() || lhsTy->IsPtrInt1() || lhsTy->IsArray()) ||
|
|
|
(rhsTy->IsPtrInt32() || rhsTy->IsPtrFloat() || rhsTy->IsPtrInt1() || rhsTy->IsArray()) ||
|
|
|
inst.GetType()->IsPtrInt32() || inst.GetType()->IsPtrFloat() || inst.GetType()->IsPtrInt1() || inst.GetType()->IsArray();
|
|
|
int slotSize = isPointer ? 8 : 4;
|
|
|
PhysReg lhsReg = isPointer ? PhysReg::X8 : PhysReg::W8;
|
|
|
PhysReg rhsReg = isPointer ? PhysReg::X9 : PhysReg::W9;
|
|
|
PhysReg dstReg = isPointer ? PhysReg::X8 : PhysReg::W8;
|
|
|
|
|
|
int dst_slot = function.CreateFrameIndex(slotSize); // 使用计算出的 slotSize
|
|
|
EmitValueToReg(bin.GetLhs(), lhsReg, slots, block, function);
|
|
|
EmitValueToReg(bin.GetRhs(), rhsReg, slots, block, function);
|
|
|
block.Append(Opcode::AddRR, {Operand::Reg(dstReg), Operand::Reg(lhsReg), Operand::Reg(rhsReg)});
|
|
|
block.Append(Opcode::StoreStack, {Operand::Reg(dstReg), Operand::FrameIndex(dst_slot)});
|
|
|
slots.emplace(&inst, dst_slot);
|
|
|
return;
|
|
|
}
|
|
|
case ir::Opcode::Sub: {
|
|
|
auto& bin = static_cast<const ir::BinaryInst&>(inst);
|
|
|
const ir::Type* lhsTy = bin.GetLhs()->GetType().get();
|
|
|
const ir::Type* rhsTy = bin.GetRhs()->GetType().get();
|
|
|
|
|
|
// 指针判断：指令结果类型是指针，或者任一操作数是指针（指针算术）
|
|
|
bool isPointer = (lhsTy->IsPtrInt32() || lhsTy->IsPtrFloat() || lhsTy->IsPtrInt1() || lhsTy->IsArray()) ||
|
|
|
(rhsTy->IsPtrInt32() || rhsTy->IsPtrFloat() || rhsTy->IsPtrInt1() || rhsTy->IsArray()) ||
|
|
|
inst.GetType()->IsPtrInt32() || inst.GetType()->IsPtrFloat() || inst.GetType()->IsPtrInt1() || inst.GetType()->IsArray();
|
|
|
int slotSize = isPointer ? 8 : 4;
|
|
|
PhysReg lhsReg = isPointer ? PhysReg::X8 : PhysReg::W8;
|
|
|
PhysReg rhsReg = isPointer ? PhysReg::X9 : PhysReg::W9;
|
|
|
PhysReg dstReg = isPointer ? PhysReg::X8 : PhysReg::W8;
|
|
|
|
|
|
int dst_slot = function.CreateFrameIndex(slotSize); // 使用计算出的 slotSize
|
|
|
EmitValueToReg(bin.GetLhs(), lhsReg, slots, block, function);
|
|
|
EmitValueToReg(bin.GetRhs(), rhsReg, slots, block, function);
|
|
|
block.Append(Opcode::SubRR, {Operand::Reg(dstReg), Operand::Reg(lhsReg), Operand::Reg(rhsReg)});
|
|
|
block.Append(Opcode::StoreStack, {Operand::Reg(dstReg), Operand::FrameIndex(dst_slot)});
|
|
|
slots.emplace(&inst, dst_slot);
|
|
|
return;
|
|
|
}
|
|
|
case ir::Opcode::Mul: {
|
|
|
auto& bin = static_cast<const ir::BinaryInst&>(inst);
|
|
|
const ir::Type* ty = inst.GetType().get();
|
|
|
bool isPointer = ty->IsPtrInt32() || ty->IsPtrFloat() || ty->IsPtrInt1();
|
|
|
int slotSize = isPointer ? 8 : 4;
|
|
|
PhysReg lhsReg = isPointer ? PhysReg::X8 : PhysReg::W8;
|
|
|
PhysReg rhsReg = isPointer ? PhysReg::X9 : PhysReg::W9;
|
|
|
PhysReg dstReg = isPointer ? PhysReg::X8 : PhysReg::W8; // 可复用 lhsReg
|
|
|
|
|
|
int dst_slot = function.CreateFrameIndex(GetTypeSize(inst.GetType().get())); // 分配结果栈槽
|
|
|
EmitValueToReg(bin.GetLhs(), lhsReg, slots, block, function);
|
|
|
EmitValueToReg(bin.GetRhs(), rhsReg, slots, block, function);
|
|
|
block.Append(Opcode::MulRR, {Operand::Reg(dstReg),
|
|
|
Operand::Reg(lhsReg),
|
|
|
Operand::Reg(rhsReg)});
|
|
|
block.Append(Opcode::StoreStack,
|
|
|
{Operand::Reg(dstReg), Operand::FrameIndex(dst_slot)});
|
|
|
slots.emplace(&inst, dst_slot);
|
|
|
return;
|
|
|
}
|
|
|
case ir::Opcode::Div: {
|
|
|
auto& bin = static_cast<const ir::BinaryInst&>(inst);
|
|
|
const ir::Type* ty = inst.GetType().get();
|
|
|
bool isPointer = ty->IsPtrInt32() || ty->IsPtrFloat() || ty->IsPtrInt1();
|
|
|
int slotSize = isPointer ? 8 : 4;
|
|
|
PhysReg lhsReg = isPointer ? PhysReg::X8 : PhysReg::W8;
|
|
|
PhysReg rhsReg = isPointer ? PhysReg::X9 : PhysReg::W9;
|
|
|
PhysReg dstReg = isPointer ? PhysReg::X8 : PhysReg::W8; // 可复用 lhsReg
|
|
|
|
|
|
int dst_slot = function.CreateFrameIndex(GetTypeSize(inst.GetType().get())); // 分配结果栈槽
|
|
|
EmitValueToReg(bin.GetLhs(), lhsReg, slots, block, function);
|
|
|
EmitValueToReg(bin.GetRhs(), rhsReg, slots, block, function);
|
|
|
block.Append(Opcode::SDivRR, {Operand::Reg(dstReg),
|
|
|
Operand::Reg(lhsReg),
|
|
|
Operand::Reg(rhsReg)});
|
|
|
block.Append(Opcode::StoreStack,
|
|
|
{Operand::Reg(dstReg), Operand::FrameIndex(dst_slot)});
|
|
|
slots.emplace(&inst, dst_slot);
|
|
|
return;
|
|
|
}
|
|
|
case ir::Opcode::Ret: {
|
|
|
auto& ret = static_cast<const ir::ReturnInst&>(inst);
|
|
|
const ir::Value* retVal = ret.GetValue();
|
|
|
if (retVal != nullptr) {
|
|
|
const ir::Type* retType = retVal->GetType().get();
|
|
|
PhysReg retReg = PhysReg::W0; // 默认整数返回值
|
|
|
if (retType->IsFloat()) {
|
|
|
retReg = PhysReg::S0;
|
|
|
} else if (retType->IsPtrInt32() || retType->IsPtrFloat() || retType->IsPtrInt1()) {
|
|
|
retReg = PhysReg::X0;
|
|
|
} else {
|
|
|
retReg = PhysReg::W0;
|
|
|
}
|
|
|
EmitValueToReg(retVal, retReg, 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 if (argType->IsPtrInt32() || argType->IsPtrFloat() || argType->IsPtrInt1()) {
|
|
|
// 指针参数 → X 寄存器（占用一个整数参数槽）
|
|
|
PhysReg reg = static_cast<PhysReg>(static_cast<int>(PhysReg::X0) + intArgCount);
|
|
|
EmitValueToReg(arg, reg, slots, block, function);
|
|
|
intArgCount++;
|
|
|
} else {
|
|
|
// 普通整数 → W 寄存器
|
|
|
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) {
|
|
|
const ir::Type* retType = inst.GetType().get();
|
|
|
PhysReg srcReg = PhysReg::W0;
|
|
|
if (retType->IsFloat()) {
|
|
|
srcReg = PhysReg::S0;
|
|
|
} else if (retType->IsPtrInt32() || retType->IsPtrFloat() || retType->IsPtrInt1()) {
|
|
|
srcReg = PhysReg::X0;
|
|
|
} else {
|
|
|
srcReg = PhysReg::W0;
|
|
|
}
|
|
|
block.Append(Opcode::StoreStack,
|
|
|
{Operand::Reg(srcReg), 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;
|
|
|
}
|
|
|
case ir::Opcode::GEP: {
|
|
|
auto& gep = static_cast<const ir::GEPInst&>(inst);
|
|
|
|
|
|
DEBUG_MSG("Processing GEP instruction: " << inst.GetName());
|
|
|
|
|
|
// GEP 返回指针类型，在 ARM64 上指针是 8 字节
|
|
|
int dst_slot = function.CreateFrameIndex(8);
|
|
|
|
|
|
// 获取基地址（数组的起始地址）
|
|
|
ir::Value* base = gep.GetBase();
|
|
|
const auto& indices = gep.GetIndices();
|
|
|
|
|
|
std::string baseName = base->GetName().empty() ? "unnamed" : base->GetName();
|
|
|
DEBUG_MSG("Base value: " << baseName);
|
|
|
DEBUG_MSG("Number of indices: " << indices.size());
|
|
|
|
|
|
// 打印索引值
|
|
|
for (size_t idx_i = 0; idx_i < indices.size(); ++idx_i) {
|
|
|
if (auto* const_int = dynamic_cast<const ir::ConstantInt*>(indices[idx_i])) {
|
|
|
DEBUG_MSG(" Index[" << idx_i << "] = " << const_int->GetValue() << " (constant)");
|
|
|
} else {
|
|
|
DEBUG_MSG(" Index[" << idx_i << "] = variable");
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 加载基地址到 x8
|
|
|
EmitValueToReg(base, PhysReg::X8, slots, block, function);
|
|
|
|
|
|
if (indices.empty()) {
|
|
|
DEBUG_MSG("No indices, storing base address directly");
|
|
|
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();
|
|
|
DEBUG_MSG("Base type kind: " << static_cast<int>(baseType->GetKind()));
|
|
|
|
|
|
// 关键修改：对于数组指针类型，第一个索引是多余的，应该跳过
|
|
|
size_t start_index = 0;
|
|
|
if (baseType->IsPtrInt32() || baseType->IsPtrFloat() || baseType->IsPtrInt1()) {
|
|
|
// 对于指针类型，第一个索引是偏移量，不能跳过
|
|
|
DEBUG_MSG("Base is pointer type, using all indices for pointer arithmetic");
|
|
|
start_index = 0;
|
|
|
} else if (baseType->IsArray()) {
|
|
|
// 对于数组类型（非指针），第一个索引是多余的
|
|
|
// 因为 base 已经是数组本身，不需要再解引用
|
|
|
DEBUG_MSG("Base is array type, skipping first index (array decay)");
|
|
|
start_index = 1;
|
|
|
}
|
|
|
|
|
|
// 如果基地址是数组类型，需要处理多维数组
|
|
|
if (baseType->IsArray()) {
|
|
|
DEBUG_MSG("Base is array type, processing multi-dimensional array");
|
|
|
const ir::ArrayType* arrayType = static_cast<const ir::ArrayType*>(baseType);
|
|
|
const std::vector<int>& dims = arrayType->GetDimensions();
|
|
|
|
|
|
DEBUG_MSG("Array dimensions: ");
|
|
|
for (size_t i = 0; i < dims.size(); ++i) {
|
|
|
DEBUG_MSG(" dim[" << i << "] = " << dims[i]);
|
|
|
}
|
|
|
|
|
|
// 正确计算每个维度的步长
|
|
|
std::vector<int> strides(dims.size());
|
|
|
int element_size = 4; // 元素大小（int/float 是 4 字节）
|
|
|
for (int i = dims.size() - 1; i >= 0; --i) {
|
|
|
if (i == static_cast<int>(dims.size()) - 1) {
|
|
|
strides[i] = element_size;
|
|
|
DEBUG_MSG("strides[" << i << "] = " << strides[i] << " (element size)");
|
|
|
} else {
|
|
|
strides[i] = strides[i + 1] * dims[i + 1];
|
|
|
DEBUG_MSG("strides[" << i << "] = " << strides[i+1] << " * " << dims[i+1]
|
|
|
<< " = " << strides[i]);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 计算总偏移，跳过第一个索引
|
|
|
size_t numIndices = indices.size();
|
|
|
size_t effective_indices = numIndices - start_index;
|
|
|
if (effective_indices > dims.size()) {
|
|
|
DEBUG_MSG("Warning: effective indices (" << effective_indices << ") > dims.size() ("
|
|
|
<< dims.size() << "), truncating");
|
|
|
effective_indices = dims.size();
|
|
|
}
|
|
|
|
|
|
DEBUG_MSG("Using " << effective_indices << " effective indices (starting from " << start_index << ")");
|
|
|
|
|
|
// 加载当前地址到 x9 作为偏移量累加器
|
|
|
block.Append(Opcode::MovImm, {Operand::Reg(PhysReg::X9), Operand::Imm(0)});
|
|
|
|
|
|
// 用于调试的静态偏移计算
|
|
|
int debug_offset = 0;
|
|
|
|
|
|
for (size_t i = 0; i < effective_indices; ++i) {
|
|
|
size_t idx_pos = start_index + i;
|
|
|
int index_value = 0;
|
|
|
if (auto* const_int = dynamic_cast<const ir::ConstantInt*>(indices[idx_pos])) {
|
|
|
index_value = const_int->GetValue();
|
|
|
DEBUG_MSG("Index[" << idx_pos << "] = " << index_value << " (constant)");
|
|
|
debug_offset += index_value * strides[i];
|
|
|
DEBUG_MSG(" Contribution = " << index_value << " * " << strides[i]
|
|
|
<< " = " << (index_value * strides[i]));
|
|
|
DEBUG_MSG(" Running offset = " << debug_offset);
|
|
|
} else {
|
|
|
DEBUG_MSG("Index[" << idx_pos << "] = variable");
|
|
|
}
|
|
|
|
|
|
// 加载当前索引到 x10
|
|
|
EmitValueToReg(indices[idx_pos], 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)});
|
|
|
}
|
|
|
|
|
|
DEBUG_MSG("Total computed offset = " << debug_offset);
|
|
|
|
|
|
// 最终地址 = 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);
|
|
|
DEBUG_MSG("Array GEP completed, result stored in slot " << dst_slot);
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
// 其他情况的处理...
|
|
|
DEBUG_MSG("Base is other type, using simple handling");
|
|
|
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);
|
|
|
DEBUG_MSG("Simple GEP completed");
|
|
|
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;
|
|
|
bool isPointer;
|
|
|
};
|
|
|
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();
|
|
|
bool isPointer = arg->GetType()->IsPtrInt32() || arg->GetType()->IsPtrFloat() || arg->GetType()->IsPtrInt1();
|
|
|
paramInfos.push_back({arg.get(), slot, isFloat, isPointer});
|
|
|
}
|
|
|
|
|
|
// 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 (param.isPointer) {
|
|
|
if (intArgIdx < 8) {
|
|
|
PhysReg reg = static_cast<PhysReg>(static_cast<int>(PhysReg::X0) + intArgIdx);
|
|
|
entryBB->Append(Opcode::StoreStack, {Operand::Reg(reg), Operand::FrameIndex(param.slot)});
|
|
|
}
|
|
|
intArgIdx++;
|
|
|
} 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>();
|
|
|
|
|
|
// 收集全局变量信息
|
|
|
for (const auto& global : module.GetGlobals()) {
|
|
|
int size = GetTypeSize(global->GetType().get());
|
|
|
int alignment = global->GetType()->Alignment();
|
|
|
// 简化：假设无显式初始化的全局变量都是零初始化
|
|
|
bool is_zero_init = !global->HasInitializer();
|
|
|
machine_module->AddGlobal(global->GetName(), size, alignment, is_zero_init);
|
|
|
}
|
|
|
|
|
|
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
|
