Update to work with dolphin@dc0814ae4622313d513468bdc377ee9c031de199

Source/Core/Core/ActionReplay.cpp

@@ -992,7 +992,7 @@ static bool RunCodeLocked(const Core::CPUThreadGuard& guard, const ARCode& arcod
 
 void RunAllActive(const Core::CPUThreadGuard& cpu_guard)
 {
-  prime::GetHackManager()->run_active_mods();
+  prime::GetHackManager()->run_active_mods(cpu_guard);
 
   if (!Config::Get(Config::MAIN_ENABLE_CHEATS))
     return;

Source/Core/Core/HW/Wiimote.cpp

@@ -37,11 +37,6 @@ namespace
 static std::array<std::atomic<WiimoteSource>, MAX_BBMOTES> s_wiimote_sources;
 static std::optional<Config::ConfigChangedCallbackID> s_config_callback_id = std::nullopt;
 
-WiimoteSource GetSource(unsigned int index)
-{
-  return s_wiimote_sources[index];
-}
-
 void OnSourceChanged(unsigned int index, WiimoteSource source)
 {
   const WiimoteSource previous_source = s_wiimote_sources[index].exchange(source);
@@ -80,7 +75,7 @@ HIDWiimote* GetHIDWiimoteSource(unsigned int index)
 {
   HIDWiimote* hid_source = nullptr;
 
-  WiimoteSource src = GetSource(index);
+  WiimoteSource src = Wiimote::GetSource(index);
   switch (src)
   {
   case WiimoteSource::Emulated:
@@ -359,6 +354,11 @@ std::tuple<double, double, bool, bool, bool, bool, bool> PrimeSettings()
   return wiimote->GetPrimeSettings();
 }
 
+WiimoteSource GetSource(unsigned int index)
+{
+  return s_wiimote_sources[index];
+}
+
 bool CheckPitchRecentre()
 {
   WiimoteEmu::Wiimote* wiimote = static_cast<WiimoteEmu::Wiimote*>(s_config.GetController(0));

Source/Core/Core/HW/Wiimote.h

@@ -124,6 +124,7 @@ std::tuple<double, double> GetPrimeStickXY();
 std::tuple<bool, bool> GetBVMenuOptions();
 
 std::tuple<double, double, bool, bool, bool, bool, bool> PrimeSettings();
+WiimoteSource GetSource(unsigned int index);
 }  // namespace Wiimote
 
 namespace WiimoteReal

Source/Core/Core/HW/WiimoteEmu/WiimoteEmu.cpp

@@ -332,12 +332,12 @@ Wiimote::Wiimote(const unsigned int index) : m_index(index), m_bt_device_index(i
   {
     const std::string& ui_name = prime_button;
     m_primehack_beams->controls.emplace_back(
-        new ControllerEmu::Input(ControllerEmu::DoNotTranslate, prime_button, ui_name));
+        new ControllerEmu::Input(Translatability::DoNotTranslate, prime_button, ui_name));
   }
   m_primehack_beams->controls.emplace_back(
-    new ControllerEmu::Input(ControllerEmu::DoNotTranslate, _trans("Next Beam"), "Next Beam"));
+    new ControllerEmu::Input(Translatability::DoNotTranslate, _trans("Next Beam"), "Next Beam"));
   m_primehack_beams->controls.emplace_back(
-    new ControllerEmu::Input(ControllerEmu::DoNotTranslate, _trans("Previous Beam"), "Previous Beam"));
+    new ControllerEmu::Input(Translatability::DoNotTranslate, _trans("Previous Beam"), "Previous Beam"));
 
   m_primehack_beams->AddSetting(
     &m_primehack_beam_menu, {"Enable Beam Menu", nullptr, nullptr, _trans("Enable Beam Menu")}, false);
@@ -347,13 +347,13 @@ Wiimote::Wiimote(const unsigned int index) : m_index(index), m_bt_device_index(i
   {
     const std::string& ui_name = prime_button;
     m_primehack_visors->controls.emplace_back(
-        new ControllerEmu::Input(ControllerEmu::DoNotTranslate, prime_button, ui_name));
+        new ControllerEmu::Input(Translatability::DoNotTranslate, prime_button, ui_name));
   }
 
   m_primehack_visors->controls.emplace_back(
-    new ControllerEmu::Input(ControllerEmu::DoNotTranslate, _trans("Next Visor"), "Next Visor"));
+    new ControllerEmu::Input(Translatability::DoNotTranslate, _trans("Next Visor"), "Next Visor"));
   m_primehack_visors->controls.emplace_back(
-    new ControllerEmu::Input(ControllerEmu::DoNotTranslate, _trans("Previous Visor"), "Previous Visor"));
+    new ControllerEmu::Input(Translatability::DoNotTranslate, _trans("Previous Visor"), "Previous Visor"));
 
   m_primehack_visors->AddSetting(
     &m_primehack_visor_menu, {"Enable Visor Menu", nullptr, nullptr, _trans("Enable Visor Menu")}, false);
