From b05bfc603689419dc515a656b9fc711d79994f13 Mon Sep 17 00:00:00 2001
From: Lioncash <mathew1800@gmail.com>
Date: Tue, 26 Nov 2019 16:29:34 -0500
Subject: core/memory: Migrate over Read{8, 16, 32, 64, Block} to the Memory
 class

With all of the trivial parts of the memory interface moved over, we can
get right into moving over the bits that are used.

Note that this does require the use of GetInstance from the global
system instance to be used within hle_ipc.cpp and the gdbstub. This is
fine for the time being, as they both already rely on the global system
instance in other functions. These will be removed in a change directed
at both of these respectively.

For now, it's sufficient, as it still accomplishes the goal of
de-globalizing the memory code.
---
 src/core/hle/kernel/address_arbiter.cpp | 28 +++++++++++++++++++---------
 1 file changed, 19 insertions(+), 9 deletions(-)

(limited to 'src/core/hle/kernel/address_arbiter.cpp')

diff --git a/src/core/hle/kernel/address_arbiter.cpp b/src/core/hle/kernel/address_arbiter.cpp
index 7f9a559d2..07f0dac67 100644
--- a/src/core/hle/kernel/address_arbiter.cpp
+++ b/src/core/hle/kernel/address_arbiter.cpp
@@ -67,12 +67,14 @@ ResultCode AddressArbiter::SignalToAddressOnly(VAddr address, s32 num_to_wake) {
 
 ResultCode AddressArbiter::IncrementAndSignalToAddressIfEqual(VAddr address, s32 value,
                                                               s32 num_to_wake) {
+    auto& memory = system.Memory();
+
     // Ensure that we can write to the address.
-    if (!system.Memory().IsValidVirtualAddress(address)) {
+    if (!memory.IsValidVirtualAddress(address)) {
         return ERR_INVALID_ADDRESS_STATE;
     }
 
-    if (static_cast<s32>(Memory::Read32(address)) != value) {
+    if (static_cast<s32>(memory.Read32(address)) != value) {
         return ERR_INVALID_STATE;
     }
 
@@ -82,8 +84,10 @@ ResultCode AddressArbiter::IncrementAndSignalToAddressIfEqual(VAddr address, s32
 
 ResultCode AddressArbiter::ModifyByWaitingCountAndSignalToAddressIfEqual(VAddr address, s32 value,
                                                                          s32 num_to_wake) {
+    auto& memory = system.Memory();
+
     // Ensure that we can write to the address.
-    if (!system.Memory().IsValidVirtualAddress(address)) {
+    if (!memory.IsValidVirtualAddress(address)) {
         return ERR_INVALID_ADDRESS_STATE;
     }
 
@@ -109,7 +113,7 @@ ResultCode AddressArbiter::ModifyByWaitingCountAndSignalToAddressIfEqual(VAddr a
         }
     }
 
-    if (static_cast<s32>(Memory::Read32(address)) != value) {
+    if (static_cast<s32>(memory.Read32(address)) != value) {
         return ERR_INVALID_STATE;
     }
 
@@ -134,12 +138,14 @@ ResultCode AddressArbiter::WaitForAddress(VAddr address, ArbitrationType type, s
 
 ResultCode AddressArbiter::WaitForAddressIfLessThan(VAddr address, s32 value, s64 timeout,
                                                     bool should_decrement) {
+    auto& memory = system.Memory();
+
     // Ensure that we can read the address.
-    if (!system.Memory().IsValidVirtualAddress(address)) {
+    if (!memory.IsValidVirtualAddress(address)) {
         return ERR_INVALID_ADDRESS_STATE;
     }
 
-    const s32 cur_value = static_cast<s32>(Memory::Read32(address));
+    const s32 cur_value = static_cast<s32>(memory.Read32(address));
     if (cur_value >= value) {
         return ERR_INVALID_STATE;
     }
@@ -157,15 +163,19 @@ ResultCode AddressArbiter::WaitForAddressIfLessThan(VAddr address, s32 value, s6
 }
 
 ResultCode AddressArbiter::WaitForAddressIfEqual(VAddr address, s32 value, s64 timeout) {
+    auto& memory = system.Memory();
+
     // Ensure that we can read the address.
-    if (!system.Memory().IsValidVirtualAddress(address)) {
+    if (!memory.IsValidVirtualAddress(address)) {
         return ERR_INVALID_ADDRESS_STATE;
     }
+
     // Only wait for the address if equal.
-    if (static_cast<s32>(Memory::Read32(address)) != value) {
+    if (static_cast<s32>(memory.Read32(address)) != value) {
         return ERR_INVALID_STATE;
     }
-    // Short-circuit without rescheduling, if timeout is zero.
+
+    // Short-circuit without rescheduling if timeout is zero.
     if (timeout == 0) {
         return RESULT_TIMEOUT;
     }
-- 
cgit v1.2.3