nyxstone.h

#pragma once
 
#include <expected.hpp>
 
#include <llvm/MC/MCAsmInfo.h>
#include <llvm/MC/MCInstPrinter.h>
#include <llvm/MC/MCInstrInfo.h>
#include <llvm/MC/MCRegisterInfo.h>
#include <llvm/MC/MCSubtargetInfo.h>
#include <llvm/MC/TargetRegistry.h>
 
namespace nyxstone {
 
using u8 = uint8_t;
using u64 = uint64_t;
 
class Nyxstone {
public:
    struct LabelDefinition {
        std::string name;
        uint64_t address;
    };
 
    struct Instruction {
        uint64_t address;
        std::string assembly;
        std::vector<uint8_t> bytes {};
 
        bool operator==(const Instruction& other) const;
    };
 
    Nyxstone(llvm::Triple&& triple, const llvm::Target& target, llvm::MCTargetOptions&& target_options,
        std::unique_ptr<llvm::MCRegisterInfo>&& register_info, std::unique_ptr<llvm::MCAsmInfo>&& assembler_info,
        std::unique_ptr<llvm::MCInstrInfo>&& instruction_info, std::unique_ptr<llvm::MCSubtargetInfo>&& subtarget_info,
        std::unique_ptr<llvm::MCInstPrinter>&& instruction_printer) noexcept
        : triple(std::move(triple))
        , target(target)
        , target_options(std::move(target_options))
        , register_info(std::move(register_info))
        , assembler_info(std::move(assembler_info))
        , instruction_info(std::move(instruction_info))
        , subtarget_info(std::move(subtarget_info))
        , instruction_printer(std::move(instruction_printer))
    {
    }
 
    tl::expected<std::vector<u8>, std::string> assemble(
        const std::string& assembly, uint64_t address, const std::vector<LabelDefinition>& labels) const;
 
    tl::expected<std::vector<Instruction>, std::string> assemble_to_instructions(
        const std::string& assembly, uint64_t address, const std::vector<LabelDefinition>& labels) const;
 
    tl::expected<std::string, std::string> disassemble(
        const std::vector<uint8_t>& bytes, uint64_t address, size_t count) const;
 
    tl::expected<std::vector<Instruction>, std::string> disassemble_to_instructions(
        const std::vector<uint8_t>& bytes, uint64_t address, size_t count) const;
 
private:
    // Uses LLVM to assemble instructions.
    // Utilizes some custom overloads to import user-supplied label definitions and extract instruction details.
    tl::expected<void, std::string> assemble_impl(const std::string& assembly, uint64_t address,
        const std::vector<LabelDefinition>& labels, std::vector<uint8_t>& bytes,
        std::vector<Instruction>* instructions) const;
 
    // Uses LLVM to disassemble instructions.
    tl::expected<void, std::string> disassemble_impl(const std::vector<uint8_t>& bytes, uint64_t address, size_t count,
        std::string* disassembly, std::vector<Instruction>* instructions) const;
 
    llvm::Triple triple;
 
    // Target is a static object, thus it is safe to take its const reference.
    const llvm::Target& target;
 
    llvm::MCTargetOptions target_options;
 
    std::unique_ptr<llvm::MCRegisterInfo> register_info;
    std::unique_ptr<llvm::MCAsmInfo> assembler_info;
    std::unique_ptr<llvm::MCInstrInfo> instruction_info;
    std::unique_ptr<llvm::MCSubtargetInfo> subtarget_info;
    std::unique_ptr<llvm::MCInstPrinter> instruction_printer;
};
 
class NyxstoneBuilder {
public:
    // This is a uint8_t for better interoperability with rust.
    enum class IntegerBase : uint8_t {
        Dec = 0,
        HexPrefix = 1,
        HexSuffix = 2,
    };
 
    explicit NyxstoneBuilder(std::string&& triple)
        : m_triple(std::move(triple)) {};
    NyxstoneBuilder(const NyxstoneBuilder&) = default;
    NyxstoneBuilder(NyxstoneBuilder&&) = default;
    NyxstoneBuilder& operator=(const NyxstoneBuilder&) = default;
    NyxstoneBuilder& operator=(NyxstoneBuilder&&) = default;
    ~NyxstoneBuilder() = default;
 
    NyxstoneBuilder& with_cpu(std::string&& cpu) noexcept;
 
    NyxstoneBuilder& with_features(std::string&& features) noexcept;
 
    NyxstoneBuilder& with_immediate_style(IntegerBase style) noexcept;
 
    tl::expected<std::unique_ptr<Nyxstone>, std::string> build();
 
private:
    std::string m_triple;
    std::string m_cpu;
    std::string m_features;
    IntegerBase m_imm_style = IntegerBase::Dec;
};
 
bool is_ArmT16_or_ArmT32(const llvm::Triple& triple);
} // namespace nyxstone