@@ -392,17 +392,17 @@ Wiimote::Wiimote(const unsigned int index) : m_index(index), m_bt_device_index(i
 
   m_primehack_stick->AddSetting(&m_primehack_horizontal_sensitivity, {"Horizontal Sensitivity", nullptr, nullptr, _trans("Horizontal Sensitivity")}, 45, 1, 100);
   m_primehack_stick->AddSetting(&m_primehack_vertical_sensitivity, {"Vertical Sensitivity", nullptr, nullptr, _trans("Vertical Sensitivity")}, 35, 1, 100);
-  m_primehack_stick->AddInput(ControllerEmu::Translatability::Translate, _trans("Reset Camera Pitch"));
+  m_primehack_stick->AddInput(Translatability::Translate, _trans("Reset Camera Pitch"));
 
   groups.emplace_back(m_primehack_modes = new ControllerEmu::PrimeHackModes(_trans("PrimeHack")));
 
   groups.emplace_back(m_primehack_misc = new ControllerEmu::ControlGroup(_trans("PrimeHack")));
 
   m_primehack_misc->controls.emplace_back(
-      new ControllerEmu::Input(ControllerEmu::DoNotTranslate, "Spring Ball", "Spring Ball"));
+      new ControllerEmu::Input(Translatability::DoNotTranslate, "Spring Ball", "Spring Ball"));
 
   m_primehack_misc->controls.emplace_back(
-      new ControllerEmu::Input(ControllerEmu::DoNotTranslate, "Grapple Lasso", "Grapple Lasso"));
+      new ControllerEmu::Input(Translatability::DoNotTranslate, "Grapple Lasso", "Grapple Lasso"));
 
   m_primehack_misc->AddSetting(
     &m_primehack_tapping_grapple, {"Tap Grapple Repeatedly To Pull", nullptr, nullptr, _trans("Tap Grapple Repeatedly To Pull")}, false);

Source/Core/Core/HotkeyManager.cpp

@@ -196,13 +196,13 @@ constexpr std::array<const char*, NUM_HOTKEYS> s_hotkey_labels{{
     _trans("4x"),
 
     _trans("Show Skylanders Portal"),
-    _trans("Show Infinity Base")
+    _trans("Show Infinity Base"),
 
     _trans("Toggle Noclip"),
     _trans("Toggle Invulnerability"),
     _trans("Toggle Skippable Cutscenes"),
     _trans("Toggle Dashing Restoration"),
-    _trans("Toggle Lock Camera In Motion Puzzles")
+    _trans("Toggle Lock Camera In Motion Puzzles"),
 }};
 // clang-format on
 static_assert(NUM_HOTKEYS == s_hotkey_labels.size(), "Wrong count of hotkey_labels");
