diff options
1 files changed, 517 insertions, 0 deletions
| -rw-r--r-- | spasm/src/spasm.cpp | 517 |
diff --git a/spasm/src/spasm.cpp b/spasm/src/spasm.cpp new file mode 100644 index 0000000..94086a6 --- /dev/null +++ b/spasm/src/spasm.cpp @@ -0,0 +1,517 @@ +#include <algorithm> +#include <cassert> +#include <iostream> + +#include "spasm.hpp" + +namespace SpasmImpl +{ +Spasm::Spasm() {} + +/*! +** Constructs new Spasm object +** +** \param _bc_size - size/length of the bytecode +** \param _bytecode - the bytecode of the program +** \param _istr - input stream for the machine +** \param _ostr - output stream for the machine +*/ +void Spasm::Initialize(PC_t _bc_size, + const byte* _bytecode, + std::istream& _istr, + std::ostream& _ostr) + +{ + m_PC = 0; + m_ByteCode.assign(_bytecode, _bytecode + _bc_size); + istr = &_istr; + ostr = &_ostr; + data_stack.resize(1024); + m_SP = &data_stack[0]; + m_FP = &data_stack[0]; +} + +Spasm::~Spasm() {} + +/*! +** Runs the machine. The machine stops if it reaches an invalid opcode +** or opcode 0 or the pc reaches beyond the end of the bytecode. +** @return error code for success or failure +*/ +Spasm::RunResult Spasm::run() +{ + const auto codeSize = m_ByteCode.size(); + while (m_PC < codeSize) + { + const auto instruction = m_ByteCode[m_PC++]; + const auto opcode = OpCodes(instruction & 0x3f); + const auto size = instruction >> 6; + switch (opcode) + { + case OpCodes::Halt: + return RunResult::Success; + case OpCodes::Dup: + dup(); + break; + case OpCodes::Pop: + { + const auto count = PC_t(read_reg(size)); + assert(m_SP - count >= m_FP); + m_SP -= count; + break; + } + case OpCodes::PopTo: + { + const auto arg0 = read_reg(size); + popto(arg0); + break; + } + case OpCodes::PushFrom: + { + const auto arg0 = read_reg(size); + push(arg0); + break; + } + case OpCodes::Push: + { + const auto count = PC_t(read_reg(size)); + assert(m_SP + count <= &data_stack[data_stack.size() - 1]); + std::fill(m_SP, m_SP + count, data_t{}); + m_SP += count; + break; + } + case OpCodes::Print: + { + const auto arg0 = read_reg(size); + print(arg0); + break; + } + case OpCodes::Read: + { + const auto arg0 = read_reg(size); + read(arg0); + break; + } + case OpCodes::Call: + { + const auto arg0 = read_reg(size); + call(arg0); + break; + } + case OpCodes::Ret: + { + const auto arg0 = read_reg(size); + ret(arg0); + break; + } + case OpCodes::Jump: + { + const auto arg0 = read_reg(size); + go(arg0); + break; + } + case OpCodes::JumpT: + { + const auto arg0 = read_reg(size); + const auto arg1 = read_reg(size); + gotrue(arg0, arg1); + break; + } + case OpCodes::JumpF: + { + const auto arg0 = read_reg(size); + const auto arg1 = read_reg(size); + gofalse(arg0, arg1); + break; + } + case OpCodes::Const: + { + const auto reg = read_reg(size); + const auto value = read_number(size); + set_local(reg, value); + break; + } + case OpCodes::String: + { + const auto reg = read_reg(size); + const auto value = read_string(size); + set_local(reg, value); + break; + } + case OpCodes::Add: + { + const auto arg0 = read_reg(size); + const auto arg1 = read_reg(size); + const auto arg2 = read_reg(size); + plus(arg0, arg1, arg2); + break; + } + case OpCodes::Sub: + { + const auto arg0 = read_reg(size); + const auto arg1 = read_reg(size); + const auto arg2 = read_reg(size); + minus(arg0, arg1, arg2); + break; + } + case OpCodes::Mul: + { + const auto arg0 = read_reg(size); + const auto arg1 = read_reg(size); + const auto arg2 = read_reg(size); + multiply(arg0, arg1, arg2); + break; + } + case OpCodes::Div: + { + const auto arg0 = read_reg(size); + const auto arg1 = read_reg(size); + const auto arg2 = read_reg(size); + divide(arg0, arg1, arg2); + break; + } + case OpCodes::Mod: + { + const auto arg0 = read_reg(size); + const auto arg1 = read_reg(size); + const auto arg2 = read_reg(size); + modulus(arg0, arg1, arg2); + break; + } + case OpCodes::Less: + { + const auto arg0 = read_reg(size); + const auto arg1 = read_reg(size); + const auto arg2 = read_reg(size); + less(arg0, arg1, arg2); + break; + } + case OpCodes::LessEq: + { + const auto arg0 = read_reg(size); + const auto arg1 = read_reg(size); + const auto arg2 = read_reg(size); + lesseq(arg0, arg1, arg2); + break; + } + case OpCodes::Greater: + { + const auto arg0 = read_reg(size); + const auto arg1 = read_reg(size); + const auto arg2 = read_reg(size); + greater(arg0, arg1, arg2); + break; + } + case OpCodes::GreaterEq: + { + const auto arg0 = read_reg(size); + const auto arg1 = read_reg(size); + const auto arg2 = read_reg(size); + greatereq(arg0, arg1, arg2); + break; + } + case OpCodes::Equal: + { + const auto arg0 = read_reg(size); + const auto arg1 = read_reg(size); + const auto arg2 = read_reg(size); + equal(arg0, arg1, arg2); + break; + } + case OpCodes::NotEqual: + { + const auto arg0 = read_reg(size); + const auto arg1 = read_reg(size); + const auto arg2 = read_reg(size); + not_equal(arg0, arg1, arg2); + break; + } + default: + { + std::cerr << opcode << ": not implemented" << std::endl; + return RunResult::NotImplemented; + } + } + } + return RunResult::Success; +} + +/*! +** Pushes the next data_t object on the data stack +*/ +void Spasm::push(reg_t reg) +{ + push_data(get_local(reg)); +} + +void Spasm::popto(reg_t reg) +{ + m_FP[reg] = *(--m_SP); +} + +/*! +** Dups the data_t object on top of the data stack. +*/ +void Spasm::dup() +{ + push_data(*(m_SP - 1)); +} + +/*! +** Reads a data_t object from the input stream and pushes it on the data +** stack. +*/ +void Spasm::read(reg_t reg) +{ + data_t x; + *istr >> x; + set_local(reg, x); +} + +/*! +** Pops a data_t object from the data stack and prints it on the output +** stream. +*/ +void Spasm::print(reg_t reg) +{ + *ostr << get_local(reg); +} + +/*! +** Pops two data objects from the data stack and pushes their sum on the +** data stack. +*/ +void Spasm::plus(reg_t a0, reg_t a1, reg_t a2) +{ + set_local(a0, get_local(a1) + get_local(a2)); +} + +/*! +** Pops two data objects from the data stack and pushes their difference +** on the data stack. +*/ +void Spasm::minus(reg_t a0, reg_t a1, reg_t a2) +{ + set_local(a0, get_local(a1) - get_local(a2)); +} + +/*! +** Pops two data objects from the data stack and pushes their product +** on the data stack. +*/ +void Spasm::multiply(reg_t a0, reg_t a1, reg_t a2) +{ + set_local(a0, get_local(a1) * get_local(a2)); +} + +/*! +** Pops two data objects from the data stack and pushes their division +** on the data stack. +*/ +void Spasm::divide(reg_t a0, reg_t a1, reg_t a2) +{ + set_local(a0, get_local(a1) / get_local(a2)); +} + +/*! +** Pops two data objects from the data stack and pushes their modulus +** on the data stack. +*/ +void Spasm::modulus(reg_t a0, reg_t a1, reg_t a2) +{ + set_local(a0, get_local(a1) % get_local(a2)); +} + +/*! +** Conditional execution. +** If the data_t object on top of the data stack evaluates to true +** execution continues from the place pointed by number in the next bytes +*/ +void Spasm::gotrue(reg_t a0, reg_t a1) +{ + if (get_local(a0)) + { + go(a1); + } +} + +/*! +** Conditional execution. +** If the data_t object on top of the data stack evaluates to false +** execution continues from the place pointed by number in the next bytes +*/ +void Spasm::gofalse(reg_t a0, reg_t a1) +{ + if (!get_local(a0)) + { + go(a1); + } +} + +/*! +** Unconditional execution. +** Execution continues from the opcode pointed by the next bytes +*/ +void Spasm::go(reg_t a0) +{ + m_PC = PC_t(a0); +} + +/*! +** Function call. A new frame with the specified size is created, the +** return address is saved in the return stack and the new pc is loaded. +*/ +void Spasm::call(reg_t a0) +{ + Frame call{m_PC, PC_t(m_FP - &data_stack[0]), + m_SP - &data_stack[0] - PC_t((*(m_SP - 1)).get_double()) - 1}; + m_Frames.push(std::move(call)); + m_FP = m_SP - 1; + go(a0); +} + +/*! +** Function return. The frame of the current function is destroyed and the +** saved return address is loaded in the pc +*/ +void Spasm::ret(reg_t reg) +{ + Frame parent = m_Frames.top(); + m_Frames.pop(); + m_SP = &data_stack[parent.StackPointer]; + *(m_SP - 1) = m_FP[reg]; + m_FP = &data_stack[parent.FramePointer]; + m_PC = parent.ReturnAddress; +} + +/*! +** Local variable with index top of the data stack is pushed on top of the +** data stack. +*/ +void Spasm::load() +{ + assert(false && "not-implemented"); +} + +/*! +** Local variable is assigned value +*/ +void Spasm::store() +{ + assert(false && "not-implemented"); +} + +/*! +** Compares the values on top of the stack. Pushes 1 if the value before +** the top of the stack is less than that on top of the stack. +*/ +void Spasm::less(reg_t a0, reg_t a1, reg_t a2) +{ + set_local(a0, get_local(a1) < get_local(a2)); +} + +/*! +** Compares the values on top of the stack. Pushes 1 if the value before +** the top of the stack is less than or equal to that on top of the stack. +*/ +void Spasm::lesseq(reg_t a0, reg_t a1, reg_t a2) +{ + set_local(a0, get_local(a1) <= get_local(a2)); +} + +void Spasm::greater(reg_t a0, reg_t a1, reg_t a2) +{ + set_local(a0, get_local(a1) > get_local(a2)); +} + +void Spasm::greatereq(reg_t a0, reg_t a1, reg_t a2) +{ + set_local(a0, get_local(a1) >= get_local(a2)); +} + +void Spasm::equal(reg_t a0, reg_t a1, reg_t a2) +{ + set_local(a0, get_local(a1) == get_local(a2)); +} + +void Spasm::not_equal(reg_t a0, reg_t a1, reg_t a2) +{ + set_local(a0, get_local(a1) != get_local(a2)); +} + +data_t Spasm::get_local(reg_t reg) +{ + assert(&data_stack[0] <= (m_FP + reg)); + assert((m_FP + reg) < &data_stack[data_stack.size() - 1]); + return m_FP[reg]; +} + +void Spasm::set_local(reg_t reg, data_t data) +{ + assert(&data_stack[0] <= (m_FP + reg)); + assert((m_FP + reg) < &data_stack[data_stack.size() - 1]); + m_FP[reg] = data; +} + +data_t Spasm::pop_data() +{ + auto result = data_stack.back(); + data_stack.pop_back(); + return result; +} + +void Spasm::push_data(data_t data) +{ + assert(m_SP < &data_stack[data_stack.size() - 1]); + *(m_SP++) = data; +} + +reg_t Spasm::read_reg(size_t size) +{ + return read_integer(size); +} + +data_t Spasm::read_number(size_t size) +{ + return data_t(double(read_integer(size))); +} + +int64_t Spasm::read_integer(size_t size) +{ + switch (size) + { + case 0: + return m_ByteCode[m_PC++]; + case 1: + { + auto result = *reinterpret_cast<int16_t*>(&m_ByteCode[0] + m_PC); + m_PC += 2; + return result; + } + case 2: + { + auto result = *reinterpret_cast<int32_t*>(&m_ByteCode[0] + m_PC); + m_PC += 4; + return result; + } + case 3: + { + auto result = *reinterpret_cast<int64_t*>(&m_ByteCode[0] + m_PC); + m_PC += 8; + return result; + } + } + assert(false && "not reached"); + return 0; +} + +data_t Spasm::read_string(size_t size) +{ + const auto length = size_t(read_integer(size)); + const auto s = reinterpret_cast<const char*>(&m_ByteCode[m_PC]); + m_PC += length; + const auto value = m_Strings.Get(s, length); + return data_t(::Spasm::ValueType::String, (void*)value); +} + +} // namespace SpasmImpl |
