admin/pl
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: support function params + stack based compiler!

Browse Source
This commit is contained in:
Amir Adal
2025-12-01 13:59:30 +01:00
parent b3498135aa
commit 952df07ce3
5 changed files with 156 additions and 118 deletions
Download Patch File Download Diff File Expand all files Collapse all files

223
include/codegen.hpp
View File

@ -53,98 +53,98 @@ private:
Builder<StackSlot> m_slots;
};
struct ConstSlot
{
long value;
StringView addr;
};
// struct ConstSlot
// {
// long value;
// StringView addr;
// };
class ConstAllocator : public Allocator<ConstSlot>
{
public:
ConstAllocator() = default;
~ConstAllocator() override = default;
public:
const ConstSlot& Allocate(const StringView& addr)
{
m_slots.Push(ConstSlot { 0, addr });
return m_slots.data[m_slots.size - 1];
}
// class ConstAllocator : public Allocator<ConstSlot>
// {
// public:
// ConstAllocator() = default;
// ~ConstAllocator() override = default;
// public:
// const ConstSlot& Allocate(const StringView& addr)
// {
// m_slots.Push(ConstSlot { 0, addr });
// return m_slots.data[m_slots.size - 1];
// }
const ConstSlot& StoreValue(const StringView& addr, long value)
{
for (size_t i = 0; i < m_slots.size; ++i)
{
if (strcmp(m_slots.data[i].addr.c_str(), addr.c_str()) == 0)
{
m_slots.data[i].value = value;
return m_slots.data[i];
}
}
// const ConstSlot& StoreValue(const StringView& addr, long value)
// {
// for (size_t i = 0; i < m_slots.size; ++i)
// {
// if (strcmp(m_slots.data[i].addr.c_str(), addr.c_str()) == 0)
// {
// m_slots.data[i].value = value;
// return m_slots.data[i];
// }
// }
assert(0 && "could not resolve const under specified address");
}
// assert(0 && "could not resolve const under specified address");
// }
const ConstSlot& Resolve(const StringView& addr)
{
for (size_t i = 0; i < m_slots.size; ++i)
{
if (strcmp(m_slots.data[i].addr.c_str(), addr.c_str()) == 0)
{
return m_slots.data[i];
}
}
// const ConstSlot& Resolve(const StringView& addr)
// {
// for (size_t i = 0; i < m_slots.size; ++i)
// {
// if (strcmp(m_slots.data[i].addr.c_str(), addr.c_str()) == 0)
// {
// return m_slots.data[i];
// }
// }
assert(0 && "could not resolve const under specified address");
}
private:
Builder<ConstSlot> m_slots;
};
// assert(0 && "could not resolve const under specified address");
// }
// private:
// Builder<ConstSlot> m_slots;
// };
struct RegisterSlot
{
const StringView& reg;
StringView addr;
};
// struct RegisterSlot
// {
// const StringView& reg;
// StringView addr;
// };
class RegisterAllocator : public Allocator<RegisterSlot>
{
public:
RegisterAllocator()
{
m_regs.Push(std::move(StringView("eax")));
m_regs.Push(std::move(StringView("ecx")));
}
~RegisterAllocator() override = default;
public:
const RegisterSlot& Allocate(const StringView& addr)
{
assert(m_slots.size < m_regs.size && "no space available for allocating to register");
m_slots.Push(RegisterSlot { m_regs.data[m_slots.size], addr });
return m_slots.data[m_slots.size - 1];
}
// class RegisterAllocator : public Allocator<RegisterSlot>
// {
// public:
// RegisterAllocator()
// {
// m_regs.Push(std::move(StringView("eax")));
// m_regs.Push(std::move(StringView("ecx")));
// }
// ~RegisterAllocator() override = default;
// public:
// const RegisterSlot& Allocate(const StringView& addr)
// {
// assert(m_slots.size < m_regs.size && "no space available for allocating to register");
// m_slots.Push(RegisterSlot { m_regs.data[m_slots.size], addr });
// return m_slots.data[m_slots.size - 1];
// }
const RegisterSlot& Resolve(const StringView& addr)
{
for (size_t i = 0; i < m_slots.size; ++i)
{
if (strcmp(m_slots.data[i].addr.c_str(), addr.c_str()) == 0)
{
return m_slots.data[i];
}
}
// const RegisterSlot& Resolve(const StringView& addr)
// {
// for (size_t i = 0; i < m_slots.size; ++i)
// {
// if (strcmp(m_slots.data[i].addr.c_str(), addr.c_str()) == 0)
// {
// return m_slots.data[i];
// }
// }
assert(0 && "could not resolve register for specified address");
}
// assert(0 && "could not resolve register for specified address");
// }
void Clear()
{
m_slots.size = 0;
}
private:
Builder<RegisterSlot> m_slots;
Builder<StringView> m_regs;
};
// void Clear()
// {
// m_slots.size = 0;
// }
// private:
// Builder<RegisterSlot> m_slots;
// Builder<StringView> m_regs;
// };
class CodeGenerator
{
@ -164,7 +164,15 @@ private:
int stackSize = 0;
for (auto &op : ops)
{
if (op->GetType() == IR::OpType::STORE) stackSize += 4;
switch (op->GetType())
{
case IR::OpType::STORE:
case IR::OpType::LOAD:
case IR::OpType::LOAD_CONST:
case IR::OpType::ADD:
case IR::OpType::CALL:
stackSize += 4;
}
}
return stackSize;
}
@ -194,12 +202,19 @@ private:
printf("%s:\n", name.c_str());
printf("push rbp\n");
printf("mov rbp, rsp\n");
m_stack = new StackAllocator();
int stackSize = GetStackSize(fn->ops());
printf("sub rsp, %d\n", stackSize);
if (fn->params().size > 0)
{
auto param_slot = m_stack->Allocate(fn->params().data[0]);
printf("mov [rbp-%d], edi\n", param_slot.offset);
}
for(auto &fOp : fn->ops())
{
GenerateOp(fOp);
}
m_stack = nullptr;
printf("leave\nret\n");
}
break;
@ -209,46 +224,50 @@ private:
// TODO: support several arguments
if (call->args().size == 1)
{
auto reg_slot = m_registers.Resolve(GetTempAddr(call->args().data[0]));
printf("mov edi, %s\n", reg_slot.reg.c_str());
auto slot = m_stack->Resolve(GetTempAddr(call->args().data[0]));
printf("mov edi, [rbp-%d]\n", slot.offset);
}
printf("call %s\n", call->callee().c_str());
m_registers.Clear();
auto result_slot = m_stack->Allocate(GetTempAddr(call->result()));
printf("mov dword [rbp-%d], eax\n", result_slot.offset);
}
break;
case IR::OpType::LOAD_CONST:
{
auto lc = reinterpret_cast<const IR::LoadConstOp *>(op);
auto addr = GetTempAddr(lc->result());
m_consts.Allocate(addr);
m_consts.StoreValue(addr, lc->value());
auto slot = m_stack->Allocate(addr);
printf("mov dword [rbp-%d], %ld\n", slot.offset, lc->value());
}
break;
case IR::OpType::STORE:
{
auto s = reinterpret_cast<const IR::StoreOp *>(op);
printf("; DEBUG: resolving stack slot at %s\n", s->addr().c_str());
auto slot = m_stack.Allocate(s->addr());
auto value = m_consts.Resolve(GetTempAddr(s->src()));
printf("mov dword [rbp-%d], %ld\n", slot.offset, value.value);
auto slot = m_stack->Allocate(s->addr());
auto value_slot = m_stack->Resolve(GetTempAddr(s->src()));
printf("mov eax, [rbp-%d]\n", value_slot.offset);
printf("mov dword [rbp-%d], eax\n", slot.offset);
}
break;
case IR::OpType::LOAD:
{
auto l = reinterpret_cast<const IR::LoadOp *>(op);
auto reg_slot = m_registers.Allocate(GetTempAddr(l->result()));
auto stack_slot = m_stack.Resolve(l->addr());
printf("mov %s, [rbp-%d]\n", reg_slot.reg.c_str(), stack_slot.offset);
auto value_slot = m_stack->Allocate(GetTempAddr(l->result()));
auto variable_slot = m_stack->Resolve(l->addr());
printf("mov eax, [rbp-%d]\n", variable_slot.offset);
printf("mov dword [rbp-%d], eax\n", value_slot.offset);
}
break;
case IR::OpType::ADD:
{
auto expr = reinterpret_cast<const IR::AddOp *>(op);
auto lhs_slot = m_registers.Resolve(GetTempAddr(expr->lhs()));
auto rhs_slot = m_registers.Resolve(GetTempAddr(expr->rhs()));
printf("add %s, %s\n", lhs_slot.reg.c_str(), rhs_slot.reg.c_str());
m_registers.Clear();
m_registers.Allocate(GetTempAddr(expr->result()));
auto lhs_slot = m_stack->Resolve(GetTempAddr(expr->lhs()));
printf("mov eax, [rbp-%d]\n", lhs_slot.offset);
auto rhs_slot = m_stack->Resolve(GetTempAddr(expr->rhs()));
printf("add eax, [rbp-%d]\n", rhs_slot.offset);
auto result_slot = m_stack->Allocate(GetTempAddr(expr->result()));
printf("mov dword [rbp-%d], eax\n", result_slot.offset);
}
break;
default: printf("; NOT HANDLED\n; %s\n", op->Format(0).c_str()); break;
@ -268,7 +287,5 @@ public:
}
public:
// TODO: handle sub-blocks
StackAllocator m_stack;
ConstAllocator m_consts;
RegisterAllocator m_registers;
};
StackAllocator* m_stack = nullptr;
};