program_builder.h

Go to the documentation of this file.

 
#pragma once
 
#include <cstdint>
 
#include "contur/core/types.h"
 
#include "contur/arch/block.h"
#include "contur/arch/instruction.h"
#include "contur/arch/interrupt.h"
 
namespace contur {

    [[nodiscard]] inline Block movImm(std::uint8_t reg, RegisterValue value) noexcept
    {
        return Block{Instruction::Mov, reg, value, 0};
    }

    [[nodiscard]] inline Block movReg(std::uint8_t dst, std::uint8_t src) noexcept
    {
        return Block{Instruction::Mov, dst, static_cast<RegisterValue>(src), 1};
    }

    [[nodiscard]] inline Block addImm(std::uint8_t reg, RegisterValue value) noexcept
    {
        return Block{Instruction::Add, reg, value, 0};
    }

    [[nodiscard]] inline Block addReg(std::uint8_t dst, std::uint8_t src) noexcept
    {
        return Block{Instruction::Add, dst, static_cast<RegisterValue>(src), 1};
    }

    [[nodiscard]] inline Block subImm(std::uint8_t reg, RegisterValue value) noexcept
    {
        return Block{Instruction::Sub, reg, value, 0};
    }

    [[nodiscard]] inline Block subReg(std::uint8_t dst, std::uint8_t src) noexcept
    {
        return Block{Instruction::Sub, dst, static_cast<RegisterValue>(src), 1};
    }

    [[nodiscard]] inline Block mulImm(std::uint8_t reg, RegisterValue value) noexcept
    {
        return Block{Instruction::Mul, reg, value, 0};
    }

    [[nodiscard]] inline Block mulReg(std::uint8_t dst, std::uint8_t src) noexcept
    {
        return Block{Instruction::Mul, dst, static_cast<RegisterValue>(src), 1};
    }

    [[nodiscard]] inline Block divImm(std::uint8_t reg, RegisterValue value) noexcept
    {
        return Block{Instruction::Div, reg, value, 0};
    }

    [[nodiscard]] inline Block divReg(std::uint8_t dst, std::uint8_t src) noexcept
    {
        return Block{Instruction::Div, dst, static_cast<RegisterValue>(src), 1};
    }

    [[nodiscard]] inline Block readMem(std::uint8_t reg, MemoryAddress addr) noexcept
    {
        return Block{Instruction::ReadMemory, reg, static_cast<RegisterValue>(addr), 0};
    }

    [[nodiscard]] inline Block writeMem(std::uint8_t reg, MemoryAddress addr) noexcept
    {
        return Block{Instruction::WriteMemory, reg, static_cast<RegisterValue>(addr), 0};
    }

    [[nodiscard]] inline Block compareImm(std::uint8_t reg, RegisterValue value) noexcept
    {
        return Block{Instruction::Compare, reg, value, 0};
    }

    [[nodiscard]] inline Block compareReg(std::uint8_t reg, std::uint8_t other) noexcept
    {
        return Block{Instruction::Compare, reg, static_cast<RegisterValue>(other), 1};
    }

    [[nodiscard]] inline Block jumpEqual(RegisterValue target) noexcept
    {
        return Block{Instruction::JumpEqual, 0, target, 0};
    }

    [[nodiscard]] inline Block jumpNotEqual(RegisterValue target) noexcept
    {
        return Block{Instruction::JumpNotEqual, 0, target, 0};
    }

    [[nodiscard]] inline Block jumpGreater(RegisterValue target) noexcept
    {
        return Block{Instruction::JumpGreater, 0, target, 0};
    }

    [[nodiscard]] inline Block jumpLess(RegisterValue target) noexcept
    {
        return Block{Instruction::JumpLess, 0, target, 0};
    }

    [[nodiscard]] inline Block jumpGreaterEqual(RegisterValue target) noexcept
    {
        return Block{Instruction::JumpGreaterEqual, 0, target, 0};
    }

    [[nodiscard]] inline Block jumpLessEqual(RegisterValue target) noexcept
    {
        return Block{Instruction::JumpLessEqual, 0, target, 0};
    }

    [[nodiscard]] inline Block interrupt(Interrupt code) noexcept
    {
        return Block{Instruction::Interrupt, 0, static_cast<RegisterValue>(code), 0};
    }

    [[nodiscard]] inline Block nop() noexcept
    {
        return Block{Instruction::Nop, 0, 0, 0};
    }

    [[nodiscard]] inline Block halt() noexcept
    {
        return Block{Instruction::Halt, 0, 0, 0};
    }
 
} // namespace contur