Generate code for loops
This commit is contained in:
@ -1,5 +1,6 @@
|
||||
#include "elna/backend/riscv.hpp"
|
||||
#include <cassert>
|
||||
#include <functional>
|
||||
#include <memory>
|
||||
|
||||
namespace elna::riscv
|
||||
@ -77,366 +78,378 @@ namespace elna::riscv
|
||||
return reinterpret_cast<const std::byte *>(&this->representation) + sizeof(this->representation);
|
||||
}
|
||||
|
||||
visitor::visitor(std::shared_ptr<source::writer> writer,
|
||||
std::shared_ptr<source::symbol_table> table)
|
||||
: writer(writer), table(table)
|
||||
static void relocate(std::string_view name, address_t target, std::vector<reference>& references,
|
||||
std::vector<instruction>& instructions, std::shared_ptr<source::writer<std::byte>> writer)
|
||||
{
|
||||
references.push_back(reference());
|
||||
references.back().name = name;
|
||||
references.back().offset = writer->size() + instructions.size() * 4;
|
||||
references.back().target = target;
|
||||
}
|
||||
|
||||
void visitor::generate_intrinsics()
|
||||
static void prologue(std::vector<instruction>& instructions)
|
||||
{
|
||||
this->writer->sink("printf");
|
||||
{
|
||||
auto format_string = this->writer->sink(reinterpret_cast<const std::byte *>("%c\n\0"), 4);
|
||||
|
||||
prologue();
|
||||
this->instructions.push_back(instruction(base_opcode::opImm)
|
||||
.i(x_register::a1, funct3_t::addi, x_register::zero, 't'));
|
||||
this->instructions.push_back(instruction(base_opcode::branch)
|
||||
.b(8, funct3_t::bne, x_register::zero, x_register::a0));
|
||||
this->instructions.push_back(instruction(base_opcode::opImm)
|
||||
.i(x_register::a1, funct3_t::addi, x_register::zero, 'f'));
|
||||
|
||||
relocate(format_string, address_t::high20);
|
||||
this->instructions.push_back(instruction(base_opcode::lui).u(x_register::a5, 0));
|
||||
relocate(format_string, address_t::lower12i);
|
||||
this->instructions.push_back(instruction(base_opcode::opImm)
|
||||
.i(x_register::a0, funct3_t::addi, x_register::a5, 0));
|
||||
|
||||
relocate("printf", 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));
|
||||
|
||||
epilogue(8);
|
||||
|
||||
this->writer->sink("writeb", reinterpret_cast<const std::byte *>(this->instructions.data()),
|
||||
this->instructions.size() * sizeof(instruction));
|
||||
this->instructions.clear();
|
||||
}
|
||||
{
|
||||
auto format_string = this->writer->sink(reinterpret_cast<const std::byte *>("%d\n\0"), 4);
|
||||
|
||||
prologue();
|
||||
this->instructions.push_back(instruction(base_opcode::opImm)
|
||||
.i(x_register::a1, funct3_t::addi, x_register::a0, 0));
|
||||
|
||||
relocate(format_string, address_t::high20);
|
||||
this->instructions.push_back(instruction(base_opcode::lui).u(x_register::a5, 0));
|
||||
relocate(format_string, address_t::lower12i);
|
||||
this->instructions.push_back(instruction(base_opcode::opImm)
|
||||
.i(x_register::a0, funct3_t::addi, x_register::a5, 0));
|
||||
|
||||
relocate("printf", 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));
|
||||
|
||||
epilogue(8);
|
||||
|
||||
this->writer->sink("writei", reinterpret_cast<const std::byte *>(this->instructions.data()),
|
||||
this->instructions.size() * sizeof(instruction));
|
||||
this->instructions.clear();
|
||||
}
|
||||
}
|
||||
|
||||
void visitor::relocate(std::string_view name, address_t target)
|
||||
{
|
||||
this->references.push_back(reference());
|
||||
this->references.back().name = name;
|
||||
this->references.back().offset = writer->size() + instructions.size() * 4;
|
||||
this->references.back().target = target;
|
||||
}
|
||||
|
||||
void visitor::visit(source::declaration *declaration)
|
||||
{
|
||||
}
|
||||
|
||||
void visitor::visit(source::constant_definition *definition)
|
||||
{
|
||||
}
|
||||
|
||||
void visitor::prologue()
|
||||
{
|
||||
this->variable_counter = 1;
|
||||
|
||||
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));
|
||||
instructions.push_back(instruction(base_opcode::opImm));
|
||||
instructions.push_back(instruction(base_opcode::store));
|
||||
instructions.push_back(instruction(base_opcode::store));
|
||||
instructions.push_back(instruction(base_opcode::opImm));
|
||||
}
|
||||
|
||||
void visitor::epilogue(const std::size_t stack_size)
|
||||
static void epilogue(const std::size_t stack_size, std::vector<instruction>& instructions)
|
||||
{
|
||||
this->instructions[0].i(x_register::sp, funct3_t::addi, x_register::sp, -stack_size);
|
||||
this->instructions[1].s(0, funct3_t::sw, x_register::sp, x_register::s0);
|
||||
this->instructions[2].s(4, funct3_t::sw, x_register::sp, x_register::ra);
|
||||
this->instructions[3].i(x_register::s0, funct3_t::addi, x_register::sp, stack_size);
|
||||
instructions[0].i(x_register::sp, funct3_t::addi, x_register::sp, -stack_size);
|
||||
instructions[1].s(0, funct3_t::sw, x_register::sp, x_register::s0);
|
||||
instructions[2].s(4, funct3_t::sw, x_register::sp, x_register::ra);
|
||||
instructions[3].i(x_register::s0, funct3_t::addi, x_register::sp, stack_size);
|
||||
|
||||
// Epilogue.
|
||||
this->instructions.push_back(instruction(base_opcode::load)
|
||||
instructions.push_back(instruction(base_opcode::load)
|
||||
.i(x_register::s0, funct3_t::lw, x_register::sp, 0));
|
||||
this->instructions.push_back(instruction(base_opcode::load)
|
||||
instructions.push_back(instruction(base_opcode::load)
|
||||
.i(x_register::ra, funct3_t::lw, x_register::sp, 4));
|
||||
this->instructions.push_back(instruction(base_opcode::opImm)
|
||||
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)
|
||||
instructions.push_back(instruction(base_opcode::jalr)
|
||||
.i(x_register::zero, funct3_t::jalr, x_register::ra, 0));
|
||||
}
|
||||
|
||||
void visitor::visit(source::procedure_definition *definition)
|
||||
static void generate_intrinsics(std::shared_ptr<source::writer<std::byte>> writer,
|
||||
std::vector<reference>& references)
|
||||
{
|
||||
prologue();
|
||||
|
||||
auto main_symbol =
|
||||
std::dynamic_pointer_cast<source::procedure_info>(this->table->lookup(definition->identifier()));
|
||||
this->table = main_symbol->scope();
|
||||
definition->body().accept(this);
|
||||
this->table = main_symbol->scope()->scope();
|
||||
|
||||
// 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));
|
||||
|
||||
epilogue(static_cast<std::uint32_t>(this->variable_counter * 4 + 8 + main_symbol->stack_size()));
|
||||
this->writer->sink(definition->identifier(),
|
||||
reinterpret_cast<const std::byte *>(this->instructions.data()),
|
||||
this->instructions.size() * sizeof(instruction));
|
||||
this->instructions.clear();
|
||||
}
|
||||
|
||||
void visitor::visit(source::block *block)
|
||||
{
|
||||
block->body().accept(this);
|
||||
}
|
||||
|
||||
void visitor::visit(source::program *program)
|
||||
{
|
||||
generate_intrinsics();
|
||||
for (auto& definition : program->definitions())
|
||||
writer->sink("printf");
|
||||
{
|
||||
definition->accept(this);
|
||||
std::vector<instruction> instructions;
|
||||
auto format_string = writer->sink(reinterpret_cast<const std::byte *>("%c\n\0"), 4);
|
||||
|
||||
prologue(instructions);
|
||||
instructions.push_back(instruction(base_opcode::opImm)
|
||||
.i(x_register::a1, funct3_t::addi, x_register::zero, 't'));
|
||||
instructions.push_back(instruction(base_opcode::branch)
|
||||
.b(8, funct3_t::bne, x_register::zero, x_register::a0));
|
||||
instructions.push_back(instruction(base_opcode::opImm)
|
||||
.i(x_register::a1, funct3_t::addi, x_register::zero, 'f'));
|
||||
|
||||
relocate(format_string, address_t::high20, references, instructions, writer);
|
||||
instructions.push_back(instruction(base_opcode::lui).u(x_register::a5, 0));
|
||||
relocate(format_string, address_t::lower12i, references, instructions, writer);
|
||||
instructions.push_back(instruction(base_opcode::opImm)
|
||||
.i(x_register::a0, funct3_t::addi, x_register::a5, 0));
|
||||
|
||||
relocate("printf", address_t::text, references, instructions ,writer);
|
||||
instructions.push_back(instruction(base_opcode::auipc).u(x_register::ra, 0));
|
||||
instructions.push_back(instruction(base_opcode::jalr)
|
||||
.i(x_register::ra, funct3_t::jalr, x_register::ra, 0));
|
||||
|
||||
epilogue(8, instructions);
|
||||
|
||||
writer->sink("writeb", reinterpret_cast<const std::byte *>(instructions.data()),
|
||||
instructions.size() * sizeof(instruction));
|
||||
}
|
||||
prologue();
|
||||
|
||||
auto main_symbol =
|
||||
std::dynamic_pointer_cast<source::procedure_info>(this->table->lookup("main"));
|
||||
program->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));
|
||||
|
||||
epilogue(static_cast<std::uint32_t>(this->variable_counter * 4 + 8 + main_symbol->local_stack_size));
|
||||
this->writer->sink("main", reinterpret_cast<const std::byte *>(this->instructions.data()),
|
||||
this->instructions.size() * sizeof(instruction));
|
||||
}
|
||||
|
||||
void visitor::visit(source::call_statement *statement)
|
||||
{
|
||||
std::size_t argument_offset{ 0 };
|
||||
|
||||
for (auto& argument : statement->arguments())
|
||||
{
|
||||
argument->accept(this);
|
||||
const auto free_register = this->register_in_use ? x_register::a0 : x_register::t0;
|
||||
this->instructions.push_back(instruction(base_opcode::store)
|
||||
.s(argument_offset, funct3_t::sw, x_register::sp, free_register));
|
||||
argument_offset += 4;
|
||||
}
|
||||
relocate(statement->name(), 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));
|
||||
}
|
||||
std::vector<instruction> instructions;
|
||||
auto format_string = writer->sink(reinterpret_cast<const std::byte *>("%d\n\0"), 4);
|
||||
|
||||
void visitor::visit(source::compound_statement *statement)
|
||||
{
|
||||
for (auto& nested_statement : statement->statements())
|
||||
{
|
||||
nested_statement->accept(this);
|
||||
prologue(instructions);
|
||||
instructions.push_back(instruction(base_opcode::opImm)
|
||||
.i(x_register::a1, funct3_t::addi, x_register::a0, 0));
|
||||
|
||||
relocate(format_string, address_t::high20, references, instructions, writer);
|
||||
instructions.push_back(instruction(base_opcode::lui).u(x_register::a5, 0));
|
||||
relocate(format_string, address_t::lower12i, references, instructions, writer);
|
||||
instructions.push_back(instruction(base_opcode::opImm)
|
||||
.i(x_register::a0, funct3_t::addi, x_register::a5, 0));
|
||||
|
||||
relocate("printf", address_t::text, references, instructions, writer);
|
||||
instructions.push_back(instruction(base_opcode::auipc).u(x_register::ra, 0));
|
||||
instructions.push_back(instruction(base_opcode::jalr)
|
||||
.i(x_register::ra, funct3_t::jalr, x_register::ra, 0));
|
||||
|
||||
epilogue(8, instructions);
|
||||
|
||||
writer->sink("writei", reinterpret_cast<const std::byte *>(instructions.data()),
|
||||
instructions.size() * sizeof(instruction));
|
||||
}
|
||||
}
|
||||
|
||||
void visitor::visit(source::assign_statement *statement)
|
||||
static void load_in_register(std::shared_ptr<source::operand> operand, const x_register target,
|
||||
std::shared_ptr<source::procedure_info> procedure_info, std::vector<instruction>& instructions)
|
||||
{
|
||||
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);
|
||||
std::shared_ptr<source::integer_operand> integer_operand{ nullptr };
|
||||
std::shared_ptr<source::variable_operand> variable_operand{ nullptr };
|
||||
std::shared_ptr<source::temporary_variable> temporary_variable{ nullptr };
|
||||
std::shared_ptr<source::variable_info> variable_symbol{ nullptr };
|
||||
std::shared_ptr<source::parameter_info> parameter_symbol{ nullptr };
|
||||
|
||||
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)
|
||||
{
|
||||
statement->prerequisite().accept(this);
|
||||
|
||||
const auto free_register = this->register_in_use ? x_register::a0 : x_register::t0;
|
||||
|
||||
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, 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::type_expression *type)
|
||||
{
|
||||
}
|
||||
|
||||
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))
|
||||
if ((integer_operand = std::dynamic_pointer_cast<source::integer_operand>(operand)) != nullptr)
|
||||
{
|
||||
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())
|
||||
);
|
||||
instructions.push_back(instruction(base_opcode::opImm)
|
||||
.i(target, funct3_t::addi, x_register::zero, integer_operand->value()));
|
||||
}
|
||||
else if (auto variable_symbol = std::dynamic_pointer_cast<source::variable_info>(symbol))
|
||||
else if ((variable_operand = std::dynamic_pointer_cast<source::variable_operand>(operand)) != nullptr)
|
||||
{
|
||||
this->instructions.push_back(
|
||||
instruction(base_opcode::load)
|
||||
.i(free_register, funct3_t::lw, x_register::s0, variable_symbol->offset)
|
||||
);
|
||||
const auto& name = procedure_info->scope()->lookup(variable_operand->name());
|
||||
if ((variable_symbol = std::dynamic_pointer_cast<source::variable_info>(name)) != nullptr)
|
||||
{
|
||||
instructions.push_back(instruction(base_opcode::load)
|
||||
.i(target, funct3_t::lw, x_register::s0, variable_symbol->offset));
|
||||
}
|
||||
else if ((parameter_symbol = std::dynamic_pointer_cast<source::parameter_info>(name)) != nullptr)
|
||||
{
|
||||
instructions.push_back(instruction(base_opcode::load)
|
||||
.i(target, funct3_t::lw, x_register::s0, parameter_symbol->offset));
|
||||
}
|
||||
}
|
||||
else if (auto parameter_symbol = std::dynamic_pointer_cast<source::parameter_info>(symbol))
|
||||
else if ((temporary_variable = std::dynamic_pointer_cast<source::temporary_variable>(operand)) != nullptr)
|
||||
{
|
||||
this->instructions.push_back(
|
||||
instruction(base_opcode::load)
|
||||
.i(free_register, funct3_t::lw, x_register::s0, parameter_symbol->offset)
|
||||
);
|
||||
instructions.push_back(instruction(base_opcode::load));
|
||||
instructions.back().i(target, funct3_t::lw, x_register::s0,
|
||||
procedure_info->local_stack_size + 4 * temporary_variable->counter());
|
||||
}
|
||||
}
|
||||
|
||||
void visitor::visit(source::binary_expression *expression)
|
||||
static void store_from_register(std::shared_ptr<source::operand> destination, const x_register target,
|
||||
std::shared_ptr<source::procedure_info> procedure_info, std::vector<instruction>& instructions)
|
||||
{
|
||||
const auto lhs_register = this->register_in_use ? x_register::a0 : x_register::t0;
|
||||
std::shared_ptr<source::variable_operand> variable_operand{ nullptr };
|
||||
std::shared_ptr<source::temporary_variable> temporary_variable{ nullptr };
|
||||
std::shared_ptr<source::variable_info> variable_symbol{ nullptr };
|
||||
|
||||
this->register_in_use = true;
|
||||
expression->lhs().accept(this);
|
||||
auto lhs_stack_position = this->variable_counter * 4;
|
||||
++this->variable_counter;
|
||||
if ((variable_operand = std::dynamic_pointer_cast<source::variable_operand>(destination)) != nullptr)
|
||||
{
|
||||
variable_symbol = std::dynamic_pointer_cast<source::variable_info>(
|
||||
procedure_info->scope()->lookup(variable_operand->name()));
|
||||
instructions.push_back(instruction(base_opcode::store)
|
||||
.s(variable_symbol->offset, funct3_t::sw, x_register::s0, target));
|
||||
}
|
||||
else if ((temporary_variable = std::dynamic_pointer_cast<source::temporary_variable>(destination)) != nullptr)
|
||||
{
|
||||
instructions.push_back(instruction(base_opcode::store));
|
||||
instructions.back().s(procedure_info->local_stack_size + 4 * temporary_variable->counter(),
|
||||
funct3_t::sw, x_register::s0, target);
|
||||
}
|
||||
}
|
||||
|
||||
this->instructions.push_back(
|
||||
instruction(base_opcode::store)
|
||||
.s(static_cast<std::uint32_t>(lhs_stack_position), funct3_t::sw, x_register::sp, x_register::a0)
|
||||
);
|
||||
static void perform_binary_operation(const source::binary_operator operation, std::shared_ptr<source::operand> lhs,
|
||||
std::shared_ptr<source::operand> rhs, std::shared_ptr<source::operand> destination,
|
||||
std::shared_ptr<source::procedure_info> procedure_info, std::vector<instruction>& instructions)
|
||||
{
|
||||
constexpr auto lhs_register = x_register::a0;
|
||||
std::shared_ptr<source::variable_operand> variable_operand{ nullptr };
|
||||
std::shared_ptr<source::temporary_variable> temporary_variable{ nullptr };
|
||||
std::shared_ptr<source::variable_info> variable_symbol{ nullptr };
|
||||
|
||||
this->register_in_use = false;
|
||||
expression->rhs().accept(this);
|
||||
this->register_in_use = lhs_register == x_register::a0; // Restore.
|
||||
|
||||
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))
|
||||
);
|
||||
load_in_register(lhs, x_register::a0, procedure_info, instructions);
|
||||
load_in_register(rhs, x_register::t0, procedure_info, instructions);
|
||||
|
||||
// Calculate the result and assign it to a variable on the stack.
|
||||
switch (expression->operation())
|
||||
switch (operation)
|
||||
{
|
||||
case source::binary_operator::sum:
|
||||
this->instructions.push_back(instruction(base_opcode::op)
|
||||
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)
|
||||
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)
|
||||
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)
|
||||
instructions.push_back(instruction(base_opcode::op)
|
||||
.r(lhs_register, funct3_t::div, x_register::a0, x_register::t0, funct7_t::muldiv));
|
||||
break;
|
||||
case source::binary_operator::equals:
|
||||
this->instructions.push_back(instruction(base_opcode::op)
|
||||
instructions.push_back(instruction(base_opcode::op)
|
||||
.r(lhs_register, funct3_t::sub, x_register::a0, x_register::t0, funct7_t::sub));
|
||||
this->instructions.push_back(instruction(base_opcode::opImm)
|
||||
instructions.push_back(instruction(base_opcode::opImm)
|
||||
.i(lhs_register, funct3_t::sltiu, lhs_register, 1));
|
||||
break;
|
||||
case source::binary_operator::not_equals:
|
||||
this->instructions.push_back(instruction(base_opcode::op)
|
||||
instructions.push_back(instruction(base_opcode::op)
|
||||
.r(lhs_register, funct3_t::sub, x_register::a0, x_register::t0, funct7_t::sub));
|
||||
this->instructions.push_back(instruction(base_opcode::op)
|
||||
instructions.push_back(instruction(base_opcode::op)
|
||||
.r(lhs_register, funct3_t::sltu, x_register::zero, lhs_register));
|
||||
break;
|
||||
case source::binary_operator::less:
|
||||
this->instructions.push_back(instruction(base_opcode::op)
|
||||
instructions.push_back(instruction(base_opcode::op)
|
||||
.r(lhs_register, funct3_t::sltu, x_register::a0, x_register::t0));
|
||||
break;
|
||||
case source::binary_operator::greater_equal:
|
||||
this->instructions.push_back(instruction(base_opcode::op)
|
||||
instructions.push_back(instruction(base_opcode::op)
|
||||
.r(lhs_register, funct3_t::sltu, x_register::t0, x_register::a0));
|
||||
break;
|
||||
case source::binary_operator::greater:
|
||||
this->instructions.push_back(instruction(base_opcode::op)
|
||||
instructions.push_back(instruction(base_opcode::op)
|
||||
.r(lhs_register, funct3_t::slt, x_register::a0, x_register::t0));
|
||||
this->instructions.push_back(instruction(base_opcode::opImm)
|
||||
instructions.push_back(instruction(base_opcode::opImm)
|
||||
.i(lhs_register, funct3_t::xori, lhs_register, 1));
|
||||
break;
|
||||
case source::binary_operator::less_equal:
|
||||
this->instructions.push_back(instruction(base_opcode::op)
|
||||
instructions.push_back(instruction(base_opcode::op)
|
||||
.r(lhs_register, funct3_t::slt, x_register::t0, x_register::a0));
|
||||
this->instructions.push_back(instruction(base_opcode::opImm)
|
||||
instructions.push_back(instruction(base_opcode::opImm)
|
||||
.i(lhs_register, funct3_t::xori, lhs_register, 1));
|
||||
break;
|
||||
}
|
||||
store_from_register(destination, lhs_register, procedure_info, instructions);
|
||||
}
|
||||
|
||||
void visitor::visit(source::unary_expression *expression)
|
||||
std::vector<reference> generate(source::intermediate_code_generator generator,
|
||||
std::shared_ptr<source::symbol_table> table, std::shared_ptr<source::writer<std::byte>> writer)
|
||||
{
|
||||
switch (expression->operation())
|
||||
std::vector<reference> references;
|
||||
|
||||
generate_intrinsics(writer, references);
|
||||
|
||||
for (auto& [identifier, intermediate_code] : generator)
|
||||
{
|
||||
case source::unary_operator::dereference:
|
||||
expression->operand().accept(this);
|
||||
std::vector<instruction> instructions;
|
||||
auto main_symbol = std::dynamic_pointer_cast<source::procedure_info>(table->lookup(identifier));
|
||||
std::size_t argument_offset{ 0 };
|
||||
const auto stack_size = static_cast<std::uint32_t>(
|
||||
intermediate_code.variable_counter() * 4 + 8 + main_symbol->stack_size());
|
||||
std::unordered_map<std::size_t, std::function<void(std::size_t)>> missing_labels;
|
||||
std::unordered_map<std::size_t, std::function<void(std::size_t)>>::iterator missing_label =
|
||||
missing_labels.end();
|
||||
std::unordered_map<std::size_t, std::size_t> local_labels;
|
||||
|
||||
this->instructions.push_back(instruction(base_opcode::load)
|
||||
.i(x_register::a0, funct3_t::lw, x_register::a0, 0));
|
||||
break;
|
||||
case source::unary_operator::reference:
|
||||
const auto free_register = this->register_in_use ? x_register::a0 : x_register::t0;
|
||||
auto operand_identifier = dynamic_cast<source::variable_expression&>(expression->operand()).name();
|
||||
auto variable_symbol =
|
||||
std::dynamic_pointer_cast<source::variable_info>(this->table->lookup(operand_identifier));
|
||||
for (auto& quadruple : intermediate_code)
|
||||
{
|
||||
switch (quadruple.operation())
|
||||
{
|
||||
case source::quadruple_operator::start:
|
||||
prologue(instructions);
|
||||
break;
|
||||
case source::quadruple_operator::stop:
|
||||
epilogue(stack_size, instructions);
|
||||
break;
|
||||
case source::quadruple_operator::add:
|
||||
perform_binary_operation(source::binary_operator::sum, quadruple.operand1(),
|
||||
quadruple.operand2(), quadruple.operand3(), main_symbol, instructions);
|
||||
break;
|
||||
case source::quadruple_operator::sub:
|
||||
perform_binary_operation(source::binary_operator::subtraction, quadruple.operand1(),
|
||||
quadruple.operand2(), quadruple.operand3(), main_symbol, instructions);
|
||||
break;
|
||||
case source::quadruple_operator::mul:
|
||||
perform_binary_operation(source::binary_operator::multiplication, quadruple.operand1(),
|
||||
quadruple.operand2(), quadruple.operand3(), main_symbol, instructions);
|
||||
break;
|
||||
case source::quadruple_operator::div:
|
||||
perform_binary_operation(source::binary_operator::division, quadruple.operand1(),
|
||||
quadruple.operand2(), quadruple.operand3(), main_symbol, instructions);
|
||||
break;
|
||||
case source::quadruple_operator::eq:
|
||||
perform_binary_operation(source::binary_operator::equals, quadruple.operand1(),
|
||||
quadruple.operand2(), quadruple.operand3(), main_symbol, instructions);
|
||||
break;
|
||||
case source::quadruple_operator::neq:
|
||||
perform_binary_operation(source::binary_operator::not_equals, quadruple.operand1(),
|
||||
quadruple.operand2(), quadruple.operand3(), main_symbol, instructions);
|
||||
break;
|
||||
case source::quadruple_operator::lt:
|
||||
perform_binary_operation(source::binary_operator::less, quadruple.operand1(),
|
||||
quadruple.operand2(), quadruple.operand3(), main_symbol, instructions);
|
||||
break;
|
||||
case source::quadruple_operator::ge:
|
||||
perform_binary_operation(source::binary_operator::greater_equal, quadruple.operand1(),
|
||||
quadruple.operand2(), quadruple.operand3(), main_symbol, instructions);
|
||||
break;
|
||||
case source::quadruple_operator::gt:
|
||||
perform_binary_operation(source::binary_operator::greater, quadruple.operand1(),
|
||||
quadruple.operand2(), quadruple.operand3(), main_symbol, instructions);
|
||||
break;
|
||||
case source::quadruple_operator::le:
|
||||
perform_binary_operation(source::binary_operator::less_equal, quadruple.operand1(),
|
||||
quadruple.operand2(), quadruple.operand3(), main_symbol, instructions);
|
||||
break;
|
||||
case source::quadruple_operator::load:
|
||||
{
|
||||
auto operand_identifier =
|
||||
std::dynamic_pointer_cast<source::variable_operand>(quadruple.operand1())->name();
|
||||
auto variable_symbol = std::dynamic_pointer_cast<source::variable_info>(
|
||||
main_symbol->scope()->lookup(operand_identifier));
|
||||
|
||||
this->instructions.push_back(instruction(base_opcode::opImm)
|
||||
.i(free_register, funct3_t::addi, x_register::s0, variable_symbol->offset));
|
||||
break;
|
||||
load_in_register(quadruple.operand1(), x_register::a0, main_symbol, instructions);
|
||||
instructions.push_back(instruction(base_opcode::load)
|
||||
.i(x_register::a0, funct3_t::lw, x_register::a0, 0));
|
||||
store_from_register(quadruple.operand3(), x_register::a0, main_symbol, instructions);
|
||||
}
|
||||
break;
|
||||
case source::quadruple_operator::ref:
|
||||
{
|
||||
auto operand_identifier =
|
||||
std::dynamic_pointer_cast<source::variable_operand>(quadruple.operand1())->name();
|
||||
auto variable_symbol = std::dynamic_pointer_cast<source::variable_info>(
|
||||
main_symbol->scope()->lookup(operand_identifier));
|
||||
|
||||
instructions.push_back(instruction(base_opcode::opImm)
|
||||
.i(x_register::a0, funct3_t::addi, x_register::s0, variable_symbol->offset));
|
||||
store_from_register(quadruple.operand3(), x_register::a0, main_symbol, instructions);
|
||||
}
|
||||
break;
|
||||
case source::quadruple_operator::beqz:
|
||||
load_in_register(quadruple.operand1(), x_register::a0, main_symbol, instructions);
|
||||
instructions.push_back(instruction(base_opcode::branch));
|
||||
missing_labels.emplace(
|
||||
std::dynamic_pointer_cast<source::label_operand>(quadruple.operand3())->counter(),
|
||||
[before_branch = instructions.size() - 1, &instructions](std::size_t target) {
|
||||
instructions[before_branch].b((target - before_branch) * 4,
|
||||
funct3_t::beq, x_register::zero, x_register::a0);
|
||||
});
|
||||
break;
|
||||
case source::quadruple_operator::j:
|
||||
{
|
||||
auto local_label = local_labels.find(
|
||||
std::dynamic_pointer_cast<source::label_operand>(quadruple.operand3())->counter());
|
||||
if (local_label != local_labels.end())
|
||||
{
|
||||
auto offset = -(instructions.size() - local_label->second) * 4;
|
||||
instructions.push_back(instruction(base_opcode::auipc).u(x_register::a0, 0));
|
||||
instructions.push_back(instruction(base_opcode::jalr)
|
||||
.i(x_register::zero, funct3_t::jalr, x_register::a0, offset));
|
||||
}
|
||||
}
|
||||
break;
|
||||
case source::quadruple_operator::label:
|
||||
{
|
||||
auto label_counter =
|
||||
std::dynamic_pointer_cast<source::label_operand>(quadruple.operand3())->counter();
|
||||
missing_label = missing_labels.find(label_counter);
|
||||
|
||||
if (missing_label != missing_labels.end())
|
||||
{
|
||||
missing_label->second(instructions.size());
|
||||
}
|
||||
local_labels[label_counter] = instructions.size();
|
||||
}
|
||||
break;
|
||||
case source::quadruple_operator::assign:
|
||||
load_in_register(quadruple.operand1(), x_register::a0, main_symbol, instructions);
|
||||
store_from_register(quadruple.operand3(), x_register::a0, main_symbol, instructions);
|
||||
break;
|
||||
case source::quadruple_operator::param:
|
||||
load_in_register(quadruple.operand1(), x_register::a0, main_symbol, instructions);
|
||||
instructions.push_back(instruction(base_opcode::store)
|
||||
.s(argument_offset, funct3_t::sw, x_register::sp, x_register::a0));
|
||||
argument_offset += 4;
|
||||
break;
|
||||
case source::quadruple_operator::call:
|
||||
relocate(std::dynamic_pointer_cast<source::variable_operand>(quadruple.operand1())->name(),
|
||||
address_t::text, references, instructions, writer);
|
||||
instructions.push_back(instruction(base_opcode::auipc).u(x_register::ra, 0));
|
||||
instructions.push_back(instruction(base_opcode::jalr)
|
||||
.i(x_register::ra, funct3_t::jalr, x_register::ra, 0));
|
||||
argument_offset = 0;
|
||||
break;
|
||||
}
|
||||
}
|
||||
writer->sink(identifier,
|
||||
reinterpret_cast<const std::byte *>(instructions.data()),
|
||||
instructions.size() * sizeof(instruction));
|
||||
}
|
||||
}
|
||||
|
||||
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())
|
||||
);
|
||||
return references;
|
||||
}
|
||||
}
|
||||
|
@ -146,8 +146,8 @@ namespace elna::riscv
|
||||
return -1;
|
||||
}
|
||||
|
||||
void riscv32_elf(source::program *ast, std::shared_ptr<source::symbol_table> table,
|
||||
const std::filesystem::path& out_file)
|
||||
void riscv32_elf(source::program *ast, source::intermediate_code_generator intermediate_code_generator,
|
||||
std::shared_ptr<source::symbol_table> table, const std::filesystem::path& out_file)
|
||||
{
|
||||
ELFIO::elfio writer;
|
||||
|
||||
@ -198,12 +198,14 @@ namespace elna::riscv
|
||||
ELFIO::relocation_section_accessor rela(writer, rel_sec);
|
||||
auto _writer = std::make_shared<elfio_writer>(text_sec, ro_sec, syma, stra);
|
||||
|
||||
visitor _visitor{ _writer, table };
|
||||
_visitor.visit(ast);
|
||||
// visitor _visitor{ _writer, table };
|
||||
// _visitor.visit(ast);
|
||||
auto references = generate(intermediate_code_generator, table, _writer);
|
||||
|
||||
syma.arrange_local_symbols();
|
||||
|
||||
for (auto& reference : _visitor.references)
|
||||
for (auto& reference : references)
|
||||
// for (auto& reference : _visitor.references)
|
||||
{
|
||||
ELFIO::Elf_Word relocated_symbol = lookup(syma, reference.name);
|
||||
|
||||
|
Reference in New Issue
Block a user