From 02153da4d5954261f6649e2980bc88f6d29e45a6 Mon Sep 17 00:00:00 2001 From: Roland Reichwein Date: Sat, 31 Aug 2024 18:29:58 +0200 Subject: ARM assembler (WIP) --- asm/arm/README.md | 4 + asm/arm/TODO | 1 + asm/arm/YMakefile | 8 + asm/arm/assembler.h | 38 +++++ asm/arm/instruction.h | 109 +++++++++++++ asm/arm/main.cpp | 41 +++++ asm/arm/parse.cpp | 441 ++++++++++++++++++++++++++++++++++++++++++++++++++ asm/arm/parse.h | 7 + 8 files changed, 649 insertions(+) create mode 100644 asm/arm/README.md create mode 100644 asm/arm/TODO create mode 100644 asm/arm/YMakefile create mode 100644 asm/arm/assembler.h create mode 100644 asm/arm/instruction.h create mode 100644 asm/arm/main.cpp create mode 100644 asm/arm/parse.cpp create mode 100644 asm/arm/parse.h (limited to 'asm/arm') diff --git a/asm/arm/README.md b/asm/arm/README.md new file mode 100644 index 0000000..742c243 --- /dev/null +++ b/asm/arm/README.md @@ -0,0 +1,4 @@ +Assembler for ARMv6-M +===================== + +Supports thumb instruction set diff --git a/asm/arm/TODO b/asm/arm/TODO new file mode 100644 index 0000000..2d47ab0 --- /dev/null +++ b/asm/arm/TODO @@ -0,0 +1 @@ +mnemonic alias diff --git a/asm/arm/YMakefile b/asm/arm/YMakefile new file mode 100644 index 0000000..833bb88 --- /dev/null +++ b/asm/arm/YMakefile @@ -0,0 +1,8 @@ + + + arm + main.cpp + fmt + reichwein + + diff --git a/asm/arm/assembler.h b/asm/arm/assembler.h new file mode 100644 index 0000000..13eca00 --- /dev/null +++ b/asm/arm/assembler.h @@ -0,0 +1,38 @@ +#pragma once + +#include +#include + +#include "instruction.h" +#include "parse.h" + +class Encoding +{ +}; + +class OpCode: public Encoding +{ +private: + Instruction _instruction; + std::vector _arguments; +}; + +class Data: public Encoding +{ +}; + +using Assembly = std::vector; + +class Assembler +{ +public: + Assembler(){} + +// passes: +// 0. parse +// 1. assign sizes and offsets to codes (assign labels) +// 2. assemble to code sequence (use labels for offsets) + + code_sequence encode(const std::string& source){ throw std::runtime_error("Assembler.encode unimplemented");} + std::string decode(code_sequence) { throw std::runtime_error("Assembler.decode unimplemented");} +}; diff --git a/asm/arm/instruction.h b/asm/arm/instruction.h new file mode 100644 index 0000000..224cc6e --- /dev/null +++ b/asm/arm/instruction.h @@ -0,0 +1,109 @@ +#pragma once + +#include +#include +#include +#include + +using namespace std::string_literals; + +using code_sequence = std::vector; + +template +code_sequence to_code_sequence(from_t v); + +template<> +code_sequence to_code_sequence(uint16_t v) { + return code_sequence{static_cast(v & 0xFF), static_cast(v >> 8)}; +} + +template<> +code_sequence to_code_sequence(uint32_t v) { + return code_sequence{static_cast(v & 0xFF), static_cast(v >> 8), static_cast(v >> 16),static_cast(v >> 24) }; +} + +uint32_t high_bits(uint8_t number) +{ + return ~((static_cast(1) << (32 - number)) - 1); +} + +// Identify operator with leading bits +class Pattern +{ +public: + Pattern(uint32_t bits, uint32_t mask): _bits{bits}, _mask{mask} {} + + template + T encode() + { + return static_cast(_bits); + } + + +private: + uint32_t _bits; + uint32_t _mask; +}; + +class Operand +{ +protected: + Operand(uint8_t pos): _pos(pos){} +private: + uint8_t _pos; +}; + +class Register: public Operand +{ +public: + Register(uint8_t pos): Operand{pos} {}; +}; + +class Immediate: public Operand +{ +public: + Immediate(uint8_t pos, uint8_t bits): Operand{pos}, _bits{bits} {} +private: + uint8_t _bits; +}; + +using Operands = std::vector>; + +// Pattern [, Operand, ...] +class Instruction +{ +public: + Instruction(const std::string& mnemonic, uint8_t size, Pattern pattern, Operands operands): _mnemonic(mnemonic), _size(size), _pattern(pattern), _operands(operands) {} + code_sequence encode(const std::vector& arguments) + { + if (_size == 2) { // 16 bit thumb insn + uint16_t result{ _pattern.encode()}; + return to_code_sequence(result); + } else if (_size == 4) { // 32 bit thumb insn + uint32_t result{ _pattern.encode()}; + return to_code_sequence(result); + } else { + throw std::runtime_error("Unsupported instruction size "s + std::to_string(_size)); + } + } + +private: + std::string _mnemonic; + uint8_t _size; + Pattern _pattern; + Operands _operands; +}; + +namespace { + // factory functions + std::shared_ptr imm(uint8_t pos, uint8_t size){ return std::make_shared(pos, size); }; + std::shared_ptr reg(uint8_t pos) { return std::make_shared(pos); }; + + std::vector insns{ + {"adcs", 2, Pattern(0x4140, high_bits(10)), Operands{reg(0), reg(3)}}, + + {"lsls", 2, Pattern(0x0000, high_bits(5)), Operands{reg(0), reg(3), imm(6, 5)}} + }; +}; + + diff --git a/asm/arm/main.cpp b/asm/arm/main.cpp new file mode 100644 index 0000000..20e67ab --- /dev/null +++ b/asm/arm/main.cpp @@ -0,0 +1,41 @@ +#include +#include + +#include + +#include + +#include "assembler.h" +#include "instruction.h" + +void dump(const code_sequence& c) +{ + for (size_t i = 0; i < c.size(); ++i) { + if ((i % 16) == 0) { + if (i > 0) + std::cout << std::endl; + } else { + std::cout << " "; + } + std::cout << fmt::format("{:02x}", c[i]); + } + std::cout << std::endl; +} + +int main(int argc, char* argv[]) +{ + try { + if (argc == 2) { + Assembler assembler; + std::string source {Reichwein::File::getFile(argv[1])}; + code_sequence result {assembler.encode(source)}; + dump(result); + } + return 0; + } catch (const std::exception& ex) { + std::cerr << "Error: " << ex.what() << std::endl; + return 1; + } + return 2; +} + diff --git a/asm/arm/parse.cpp b/asm/arm/parse.cpp new file mode 100644 index 0000000..a3156c2 --- /dev/null +++ b/asm/arm/parse.cpp @@ -0,0 +1,441 @@ +#include "parse.h" + +#include "asm/assembler.h" + +#include + +#include +#include +#include +#include + +using namespace std::string_literals; + +namespace { + + std::unordered_set reg8 { + "al", "ah", + "bl", "bh", + "cl", "ch", + "dl", "dh", + }; + + std::unordered_set reg16 { + "ax", "sp", + "bx", "bp", + "cx", "si", + "dx", "di", + }; + + std::unordered_set reg32 { + "eax", "esp", + "ebx", "ebp", + "ecx", "esi", + "edx", "edi", + }; + + std::unordered_set reg64 { + "rax", "rsp", + "rbx", "rbp", + "rcx", "rsi", + "rdx", "rdi", + }; + + // skip optional whitespace + void parseWhitespace(const std::string& asm_code, size_t& pos) { + std::regex re_whitespace("[ \\t]+", std::regex_constants::ECMAScript); + + std::smatch match; + if (std::regex_search(asm_code.cbegin() + pos, asm_code.cend(), match, re_whitespace, std::regex_constants::match_continuous)) { + pos += match[0].length(); + } + } + + std::string reg_re{"[[:alpha:]][[:alnum:]]*"}; + + // parse optional label + bool parseLabel(const std::string& asm_code, size_t& pos, std::string& result) { + parseWhitespace(asm_code, pos); + + std::regex re_label("("s + reg_re + "):"s, std::regex_constants::ECMAScript); + + std::smatch match; + if (std::regex_search(asm_code.cbegin() + pos, asm_code.cend(), match, re_label, std::regex_constants::match_continuous)) { + pos += match[0].length(); + result = match[1]; + return true; + } + + return false; + } + + // parse optional mnemonic + // return true iff mnemonic found + bool parseMnemonic(const std::string& asm_code, size_t& pos, std::string& result) { + parseWhitespace(asm_code, pos); + + std::regex re_mnemonic(reg_re, std::regex_constants::ECMAScript); + + std::smatch match; + if (std::regex_search(asm_code.cbegin() + pos, asm_code.cend(), match, re_mnemonic, std::regex_constants::match_continuous)) { + std::string name {boost::algorithm::to_lower_copy(match[0].str())}; + pos += name.size(); + result = name; + return true; + } + + return false; + } + + bool parseRegister8(const std::string& asm_code, size_t& pos, std::any& result, size_t& size_hint) { + parseWhitespace(asm_code, pos); + + std::regex re_name(reg_re, std::regex_constants::ECMAScript); + + std::smatch match; + if (std::regex_search(asm_code.cbegin() + pos, asm_code.cend(), match, re_name, std::regex_constants::match_continuous)) { + std::string name {boost::algorithm::to_lower_copy(match[0].str())}; + if (reg8.contains(name)) { + pos += name.size(); + result = Asm::Args::Register8(name); + size_hint = 8; + return true; + } + } + + return false; + } + + bool parseRegister16(const std::string& asm_code, size_t& pos, std::any& result, size_t& size_hint) { + parseWhitespace(asm_code, pos); + + std::regex re_name(reg_re, std::regex_constants::ECMAScript); + + std::smatch match; + if (std::regex_search(asm_code.cbegin() + pos, asm_code.cend(), match, re_name, std::regex_constants::match_continuous)) { + std::string name {boost::algorithm::to_lower_copy(match[0].str())}; + if (reg16.contains(name)) { + pos += name.size(); + result = Asm::Args::Register16(name); + size_hint = 16; + return true; + } + } + + return false; + } + + bool parseRegister32(const std::string& asm_code, size_t& pos, std::any& result, size_t& size_hint) { + parseWhitespace(asm_code, pos); + + std::regex re_name(reg_re, std::regex_constants::ECMAScript); + + std::smatch match; + if (std::regex_search(asm_code.cbegin() + pos, asm_code.cend(), match, re_name, std::regex_constants::match_continuous)) { + std::string name {boost::algorithm::to_lower_copy(match[0].str())}; + if (reg32.contains(name)) { + pos += name.size(); + result = Asm::Args::Register32(name); + size_hint = 32; + return true; + } + } + + return false; + } + + bool parseRegister64(const std::string& asm_code, size_t& pos, std::any& result, size_t& size_hint) { + parseWhitespace(asm_code, pos); + + std::regex re_name(reg_re, std::regex_constants::ECMAScript); + + std::smatch match; + if (std::regex_search(asm_code.cbegin() + pos, asm_code.cend(), match, re_name, std::regex_constants::match_continuous)) { + std::string name {boost::algorithm::to_lower_copy(match[0].str())}; + if (reg64.contains(name)) { + pos += name.size(); + result = Asm::Args::Register64(name); + size_hint = 64; + return true; + } + } + + return false; + } + + bool parseMem8Ptr64(const std::string& asm_code, size_t& pos, std::any& result, size_t& size_hint) { + parseWhitespace(asm_code, pos); + + std::regex re_name("byte ptr *\\[("s + reg_re + ")\\]"s, std::regex_constants::ECMAScript); + + std::smatch match; + if (std::regex_search(asm_code.cbegin() + pos, asm_code.cend(), match, re_name, std::regex_constants::match_continuous)) { + std::string name {boost::algorithm::to_lower_copy(match[1].str())}; + if (reg64.contains(name)) { + pos += match[0].length(); + result = Asm::Args::Mem8Ptr64{name}; + size_hint = 8; + return true; + } + } + + return false; + } + + bool parseMem16Ptr64(const std::string& asm_code, size_t& pos, std::any& result, size_t& size_hint) { + parseWhitespace(asm_code, pos); + + std::regex re_name("(word ptr *)?\\[("s + reg_re + ")\\]"s, std::regex_constants::ECMAScript); + + std::smatch match; + if (std::regex_search(asm_code.cbegin() + pos, asm_code.cend(), match, re_name, std::regex_constants::match_continuous)) { + std::string name {boost::algorithm::to_lower_copy(match[2].str())}; + if (reg16.contains(name)) { + pos += match[0].length(); + result = Asm::Args::Mem16Ptr64(name); + size_hint = 16; + return true; + } + } + + return false; + } + + bool parseMem32Ptr64(const std::string& asm_code, size_t& pos, std::any& result, size_t& size_hint) { + parseWhitespace(asm_code, pos); + + std::regex re_name("(dword ptr *)?\\[("s + reg_re + ")\\]"s, std::regex_constants::ECMAScript); + + std::smatch match; + if (std::regex_search(asm_code.cbegin() + pos, asm_code.cend(), match, re_name, std::regex_constants::match_continuous)) { + std::string name {boost::algorithm::to_lower_copy(match[2].str())}; + if (reg64.contains(name)) { + pos += match[0].length(); + result = Asm::Args::Mem32Ptr64(name); + size_hint = 32; + return true; + } + } + + return false; + } + + bool parseMem64Ptr64(const std::string& asm_code, size_t& pos, std::any& result, size_t& size_hint) { + parseWhitespace(asm_code, pos); + + std::regex re_name("qword ptr *\\[("s + reg_re + ")\\]"s, std::regex_constants::ECMAScript); + + std::smatch match; + if (std::regex_search(asm_code.cbegin() + pos, asm_code.cend(), match, re_name, std::regex_constants::match_continuous)) { + std::string name {boost::algorithm::to_lower_copy(match[1].str())}; + if (reg64.contains(name)) { + pos += match[0].length(); + result = Asm::Args::Mem64Ptr64(name); + size_hint = 64; + return true; + } + } + + return false; + } + + bool parseImmediate8(const std::string& asm_code, size_t& pos, std::any& result, size_t& size_hint) { + if (size_hint != 8) + return false; + + parseWhitespace(asm_code, pos); + + std::regex re_name("[[:digit:]]+|0x[[:xdigit:]]+", std::regex_constants::ECMAScript); + + std::smatch match; + if (std::regex_search(asm_code.cbegin() + pos, asm_code.cend(), match, re_name, std::regex_constants::match_continuous)) { + int32_t value{}; + try { + value = stoll(match[0]); + } catch (...) { + throw std::runtime_error("Assembler parse error: Bad immediate: "s + match[0].str()); + } + if (value < -128 || value > 255) + throw std::runtime_error("Assembler parse error: Bad 8 bit immediate: "s + match[0].str()); + + pos += match[0].length(); + result = Asm::Args::Immediate8(static_cast(value)); + return true; + } + + return false; + } + + bool parseImmediate32(const std::string& asm_code, size_t& pos, std::any& result, size_t& size_hint) { + if (size_hint != 32 && size_hint != 0) + return false; + + parseWhitespace(asm_code, pos); + + std::regex re_name("[[:digit:]]+|0x[[:xdigit:]]+", std::regex_constants::ECMAScript); + + std::smatch match; + if (std::regex_search(asm_code.cbegin() + pos, asm_code.cend(), match, re_name, std::regex_constants::match_continuous)) { + int32_t value{}; + try { + value = stoll(match[0]); + } catch (...) { + throw std::runtime_error("Assembler parse error: Bad Immediate: "s + match[0].str()); + } + pos += match[0].length(); + result = Asm::Args::Immediate32(static_cast(value)); + return true; + } + + return false; + } + + bool parseImmediate64(const std::string& asm_code, size_t& pos, std::any& result, size_t& size_hint) { + if (size_hint != 64) + return false; + + parseWhitespace(asm_code, pos); + + std::regex re_name("[[:digit:]]+|0x[[:xdigit:]]+", std::regex_constants::ECMAScript); + + std::smatch match; + if (std::regex_search(asm_code.cbegin() + pos, asm_code.cend(), match, re_name, std::regex_constants::match_continuous)) { + int64_t value{}; + try { + value = stoll(match[0]); + } catch (...) { + throw std::runtime_error("Assembler parse error: Bad immediate: "s + match[0].str()); + } + + pos += match[0].length(); + result = Asm::Args::Immediate64(static_cast(value)); + return true; + } + + return false; + } + + // parse optional single operand + bool parseOperand(const std::string& asm_code, size_t& pos, std::any& result, size_t& size_hint) { + parseWhitespace(asm_code, pos); + + if (parseRegister8(asm_code, pos, result, size_hint)) + return true; + if (parseRegister16(asm_code, pos, result, size_hint)) + return true; + if (parseRegister32(asm_code, pos, result, size_hint)) + return true; + if (parseRegister64(asm_code, pos, result, size_hint)) + return true; + + if (parseMem8Ptr64(asm_code, pos, result, size_hint)) + return true; + if (parseMem16Ptr64(asm_code, pos, result, size_hint)) + return true; + if (parseMem32Ptr64(asm_code, pos, result, size_hint)) + return true; + if (parseMem64Ptr64(asm_code, pos, result, size_hint)) + return true; + + if (parseImmediate8(asm_code, pos, result, size_hint)) + return true; + if (parseImmediate32(asm_code, pos, result, size_hint)) + return true; + if (parseImmediate64(asm_code, pos, result, size_hint)) + return true; + + return false; + } + + // parse optional multiple operands, separated by commas + void parseOperands(const std::string& asm_code, size_t& pos, Asm::Args& result) { + std::any operand; + size_t size_hint{0}; // in bits, 0=no hint + if (parseOperand(asm_code, pos, operand, size_hint)) { + result.push_back(operand); + parseWhitespace(asm_code, pos); + while (pos < asm_code.size() && asm_code[pos] == ',') { + pos++; + if (parseOperand(asm_code, pos, operand, size_hint)) { + result.push_back(operand); + } else { + throw std::runtime_error("Assembler error: expected operand after comma"); + } + parseWhitespace(asm_code, pos); + } + } + } + + // parse optional comment + void parseComment(const std::string& asm_code, size_t& pos) { + parseWhitespace(asm_code, pos); + + std::regex re_comment("(;|//).*", std::regex_constants::ECMAScript); + + std::smatch match; + if (std::regex_search(asm_code.cbegin() + pos, asm_code.cend(), match, re_comment, std::regex_constants::match_continuous)) { + pos += match[0].length(); + } + } + + // parse end of line (or whole code) + bool parseEol(const std::string& asm_code, size_t& pos) { + parseWhitespace(asm_code, pos); + + if (pos < asm_code.size() && asm_code[pos] != 0x0a && asm_code[pos] != 0x0d) + return false; // this is the only case where parseEol() doesn't work + + while (pos < asm_code.size()) { + char c { asm_code[pos] }; + if (c == 0x0a || c == 0x0d) { + pos++; + } else { + break; + } + } + + return true; + } + + // parse single line + void parseLine(const std::string& asm_code, size_t& pos, std::vector>& result) { + // all optional: + // label: mnemonic operands... ;comment + + std::string label; + std::function label_fn {[](){}}; + if (parseLabel(asm_code, pos, label)) + label_fn = [&]() { result.emplace_back(std::make_shared