early-access version 1730

externals/dynarmic/tests/A32/testenv.h

@@ -11,12 +11,11 @@
 #include <string>
 #include <vector>
 
-#include <dynarmic/A32/a32.h>
+#include "dynarmic/common/assert.h"
+#include "dynarmic/common/common_types.h"
+#include "dynarmic/interface/A32/a32.h"
 
-#include "common/assert.h"
-#include "common/common_types.h"
-
-template <typename InstructionType_, u32 infinite_loop_u32>
+template<typename InstructionType_, u32 infinite_loop_u32>
 class A32TestEnv final : public Dynarmic::A32::UserCallbacks {
 public:
     using InstructionType = InstructionType_;
@@ -24,12 +23,12 @@ public:
     using ExtRegsArray = std::array<u32, 64>;
 
 #ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable:4309) // C4309: 'static_cast': truncation of constant value
+#    pragma warning(push)
+#    pragma warning(disable : 4309)  // C4309: 'static_cast': truncation of constant value
 #endif
     static constexpr InstructionType infinite_loop = static_cast<InstructionType>(infinite_loop_u32);
 #ifdef _MSC_VER
-#pragma warning(pop)
+#    pragma warning(pop)
 #endif
 
     u64 ticks_left = 0;
@@ -54,7 +53,7 @@ public:
             std::memcpy(&value, &code_mem[vaddr / sizeof(InstructionType)], sizeof(u32));
             return value;
         }
-        return infinite_loop_u32; // B .
+        return infinite_loop_u32;  // B .
     }
 
     std::uint8_t MemoryRead8(u32 vaddr) override {
@@ -115,3 +114,86 @@ public:
 
 using ArmTestEnv = A32TestEnv<u32, 0xEAFFFFFE>;
 using ThumbTestEnv = A32TestEnv<u16, 0xE7FEE7FE>;
+
+class A32FastmemTestEnv final : public Dynarmic::A32::UserCallbacks {
+public:
+    u64 ticks_left = 0;
+    char* backing_memory = nullptr;
+
+    explicit A32FastmemTestEnv(char* addr) : backing_memory(addr) {}
+
+    template<typename T>
+    T read(std::uint32_t vaddr) {
+        T value;
+        memcpy(&value, backing_memory + vaddr, sizeof(T));
+        return value;
+    }
+    template<typename T>
+    void write(std::uint32_t vaddr, const T& value) {
+        memcpy(backing_memory + vaddr, &value, sizeof(T));
+    }
+
+    std::uint32_t MemoryReadCode(std::uint32_t vaddr) override {
+        return read<std::uint32_t>(vaddr);
+    }
+
+    std::uint8_t MemoryRead8(std::uint32_t vaddr) override {
+        return read<std::uint8_t>(vaddr);
+    }
+    std::uint16_t MemoryRead16(std::uint32_t vaddr) override {
+        return read<std::uint16_t>(vaddr);
+    }
+    std::uint32_t MemoryRead32(std::uint32_t vaddr) override {
+        return read<std::uint32_t>(vaddr);
+    }
+    std::uint64_t MemoryRead64(std::uint32_t vaddr) override {
+        return read<std::uint64_t>(vaddr);
+    }
+
+    void MemoryWrite8(std::uint32_t vaddr, std::uint8_t value) override {
+        write(vaddr, value);
+    }
+    void MemoryWrite16(std::uint32_t vaddr, std::uint16_t value) override {
+        write(vaddr, value);
+    }
+    void MemoryWrite32(std::uint32_t vaddr, std::uint32_t value) override {
+        write(vaddr, value);
+    }
+    void MemoryWrite64(std::uint32_t vaddr, std::uint64_t value) override {
+        write(vaddr, value);
+    }
+
+    bool MemoryWriteExclusive8(std::uint32_t vaddr, std::uint8_t value, [[maybe_unused]] std::uint8_t expected) override {
+        MemoryWrite8(vaddr, value);
+        return true;
+    }
+    bool MemoryWriteExclusive16(std::uint32_t vaddr, std::uint16_t value, [[maybe_unused]] std::uint16_t expected) override {
+        MemoryWrite16(vaddr, value);
+        return true;
+    }
+    bool MemoryWriteExclusive32(std::uint32_t vaddr, std::uint32_t value, [[maybe_unused]] std::uint32_t expected) override {
+        MemoryWrite32(vaddr, value);
+        return true;
+    }
+    bool MemoryWriteExclusive64(std::uint32_t vaddr, std::uint64_t value, [[maybe_unused]] std::uint64_t expected) override {
+        MemoryWrite64(vaddr, value);
+        return true;
+    }
+
+    void InterpreterFallback(std::uint32_t pc, size_t num_instructions) override { ASSERT_MSG(false, "InterpreterFallback({:016x}, {})", pc, num_instructions); }
+
+    void CallSVC(std::uint32_t swi) override { ASSERT_MSG(false, "CallSVC({})", swi); }
+
+    void ExceptionRaised(std::uint32_t pc, Dynarmic::A32::Exception) override { ASSERT_MSG(false, "ExceptionRaised({:016x})", pc); }
+
+    void AddTicks(std::uint64_t ticks) override {
+        if (ticks > ticks_left) {
+            ticks_left = 0;
+            return;
+        }
+        ticks_left -= ticks;
+    }
+    std::uint64_t GetTicksRemaining() override {
+        return ticks_left;
+    }
+};