From a095428a4cd6a7c34452650bf7916880c2e0d937 Mon Sep 17 00:00:00 2001 From: aceinetx Date: Mon, 21 Apr 2025 16:33:54 +0300 Subject: [PATCH 1/2] Add missing XIP to the switch-case in ModeFromRegister() --- src/Assembler/Core/Compiler.hpp | 499 +++++++++++++++++--------------- 1 file changed, 265 insertions(+), 234 deletions(-) diff --git a/src/Assembler/Core/Compiler.hpp b/src/Assembler/Core/Compiler.hpp index c3aad60a..adacefea 100644 --- a/src/Assembler/Core/Compiler.hpp +++ b/src/Assembler/Core/Compiler.hpp @@ -2,253 +2,284 @@ #include -#include -#include #include -#include +#include +#include #include -#include +#include #include +#include #include #include #include - namespace HCAsm { - enum class ValueType { - operand, - string, - sint, - uint, - }; - - enum class OperandType { - reg, - mem_reg_add_int, - sint, - uint, - memaddr_reg, - memaddr_int, - memaddr_lbl, - label, - str_lit, - none - }; - - enum class Mode : std::uint8_t { - b8 = 0b00, - b16 = 0b01, - b32 = 0b10, - b64 = 0b11, - b64_label, - b8_str, - none - }; - - struct Value; - - struct Operand { - OperandType type; - HyperCPU::Registers reg; - enum Mode mode; - bool needs_resolve; - std::array, hpool::ReallocationPolicy::OffsetRealloc>, 2> tokens; - std::variant> variant; - }; - - struct Instruction { - HyperCPU::Opcode opcode; - Operand op1, op2; - }; - - struct RawValue { - enum Mode mode; - Operand value; // Label resolver requires reference to operand - }; - - struct Value { - std::variant val; - }; - - struct Label { - std::string name; - std::uint64_t index; - bool is_entry_point; - }; - - template - concept UnsignedIntegral = std::is_integral_v && std::is_unsigned_v; - - struct BinaryResult { - BinaryResult() : binary(nullptr), ptr(0), entry_point(0) { } - BinaryResult(unsigned char* ptr) : binary(ptr), ptr(0), entry_point(0) { } - - unsigned char* binary; - std::uint64_t ptr; - std::uint32_t entry_point; - - template - constexpr inline void push(T data) { - std::memcpy(binary + ptr, &data, sizeof(data)); - ptr += sizeof(data); - } - - inline void push(const std::string& data) { - std::memcpy(binary + ptr, data.data(), data.length()); - ptr += data.length(); - } - - ~BinaryResult() { - delete[] binary; - } - }; - - struct PendingLabelReferenceResolve { - std::uint32_t idx; - std::uint8_t op; - }; - - // Some magic for std::visit - template - struct MakeOverload : T... { - using T::operator()...; - }; - - template - MakeOverload(T...) -> MakeOverload; - - template - constexpr inline decltype(auto) VisitVariant(Variant&& variant, Alternatives&&... alternatives) { - return std::visit( - MakeOverload{std::forward(alternatives)..., [](auto const&){}}, - variant - ); +enum class ValueType { + operand, + string, + sint, + uint, +}; + +enum class OperandType { + reg, + mem_reg_add_int, + sint, + uint, + memaddr_reg, + memaddr_int, + memaddr_lbl, + label, + str_lit, + none +}; + +enum class Mode : std::uint8_t { + b8 = 0b00, + b16 = 0b01, + b32 = 0b10, + b64 = 0b11, + b64_label, + b8_str, + none +}; + +struct Value; + +struct Operand { + OperandType type; + HyperCPU::Registers reg; + enum Mode mode; + bool needs_resolve; + std::array, + hpool::ReallocationPolicy::OffsetRealloc>, + 2> + tokens; + std::variant> + variant; +}; + +struct Instruction { + HyperCPU::Opcode opcode; + Operand op1, op2; +}; + +struct RawValue { + enum Mode mode; + Operand value; // Label resolver requires reference to operand +}; + +struct Value { + std::variant + val; +}; + +struct Label { + std::string name; + std::uint64_t index; + bool is_entry_point; +}; + +template +concept UnsignedIntegral = std::is_integral_v && std::is_unsigned_v; + +struct BinaryResult { + BinaryResult() : binary(nullptr), ptr(0), entry_point(0) {} + BinaryResult(unsigned char *ptr) : binary(ptr), ptr(0), entry_point(0) {} + + unsigned char *binary; + std::uint64_t ptr; + std::uint32_t entry_point; + + template constexpr inline void push(T data) { + std::memcpy(binary + ptr, &data, sizeof(data)); + ptr += sizeof(data); } - // Needs improvements and optimizations - struct CompilerState { - CompilerState(hpool::HPool, hpool::ReallocationPolicy::OffsetRealloc>& pool) : pool(pool), code_size(0), entry_point(0) { } - - std::vector pending_resolves; - std::vector> tmp_args; - std::vector> ir; - std::unordered_map labels; - hpool::HPool, hpool::ReallocationPolicy::OffsetRealloc>& pool; - std::uint64_t code_size; - std::uint32_t entry_point; - }; - - constexpr inline Mode ModeFromRegister(HyperCPU::Registers reg) { - using namespace HyperCPU; - switch (reg) { - case Registers::X0: - case Registers::X1: - case Registers::X2: - case Registers::X3: - case Registers::X4: - case Registers::X5: - case Registers::X6: - case Registers::X7: - case Registers::XBP: - case Registers::XSP: - return Mode::b64; - case Registers::XH0: - case Registers::XH1: - case Registers::XH2: - case Registers::XH3: - case Registers::XH4: - case Registers::XH5: - case Registers::XH6: - case Registers::XH7: - case Registers::XL0: - case Registers::XL1: - case Registers::XL2: - case Registers::XL3: - case Registers::XL4: - case Registers::XL5: - case Registers::XL6: - case Registers::XL7: - return Mode::b32; - case Registers::XLL0: - case Registers::XLL1: - case Registers::XLL2: - case Registers::XLL3: - return Mode::b16; - case Registers::XLLH0: - case Registers::XLLH1: - case Registers::XLLH2: - case Registers::XLLH3: - case Registers::XLLL0: - case Registers::XLLL1: - case Registers::XLLL2: - case Registers::XLLL3: - return Mode::b8; - default: - UNREACHABLE(); - } + inline void push(const std::string &data) { + std::memcpy(binary + ptr, data.data(), data.length()); + ptr += data.length(); } - std::string_view FindLine(const pog::LineSpecialization&, const std::string_view&); - void WriteResultFile(HyperCPU::FileType type, HCAsm::BinaryResult& result, std::ofstream& output, std::uint32_t code_size, std::uint32_t entry_point); - - [[noreturn]] void ThrowError(pog::TokenWithLineSpec& err_token, pog::Parser& parser, std::string err_msg); - - Value TokenizeSignedInt(std::string_view str); - Value TokenizeUnsignedInt(std::string_view str); - Value TokenizeString(std::string_view str); - Value TokenizeHexadecimal(std::string_view str); - Value TokenizeIdentifier(std::string_view str); - Value TokenizeBinary(std::string_view str); - Value TokenizeChar(std::string_view str); - - Value ParseOperand1(pog::Parser&, std::vector>&& args); - Value ParseOperand2(pog::Parser&, std::vector>&& args); - Value ParseOperand3(pog::Parser&, std::vector>&& args); - Value ParseOperand4(pog::Parser&, std::vector>&& args); - Value ParseOperand5(pog::Parser&, std::vector>&& args); - Value ParseOperand6(pog::Parser&, std::vector>&& args); - Value ParseOperand7(pog::Parser&, std::vector>&& args); - Value ParseOperand8(pog::Parser&, std::vector>&& args); - Value ParseOperand9(pog::Parser&, std::vector>&& args); - Value ParseOperand10(pog::Parser&, std::vector>&& args); - Value ParseOperand11(pog::Parser&, std::vector>&& args); - Value ParseOperand12(pog::Parser&, std::vector>&& args); - - Value CompileStatement1(pog::Parser&, std::vector>&& args); - Value CompileStatement2(pog::Parser&, std::vector>&& args); - Value CompileStatement3(pog::Parser&, std::vector>&& args); - Value CompileEntryLabel(pog::Parser&, std::vector>&& args); - Value CompileLabel(pog::Parser&, std::vector>&& args); - Value CompileRawValueb8_str(pog::Parser&, std::vector>&& args); - Value CompileRawValueb8(pog::Parser&, std::vector>&& args); - Value CompileRawValueb16(pog::Parser&, std::vector>&& args); - Value CompileRawValueb32(pog::Parser&, std::vector>&& args); - Value CompileRawValueb64(pog::Parser&, std::vector>&& args); - - extern HyperCPU::Logger logger; - extern CompilerState* current_state; - extern std::uint64_t current_index; - - class HCAsmCompiler { - public: - HCAsmCompiler(HyperCPU::LogLevel lvl = HyperCPU::LogLevel::WARNING); - - BinaryResult Compile(std::string& contents, std::uint32_t& code_size); - CompilerState TransformToIR(std::string& src); - BinaryResult TransformToBinary(CompilerState& ir); - - private: - pog::Parser parser; - CompilerState* state; - std::queue files; - hpool::HPool, hpool::ReallocationPolicy::OffsetRealloc> pool; - - constexpr inline std::uint8_t OperandSize(const OperandType op); - std::uint8_t InstructionSize(Instruction& instr); - std::uint8_t ModeToSize(const Operand& op); - std::uint8_t ModeToSize(Mode md); - }; + ~BinaryResult() { delete[] binary; } +}; + +struct PendingLabelReferenceResolve { + std::uint32_t idx; + std::uint8_t op; +}; + +// Some magic for std::visit +template struct MakeOverload : T... { + using T::operator()...; +}; + +template MakeOverload(T...) -> MakeOverload; +template +constexpr inline decltype(auto) VisitVariant(Variant &&variant, + Alternatives &&...alternatives) { + return std::visit(MakeOverload{std::forward(alternatives)..., + [](auto const &) {}}, + variant); } + +// Needs improvements and optimizations +struct CompilerState { + CompilerState(hpool::HPool, + hpool::ReallocationPolicy::OffsetRealloc> &pool) + : pool(pool), code_size(0), entry_point(0) {} + + std::vector pending_resolves; + std::vector> tmp_args; + std::vector> ir; + std::unordered_map labels; + hpool::HPool, + hpool::ReallocationPolicy::OffsetRealloc> &pool; + std::uint64_t code_size; + std::uint32_t entry_point; +}; + +constexpr inline Mode ModeFromRegister(HyperCPU::Registers reg) { + using namespace HyperCPU; + switch (reg) { + case Registers::X0: + case Registers::X1: + case Registers::X2: + case Registers::X3: + case Registers::X4: + case Registers::X5: + case Registers::X6: + case Registers::X7: + case Registers::XBP: + case Registers::XSP: + case Registers::XIP: + return Mode::b64; + case Registers::XH0: + case Registers::XH1: + case Registers::XH2: + case Registers::XH3: + case Registers::XH4: + case Registers::XH5: + case Registers::XH6: + case Registers::XH7: + case Registers::XL0: + case Registers::XL1: + case Registers::XL2: + case Registers::XL3: + case Registers::XL4: + case Registers::XL5: + case Registers::XL6: + case Registers::XL7: + return Mode::b32; + case Registers::XLL0: + case Registers::XLL1: + case Registers::XLL2: + case Registers::XLL3: + return Mode::b16; + case Registers::XLLH0: + case Registers::XLLH1: + case Registers::XLLH2: + case Registers::XLLH3: + case Registers::XLLL0: + case Registers::XLLL1: + case Registers::XLLL2: + case Registers::XLLL3: + return Mode::b8; + default: + UNREACHABLE(); + } +} + +std::string_view FindLine(const pog::LineSpecialization &, + const std::string_view &); +void WriteResultFile(HyperCPU::FileType type, HCAsm::BinaryResult &result, + std::ofstream &output, std::uint32_t code_size, + std::uint32_t entry_point); + +[[noreturn]] void ThrowError(pog::TokenWithLineSpec &err_token, + pog::Parser &parser, std::string err_msg); + +Value TokenizeSignedInt(std::string_view str); +Value TokenizeUnsignedInt(std::string_view str); +Value TokenizeString(std::string_view str); +Value TokenizeHexadecimal(std::string_view str); +Value TokenizeIdentifier(std::string_view str); +Value TokenizeBinary(std::string_view str); +Value TokenizeChar(std::string_view str); + +Value ParseOperand1(pog::Parser &, + std::vector> &&args); +Value ParseOperand2(pog::Parser &, + std::vector> &&args); +Value ParseOperand3(pog::Parser &, + std::vector> &&args); +Value ParseOperand4(pog::Parser &, + std::vector> &&args); +Value ParseOperand5(pog::Parser &, + std::vector> &&args); +Value ParseOperand6(pog::Parser &, + std::vector> &&args); +Value ParseOperand7(pog::Parser &, + std::vector> &&args); +Value ParseOperand8(pog::Parser &, + std::vector> &&args); +Value ParseOperand9(pog::Parser &, + std::vector> &&args); +Value ParseOperand10(pog::Parser &, + std::vector> &&args); +Value ParseOperand11(pog::Parser &, + std::vector> &&args); +Value ParseOperand12(pog::Parser &, + std::vector> &&args); + +Value CompileStatement1(pog::Parser &, + std::vector> &&args); +Value CompileStatement2(pog::Parser &, + std::vector> &&args); +Value CompileStatement3(pog::Parser &, + std::vector> &&args); +Value CompileEntryLabel(pog::Parser &, + std::vector> &&args); +Value CompileLabel(pog::Parser &, + std::vector> &&args); +Value CompileRawValueb8_str(pog::Parser &, + std::vector> &&args); +Value CompileRawValueb8(pog::Parser &, + std::vector> &&args); +Value CompileRawValueb16(pog::Parser &, + std::vector> &&args); +Value CompileRawValueb32(pog::Parser &, + std::vector> &&args); +Value CompileRawValueb64(pog::Parser &, + std::vector> &&args); + +extern HyperCPU::Logger logger; +extern CompilerState *current_state; +extern std::uint64_t current_index; + +class HCAsmCompiler { +public: + HCAsmCompiler(HyperCPU::LogLevel lvl = HyperCPU::LogLevel::WARNING); + + BinaryResult Compile(std::string &contents, std::uint32_t &code_size); + CompilerState TransformToIR(std::string &src); + BinaryResult TransformToBinary(CompilerState &ir); + +private: + pog::Parser parser; + CompilerState *state; + std::queue files; + hpool::HPool, + hpool::ReallocationPolicy::OffsetRealloc> + pool; + + constexpr inline std::uint8_t OperandSize(const OperandType op); + std::uint8_t InstructionSize(Instruction &instr); + std::uint8_t ModeToSize(const Operand &op); + std::uint8_t ModeToSize(Mode md); +}; + +} // namespace HCAsm From c176507bc3caaba63df5751e35b32d0c5e5e0153 Mon Sep 17 00:00:00 2001 From: aceinetx Date: Mon, 21 Apr 2025 16:38:32 +0300 Subject: [PATCH 2/2] Correct formatting --- src/Assembler/Core/Compiler.hpp | 500 +++++++++++++++----------------- 1 file changed, 235 insertions(+), 265 deletions(-) diff --git a/src/Assembler/Core/Compiler.hpp b/src/Assembler/Core/Compiler.hpp index adacefea..bc7300a7 100644 --- a/src/Assembler/Core/Compiler.hpp +++ b/src/Assembler/Core/Compiler.hpp @@ -2,284 +2,254 @@ #include -#include -#include #include -#include +#include +#include #include -#include +#include #include +#include #include #include #include + namespace HCAsm { -enum class ValueType { - operand, - string, - sint, - uint, -}; - -enum class OperandType { - reg, - mem_reg_add_int, - sint, - uint, - memaddr_reg, - memaddr_int, - memaddr_lbl, - label, - str_lit, - none -}; - -enum class Mode : std::uint8_t { - b8 = 0b00, - b16 = 0b01, - b32 = 0b10, - b64 = 0b11, - b64_label, - b8_str, - none -}; - -struct Value; - -struct Operand { - OperandType type; - HyperCPU::Registers reg; - enum Mode mode; - bool needs_resolve; - std::array, - hpool::ReallocationPolicy::OffsetRealloc>, - 2> - tokens; - std::variant> - variant; -}; - -struct Instruction { - HyperCPU::Opcode opcode; - Operand op1, op2; -}; - -struct RawValue { - enum Mode mode; - Operand value; // Label resolver requires reference to operand -}; - -struct Value { - std::variant - val; -}; - -struct Label { - std::string name; - std::uint64_t index; - bool is_entry_point; -}; - -template -concept UnsignedIntegral = std::is_integral_v && std::is_unsigned_v; - -struct BinaryResult { - BinaryResult() : binary(nullptr), ptr(0), entry_point(0) {} - BinaryResult(unsigned char *ptr) : binary(ptr), ptr(0), entry_point(0) {} - - unsigned char *binary; - std::uint64_t ptr; - std::uint32_t entry_point; - - template constexpr inline void push(T data) { - std::memcpy(binary + ptr, &data, sizeof(data)); - ptr += sizeof(data); + enum class ValueType { + operand, + string, + sint, + uint, + }; + + enum class OperandType { + reg, + mem_reg_add_int, + sint, + uint, + memaddr_reg, + memaddr_int, + memaddr_lbl, + label, + str_lit, + none + }; + + enum class Mode : std::uint8_t { + b8 = 0b00, + b16 = 0b01, + b32 = 0b10, + b64 = 0b11, + b64_label, + b8_str, + none + }; + + struct Value; + + struct Operand { + OperandType type; + HyperCPU::Registers reg; + enum Mode mode; + bool needs_resolve; + std::array, hpool::ReallocationPolicy::OffsetRealloc>, 2> tokens; + std::variant> variant; + }; + + struct Instruction { + HyperCPU::Opcode opcode; + Operand op1, op2; + }; + + struct RawValue { + enum Mode mode; + Operand value; // Label resolver requires reference to operand + }; + + struct Value { + std::variant val; + }; + + struct Label { + std::string name; + std::uint64_t index; + bool is_entry_point; + }; + + template + concept UnsignedIntegral = std::is_integral_v && std::is_unsigned_v; + + struct BinaryResult { + BinaryResult() : binary(nullptr), ptr(0), entry_point(0) { } + BinaryResult(unsigned char* ptr) : binary(ptr), ptr(0), entry_point(0) { } + + unsigned char* binary; + std::uint64_t ptr; + std::uint32_t entry_point; + + template + constexpr inline void push(T data) { + std::memcpy(binary + ptr, &data, sizeof(data)); + ptr += sizeof(data); + } + + inline void push(const std::string& data) { + std::memcpy(binary + ptr, data.data(), data.length()); + ptr += data.length(); + } + + ~BinaryResult() { + delete[] binary; + } + }; + + struct PendingLabelReferenceResolve { + std::uint32_t idx; + std::uint8_t op; + }; + + // Some magic for std::visit + template + struct MakeOverload : T... { + using T::operator()...; + }; + + template + MakeOverload(T...) -> MakeOverload; + + template + constexpr inline decltype(auto) VisitVariant(Variant&& variant, Alternatives&&... alternatives) { + return std::visit( + MakeOverload{std::forward(alternatives)..., [](auto const&){}}, + variant + ); } - inline void push(const std::string &data) { - std::memcpy(binary + ptr, data.data(), data.length()); - ptr += data.length(); + // Needs improvements and optimizations + struct CompilerState { + CompilerState(hpool::HPool, hpool::ReallocationPolicy::OffsetRealloc>& pool) : pool(pool), code_size(0), entry_point(0) { } + + std::vector pending_resolves; + std::vector> tmp_args; + std::vector> ir; + std::unordered_map labels; + hpool::HPool, hpool::ReallocationPolicy::OffsetRealloc>& pool; + std::uint64_t code_size; + std::uint32_t entry_point; + }; + + constexpr inline Mode ModeFromRegister(HyperCPU::Registers reg) { + using namespace HyperCPU; + switch (reg) { + case Registers::X0: + case Registers::X1: + case Registers::X2: + case Registers::X3: + case Registers::X4: + case Registers::X5: + case Registers::X6: + case Registers::X7: + case Registers::XBP: + case Registers::XSP: + case Registers::XIP: + return Mode::b64; + case Registers::XH0: + case Registers::XH1: + case Registers::XH2: + case Registers::XH3: + case Registers::XH4: + case Registers::XH5: + case Registers::XH6: + case Registers::XH7: + case Registers::XL0: + case Registers::XL1: + case Registers::XL2: + case Registers::XL3: + case Registers::XL4: + case Registers::XL5: + case Registers::XL6: + case Registers::XL7: + return Mode::b32; + case Registers::XLL0: + case Registers::XLL1: + case Registers::XLL2: + case Registers::XLL3: + return Mode::b16; + case Registers::XLLH0: + case Registers::XLLH1: + case Registers::XLLH2: + case Registers::XLLH3: + case Registers::XLLL0: + case Registers::XLLL1: + case Registers::XLLL2: + case Registers::XLLL3: + return Mode::b8; + default: + UNREACHABLE(); + } } - ~BinaryResult() { delete[] binary; } -}; - -struct PendingLabelReferenceResolve { - std::uint32_t idx; - std::uint8_t op; -}; - -// Some magic for std::visit -template struct MakeOverload : T... { - using T::operator()...; -}; - -template MakeOverload(T...) -> MakeOverload; + std::string_view FindLine(const pog::LineSpecialization&, const std::string_view&); + void WriteResultFile(HyperCPU::FileType type, HCAsm::BinaryResult& result, std::ofstream& output, std::uint32_t code_size, std::uint32_t entry_point); + + [[noreturn]] void ThrowError(pog::TokenWithLineSpec& err_token, pog::Parser& parser, std::string err_msg); + + Value TokenizeSignedInt(std::string_view str); + Value TokenizeUnsignedInt(std::string_view str); + Value TokenizeString(std::string_view str); + Value TokenizeHexadecimal(std::string_view str); + Value TokenizeIdentifier(std::string_view str); + Value TokenizeBinary(std::string_view str); + Value TokenizeChar(std::string_view str); + + Value ParseOperand1(pog::Parser&, std::vector>&& args); + Value ParseOperand2(pog::Parser&, std::vector>&& args); + Value ParseOperand3(pog::Parser&, std::vector>&& args); + Value ParseOperand4(pog::Parser&, std::vector>&& args); + Value ParseOperand5(pog::Parser&, std::vector>&& args); + Value ParseOperand6(pog::Parser&, std::vector>&& args); + Value ParseOperand7(pog::Parser&, std::vector>&& args); + Value ParseOperand8(pog::Parser&, std::vector>&& args); + Value ParseOperand9(pog::Parser&, std::vector>&& args); + Value ParseOperand10(pog::Parser&, std::vector>&& args); + Value ParseOperand11(pog::Parser&, std::vector>&& args); + Value ParseOperand12(pog::Parser&, std::vector>&& args); + + Value CompileStatement1(pog::Parser&, std::vector>&& args); + Value CompileStatement2(pog::Parser&, std::vector>&& args); + Value CompileStatement3(pog::Parser&, std::vector>&& args); + Value CompileEntryLabel(pog::Parser&, std::vector>&& args); + Value CompileLabel(pog::Parser&, std::vector>&& args); + Value CompileRawValueb8_str(pog::Parser&, std::vector>&& args); + Value CompileRawValueb8(pog::Parser&, std::vector>&& args); + Value CompileRawValueb16(pog::Parser&, std::vector>&& args); + Value CompileRawValueb32(pog::Parser&, std::vector>&& args); + Value CompileRawValueb64(pog::Parser&, std::vector>&& args); + + extern HyperCPU::Logger logger; + extern CompilerState* current_state; + extern std::uint64_t current_index; + + class HCAsmCompiler { + public: + HCAsmCompiler(HyperCPU::LogLevel lvl = HyperCPU::LogLevel::WARNING); + + BinaryResult Compile(std::string& contents, std::uint32_t& code_size); + CompilerState TransformToIR(std::string& src); + BinaryResult TransformToBinary(CompilerState& ir); + + private: + pog::Parser parser; + CompilerState* state; + std::queue files; + hpool::HPool, hpool::ReallocationPolicy::OffsetRealloc> pool; + + constexpr inline std::uint8_t OperandSize(const OperandType op); + std::uint8_t InstructionSize(Instruction& instr); + std::uint8_t ModeToSize(const Operand& op); + std::uint8_t ModeToSize(Mode md); + }; -template -constexpr inline decltype(auto) VisitVariant(Variant &&variant, - Alternatives &&...alternatives) { - return std::visit(MakeOverload{std::forward(alternatives)..., - [](auto const &) {}}, - variant); } - -// Needs improvements and optimizations -struct CompilerState { - CompilerState(hpool::HPool, - hpool::ReallocationPolicy::OffsetRealloc> &pool) - : pool(pool), code_size(0), entry_point(0) {} - - std::vector pending_resolves; - std::vector> tmp_args; - std::vector> ir; - std::unordered_map labels; - hpool::HPool, - hpool::ReallocationPolicy::OffsetRealloc> &pool; - std::uint64_t code_size; - std::uint32_t entry_point; -}; - -constexpr inline Mode ModeFromRegister(HyperCPU::Registers reg) { - using namespace HyperCPU; - switch (reg) { - case Registers::X0: - case Registers::X1: - case Registers::X2: - case Registers::X3: - case Registers::X4: - case Registers::X5: - case Registers::X6: - case Registers::X7: - case Registers::XBP: - case Registers::XSP: - case Registers::XIP: - return Mode::b64; - case Registers::XH0: - case Registers::XH1: - case Registers::XH2: - case Registers::XH3: - case Registers::XH4: - case Registers::XH5: - case Registers::XH6: - case Registers::XH7: - case Registers::XL0: - case Registers::XL1: - case Registers::XL2: - case Registers::XL3: - case Registers::XL4: - case Registers::XL5: - case Registers::XL6: - case Registers::XL7: - return Mode::b32; - case Registers::XLL0: - case Registers::XLL1: - case Registers::XLL2: - case Registers::XLL3: - return Mode::b16; - case Registers::XLLH0: - case Registers::XLLH1: - case Registers::XLLH2: - case Registers::XLLH3: - case Registers::XLLL0: - case Registers::XLLL1: - case Registers::XLLL2: - case Registers::XLLL3: - return Mode::b8; - default: - UNREACHABLE(); - } -} - -std::string_view FindLine(const pog::LineSpecialization &, - const std::string_view &); -void WriteResultFile(HyperCPU::FileType type, HCAsm::BinaryResult &result, - std::ofstream &output, std::uint32_t code_size, - std::uint32_t entry_point); - -[[noreturn]] void ThrowError(pog::TokenWithLineSpec &err_token, - pog::Parser &parser, std::string err_msg); - -Value TokenizeSignedInt(std::string_view str); -Value TokenizeUnsignedInt(std::string_view str); -Value TokenizeString(std::string_view str); -Value TokenizeHexadecimal(std::string_view str); -Value TokenizeIdentifier(std::string_view str); -Value TokenizeBinary(std::string_view str); -Value TokenizeChar(std::string_view str); - -Value ParseOperand1(pog::Parser &, - std::vector> &&args); -Value ParseOperand2(pog::Parser &, - std::vector> &&args); -Value ParseOperand3(pog::Parser &, - std::vector> &&args); -Value ParseOperand4(pog::Parser &, - std::vector> &&args); -Value ParseOperand5(pog::Parser &, - std::vector> &&args); -Value ParseOperand6(pog::Parser &, - std::vector> &&args); -Value ParseOperand7(pog::Parser &, - std::vector> &&args); -Value ParseOperand8(pog::Parser &, - std::vector> &&args); -Value ParseOperand9(pog::Parser &, - std::vector> &&args); -Value ParseOperand10(pog::Parser &, - std::vector> &&args); -Value ParseOperand11(pog::Parser &, - std::vector> &&args); -Value ParseOperand12(pog::Parser &, - std::vector> &&args); - -Value CompileStatement1(pog::Parser &, - std::vector> &&args); -Value CompileStatement2(pog::Parser &, - std::vector> &&args); -Value CompileStatement3(pog::Parser &, - std::vector> &&args); -Value CompileEntryLabel(pog::Parser &, - std::vector> &&args); -Value CompileLabel(pog::Parser &, - std::vector> &&args); -Value CompileRawValueb8_str(pog::Parser &, - std::vector> &&args); -Value CompileRawValueb8(pog::Parser &, - std::vector> &&args); -Value CompileRawValueb16(pog::Parser &, - std::vector> &&args); -Value CompileRawValueb32(pog::Parser &, - std::vector> &&args); -Value CompileRawValueb64(pog::Parser &, - std::vector> &&args); - -extern HyperCPU::Logger logger; -extern CompilerState *current_state; -extern std::uint64_t current_index; - -class HCAsmCompiler { -public: - HCAsmCompiler(HyperCPU::LogLevel lvl = HyperCPU::LogLevel::WARNING); - - BinaryResult Compile(std::string &contents, std::uint32_t &code_size); - CompilerState TransformToIR(std::string &src); - BinaryResult TransformToBinary(CompilerState &ir); - -private: - pog::Parser parser; - CompilerState *state; - std::queue files; - hpool::HPool, - hpool::ReallocationPolicy::OffsetRealloc> - pool; - - constexpr inline std::uint8_t OperandSize(const OperandType op); - std::uint8_t InstructionSize(Instruction &instr); - std::uint8_t ModeToSize(const Operand &op); - std::uint8_t ModeToSize(Mode md); -}; - -} // namespace HCAsm