@@ -364,7 +364,7 @@ constexpr std::array<HotkeyGroupInfo, NUM_HOTKEY_GROUPS> s_groups_info = {
      {_trans("GBA Core"), HK_GBA_LOAD, HK_GBA_RESET, true},
      {_trans("GBA Volume"), HK_GBA_VOLUME_DOWN, HK_GBA_TOGGLE_MUTE, true},
      {_trans("GBA Window Size"), HK_GBA_1X, HK_GBA_4X, true},
-     {_trans("USB Emulation Devices"), HK_SKYLANDERS_PORTAL, HK_INFINITY_BASE}}};
+     {_trans("USB Emulation Devices"), HK_SKYLANDERS_PORTAL, HK_INFINITY_BASE},
      {_trans("PrimeHack Cheats"), HK_NOCLIP_TOGGLE, HK_RESTORE_DASHING},
      {_trans("PrimeHack Graphics"), HK_MOTION_LOCK, HK_MOTION_LOCK}}};
 

Source/Core/Core/PowerPC/Interpreter/Interpreter_Branch.cpp

@@ -151,6 +151,6 @@ void Interpreter::sc(Interpreter& interpreter, UGeckoInstruction inst)
 
 // Added this to Dolphin, this is a major security breach
 void Interpreter::vmcall(Interpreter& interpreter, UGeckoInstruction inst) {
-  interpreter.m_ppc_state.vmcall_table[inst.VMFI](interpreter.m_ppc_state, inst.VMFP);
+  interpreter.m_ppc_state.vmcall_table[inst.VMFI](interpreter.m_ppc_state, interpreter.m_mmu, inst.VMFP);
   interpreter.m_end_block = true;
 }

Source/Core/Core/PowerPC/MMU.cpp

@@ -1778,4 +1778,14 @@ void WriteU64SwapFromJitArm64(u64 var, u32 address, MMU& mmu)
 {
   mmu.Write_U64_Swap(var, address);
 }
+
+// Additional junk for my sanity
+float MMU::Read_F32(u32 address) {
+  return Common::BitCast<float>(Read_U32(address));
+}
+
+void MMU::Write_F32(float var, u32 address) {
+  u32 uvar = Common::BitCast<u32>(var);
+  Write_U32(uvar, address);
+}
 }  // namespace PowerPC

Source/Core/Core/PowerPC/MMU.h

@@ -223,6 +223,9 @@ class MMU
   void Write_U32(u32 var, u32 address);
   void Write_U64(u64 var, u32 address);
 
+  float Read_F32(u32 address);
+  void Write_F32(float var, u32 address);
+
   void Write_U16_Swap(u32 var, u32 address);
   void Write_U32_Swap(u32 var, u32 address);
   void Write_U64_Swap(u64 var, u32 address);

Source/Core/Core/PowerPC/PowerPC.cpp

@@ -295,7 +295,7 @@ void PowerPCManager::Init(CPUCore cpu_core)
     m_breakpoints.ClearAllTemporary();
 }
 
