A64: Backend framework

src/CMakeLists.txt

@@ -89,10 +89,17 @@ if (ARCHITECTURE_x86_64)
          backend_x64/a32_interface.cpp
          backend_x64/a32_jitstate.cpp
          backend_x64/a32_jitstate.h
+         backend_x64/a64_emit_x64.cpp
+         backend_x64/a64_emit_x64.h
+         backend_x64/a64_interface.cpp
+         backend_x64/a64_jitstate.cpp
+         backend_x64/a64_jitstate.h
          backend_x64/abi.cpp
          backend_x64/abi.h
          backend_x64/block_of_code.cpp
          backend_x64/block_of_code.h
+         backend_x64/callback.cpp
+         backend_x64/callback.h
          backend_x64/constant_pool.cpp
          backend_x64/constant_pool.h
          backend_x64/emit_x64.cpp

src/backend_x64/a32_emit_x64.cpp

@@ -101,9 +101,11 @@ A32EmitX64::BlockDescriptor A32EmitX64::Emit(IR::Block& block) {
         case IR::Opcode::A32##name:                \
             A32EmitX64::EmitA32##name(ctx, inst);  \
             break;
+#define A64OPC(...)
 #include "frontend/ir/opcodes.inc"
 #undef OPCODE
 #undef A32OPC
+#undef A64OPC
 
         default:
             ASSERT_MSG(false, "Invalid opcode %zu", static_cast<size_t>(inst->GetOpcode()));

src/backend_x64/a32_interface.cpp

@@ -17,6 +17,7 @@
 #include "backend_x64/a32_emit_x64.h"
 #include "backend_x64/a32_jitstate.h"
 #include "backend_x64/block_of_code.h"
+#include "backend_x64/callback.h"
 #include "backend_x64/jitstate_info.h"
 #include "common/assert.h"
 #include "common/common_types.h"
@@ -33,12 +34,11 @@ namespace A32 {
 
 using namespace BackendX64;
 
-RunCodeCallbacks GenRunCodeCallbacks(A32::UserCallbacks cb, CodePtr (*LookupBlock)(void* lookup_block_arg), void* arg) {
+static RunCodeCallbacks GenRunCodeCallbacks(A32::UserCallbacks cb, CodePtr (*LookupBlock)(void* lookup_block_arg), void* arg) {
     return RunCodeCallbacks{
-        LookupBlock,
-        arg,
-        cb.AddTicks,
-        cb.GetTicksRemaining
+        std::make_unique<ArgCallback>(LookupBlock, reinterpret_cast<u64>(arg)),
+        std::make_unique<SimpleCallback>(cb.AddTicks),
+        std::make_unique<SimpleCallback>(cb.GetTicksRemaining),
     };
 }
 

src/backend_x64/a64_emit_x64.cpp

@@ -0,0 +1,211 @@
+/* This file is part of the dynarmic project.
+ * Copyright (c) 2016 MerryMage
+ * This software may be used and distributed according to the terms of the GNU
+ * General Public License version 2 or any later version.
+ */
+
+#include <unordered_map>
+#include <unordered_set>
+
+#include "backend_x64/a64_emit_x64.h"
+#include "backend_x64/a64_jitstate.h"
+#include "backend_x64/abi.h"
+#include "backend_x64/block_of_code.h"
+#include "backend_x64/emit_x64.h"
+#include "common/address_range.h"
+#include "common/assert.h"
+#include "common/bit_util.h"
+#include "common/common_types.h"
+#include "common/variant_util.h"
+#include "frontend/A64/location_descriptor.h"
+#include "frontend/A64/types.h"
+#include "frontend/ir/basic_block.h"
+#include "frontend/ir/microinstruction.h"
+#include "frontend/ir/opcodes.h"
+
+// TODO: Have ARM flags in host flags and not have them use up GPR registers unless necessary.
+// TODO: Actually implement that proper instruction selector you've always wanted to sweetheart.
+
+namespace Dynarmic {
+namespace BackendX64 {
+
+using namespace Xbyak::util;
+
+A64EmitContext::A64EmitContext(RegAlloc& reg_alloc, IR::Block& block)
+    : EmitContext(reg_alloc, block) {}
+
+A64::LocationDescriptor A64EmitContext::Location() const {
+    return A64::LocationDescriptor{block.Location()};
+}
+
+bool A64EmitContext::FPSCR_RoundTowardsZero() const {
+    return Location().FPCR().RMode() != A64::FPCR::RoundingMode::TowardsZero;
+}
+
+bool A64EmitContext::FPSCR_FTZ() const {
+    return Location().FPCR().FZ();
+}
+
+bool A64EmitContext::FPSCR_DN() const {
+    return Location().FPCR().DN();
+}
+
+A64EmitX64::A64EmitX64(BlockOfCode* code, A64::UserConfig conf)
+    : EmitX64(code), conf(conf)
+{
+    code->PreludeComplete();
+}
+
+A64EmitX64::~A64EmitX64() {}
+
+A64EmitX64::BlockDescriptor A64EmitX64::Emit(IR::Block& block) {
+    code->align();
+    const u8* const entrypoint = code->getCurr();
+
+    // Start emitting.
+    EmitCondPrelude(block);
+
+    RegAlloc reg_alloc{code, A64JitState::SpillCount, SpillToOpArg<A64JitState>};
+    A64EmitContext ctx{reg_alloc, block};
+
+    for (auto iter = block.begin(); iter != block.end(); ++iter) {
+        IR::Inst* inst = &*iter;
+
+        // Call the relevant Emit* member function.
+        switch (inst->GetOpcode()) {
+
+#define OPCODE(name, type, ...)                 \
+        case IR::Opcode::name:                  \
+            A64EmitX64::Emit##name(ctx, inst);  \
+            break;
+#define A32OPC(...)
+#define A64OPC(name, type, ...)                    \
+        case IR::Opcode::A64##name:                \
+            A64EmitX64::EmitA64##name(ctx, inst);  \
+            break;
+#include "frontend/ir/opcodes.inc"
+#undef OPCODE
+#undef A32OPC
+#undef A64OPC
+
+        default:
+            ASSERT_MSG(false, "Invalid opcode %zu", static_cast<size_t>(inst->GetOpcode()));
+            break;
+        }
+
+        reg_alloc.EndOfAllocScope();
+    }
+
+    reg_alloc.AssertNoMoreUses();
+
+    EmitAddCycles(block.CycleCount());
+    EmitX64::EmitTerminal(block.GetTerminal(), block.Location());
+    code->int3();
+
+    const A64::LocationDescriptor descriptor{block.Location()};
+    Patch(descriptor, entrypoint);
+
+    const size_t size = static_cast<size_t>(code->getCurr() - entrypoint);
+    const A64::LocationDescriptor end_location{block.EndLocation()};
+    const auto range = boost::icl::discrete_interval<u64>::closed(descriptor.PC(), end_location.PC() - 1);
+    A64EmitX64::BlockDescriptor block_desc{entrypoint, size, block.Location(), range};
+    block_descriptors.emplace(descriptor.UniqueHash(), block_desc);
+    block_ranges.add(std::make_pair(range, std::set<IR::LocationDescriptor>{descriptor}));
+
+    return block_desc;
+}
+
+void A64EmitX64::EmitTerminalImpl(IR::Term::Interpret terminal, IR::LocationDescriptor) {
+    code->mov(code->ABI_PARAM1.cvt32(), A64::LocationDescriptor{terminal.next}.PC());
+    //code->mov(code->ABI_PARAM2, reinterpret_cast<u64>(jit_interface));
+    //code->mov(code->ABI_PARAM3, reinterpret_cast<u64>(cb.user_arg));
+    //code->mov(MJitStateReg(A64::Reg::PC), code->ABI_PARAM1.cvt32());
+    code->SwitchMxcsrOnExit();
+    //code->CallFunction(cb.InterpreterFallback);
+    code->ReturnFromRunCode(true); // TODO: Check cycles
+}
+
+void A64EmitX64::EmitTerminalImpl(IR::Term::ReturnToDispatch, IR::LocationDescriptor) {
+    code->ReturnFromRunCode();
+}
+
+void A64EmitX64::EmitTerminalImpl(IR::Term::LinkBlock terminal, IR::LocationDescriptor) {
+    code->cmp(qword[r15 + offsetof(A64JitState, cycles_remaining)], 0);
+
+    patch_information[terminal.next].jg.emplace_back(code->getCurr());
+    if (auto next_bb = GetBasicBlock(terminal.next)) {
+        EmitPatchJg(terminal.next, next_bb->entrypoint);
+    } else {
+        EmitPatchJg(terminal.next);
+    }
+    Xbyak::Label dest;
+    code->jmp(dest, Xbyak::CodeGenerator::T_NEAR);
+
+    code->SwitchToFarCode();
+    code->align(16);
+    code->L(dest);
+    //code->mov(MJitStateReg(A64::Reg::PC), A64::LocationDescriptor{terminal.next}.PC());
+    PushRSBHelper(rax, rbx, terminal.next);
+    code->ForceReturnFromRunCode();
+    code->SwitchToNearCode();
+}
+
+void A64EmitX64::EmitTerminalImpl(IR::Term::LinkBlockFast terminal, IR::LocationDescriptor) {
+    patch_information[terminal.next].jmp.emplace_back(code->getCurr());
+    if (auto next_bb = GetBasicBlock(terminal.next)) {
+        EmitPatchJmp(terminal.next, next_bb->entrypoint);
+    } else {
+        EmitPatchJmp(terminal.next);
+    }
+}
+
+void A64EmitX64::EmitTerminalImpl(IR::Term::PopRSBHint, IR::LocationDescriptor) {
+    ASSERT(false);
+}
+
+void A64EmitX64::EmitTerminalImpl(IR::Term::If terminal, IR::LocationDescriptor initial_location) {
+    Xbyak::Label pass = EmitCond(terminal.if_);
+    EmitTerminal(terminal.else_, initial_location);
+    code->L(pass);
+    EmitTerminal(terminal.then_, initial_location);
+}
+
+void A64EmitX64::EmitTerminalImpl(IR::Term::CheckHalt terminal, IR::LocationDescriptor initial_location) {
+    code->cmp(code->byte[r15 + offsetof(A64JitState, halt_requested)], u8(0));
+    code->jne(code->GetForceReturnFromRunCodeAddress());
+    EmitTerminal(terminal.else_, initial_location);
+}
+
+void A64EmitX64::EmitPatchJg(const IR::LocationDescriptor& /*target_desc*/, CodePtr target_code_ptr) {
+    const CodePtr patch_location = code->getCurr();
+    if (target_code_ptr) {
+        code->jg(target_code_ptr);
+    } else {
+        //code->mov(MJitStateReg(A64::Reg::PC), A64::LocationDescriptor{target_desc}.PC());
+        code->jg(code->GetReturnFromRunCodeAddress());
+    }
+    code->EnsurePatchLocationSize(patch_location, 14);
+}
+
+void A64EmitX64::EmitPatchJmp(const IR::LocationDescriptor& /*target_desc*/, CodePtr target_code_ptr) {
+    const CodePtr patch_location = code->getCurr();
+    if (target_code_ptr) {
+        code->jmp(target_code_ptr);
+    } else {
+        //code->mov(MJitStateReg(A64::Reg::PC), A64::LocationDescriptor{target_desc}.PC());
+        code->jmp(code->GetReturnFromRunCodeAddress());
+    }
+    code->EnsurePatchLocationSize(patch_location, 13);
+}
+
+void A64EmitX64::EmitPatchMovRcx(CodePtr target_code_ptr) {
+    if (!target_code_ptr) {
+        target_code_ptr = code->GetReturnFromRunCodeAddress();
+    }
+    const CodePtr patch_location = code->getCurr();
+    code->mov(code->rcx, reinterpret_cast<u64>(target_code_ptr));
+    code->EnsurePatchLocationSize(patch_location, 10);
+}
+
+} // namespace BackendX64
+} // namespace Dynarmic

src/backend_x64/a64_emit_x64.h

@@ -0,0 +1,78 @@
+/* This file is part of the dynarmic project.
+ * Copyright (c) 2016 MerryMage
+ * This software may be used and distributed according to the terms of the GNU
+ * General Public License version 2 or any later version.
+ */
+
+#pragma once
+
+#include <unordered_map>
+#include <vector>
+
+#include <boost/icl/interval_map.hpp>
+#include <boost/icl/interval_set.hpp>
+#include <boost/optional.hpp>
+
+#include <xbyak_util.h>
+
+#include "backend_x64/a64_jitstate.h"
+#include "backend_x64/emit_x64.h"
+#include "common/address_range.h"
+#include "dynarmic/A64/a64.h"
+#include "dynarmic/A64/config.h"
+#include "frontend/A64/location_descriptor.h"
+#include "frontend/ir/terminal.h"
+
+namespace Dynarmic {
+namespace BackendX64 {
+
+class RegAlloc;
+
+struct A64EmitContext final : public EmitContext {
+    A64EmitContext(RegAlloc& reg_alloc, IR::Block& block);
+    A64::LocationDescriptor Location() const;
+    bool FPSCR_RoundTowardsZero() const override;
+    bool FPSCR_FTZ() const override;
+    bool FPSCR_DN() const override;
+};
+
+class A64EmitX64 final : public EmitX64<A64JitState> {
+public:
+    A64EmitX64(BlockOfCode* code, A64::UserConfig conf);
+    ~A64EmitX64();
+
+    /**
+     * Emit host machine code for a basic block with intermediate representation `ir`.
+     * @note ir is modified.
+     */
+    BlockDescriptor Emit(IR::Block& ir);
+
+protected:
+    const A64::UserConfig conf;
+
+    // Microinstruction emitters
+#define OPCODE(...)
+#define A32OPC(...)
+#define A64OPC(name, type, ...) void EmitA64##name(A64EmitContext& ctx, IR::Inst* inst);
+#include "frontend/ir/opcodes.inc"
+#undef OPCODE
+#undef A32OPC
+#undef A64OPC
+
+    // Terminal instruction emitters
+    void EmitTerminalImpl(IR::Term::Interpret terminal, IR::LocationDescriptor initial_location) override;
+    void EmitTerminalImpl(IR::Term::ReturnToDispatch terminal, IR::LocationDescriptor initial_location) override;
+    void EmitTerminalImpl(IR::Term::LinkBlock terminal, IR::LocationDescriptor initial_location) override;
+    void EmitTerminalImpl(IR::Term::LinkBlockFast terminal, IR::LocationDescriptor initial_location) override;
+    void EmitTerminalImpl(IR::Term::PopRSBHint terminal, IR::LocationDescriptor initial_location) override;
+    void EmitTerminalImpl(IR::Term::If terminal, IR::LocationDescriptor initial_location) override;
+    void EmitTerminalImpl(IR::Term::CheckHalt terminal, IR::LocationDescriptor initial_location) override;
+
+    // Patching
+    void EmitPatchJg(const IR::LocationDescriptor& target_desc, CodePtr target_code_ptr = nullptr) override;
+    void EmitPatchJmp(const IR::LocationDescriptor& target_desc, CodePtr target_code_ptr = nullptr) override;
+    void EmitPatchMovRcx(CodePtr target_code_ptr = nullptr) override;
+};
+
+} // namespace BackendX64
+} // namespace Dynarmic

src/backend_x64/a64_interface.cpp

@@ -0,0 +1,263 @@
+/* This file is part of the dynarmic project.
+ * Copyright (c) 2016 MerryMage
+ * This software may be used and distributed according to the terms of the GNU
+ * General Public License version 2 or any later version.
+ */
+
+#include <memory>
+
+#include <boost/icl/interval_set.hpp>
+
+#include "backend_x64/a64_emit_x64.h"
+#include "backend_x64/a64_jitstate.h"
+#include "backend_x64/block_of_code.h"
+#include "backend_x64/jitstate_info.h"
+#include "common/assert.h"
+#include "common/scope_exit.h"
+#include "dynarmic/A64/a64.h"
+#include "frontend/A64/translate/translate.h"
+#include "frontend/ir/basic_block.h"
+#include "ir_opt/passes.h"
+
+namespace Dynarmic {
+namespace A64 {
+
+using namespace BackendX64;
+
+template <auto fn, typename Ret, typename ...Args>
+static Ret Thunk(A64::UserCallbacks* cb, Args... args) {
+    return (cb->*fn)(std::forward<Args>(args)...);
+}
+
+static RunCodeCallbacks GenRunCodeCallbacks(A64::UserCallbacks* cb, CodePtr (*LookupBlock)(void* lookup_block_arg), void* arg) {
+    return RunCodeCallbacks{
+        std::make_unique<ArgCallback>(LookupBlock, reinterpret_cast<u64>(arg)),
+        std::make_unique<ArgCallback>(&Thunk<&A64::UserCallbacks::AddTicks, void, u64>, reinterpret_cast<u64>(cb)),
+        std::make_unique<ArgCallback>(&Thunk<&A64::UserCallbacks::GetTicksRemaining, u64>, reinterpret_cast<u64>(cb)),
+    };
+}
+
+struct Jit::Impl final {
+public:
+    explicit Impl(UserConfig conf)
+        : conf(conf) 
+        , block_of_code(GenRunCodeCallbacks(conf.callbacks, &GetCurrentBlockThunk, this), JitStateInfo{jit_state})
+        , emitter(&block_of_code, conf)
+    {}
+
+    ~Impl() = default;
+
+    void Run() {
+        ASSERT(!is_executing);
+        is_executing = true;
+        SCOPE_EXIT({ this->is_executing = false; });
+        jit_state.halt_requested = false;
+
+        block_of_code.RunCode(&jit_state);
+
+        PerformRequestedCacheInvalidation();
+    }
+
+    void ClearCache() {
+        invalidate_entire_cache = true;
+        RequestCacheInvalidation();
+    }
+
+    void InvalidateCacheRange(u64 start_address, size_t length) {
+        const auto end_address = static_cast<u64>(start_address + length - 1);
+        const auto range = boost::icl::discrete_interval<u64>::closed(start_address, end_address);
+        invalid_cache_ranges.add(range);
+        RequestCacheInvalidation();
+    }
+
+    void Reset() {
+        ASSERT(!is_executing);
+        jit_state = {};
+    }
+
+    void HaltExecution() {
+        jit_state.halt_requested = true;
+    }
+
+    u64 GetSP() const {
+        return jit_state.sp;
+    }
+
+    void SetSP(u64 value) {
+        jit_state.sp = value;
+    }
+
+    u64 GetPC() const {
+        return jit_state.pc;
+    }
+
+    void SetPC(u64 value) {
+        jit_state.pc = value;
+    }
+
+    u64 GetRegister(size_t index) const {
+        if (index == 31)
+            return GetSP();
+        return jit_state.reg.at(index);
+    }
+
+    void SetRegister(size_t index, u64 value) {
+        if (index == 31)
+            return SetSP(value);
+        jit_state.reg.at(index) = value;
+    }
+
+    Vector GetVector(size_t index) const {
+        return {jit_state.vec.at(index * 2), jit_state.vec.at(index * 2 + 1)};
+    }
+
+    void SetVector(size_t index, Vector value) {
+        jit_state.vec.at(index * 2) = value.low;
+        jit_state.vec.at(index * 2 + 1) = value.high;
+    }
+
+    u32 GetFpcr() const {
+        return jit_state.GetFpcr();
+    }
+
+    void SetFpcr(u32 value) {
+        jit_state.SetFpcr(value);
+    }
+
+    bool IsExecuting() const {
+        return is_executing;
+    }
+
+private:
+    static CodePtr GetCurrentBlockThunk(void* thisptr) {
+        Jit::Impl* this_ = reinterpret_cast<Jit::Impl*>(thisptr);
+        return this_->GetCurrentBlock();
+    }
+
+    CodePtr GetCurrentBlock() {
+        IR::LocationDescriptor current_location{jit_state.GetUniqueHash()};
+
+        if (auto block = emitter.GetBasicBlock(current_location))
+            return block->entrypoint;
+
+        constexpr size_t MINIMUM_REMAINING_CODESIZE = 1 * 1024 * 1024;
+        if (block_of_code.SpaceRemaining() < MINIMUM_REMAINING_CODESIZE) {
+            // Immediately evacuate cache
+            invalidate_entire_cache = true;
+            PerformRequestedCacheInvalidation();
+        }
+
+        // JIT Compile
+        IR::Block ir_block = A64::Translate(A64::LocationDescriptor{current_location}, [this](u64 vaddr) { return conf.callbacks->MemoryReadCode(vaddr); });
+        Optimization::DeadCodeElimination(ir_block);
+        Optimization::VerificationPass(ir_block);
+        return emitter.Emit(ir_block).entrypoint;
+    }
+
+    void RequestCacheInvalidation() {
+        if (is_executing) {
+            jit_state.halt_requested = true;
+            return;
+        }
+
+        PerformRequestedCacheInvalidation();
+    }
+
+    void PerformRequestedCacheInvalidation() {
+        if (!invalidate_entire_cache && invalid_cache_ranges.empty()) {
+            return;
+        }
+
+        jit_state.ResetRSB();
+        if (invalidate_entire_cache) {
+            block_of_code.ClearCache();
+            emitter.ClearCache();
+        } else {
+            emitter.InvalidateCacheRanges(invalid_cache_ranges);
+        }
+        invalid_cache_ranges.clear();
+        invalidate_entire_cache = false;
+    }
+
+    bool is_executing = false;
+
+    UserConfig conf;
+    A64JitState jit_state;
+    BlockOfCode block_of_code;
+    A64EmitX64 emitter;
+
+    bool invalidate_entire_cache = false;
+    boost::icl::interval_set<u64> invalid_cache_ranges;
+};
+
+Jit::Jit(UserConfig conf)
+    : impl(std::make_unique<Jit::Impl>(conf)) {}
+
+Jit::~Jit() = default;
+
+void Jit::Run() {
+    impl->Run();
+}
+
+void Jit::ClearCache() {
+    impl->ClearCache();
+}
+
+void Jit::InvalidateCacheRange(u64 start_address, size_t length) {
+    impl->InvalidateCacheRange(start_address, length);
+}
+
+void Jit::Reset() {
+    impl->Reset();
+}
+
+void Jit::HaltExecution() {
+    impl->HaltExecution();
+}
+
+u64 Jit::GetSP() const {
+    return impl->GetSP();
+}
+
+void Jit::SetSP(u64 value) {
+    impl->SetSP(value);
+}
+
+u64 Jit::GetPC() const {
+    return impl->GetPC();
+}
+
+void Jit::SetPC(u64 value) {
+    impl->SetPC(value);
+}
+
+u64 Jit::GetRegister(size_t index) const {
+    return impl->GetRegister(index);
+}
+
+void Jit::SetRegister(size_t index, u64 value) {
+    impl->SetRegister(index, value);
+}
+
+Jit::Vector Jit::GetVector(size_t index) const {
+    return impl->GetVector(index);
+}
+
+void Jit::SetVector(size_t index, Vector value) {
+    impl->SetVector(index, value);
+}
+
+u32 Jit::GetFpcr() const {
+    return impl->GetFpcr();
+}
+
+void Jit::SetFpcr(u32 value) {
+    impl->SetFpcr(value);
+}
+
+bool Jit::IsExecuting() const {
+    return impl->IsExecuting();
+}
+
+} // namespace A64
+} // namespace Dynarmic

src/backend_x64/a64_jitstate.cpp

@@ -0,0 +1,20 @@
+/* This file is part of the dynarmic project.
+ * Copyright (c) 2016 MerryMage
+ * This software may be used and distributed according to the terms of the GNU
+ * General Public License version 2 or any later version.
+ */
+
+#include "backend_x64/a64_jitstate.h"
+#include "frontend/A64/location_descriptor.h"
+
+namespace Dynarmic {
+namespace BackendX64 {
+
+u64 A64JitState::GetUniqueHash() const {
+    u64 fpcr_u64 = static_cast<u64>(fpcr & A64::LocationDescriptor::FPCR_MASK) << 37;
+    u64 pc_u64 = pc & A64::LocationDescriptor::PC_MASK;
+    return pc_u64 | fpcr_u64;
+}
+
+} // namespace BackendX64
+} // namespace Dynarmic

src/backend_x64/a64_jitstate.h

@@ -0,0 +1,79 @@
+/* This file is part of the dynarmic project.
+ * Copyright (c) 2016 MerryMage
+ * This software may be used and distributed according to the terms of the GNU
+ * General Public License version 2 or any later version.
+ */
+
+#pragma once
+
+#include <array>
+
+#include <xbyak.h>
+
+#include "common/common_types.h"
+
+namespace Dynarmic {
+namespace BackendX64 {
+
+class BlockOfCode;
+
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable:4324) // Structure was padded due to alignment specifier
+#endif
+
+struct A64JitState {
+    using ProgramCounterType = u64;
+
+    A64JitState() { ResetRSB(); }
+
+    std::array<u64, 31> reg{};
+    u64 sp;
+    u64 pc;
+
+    u32 CPSR_nzcv = 0;
+    u32 FPSCR_nzcv = 0;
+
+    alignas(16) std::array<u64, 64> vec{}; // Extension registers.
+
+    static constexpr size_t SpillCount = 64;
+    std::array<u64, SpillCount> spill{}; // Spill.
+    static Xbyak::Address GetSpillLocationFromIndex(size_t i) {
+        using namespace Xbyak::util;
+        return qword[r15 + offsetof(A64JitState, spill) + i * sizeof(u64)];
+    }
+
+    // For internal use (See: BlockOfCode::RunCode)
+    u32 guest_MXCSR = 0x00001f80;
+    u32 save_host_MXCSR = 0;
+    s64 cycles_to_run = 0;
+    s64 cycles_remaining = 0;
+    bool halt_requested = false;
+
+    static constexpr size_t RSBSize = 8; // MUST be a power of 2.
+    static constexpr size_t RSBPtrMask = RSBSize - 1;
+    u32 rsb_ptr = 0;
+    std::array<u64, RSBSize> rsb_location_descriptors;
+    std::array<u64, RSBSize> rsb_codeptrs;
+    void ResetRSB() {
+        rsb_location_descriptors.fill(0xFFFFFFFFFFFFFFFFull);
+        rsb_codeptrs.fill(0);
+    }
+
+    u32 FPSCR_IDC = 0;
+    u32 FPSCR_UFC = 0;
+    u32 fpcr = 0;
+    u32 GetFpcr() const { return fpcr; }
+    void SetFpcr(u32 new_fpcr) { fpcr = new_fpcr; }
+
+    u64 GetUniqueHash() const;
+};
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+using CodePtr = const void*;
+
+} // namespace BackendX64
+} // namespace Dynarmic

src/backend_x64/block_of_code.cpp

@@ -36,7 +36,7 @@ constexpr size_t FAR_CODE_OFFSET = 100 * 1024 * 1024;
 
 BlockOfCode::BlockOfCode(RunCodeCallbacks cb, JitStateInfo jsi)
         : Xbyak::CodeGenerator(TOTAL_CODE_SIZE)
-        , cb(cb)
+        , cb(std::move(cb))
         , jsi(jsi)
         , constant_pool(this, 256)
 {
@@ -112,7 +112,7 @@ void BlockOfCode::GenRunCode() {
     mov(r15, ABI_PARAM1);
     mov(r14, ABI_PARAM2); // save temporarily in non-volatile register
 
-    CallFunction(cb.GetTicksRemaining);
+    cb.GetTicksRemaining->EmitCall(this);
     mov(qword[r15 + jsi.offsetof_cycles_to_run], ABI_RETURN);
     mov(qword[r15 + jsi.offsetof_cycles_remaining], ABI_RETURN);
 
@@ -130,15 +130,14 @@ void BlockOfCode::GenRunCode() {
 
     mov(r15, ABI_PARAM1);
 
-    CallFunction(cb.GetTicksRemaining);
+    cb.GetTicksRemaining->EmitCall(this);
     mov(qword[r15 + jsi.offsetof_cycles_to_run], ABI_RETURN);
     mov(qword[r15 + jsi.offsetof_cycles_remaining], ABI_RETURN);
 
     L(enter_mxcsr_then_loop);
     SwitchMxcsrOnEntry();
     L(loop);
-    mov(ABI_PARAM1, u64(cb.lookup_block_arg));
-    CallFunction(cb.LookupBlock);
+    cb.LookupBlock->EmitCall(this);
 
     jmp(ABI_RETURN);
 
@@ -153,9 +152,10 @@ void BlockOfCode::GenRunCode() {
             SwitchMxcsrOnExit();
         }
 
-        mov(ABI_PARAM1, qword[r15 + jsi.offsetof_cycles_to_run]);
-        sub(ABI_PARAM1, qword[r15 + jsi.offsetof_cycles_remaining]);
-        CallFunction(cb.AddTicks);
+        cb.AddTicks->EmitCall(this, [this](Xbyak::Reg64 param1) {
+            mov(param1, qword[r15 + jsi.offsetof_cycles_to_run]);
+            sub(param1, qword[r15 + jsi.offsetof_cycles_remaining]);
+        });
 
         ABI_PopCalleeSaveRegistersAndAdjustStack(this);
         ret();

src/backend_x64/block_of_code.h

@@ -12,6 +12,7 @@
 #include <xbyak.h>
 #include <xbyak_util.h>
 
+#include "backend_x64/callback.h"
 #include "backend_x64/constant_pool.h"
 #include "backend_x64/jitstate_info.h"
 #include "common/common_types.h"
@@ -23,11 +24,9 @@ namespace BackendX64 {
 using CodePtr = const void*;
 
 struct RunCodeCallbacks {
-    CodePtr (*LookupBlock)(void* lookup_block_arg);
-    void* lookup_block_arg;
-
-    void (*AddTicks)(std::uint64_t ticks);
-    std::uint64_t (*GetTicksRemaining)();
+    std::unique_ptr<Callback> LookupBlock;
+    std::unique_ptr<Callback> AddTicks;
+    std::unique_ptr<Callback> GetTicksRemaining;
 };
 
 class BlockOfCode final : public Xbyak::CodeGenerator {

src/backend_x64/callback.cpp

@@ -0,0 +1,58 @@
+/* This file is part of the dynarmic project.
+ * Copyright (c) 2018 MerryMage
+ * This software may be used and distributed according to the terms of the GNU
+ * General Public License version 2 or any later version.
+ */
+
+#include "backend_x64/block_of_code.h"
+#include "backend_x64/callback.h"
+
+namespace Dynarmic {
+namespace BackendX64 {
+
+void SimpleCallback::EmitCall(BlockOfCode* code, std::function<void()> l) {
+    l();
+    code->CallFunction(fn);
+}
+
+void SimpleCallback::EmitCall(BlockOfCode* code, std::function<void(Xbyak::Reg64)> l) {
+    l(code->ABI_PARAM1);
+    code->CallFunction(fn);
+}
+
+void SimpleCallback::EmitCall(BlockOfCode* code, std::function<void(Xbyak::Reg64, Xbyak::Reg64)> l) {
+    l(code->ABI_PARAM1, code->ABI_PARAM2);
+    code->CallFunction(fn);
+}
+
+void SimpleCallback::EmitCall(BlockOfCode* code, std::function<void(Xbyak::Reg64, Xbyak::Reg64, Xbyak::Reg64)> l) {
+    l(code->ABI_PARAM1, code->ABI_PARAM2, code->ABI_PARAM3);
+    code->CallFunction(fn);
+}
+
+void ArgCallback::EmitCall(BlockOfCode* code, std::function<void()> l) {
+    code->mov(code->ABI_PARAM1, arg);
+    l();
+    code->CallFunction(fn);
+}
+
+void ArgCallback::EmitCall(BlockOfCode* code, std::function<void(Xbyak::Reg64)> l) {
+    code->mov(code->ABI_PARAM1, arg);
+    l(code->ABI_PARAM2);
+    code->CallFunction(fn);
+}
+
+void ArgCallback::EmitCall(BlockOfCode* code, std::function<void(Xbyak::Reg64, Xbyak::Reg64)> l) {
+    code->mov(code->ABI_PARAM1, arg);
+    l(code->ABI_PARAM2, code->ABI_PARAM3);
+    code->CallFunction(fn);
+}
+
+void ArgCallback::EmitCall(BlockOfCode* code, std::function<void(Xbyak::Reg64, Xbyak::Reg64, Xbyak::Reg64)> l) {
+    code->mov(code->ABI_PARAM1, arg);
+    l(code->ABI_PARAM2, code->ABI_PARAM3, code->ABI_PARAM4);
+    code->CallFunction(fn);
+}
+
+} // namespace BackendX64
+} // namespace Dynarmic

src/backend_x64/callback.h

@@ -0,0 +1,64 @@
+/* This file is part of the dynarmic project.
+ * Copyright (c) 2018 MerryMage
+ * This software may be used and distributed according to the terms of the GNU
+ * General Public License version 2 or any later version.
+ */
+
+#pragma once
+
+#include <functional>
+
+#include <xbyak.h>
+
+#include "common/common_types.h"
+
+namespace Dynarmic {
+namespace BackendX64 {
+
+class BlockOfCode;
+
+class Callback {
+public:
+    virtual ~Callback() = default;
+
+    virtual void EmitCall(BlockOfCode* code, std::function<void()> fn = []{}) = 0;
+    virtual void EmitCall(BlockOfCode* code, std::function<void(Xbyak::Reg64)> fn) = 0;
+    virtual void EmitCall(BlockOfCode* code, std::function<void(Xbyak::Reg64, Xbyak::Reg64)> fn) = 0;
+    virtual void EmitCall(BlockOfCode* code, std::function<void(Xbyak::Reg64, Xbyak::Reg64, Xbyak::Reg64)> fn) = 0;
+};
+
+class SimpleCallback final : public Callback {
+public:
+    template <typename Function>
+    SimpleCallback(Function fn) : fn(reinterpret_cast<void(*)()>(fn)) {}
+
+    ~SimpleCallback() = default;
+
+    void EmitCall(BlockOfCode* code, std::function<void()> l = []{}) override;
+    void EmitCall(BlockOfCode* code, std::function<void(Xbyak::Reg64)> l) override;
+    void EmitCall(BlockOfCode* code, std::function<void(Xbyak::Reg64, Xbyak::Reg64)> l) override;
+    void EmitCall(BlockOfCode* code, std::function<void(Xbyak::Reg64, Xbyak::Reg64, Xbyak::Reg64)> l) override;
+
+private:
+    void (*fn)();
+};
+
+class ArgCallback final : public Callback {
+public:
+    template <typename Function>
+    ArgCallback(Function fn, u64 arg) : fn(reinterpret_cast<void(*)()>(fn)), arg(arg) {}
+
+    ~ArgCallback() = default;
+
+    void EmitCall(BlockOfCode* code, std::function<void()> l = []{}) override;
+    void EmitCall(BlockOfCode* code, std::function<void(Xbyak::Reg64)> l) override;
+    void EmitCall(BlockOfCode* code, std::function<void(Xbyak::Reg64, Xbyak::Reg64)> l) override;
+    void EmitCall(BlockOfCode* code, std::function<void(Xbyak::Reg64, Xbyak::Reg64, Xbyak::Reg64)> l) override;
+
+private:
+    void (*fn)();
+    u64 arg;
+};
+
+} // namespace BackendX64
+} // namespace Dynarmic

src/backend_x64/emit_x64.cpp

@@ -2668,5 +2668,7 @@ void EmitX64<JST>::InvalidateCacheRanges(const boost::icl::interval_set<ProgramC
 } // namespace Dynarmic
 
 #include "backend_x64/a32_jitstate.h"
+#include "backend_x64/a64_jitstate.h"
 
 template class Dynarmic::BackendX64::EmitX64<Dynarmic::BackendX64::A32JitState>;
+template class Dynarmic::BackendX64::EmitX64<Dynarmic::BackendX64::A64JitState>;

src/backend_x64/emit_x64.h

@@ -72,9 +72,11 @@ protected:
     // Microinstruction emitters
 #define OPCODE(name, type, ...) void Emit##name(EmitContext& ctx, IR::Inst* inst);
 #define A32OPC(...)
+#define A64OPC(...)
 #include "frontend/ir/opcodes.inc"
 #undef OPCODE
 #undef A32OPC
+#undef A64OPC
 
     // Helpers
     void EmitAddCycles(size_t cycles);

src/frontend/A64/ir_emitter.cpp

@@ -0,0 +1,42 @@
+/* This file is part of the dynarmic project.
+ * Copyright (c) 2016 MerryMage
+ * This software may be used and distributed according to the terms of the GNU
+ * General Public License version 2 or any later version.
+ */
+
+#include "common/assert.h"
+#include "frontend/A64/ir_emitter.h"
+#include "frontend/ir/opcodes.h"
+
+namespace Dynarmic {
+namespace A64 {
+
+using Opcode = IR::Opcode;
+
+u64 IREmitter::PC() {
+    return current_location.PC();
+}
+
+u64 IREmitter::AlignPC(size_t alignment) {
+    u64 pc = PC();
+    return static_cast<u64>(pc - pc % alignment);
+}
+
+IR::U32 IREmitter::GetW(Reg reg) {
+    return Inst<IR::U32>(Opcode::A64GetW, IR::Value(reg));
+}
+
+IR::U64 IREmitter::GetX(Reg reg) {
+    return Inst<IR::U64>(Opcode::A64GetX, IR::Value(reg));
+}
+
+void IREmitter::SetW(const Reg reg, const IR::U32& value) {
+    Inst(Opcode::A64SetW, IR::Value(reg), value);
+}
+
+void IREmitter::SetX(const Reg reg, const IR::U64& value) {
+    Inst(Opcode::A64SetX, IR::Value(reg), value);
+}
+
+} // namespace IR
+} // namespace Dynarmic

src/frontend/A64/ir_emitter.h

@@ -0,0 +1,41 @@
+/* This file is part of the dynarmic project.
+ * Copyright (c) 2016 MerryMage
+ * This software may be used and distributed according to the terms of the GNU
+ * General Public License version 2 or any later version.
+ */
+
+#pragma once
+
+#include <initializer_list>
+
+#include "common/common_types.h"
+#include "frontend/A64/location_descriptor.h"
+#include "frontend/A64/types.h"
+#include "frontend/ir/ir_emitter.h"
+#include "frontend/ir/value.h"
+
+namespace Dynarmic {
+namespace A64 {
+
+/**
+ * Convenience class to construct a basic block of the intermediate representation.
+ * `block` is the resulting block.
+ * The user of this class updates `current_location` as appropriate.
+ */
+class IREmitter : public IR::IREmitter {
+public:
+    explicit IREmitter(LocationDescriptor descriptor) : IR::IREmitter(descriptor), current_location(descriptor) {}
+
+    LocationDescriptor current_location;
+
+    u64 PC();
+    u64 AlignPC(size_t alignment);
+
+    IR::U32 GetW(Reg source_reg);
+    IR::U64 GetX(Reg source_reg);
+    void SetW(Reg dest_reg, const IR::U32& value);
+    void SetX(Reg dest_reg, const IR::U64& value);
+};
+
+} // namespace IR
+} // namespace Dynarmic

src/frontend/A64/translate/translate.h

@@ -5,6 +5,8 @@
  */
 #pragma once
 
+#include <functional>
+
 #include "common/common_types.h"
 
 namespace Dynarmic {
@@ -17,7 +19,7 @@ namespace A64 {
 
 class LocationDescriptor;
 
-using MemoryReadCodeFuncType = u32 (*)(u64 vaddr);
+using MemoryReadCodeFuncType = std::function<u32(u64 vaddr)>;
 
 /**
  * This function translates instructions in memory into our intermediate representation.