1 files changed, 21 insertions, 55 deletions

diff --git a/src/core/arm/dynarmic/arm_dynarmic_64.cpp b/src/core/arm/dynarmic/arm_dynarmic_64.cpp
index 7229fdc2a..bb97ed5bc 100644
--- a/src/core/arm/dynarmic/arm_dynarmic_64.cpp
+++ b/src/core/arm/dynarmic/arm_dynarmic_64.cpp
@@ -10,8 +10,9 @@
 #include "common/logging/log.h"
 #include "common/page_table.h"
 #include "common/settings.h"
+#include "core/arm/dynarmic/arm_dynarmic.h"
 #include "core/arm/dynarmic/arm_dynarmic_64.h"
-#include "core/arm/dynarmic/arm_exclusive_monitor.h"
+#include "core/arm/dynarmic/dynarmic_exclusive_monitor.h"
 #include "core/core.h"
 #include "core/core_timing.h"
 #include "core/debugger/debugger.h"
@@ -28,8 +29,8 @@ using namespace Common::Literals;
 class DynarmicCallbacks64 : public Dynarmic::A64::UserCallbacks {
 public:
     explicit DynarmicCallbacks64(ARM_Dynarmic_64& parent_)
-        : parent{parent_},
-          memory(parent.system.Memory()), debugger_enabled{parent.system.DebuggerEnabled()},
+        : parent{parent_}, memory(parent.system.ApplicationMemory()),
+          debugger_enabled{parent.system.DebuggerEnabled()},
           check_memory_access{debugger_enabled ||
                               !Settings::values.cpuopt_ignore_memory_aborts.GetValue()} {}
 
@@ -113,11 +114,11 @@ public:
         LOG_ERROR(Core_ARM,
                   "Unimplemented instruction @ 0x{:X} for {} instructions (instr = {:08X})", pc,
                   num_instructions, memory.Read32(pc));
-        ReturnException(pc, ARM_Interface::no_execute);
+        ReturnException(pc, PrefetchAbort);
     }
 
     void InstructionCacheOperationRaised(Dynarmic::A64::InstructionCacheOperation op,
-                                         VAddr value) override {
+                                         u64 value) override {
         switch (op) {
         case Dynarmic::A64::InstructionCacheOperation::InvalidateByVAToPoU: {
             static constexpr u64 ICACHE_LINE_SIZE = 64;
@@ -148,11 +149,11 @@ public:
             return;
         case Dynarmic::A64::Exception::NoExecuteFault:
             LOG_CRITICAL(Core_ARM, "Cannot execute instruction at unmapped address {:#016x}", pc);
-            ReturnException(pc, ARM_Interface::no_execute);
+            ReturnException(pc, PrefetchAbort);
             return;
         default:
             if (debugger_enabled) {
-                ReturnException(pc, ARM_Interface::breakpoint);
+                ReturnException(pc, InstructionBreakpoint);
                 return;
             }
 
@@ -164,7 +165,7 @@ public:
 
     void CallSVC(u32 swi) override {
         parent.svc_swi = swi;
-        parent.jit.load()->HaltExecution(ARM_Interface::svc_call);
+        parent.jit.load()->HaltExecution(SupervisorCall);
     }
 
     void AddTicks(u64 ticks) override {
@@ -199,7 +200,7 @@ public:
         return parent.system.CoreTiming().GetClockTicks();
     }
 
-    bool CheckMemoryAccess(VAddr addr, u64 size, Kernel::DebugWatchpointType type) {
+    bool CheckMemoryAccess(u64 addr, u64 size, Kernel::DebugWatchpointType type) {
         if (!check_memory_access) {
             return true;
         }
@@ -207,7 +208,7 @@ public:
         if (!memory.IsValidVirtualAddressRange(addr, size)) {
             LOG_CRITICAL(Core_ARM, "Stopping execution due to unmapped memory access at {:#x}",
                          addr);
-            parent.jit.load()->HaltExecution(ARM_Interface::no_execute);
+            parent.jit.load()->HaltExecution(PrefetchAbort);
             return false;
         }
 
@@ -218,7 +219,7 @@ public:
         const auto match{parent.MatchingWatchpoint(addr, size, type)};
         if (match) {
             parent.halted_watchpoint = match;
-            parent.jit.load()->HaltExecution(ARM_Interface::watchpoint);
+            parent.jit.load()->HaltExecution(DataAbort);
             return false;
         }
 
@@ -383,12 +384,12 @@ std::shared_ptr<Dynarmic::A64::Jit> ARM_Dynarmic_64::MakeJit(Common::PageTable*
     return std::make_shared<Dynarmic::A64::Jit>(config);
 }
 
-Dynarmic::HaltReason ARM_Dynarmic_64::RunJit() {
-    return jit.load()->Run();
+HaltReason ARM_Dynarmic_64::RunJit() {
+    return TranslateHaltReason(jit.load()->Run());
 }
 
-Dynarmic::HaltReason ARM_Dynarmic_64::StepJit() {
-    return jit.load()->Step();
+HaltReason ARM_Dynarmic_64::StepJit() {
+    return TranslateHaltReason(jit.load()->Step());
 }
 
 u32 ARM_Dynarmic_64::GetSvcNumber() const {
@@ -452,7 +453,7 @@ u64 ARM_Dynarmic_64::GetTlsAddress() const {
     return cb->tpidrro_el0;
 }
 
-void ARM_Dynarmic_64::SetTlsAddress(VAddr address) {
+void ARM_Dynarmic_64::SetTlsAddress(u64 address) {
     cb->tpidrro_el0 = address;
 }
 
@@ -464,7 +465,7 @@ void ARM_Dynarmic_64::SetTPIDR_EL0(u64 value) {
     cb->tpidr_el0 = value;
 }
 
-void ARM_Dynarmic_64::SaveContext(ThreadContext64& ctx) {
+void ARM_Dynarmic_64::SaveContext(ThreadContext64& ctx) const {
     Dynarmic::A64::Jit* j = jit.load();
     ctx.cpu_registers = j->GetRegisters();
     ctx.sp = j->GetSP();
@@ -489,18 +490,18 @@ void ARM_Dynarmic_64::LoadContext(const ThreadContext64& ctx) {
 }
 
 void ARM_Dynarmic_64::SignalInterrupt() {
-    jit.load()->HaltExecution(break_loop);
+    jit.load()->HaltExecution(BreakLoop);
 }
 
 void ARM_Dynarmic_64::ClearInterrupt() {
-    jit.load()->ClearHalt(break_loop);
+    jit.load()->ClearHalt(BreakLoop);
 }
 
 void ARM_Dynarmic_64::ClearInstructionCache() {
     jit.load()->ClearCache();
 }
 
-void ARM_Dynarmic_64::InvalidateCacheRange(VAddr addr, std::size_t size) {
+void ARM_Dynarmic_64::InvalidateCacheRange(u64 addr, std::size_t size) {
     jit.load()->InvalidateCacheRange(addr, size);
 }
 
@@ -526,39 +527,4 @@ void ARM_Dynarmic_64::PageTableChanged(Common::PageTable& page_table,
     jit_cache.emplace(key, std::move(new_jit));
 }
 
-std::vector<ARM_Interface::BacktraceEntry> ARM_Dynarmic_64::GetBacktrace(Core::System& system,
-                                                                         u64 fp, u64 lr, u64 pc) {
-    std::vector<BacktraceEntry> out;
-    auto& memory = system.Memory();
-
-    out.push_back({"", 0, pc, 0, ""});
-
-    // fp (= x29) points to the previous frame record.
-    // Frame records are two words long:
-    // fp+0 : pointer to previous frame record
-    // fp+8 : value of lr for frame
-    for (size_t i = 0; i < 256; i++) {
-        out.push_back({"", 0, lr, 0, ""});
-        if (!fp || (fp % 4 != 0) || !memory.IsValidVirtualAddressRange(fp, 16)) {
-            break;
-        }
-        lr = memory.Read64(fp + 8);
-        fp = memory.Read64(fp);
-    }
-
-    SymbolicateBacktrace(system, out);
-
-    return out;
-}
-
-std::vector<ARM_Interface::BacktraceEntry> ARM_Dynarmic_64::GetBacktraceFromContext(
-    System& system, const ThreadContext64& ctx) {
-    const auto& reg = ctx.cpu_registers;
-    return GetBacktrace(system, reg[29], reg[30], ctx.pc);
-}
-
-std::vector<ARM_Interface::BacktraceEntry> ARM_Dynarmic_64::GetBacktrace() const {
-    return GetBacktrace(system, GetReg(29), GetReg(30), GetPC());
-}
-
 } // namespace Core