320 lines
13 KiB
C++
320 lines
13 KiB
C++
#include "elna/backend/riscv.hpp"
|
|
#include <memory>
|
|
|
|
namespace elna::riscv
|
|
{
|
|
instruction::instruction(base_opcode opcode)
|
|
{
|
|
this->representation = static_cast<std::underlying_type<base_opcode>::type>(opcode);
|
|
}
|
|
|
|
instruction& instruction::i(x_register rd, funct3_t funct3, x_register rs1, std::uint32_t immediate)
|
|
{
|
|
this->representation |= (static_cast<std::underlying_type<x_register>::type>(rd) << 7)
|
|
| (static_cast<std::underlying_type<funct3_t>::type>(funct3) << 12)
|
|
| (static_cast<std::underlying_type<x_register>::type>(rs1) << 15)
|
|
| (immediate << 20);
|
|
|
|
return *this;
|
|
}
|
|
|
|
instruction& instruction::s(std::uint32_t imm, funct3_t funct3, x_register rs1, x_register rs2)
|
|
{
|
|
this->representation |= ((imm & 0x1f) << 7)
|
|
| (static_cast<std::underlying_type<funct3_t>::type>(funct3) << 12)
|
|
| (static_cast<std::underlying_type<x_register>::type>(rs1) << 15)
|
|
| (static_cast<std::underlying_type<x_register>::type>(rs2) << 20)
|
|
| ((imm & 0xfe0) << 20);
|
|
|
|
return *this;
|
|
}
|
|
|
|
instruction& instruction::b(std::uint32_t imm, funct3_t funct3, x_register rs1, x_register rs2)
|
|
{
|
|
this->representation |= ((imm & 0x800) >> 4) | ((imm & 0x1e) << 7)
|
|
| (static_cast<std::underlying_type<funct3_t>::type>(funct3) << 12)
|
|
| (static_cast<std::underlying_type<x_register>::type>(rs1) << 15)
|
|
| (static_cast<std::underlying_type<x_register>::type>(rs2) << 20)
|
|
| ((imm & 0x7e0) << 20) | ((imm & 0x1000) << 19);
|
|
|
|
return *this;
|
|
}
|
|
|
|
instruction& instruction::r(x_register rd, funct3_t funct3, x_register rs1, x_register rs2, funct7_t funct7)
|
|
{
|
|
this->representation |= (static_cast<std::underlying_type<x_register>::type>(rd) << 7)
|
|
| (static_cast<std::underlying_type<funct3_t>::type>(funct3) << 12)
|
|
| (static_cast<std::underlying_type<x_register>::type>(rs1) << 15)
|
|
| (static_cast<std::underlying_type<x_register>::type>(rs2) << 20)
|
|
| (static_cast<std::underlying_type<funct7_t>::type>(funct7) << 25);
|
|
|
|
return *this;
|
|
}
|
|
|
|
instruction& instruction::u(x_register rd, std::uint32_t imm)
|
|
{
|
|
this->representation |= (static_cast<std::underlying_type<x_register>::type>(rd) << 7) | (imm << 12);
|
|
|
|
return *this;
|
|
}
|
|
|
|
instruction& instruction::j(x_register rd, std::uint32_t imm)
|
|
{
|
|
this->representation |= (static_cast<std::underlying_type<x_register>::type>(rd) << 7)
|
|
| (imm & 0xff000) | ((imm & 0x800) << 9) | ((imm & 0x7fe) << 20) | ((imm & 0x100000) << 11);
|
|
|
|
return *this;
|
|
}
|
|
|
|
const std::byte *instruction::cbegin() const
|
|
{
|
|
return reinterpret_cast<const std::byte *>(&this->representation);
|
|
}
|
|
|
|
const std::byte *instruction::cend() const
|
|
{
|
|
return reinterpret_cast<const std::byte *>(&this->representation) + sizeof(this->representation);
|
|
}
|
|
|
|
visitor::visitor(std::function<void(const std::string&, const std::byte *, std::size_t)> write_text,
|
|
std::function<std::string_view(const std::byte *, std::size_t)> write_read_only)
|
|
: write_text(write_text), write_read_only(write_read_only)
|
|
{
|
|
}
|
|
|
|
void visitor::visit(source::declaration *declaration)
|
|
{
|
|
}
|
|
|
|
void visitor::visit(source::definition *definition)
|
|
{
|
|
}
|
|
|
|
void visitor::visit(source::block *block)
|
|
{
|
|
this->instructions.push_back(instruction(base_opcode::opImm));
|
|
this->instructions.push_back(instruction(base_opcode::store));
|
|
this->instructions.push_back(instruction(base_opcode::store));
|
|
this->instructions.push_back(instruction(base_opcode::opImm));
|
|
|
|
table = block->table();
|
|
block->body().accept(this);
|
|
|
|
// Set the return value (0).
|
|
this->instructions.push_back(instruction(base_opcode::op)
|
|
.r(x_register::a0, funct3_t::_and, x_register::zero, x_register::zero));
|
|
|
|
// Prologue.
|
|
auto main_symbol =
|
|
std::dynamic_pointer_cast<source::procedure_info>(table->lookup("main"));
|
|
const uint stack_size = static_cast<std::uint32_t>(variable_counter * 4 + 8 + main_symbol->stack_size());
|
|
|
|
this->instructions[0].i(x_register::sp, funct3_t::addi, x_register::sp, -stack_size);
|
|
this->instructions[1].s(stack_size - 4, funct3_t::sw, x_register::sp, x_register::s0);
|
|
this->instructions[2].s(stack_size - 8, funct3_t::sw, x_register::sp, x_register::ra);
|
|
this->instructions[3].i(x_register::s0, funct3_t::addi, x_register::sp, stack_size);
|
|
|
|
// Epilogue.
|
|
this->instructions.push_back(instruction(base_opcode::load)
|
|
.i(x_register::s0, funct3_t::lw, x_register::sp, stack_size - 4));
|
|
this->instructions.push_back(instruction(base_opcode::load)
|
|
.i(x_register::ra, funct3_t::lw, x_register::sp, stack_size - 8));
|
|
this->instructions.push_back(instruction(base_opcode::opImm)
|
|
.i(x_register::sp, funct3_t::addi, x_register::sp, stack_size));
|
|
this->instructions.push_back(instruction(base_opcode::jalr)
|
|
.i(x_register::zero, funct3_t::jalr, x_register::ra, 0));
|
|
}
|
|
|
|
void visitor::visit(source::program *program)
|
|
{
|
|
visit(dynamic_cast<source::block *>(program));
|
|
write_text("main", reinterpret_cast<const std::byte *>(this->instructions.data()),
|
|
this->instructions.size() * sizeof(instruction));
|
|
}
|
|
|
|
void visitor::visit(source::bang_statement *statement)
|
|
{
|
|
statement->body().accept(this);
|
|
|
|
// Print the result.
|
|
this->instructions.push_back(instruction(base_opcode::opImm)
|
|
.i(x_register::a1, funct3_t::addi, x_register::a0, 0));
|
|
|
|
auto format_string = write_read_only(reinterpret_cast<const std::byte *>("%d\n\0"), 4);
|
|
|
|
this->references.push_back(reference());
|
|
this->references.back().name = format_string;
|
|
this->references.back().offset = instructions.size() * 4;
|
|
this->references.back().target = address_t::high20;
|
|
this->instructions.push_back(instruction(base_opcode::lui).u(x_register::a5, 0));
|
|
this->references.push_back(reference());
|
|
this->references.back().name = format_string;
|
|
this->references.back().offset = instructions.size() * 4;
|
|
this->references.back().target = address_t::lower12i;
|
|
|
|
this->instructions.push_back(instruction(base_opcode::opImm)
|
|
.i(x_register::a0, funct3_t::addi, x_register::a5, 0));
|
|
this->references.push_back(reference());
|
|
this->references.back().name = "printf";
|
|
this->references.back().offset = instructions.size() * 4;
|
|
this->references.back().target = address_t::text;
|
|
this->instructions.push_back(instruction(base_opcode::auipc).u(x_register::ra, 0));
|
|
this->instructions.push_back(instruction(base_opcode::jalr)
|
|
.i(x_register::ra, funct3_t::jalr, x_register::ra, 0));
|
|
}
|
|
|
|
void visitor::visit(source::question_mark_statement *statement)
|
|
{
|
|
statement->body().accept(this);
|
|
|
|
// Print the result.
|
|
this->instructions.push_back(instruction(base_opcode::opImm)
|
|
.i(x_register::a1, funct3_t::addi, x_register::a0, 0));
|
|
|
|
auto format_string = write_read_only(reinterpret_cast<const std::byte *>("%d\n\0"), 4);
|
|
|
|
this->references.push_back(reference());
|
|
this->references.back().name = format_string;
|
|
this->references.back().offset = instructions.size() * 4;
|
|
this->references.back().target = address_t::high20;
|
|
this->instructions.push_back(instruction(base_opcode::lui).u(x_register::a5, 0));
|
|
this->references.push_back(reference());
|
|
this->references.back().name = format_string;
|
|
this->references.back().offset = instructions.size() * 4;
|
|
this->references.back().target = address_t::lower12i;
|
|
|
|
this->instructions.push_back(instruction(base_opcode::opImm)
|
|
.i(x_register::a0, funct3_t::addi, x_register::a5, 0));
|
|
this->references.push_back(reference());
|
|
this->references.back().name = "printf";
|
|
this->references.back().offset = instructions.size() * 4;
|
|
this->references.back().target = address_t::text;
|
|
this->instructions.push_back(instruction(base_opcode::auipc).u(x_register::ra, 0));
|
|
this->instructions.push_back(instruction(base_opcode::jalr)
|
|
.i(x_register::ra, funct3_t::jalr, x_register::ra, 0));
|
|
}
|
|
|
|
void visitor::visit(source::compound_statement *statement)
|
|
{
|
|
for (auto& nested_statement : statement->statements())
|
|
{
|
|
nested_statement->accept(this);
|
|
}
|
|
}
|
|
|
|
void visitor::visit(source::assign_statement *statement)
|
|
{
|
|
const auto free_register = this->register_in_use ? x_register::a0 : x_register::t0;
|
|
auto symbol = table->lookup(statement->lvalue());
|
|
auto variable_symbol = std::dynamic_pointer_cast<source::variable_info>(symbol);
|
|
|
|
statement->rvalue().accept(this);
|
|
|
|
this->instructions.push_back(instruction(base_opcode::store)
|
|
.s(variable_symbol->offset, funct3_t::sw, x_register::s0, x_register::a0));
|
|
}
|
|
|
|
void visitor::visit(source::if_statement *statement)
|
|
{
|
|
const auto free_register = this->register_in_use ? x_register::a0 : x_register::t0;
|
|
|
|
statement->prerequisite().accept(this);
|
|
|
|
auto before_branch = instructions.size();
|
|
instructions.push_back(instruction(base_opcode::branch));
|
|
statement->body().accept(this);
|
|
instructions[before_branch]
|
|
.b((instructions.size() - before_branch) * 4 - 3, funct3_t::beq, x_register::zero, free_register);
|
|
}
|
|
|
|
void visitor::visit(source::while_statement *statement)
|
|
{
|
|
statement->prerequisite().accept(this);
|
|
statement->body().accept(this);
|
|
}
|
|
|
|
void visitor::visit(source::variable_expression *variable)
|
|
{
|
|
const auto free_register = this->register_in_use ? x_register::a0 : x_register::t0;
|
|
|
|
auto symbol = table->lookup(variable->name());
|
|
if (auto constant_symbol = std::dynamic_pointer_cast<source::constant_info>(symbol))
|
|
{
|
|
this->instructions.push_back(
|
|
instruction(base_opcode::opImm) // movl $x, %eax; where $x is a number.
|
|
.i(free_register, funct3_t::addi, x_register::zero, constant_symbol->value())
|
|
);
|
|
}
|
|
else if (auto variable_symbol = std::dynamic_pointer_cast<source::variable_info>(symbol))
|
|
{
|
|
this->instructions.push_back(
|
|
instruction(base_opcode::store)
|
|
.i(free_register, funct3_t::lw, x_register::s0, variable_symbol->offset)
|
|
);
|
|
}
|
|
}
|
|
|
|
void visitor::visit(source::binary_expression *expression)
|
|
{
|
|
const auto lhs_register = this->register_in_use ? x_register::a0 : x_register::t0;
|
|
|
|
this->register_in_use = true;
|
|
expression->lhs().accept(this);
|
|
|
|
this->instructions.push_back( // movl %eax, -x(%rbp); where x is a number.
|
|
instruction(base_opcode::store)
|
|
.s(static_cast<std::uint32_t>(this->variable_counter * 4), funct3_t::sw, x_register::sp, x_register::a0)
|
|
);
|
|
auto lhs_stack_position = ++this->variable_counter;
|
|
|
|
this->register_in_use = false;
|
|
expression->rhs().accept(this);
|
|
|
|
this->instructions.push_back(instruction(base_opcode::load)
|
|
.i(x_register::a0, funct3_t::lw, x_register::sp,
|
|
static_cast<std::int8_t>((lhs_stack_position - 1) * 4))
|
|
);
|
|
|
|
// Calculate the result and assign it to a variable on the stack.
|
|
switch (expression->operation())
|
|
{
|
|
case source::binary_operator::sum:
|
|
this->instructions.push_back(instruction(base_opcode::op)
|
|
.r(lhs_register, funct3_t::add, x_register::a0, x_register::t0));
|
|
break;
|
|
case source::binary_operator::subtraction:
|
|
this->instructions.push_back(instruction(base_opcode::op)
|
|
.r(lhs_register, funct3_t::sub, x_register::a0, x_register::t0, funct7_t::sub));
|
|
break;
|
|
case source::binary_operator::multiplication:
|
|
this->instructions.push_back(instruction(base_opcode::op)
|
|
.r(lhs_register, funct3_t::mul, x_register::a0, x_register::t0, funct7_t::muldiv));
|
|
break;
|
|
case source::binary_operator::division:
|
|
this->instructions.push_back(instruction(base_opcode::op)
|
|
.r(lhs_register, funct3_t::div, x_register::a0, x_register::t0, funct7_t::muldiv));
|
|
break;
|
|
}
|
|
}
|
|
|
|
void visitor::visit(source::integer_literal *number)
|
|
{
|
|
const auto free_register = this->register_in_use ? x_register::a0 : x_register::t0;
|
|
|
|
this->instructions.push_back(
|
|
instruction(base_opcode::opImm) // movl $x, %eax; where $x is a number.
|
|
.i(free_register, funct3_t::addi, x_register::zero, number->number())
|
|
);
|
|
}
|
|
|
|
void visitor::visit(source::boolean_literal *number)
|
|
{
|
|
const auto free_register = this->register_in_use ? x_register::a0 : x_register::t0;
|
|
|
|
this->instructions.push_back(
|
|
instruction(base_opcode::opImm) // movl $x, %eax; where $x is a number.
|
|
.i(free_register, funct3_t::addi, x_register::zero, number->boolean())
|
|
);
|
|
}
|
|
}
|