-void vmcall_noop(PowerPCState& ppc_state, u32 param) {
+void vmcall_noop(PowerPCState& ppc_state, MMU&, u32 param) {
   WARN_LOG_FMT(POWERPC, "Executed unhandled vmcall, PC={:#x} VMFP={}", ppc_state.pc, param);
 }
 
@@ -343,7 +343,7 @@ void PowerPCManager::RegisterVmcallWithIndex(int index, vm_call pfn) {
 }
 
 int PowerPCManager::RegisterVmcall(vm_call pfn) {
-  for (int i = 0; i < ppcState.vmcall_table.size(); i++) {
+  for (int i = 0; i < m_ppc_state.vmcall_table.size(); i++) {
     if (m_ppc_state.vmcall_table[i] == vmcall_noop) {
       m_ppc_state.vmcall_table[i] = pfn;
       return i;
@@ -353,7 +353,7 @@ int PowerPCManager::RegisterVmcall(vm_call pfn) {
 }
 
 void PowerPCManager::VmcallDefaultFn(u32 param) {
-  vmcall_noop(param);
+  vmcall_noop(m_ppc_state, m_system.GetMMU(), param);
 }
 
 CoreMode PowerPCManager::GetMode() const

Source/Core/Core/PowerPC/PowerPC.h

@@ -106,6 +106,10 @@ struct PairedSingle
 // Paired single must be standard layout in order for offsetof to work, which is used by the JITs
 static_assert(std::is_standard_layout<PairedSingle>(), "PairedSingle must be standard layout");
 
+struct PowerPCState;
+class MMU;
+typedef void(*vm_call)(PowerPCState&, MMU&, u32);
+
 // This contains the entire state of the emulated PowerPC "Gekko" CPU.
 //
 // To minimize code size on x86, we want as much useful stuff in the first 256 bytes as possible.
@@ -232,8 +236,6 @@ struct PowerPCState
   void UpdateFPRFSingle(float fvalue);
 };
 
-typedef void(*vm_call)(PowerPCState&, u32);
-
 #if _M_X86_64
 #ifdef __GNUC__
 #pragma GCC diagnostic push

Source/Core/Core/PrimeHack/AddressDB.cpp

@@ -1,4 +1,6 @@
 #include "Core/PrimeHack/AddressDB.h"
+
+#include "Core/PowerPC/MMU.h"
 #include "Core/PrimeHack/PrimeUtils.h"
 
 namespace prime {
@@ -12,7 +14,7 @@ AddressDB::AddressDB() {
   addr_mapping.emplace(Game::PRIME_3_STANDALONE, var_map{});
   addr_mapping.emplace(Game::PRIME_1_GCN_R1, var_map{});
   addr_mapping.emplace(Game::PRIME_1_GCN_R2, var_map{});
-  
+
   dyn_addr_mapping.emplace(Game::PRIME_1, dyn_var_map{});
   dyn_addr_mapping.emplace(Game::PRIME_2, dyn_var_map{});
   dyn_addr_mapping.emplace(Game::PRIME_3, dyn_var_map{});
@@ -75,7 +77,7 @@ u32 AddressDB::lookup_address(Game game, Region region, std::string_view name) c
   }
 }
 
-u32 AddressDB::lookup_dynamic_address(Game game, Region region, std::string_view name) const {
+u32 AddressDB::lookup_dynamic_address(Core::CPUThreadGuard const& guard, Game game, Region region, std::string_view name) const {
   auto r1 = dyn_addr_mapping.find(game);
   if (r1 == dyn_addr_mapping.end()) {
     return 0;
@@ -88,14 +90,14 @@ u32 AddressDB::lookup_dynamic_address(Game game, Region region, std::string_view
   }
   u32 result_addr;
   if (r2->second.source_var_dynamic) {
-    result_addr = lookup_dynamic_address(game, region, r2->second.source_var);
+    result_addr = lookup_dynamic_address(guard, game, region, r2->second.source_var);
     if (result_addr == 0) {
       return 0;
     }
   } else {
     result_addr = lookup_address(game, region, r2->second.source_var);
     if (result_addr == 0) {
-      result_addr = lookup_dynamic_address(game, region, r2->second.source_var);
+      result_addr = lookup_dynamic_address(guard, game, region, r2->second.source_var);
       if (result_addr == 0) {
         return 0;
       }
@@ -118,7 +120,7 @@ u32 AddressDB::lookup_dynamic_address(Game game, Region region, std::string_view
     default:
       return 0;
     }
-    result_addr = read32(result_addr + offset);
+    result_addr = PowerPC::MMU::HostRead_U32(guard, result_addr + offset);
     if (!mem_check(result_addr)) {
       return 0;
     }

Source/Core/Core/PrimeHack/AddressDB.h

@@ -5,6 +5,7 @@
 #include <string_view>
 #include <vector>
 
+#include "Core/Core.h"
 #include "Core/PrimeHack/PrimeMod.h"
 #include "Common/CommonTypes.h"
 
@@ -25,7 +26,7 @@ class AddressDB {
   void register_dynamic_address(Game game, std::string_view name, std::string_view source_var,
                                 std::vector<region_triple>&& offsets);
   u32 lookup_address(Game game, Region region, std::string_view name) const;
-  u32 lookup_dynamic_address(Game game, Region region, std::string_view name) const;
+  u32 lookup_dynamic_address(Core::CPUThreadGuard const& guard, Game game, Region region, std::string_view name) const;
 
 private:
   struct DynamicVariable {

Source/Core/Core/PrimeHack/EmuVariableManager.cpp

@@ -1,55 +1,57 @@
 #include "Core/PrimeHack/EmuVariableManager.h"
+
+#include "Core/PowerPC/MMU.h"
 #include "Core/PrimeHack/PrimeUtils.h"
 
 #include <cassert>
 
 namespace prime {
-  constexpr u32 base_address = 0x80004164; 
+  constexpr u32 base_address = 0x80004164;
   constexpr int max_variables = 45;
 
-  void EmuVariableManager::set_variable(const std::string& variable, u8 value) {
+  void EmuVariableManager::set_variable(Core::CPUThreadGuard const& guard, const std::string& variable, u8 value) {
     auto result = variables_list.find(variable);
     if (result == variables_list.end()) {
       return;
     }
 
-    write8(value, result->second);
+    PowerPC::MMU::HostWrite_U8(guard, value, result->second);
   }
 
-  void EmuVariableManager::set_variable(const std::string& variable, u32 value) {
+  void EmuVariableManager::set_variable(Core::CPUThreadGuard const& guard, const std::string& variable, u32 value) {
     auto result = variables_list.find(variable);
     if (result == variables_list.end()) {
       return;
     }
 
-    write32(value, result->second);
+    PowerPC::MMU::HostWrite_U32(guard, value, result->second);
   }
 
-  void EmuVariableManager::set_variable(const std::string& variable, float value) {
+  void EmuVariableManager::set_variable(Core::CPUThreadGuard const& guard, const std::string& variable, float value) {
     auto result = variables_list.find(variable);
     if (result == variables_list.end()) {
       return;
     }
 
-    writef32(value, result->second);
+    PowerPC::MMU::HostWrite_F32(guard, value, result->second);
   }
 
-  u32 EmuVariableManager::get_uint(const std::string& variable) const {
+  u32 EmuVariableManager::get_uint(Core::CPUThreadGuard const& guard, const std::string& variable) const {
     auto result = variables_list.find(variable);
     if (result == variables_list.end()) {
       return 0;
     }
 
-    return read32(result->second);
+    return PowerPC::MMU::HostRead_U32(guard, result->second);
   }
 
-  float EmuVariableManager::get_float(const std::string& variable) const {
+  float EmuVariableManager::get_float(Core::CPUThreadGuard const& guard, const std::string& variable) const {
     auto result = variables_list.find(variable);
     if (result == variables_list.end()) {
       return 0;
     }
 
-    return readf32(result->second);
+    return PowerPC::MMU::HostRead_F32(guard, result->second);
   }
 
   u32 EmuVariableManager::get_address(const std::string& variable) const {

Source/Core/Core/PrimeHack/EmuVariableManager.h

@@ -3,18 +3,19 @@
 #include <string>
 #include <map>
 
+#include "Core/Core.h"
 #include "Common/CommonTypes.h"
 
 namespace prime {
 
 class EmuVariableManager {
 public:
-  void set_variable(const std::string& variable, u8 value);
-  void set_variable(const std::string& variable, u32 value);
-  void set_variable(const std::string& variable, float value);
+  void set_variable(Core::CPUThreadGuard const& guard, const std::string& variable, u8 value);
+  void set_variable(Core::CPUThreadGuard const& guard, const std::string& variable, u32 value);
+  void set_variable(Core::CPUThreadGuard const& guard, const std::string& variable, float value);
 
-  u32 get_uint(const std::string& variable) const;
-  float get_float(const std::string& variable) const;
+  u32 get_uint(Core::CPUThreadGuard const& guard, const std::string& variable) const;
+  float get_float(Core::CPUThreadGuard const& guard, const std::string& variable) const;
   u32 get_address(const std::string& variable) const;
 
   void register_variable(const std::string& name);