CPU/CodeCache: Pack state in struct

stenzek · stenzek · commit f9254e23f0e3 · 2026-05-01T20:27:14.000+10:00
diff --git a/src/core/cpu_code_cache.cpp b/src/core/cpu_code_cache.cpp
diff --git a/src/core/cpu_code_cache_private.h b/src/core/cpu_code_cache_private.h
@@ -254,13 +254,18 @@ u32 GetHostInstructionCount(const void* start, u32 size);
 
 extern CodeLUTArray g_code_lut;
 
-extern NORETURN_FUNCTION_POINTER void (*g_enter_recompiler)();
-extern const void* g_compile_or_revalidate_block;
-extern const void* g_run_events_and_dispatch;
-extern const void* g_dispatcher;
-extern const void* g_block_dispatcher;
-extern const void* g_interpret_block;
-extern const void* g_discard_and_recompile_block;
+struct RecompilerFunctions
+{
+  NORETURN_FUNCTION_POINTER void (*enter_recompiler)();
+  const void* compile_or_revalidate_block;
+  const void* run_events_and_dispatch;
+  const void* dispatcher;
+  const void* block_dispatcher;
+  const void* interpret_block;
+  const void* discard_and_recompile_block;
+};
+
+extern RecompilerFunctions g_recompiler_functions;
 
 #ifdef ENABLE_RECOMPILER_PROFILING
 
diff --git a/src/core/cpu_recompiler_arm32.cpp b/src/core/cpu_recompiler_arm32.cpp
@@ -261,7 +261,8 @@ u32 CPU::CodeCache::EmitASMFunctions(void* code, u32 code_size)
   Label dispatch;
   Label run_events_and_dispatch;
 
-  g_enter_recompiler = armAsm->GetCursorAddress<decltype(g_enter_recompiler)>();
+  g_recompiler_functions.enter_recompiler =
+    armAsm->GetCursorAddress<decltype(g_recompiler_functions.enter_recompiler)>();
   {
     // Need the CPU state for basically everything :-)
     armMoveAddressToReg(armAsm, RSTATE, &g_state);
@@ -275,15 +276,15 @@ u32 CPU::CodeCache::EmitASMFunctions(void* code, u32 code_size)
     armAsm->cmp(RARG1, RARG2);
     armAsm->b(lt, &skip_event_check);
 
-    g_run_events_and_dispatch = armAsm->GetCursorAddress<const void*>();
+    g_recompiler_functions.run_events_and_dispatch = armAsm->GetCursorAddress<const void*>();
     armAsm->bind(&run_events_and_dispatch);
     armEmitCall(armAsm, reinterpret_cast<const void*>(&TimingEvents::RunEvents), true);
 
     armAsm->bind(&skip_event_check);
   }
 
   // TODO: align?
-  g_dispatcher = armAsm->GetCursorAddress<const void*>();
+  g_recompiler_functions.dispatcher = armAsm->GetCursorAddress<const void*>();
   {
     armAsm->bind(&dispatch);
 
@@ -299,21 +300,21 @@ u32 CPU::CodeCache::EmitASMFunctions(void* code, u32 code_size)
     armAsm->bx(RARG1);
   }
 
-  g_compile_or_revalidate_block = armAsm->GetCursorAddress<const void*>();
+  g_recompiler_functions.compile_or_revalidate_block = armAsm->GetCursorAddress<const void*>();
   {
     armAsm->ldr(RARG1, PTR(&g_state.pc));
     armEmitCall(armAsm, reinterpret_cast<const void*>(&CompileOrRevalidateBlock), true);
     armAsm->b(&dispatch);
   }
 
-  g_discard_and_recompile_block = armAsm->GetCursorAddress<const void*>();
+  g_recompiler_functions.discard_and_recompile_block = armAsm->GetCursorAddress<const void*>();
   {
     armAsm->ldr(RARG1, PTR(&g_state.pc));
     armEmitCall(armAsm, reinterpret_cast<const void*>(&DiscardAndRecompileBlock), true);
     armAsm->b(&dispatch);
   }
 
-  g_interpret_block = armAsm->GetCursorAddress<const void*>();
+  g_recompiler_functions.interpret_block = armAsm->GetCursorAddress<const void*>();
   {
     armEmitCall(armAsm, reinterpret_cast<const void*>(GetInterpretUncachedBlockFunction()), true);
     armAsm->ldr(RARG1, PTR(&g_state.pending_ticks));
@@ -593,7 +594,7 @@ bool foo(const void* a, const void* b)
   Label block_unchanged;
   armAsm->b(&block_unchanged);
   armAsm->bind(&block_changed);
-  armEmitJmp(armAsm, CodeCache::g_discard_and_recompile_block, false);
+  armEmitJmp(armAsm, CodeCache::g_recompiler_functions.discard_and_recompile_block, false);
   armAsm->bind(&block_unchanged);
 }
 
@@ -749,16 +750,16 @@ void CPU::ARM32Recompiler::EndAndLinkBlock(const std::optional<u32>& newpc, bool
   if (cycles > 0)
     armAsm->str(RARG1, PTR(&g_state.pending_ticks));
   if (do_event_test)
-    armEmitCondBranch(armAsm, ge, CodeCache::g_run_events_and_dispatch);
+    armEmitCondBranch(armAsm, ge, CodeCache::g_recompiler_functions.run_events_and_dispatch);
 
   // jump to dispatcher or next block
   if (force_run_events)
   {
-    armEmitJmp(armAsm, CodeCache::g_run_events_and_dispatch, false);
+    armEmitJmp(armAsm, CodeCache::g_recompiler_functions.run_events_and_dispatch, false);
   }
   else if (!newpc.has_value())
   {
-    armEmitJmp(armAsm, CodeCache::g_dispatcher, false);
+    armEmitJmp(armAsm, CodeCache::g_recompiler_functions.dispatcher, false);
   }
   else
   {
diff --git a/src/core/cpu_recompiler_arm64.cpp b/src/core/cpu_recompiler_arm64.cpp
@@ -455,7 +455,8 @@ u32 CPU::CodeCache::EmitASMFunctions(void* code, u32 code_size)
   Label dispatch;
   Label run_events_and_dispatch;
 
-  g_enter_recompiler = armAsm->GetCursorAddress<decltype(g_enter_recompiler)>();
+  g_recompiler_functions.enter_recompiler =
+    armAsm->GetCursorAddress<decltype(g_recompiler_functions.enter_recompiler)>();
   {
 #ifdef _WIN32
     // Frame pointer setup is needed on Windows
@@ -481,13 +482,13 @@ u32 CPU::CodeCache::EmitASMFunctions(void* code, u32 code_size)
     armAsm->cmp(RWARG1, RWARG2);
     armAsm->b(&dispatch, lt);
 
-    g_run_events_and_dispatch = armAsm->GetCursorAddress<const void*>();
+    g_recompiler_functions.run_events_and_dispatch = armAsm->GetCursorAddress<const void*>();
     armAsm->bind(&run_events_and_dispatch);
     armEmitCall(armAsm, reinterpret_cast<const void*>(&TimingEvents::RunEvents), true);
   }
 
   armAlignCode(armAsm, Recompiler::FUNCTION_ALIGNMENT);
-  g_dispatcher = armAsm->GetCursorAddress<const void*>();
+  g_recompiler_functions.dispatcher = armAsm->GetCursorAddress<const void*>();
   {
     armAsm->bind(&dispatch);
 
@@ -504,23 +505,23 @@ u32 CPU::CodeCache::EmitASMFunctions(void* code, u32 code_size)
   }
 
   armAlignCode(armAsm, Recompiler::FUNCTION_ALIGNMENT);
-  g_compile_or_revalidate_block = armAsm->GetCursorAddress<const void*>();
+  g_recompiler_functions.compile_or_revalidate_block = armAsm->GetCursorAddress<const void*>();
   {
     armAsm->ldr(RWARG1, PTR(&g_state.pc));
     armEmitCall(armAsm, reinterpret_cast<const void*>(&CompileOrRevalidateBlock), true);
     armAsm->b(&dispatch);
   }
 
   armAlignCode(armAsm, Recompiler::FUNCTION_ALIGNMENT);
-  g_discard_and_recompile_block = armAsm->GetCursorAddress<const void*>();
+  g_recompiler_functions.discard_and_recompile_block = armAsm->GetCursorAddress<const void*>();
   {
     armAsm->ldr(RWARG1, PTR(&g_state.pc));
     armEmitCall(armAsm, reinterpret_cast<const void*>(&DiscardAndRecompileBlock), true);
     armAsm->b(&dispatch);
   }
 
   armAlignCode(armAsm, Recompiler::FUNCTION_ALIGNMENT);
-  g_interpret_block = armAsm->GetCursorAddress<const void*>();
+  g_recompiler_functions.interpret_block = armAsm->GetCursorAddress<const void*>();
   {
     armEmitCall(armAsm, reinterpret_cast<const void*>(GetInterpretUncachedBlockFunction()), true);
     armAsm->ldr(RWARG1, PTR(&g_state.pending_ticks));
@@ -780,7 +781,7 @@ void CPU::ARM64Recompiler::GenerateBlockProtectCheck(const u8* ram_ptr, const u8
   Label block_unchanged;
   armAsm->b(&block_unchanged);
   armAsm->bind(&block_changed);
-  armEmitJmp(armAsm, CodeCache::g_discard_and_recompile_block, false);
+  armEmitJmp(armAsm, CodeCache::g_recompiler_functions.discard_and_recompile_block, false);
   armAsm->bind(&block_unchanged);
 }
 
@@ -925,16 +926,16 @@ void CPU::ARM64Recompiler::EndAndLinkBlock(const std::optional<u32>& newpc, bool
   if (cycles > 0)
     armAsm->str(RWARG1, PTR(&g_state.pending_ticks));
   if (do_event_test)
-    armEmitCondBranch(armAsm, ge, CodeCache::g_run_events_and_dispatch);
+    armEmitCondBranch(armAsm, ge, CodeCache::g_recompiler_functions.run_events_and_dispatch);
 
   // jump to dispatcher or next block
   if (force_run_events)
   {
-    armEmitJmp(armAsm, CodeCache::g_run_events_and_dispatch, false);
+    armEmitJmp(armAsm, CodeCache::g_recompiler_functions.run_events_and_dispatch, false);
   }
   else if (!newpc.has_value())
   {
-    armEmitJmp(armAsm, CodeCache::g_dispatcher, false);
+    armEmitJmp(armAsm, CodeCache::g_recompiler_functions.dispatcher, false);
   }
   else
   {
diff --git a/src/core/cpu_recompiler_loongarch64.cpp b/src/core/cpu_recompiler_loongarch64.cpp
@@ -212,7 +212,8 @@ u32 CPU::CodeCache::EmitASMFunctions(void* code, u32 code_size)
   lagoon_label_t dispatch = {};
   lagoon_label_t run_events_and_dispatch = {};
 
-  g_enter_recompiler = reinterpret_cast<decltype(g_enter_recompiler)>(laAsm->cursor);
+  g_recompiler_functions.enter_recompiler =
+    reinterpret_cast<decltype(g_recompiler_functions.enter_recompiler)>(laAsm->cursor);
   {
     // TODO: reserve some space for saving caller-saved registers
 
@@ -233,15 +234,15 @@ u32 CPU::CodeCache::EmitASMFunctions(void* code, u32 code_size)
     la_bltu(laAsm, RARG1, RARG2, la_label(laAsm, &skip_event_check));
 
     la_bind(laAsm, &run_events_and_dispatch);
-    g_run_events_and_dispatch = laAsm->cursor;
+    g_recompiler_functions.run_events_and_dispatch = laAsm->cursor;
     laEmitCall(laAsm, reinterpret_cast<const void*>(&TimingEvents::RunEvents));
 
     la_bind(laAsm, &skip_event_check);
     la_label_free(laAsm, &skip_event_check);
   }
 
   // TODO: align?
-  g_dispatcher = laAsm->cursor;
+  g_recompiler_functions.dispatcher = laAsm->cursor;
   {
     la_bind(laAsm, &dispatch);
 
@@ -262,21 +263,21 @@ u32 CPU::CodeCache::EmitASMFunctions(void* code, u32 code_size)
     la_jirl(laAsm, LA_ZERO, RARG1, 0);
   }
 
-  g_compile_or_revalidate_block = laAsm->cursor;
+  g_recompiler_functions.compile_or_revalidate_block = laAsm->cursor;
   {
     la_ld_w(laAsm, RARG1, RSTATE, OFFS(&g_state.pc));
     laEmitCall(laAsm, reinterpret_cast<const void*>(&CompileOrRevalidateBlock));
     la_b(laAsm, la_label(laAsm, &dispatch));
   }
 
-  g_discard_and_recompile_block = laAsm->cursor;
+  g_recompiler_functions.discard_and_recompile_block = laAsm->cursor;
   {
     la_ld_w(laAsm, RARG1, RSTATE, OFFS(&g_state.pc));
     laEmitCall(laAsm, reinterpret_cast<const void*>(&DiscardAndRecompileBlock));
     la_b(laAsm, la_label(laAsm, &dispatch));
   }
 
-  g_interpret_block = laAsm->cursor;
+  g_recompiler_functions.interpret_block = laAsm->cursor;
   {
     laEmitCall(laAsm, CodeCache::GetInterpretUncachedBlockFunction());
     la_ld_w(laAsm, RARG1, RSTATE, OFFS(&g_state.pending_ticks));
@@ -547,7 +548,7 @@ void CPU::LoongArch64Recompiler::GenerateBlockProtectCheck(const u8* ram_ptr, co
   lagoon_label_t block_unchanged = {};
   la_b(laAsm, la_label(laAsm, &block_unchanged));
   la_bind(laAsm, &block_changed);
-  laEmitJmp(laAsm, CodeCache::g_discard_and_recompile_block);
+  laEmitJmp(laAsm, CodeCache::g_recompiler_functions.discard_and_recompile_block);
   la_bind(laAsm, &block_unchanged);
   la_label_free(laAsm, &block_changed);
   la_label_free(laAsm, &block_unchanged);
@@ -714,19 +715,19 @@ void CPU::LoongArch64Recompiler::EndAndLinkBlock(const std::optional<u32>& newpc
     // TODO: see if we can do a far jump somehow with this..
     lagoon_label_t cont = {};
     la_blt(laAsm, RARG1, RARG2, la_label(laAsm, &cont));
-    laEmitJmp(laAsm, CodeCache::g_run_events_and_dispatch);
+    laEmitJmp(laAsm, CodeCache::g_recompiler_functions.run_events_and_dispatch);
     la_bind(laAsm, &cont);
     la_label_free(laAsm, &cont);
   }
 
   // jump to dispatcher or next block
   if (force_run_events)
   {
-    laEmitJmp(laAsm, CodeCache::g_run_events_and_dispatch);
+    laEmitJmp(laAsm, CodeCache::g_recompiler_functions.run_events_and_dispatch);
   }
   else if (!newpc.has_value())
   {
-    laEmitJmp(laAsm, CodeCache::g_dispatcher);
+    laEmitJmp(laAsm, CodeCache::g_recompiler_functions.dispatcher);
   }
   else
   {
diff --git a/src/core/cpu_recompiler_riscv64.cpp b/src/core/cpu_recompiler_riscv64.cpp
@@ -243,7 +243,8 @@ u32 CPU::CodeCache::EmitASMFunctions(void* code, u32 code_size)
   Label dispatch;
   Label run_events_and_dispatch;
 
-  g_enter_recompiler = reinterpret_cast<decltype(g_enter_recompiler)>(rvAsm->GetCursorPointer());
+  g_recompiler_functions.enter_recompiler =
+    reinterpret_cast<decltype(g_recompiler_functions.enter_recompiler)>(rvAsm->GetCursorPointer());
   {
     // TODO: reserve some space for saving caller-saved registers
 
@@ -265,14 +266,14 @@ u32 CPU::CodeCache::EmitASMFunctions(void* code, u32 code_size)
     rvAsm->BLTU(RARG1, RARG2, &skip_event_check);
 
     rvAsm->Bind(&run_events_and_dispatch);
-    g_run_events_and_dispatch = rvAsm->GetCursorPointer();
+    g_recompiler_functions.run_events_and_dispatch = rvAsm->GetCursorPointer();
     rvEmitCall(rvAsm, reinterpret_cast<const void*>(&TimingEvents::RunEvents));
 
     rvAsm->Bind(&skip_event_check);
   }
 
   // TODO: align?
-  g_dispatcher = rvAsm->GetCursorPointer();
+  g_recompiler_functions.dispatcher = rvAsm->GetCursorPointer();
   {
     rvAsm->Bind(&dispatch);
 
@@ -293,21 +294,21 @@ u32 CPU::CodeCache::EmitASMFunctions(void* code, u32 code_size)
     rvAsm->JR(RARG1);
   }
 
-  g_compile_or_revalidate_block = rvAsm->GetCursorPointer();
+  g_recompiler_functions.compile_or_revalidate_block = rvAsm->GetCursorPointer();
   {
     rvAsm->LW(RARG1, PTR(&g_state.pc));
     rvEmitCall(rvAsm, reinterpret_cast<const void*>(&CompileOrRevalidateBlock));
     rvAsm->J(&dispatch);
   }
 
-  g_discard_and_recompile_block = rvAsm->GetCursorPointer();
+  g_recompiler_functions.discard_and_recompile_block = rvAsm->GetCursorPointer();
   {
     rvAsm->LW(RARG1, PTR(&g_state.pc));
     rvEmitCall(rvAsm, reinterpret_cast<const void*>(&DiscardAndRecompileBlock));
     rvAsm->J(&dispatch);
   }
 
-  g_interpret_block = rvAsm->GetCursorPointer();
+  g_recompiler_functions.interpret_block = rvAsm->GetCursorPointer();
   {
     rvEmitCall(rvAsm, CodeCache::GetInterpretUncachedBlockFunction());
     rvAsm->LW(RARG1, PTR(&g_state.pending_ticks));
@@ -553,7 +554,7 @@ void CPU::RISCV64Recompiler::GenerateBlockProtectCheck(const u8* ram_ptr, const
   Label block_unchanged;
   rvAsm->J(&block_unchanged);
   rvAsm->Bind(&block_changed);
-  rvEmitJmp(rvAsm, CodeCache::g_discard_and_recompile_block);
+  rvEmitJmp(rvAsm, CodeCache::g_recompiler_functions.discard_and_recompile_block);
   rvAsm->Bind(&block_unchanged);
 }
 
@@ -716,18 +717,18 @@ void CPU::RISCV64Recompiler::EndAndLinkBlock(const std::optional<u32>& newpc, bo
     // TODO: see if we can do a far jump somehow with this..
     Label cont;
     rvAsm->BLT(RARG1, RARG2, &cont);
-    rvEmitJmp(rvAsm, CodeCache::g_run_events_and_dispatch);
+    rvEmitJmp(rvAsm, CodeCache::g_recompiler_functions.run_events_and_dispatch);
     rvAsm->Bind(&cont);
   }
 
   // jump to dispatcher or next block
   if (force_run_events)
   {
-    rvEmitJmp(rvAsm, CodeCache::g_run_events_and_dispatch);
+    rvEmitJmp(rvAsm, CodeCache::g_recompiler_functions.run_events_and_dispatch);
   }
   else if (!newpc.has_value())
   {
-    rvEmitJmp(rvAsm, CodeCache::g_dispatcher);
+    rvEmitJmp(rvAsm, CodeCache::g_recompiler_functions.dispatcher);
   }
   else
   {
diff --git a/src/core/cpu_recompiler_x64.cpp b/src/core/cpu_recompiler_x64.cpp

Original file line number	Diff line number	Diff line change
`@@ -261,7 +261,8 @@ u32 CPU::CodeCache::EmitASMFunctions(void* code, u32 code_size)`
`261`	`261`	`Label dispatch;`
`262`	`262`	`Label run_events_and_dispatch;`
`263`	`263`
`264`		`- g_enter_recompiler = armAsm->GetCursorAddress<decltype(g_enter_recompiler)>();`
	`264`	`+ g_recompiler_functions.enter_recompiler =`
	`265`	`+ armAsm->GetCursorAddress<decltype(g_recompiler_functions.enter_recompiler)>();`
`265`	`266`	`{`
`266`	`267`	`// Need the CPU state for basically everything :-)`
`267`	`268`	`armMoveAddressToReg(armAsm, RSTATE, &g_state);`
`@@ -275,15 +276,15 @@ u32 CPU::CodeCache::EmitASMFunctions(void* code, u32 code_size)`
`275`	`276`	`armAsm->cmp(RARG1, RARG2);`
`276`	`277`	`armAsm->b(lt, &skip_event_check);`
`277`	`278`
`278`		`- g_run_events_and_dispatch = armAsm->GetCursorAddress<const void*>();`
	`279`	`+ g_recompiler_functions.run_events_and_dispatch = armAsm->GetCursorAddress<const void*>();`
`279`	`280`	`armAsm->bind(&run_events_and_dispatch);`
`280`	`281`	`armEmitCall(armAsm, reinterpret_cast<const void*>(&TimingEvents::RunEvents), true);`
`281`	`282`
`282`	`283`	`armAsm->bind(&skip_event_check);`
`283`	`284`	`}`
`284`	`285`
`285`	`286`	`// TODO: align?`
`286`		`- g_dispatcher = armAsm->GetCursorAddress<const void*>();`
	`287`	`+ g_recompiler_functions.dispatcher = armAsm->GetCursorAddress<const void*>();`
`287`	`288`	`{`
`288`	`289`	`armAsm->bind(&dispatch);`
`289`	`290`
`@@ -299,21 +300,21 @@ u32 CPU::CodeCache::EmitASMFunctions(void* code, u32 code_size)`
`299`	`300`	`armAsm->bx(RARG1);`
`300`	`301`	`}`
`301`	`302`
`302`		`- g_compile_or_revalidate_block = armAsm->GetCursorAddress<const void*>();`
	`303`	`+ g_recompiler_functions.compile_or_revalidate_block = armAsm->GetCursorAddress<const void*>();`
`303`	`304`	`{`
`304`	`305`	`armAsm->ldr(RARG1, PTR(&g_state.pc));`
`305`	`306`	`armEmitCall(armAsm, reinterpret_cast<const void*>(&CompileOrRevalidateBlock), true);`
`306`	`307`	`armAsm->b(&dispatch);`
`307`	`308`	`}`
`308`	`309`
`309`		`- g_discard_and_recompile_block = armAsm->GetCursorAddress<const void*>();`
	`310`	`+ g_recompiler_functions.discard_and_recompile_block = armAsm->GetCursorAddress<const void*>();`
`310`	`311`	`{`
`311`	`312`	`armAsm->ldr(RARG1, PTR(&g_state.pc));`
`312`	`313`	`armEmitCall(armAsm, reinterpret_cast<const void*>(&DiscardAndRecompileBlock), true);`
`313`	`314`	`armAsm->b(&dispatch);`
`314`	`315`	`}`
`315`	`316`
`316`		`- g_interpret_block = armAsm->GetCursorAddress<const void*>();`
	`317`	`+ g_recompiler_functions.interpret_block = armAsm->GetCursorAddress<const void*>();`
`317`	`318`	`{`
`318`	`319`	`armEmitCall(armAsm, reinterpret_cast<const void*>(GetInterpretUncachedBlockFunction()), true);`
`319`	`320`	`armAsm->ldr(RARG1, PTR(&g_state.pending_ticks));`
`@@ -593,7 +594,7 @@ bool foo(const void* a, const void* b)`
`593`	`594`	`Label block_unchanged;`
`594`	`595`	`armAsm->b(&block_unchanged);`
`595`	`596`	`armAsm->bind(&block_changed);`
`596`		`- armEmitJmp(armAsm, CodeCache::g_discard_and_recompile_block, false);`
	`597`	`+ armEmitJmp(armAsm, CodeCache::g_recompiler_functions.discard_and_recompile_block, false);`
`597`	`598`	`armAsm->bind(&block_unchanged);`
`598`	`599`	`}`
`599`	`600`
`@@ -749,16 +750,16 @@ void CPU::ARM32Recompiler::EndAndLinkBlock(const std::optional<u32>& newpc, bool`
`749`	`750`	`if (cycles > 0)`
`750`	`751`	`armAsm->str(RARG1, PTR(&g_state.pending_ticks));`
`751`	`752`	`if (do_event_test)`
`752`		`- armEmitCondBranch(armAsm, ge, CodeCache::g_run_events_and_dispatch);`
	`753`	`+ armEmitCondBranch(armAsm, ge, CodeCache::g_recompiler_functions.run_events_and_dispatch);`
`753`	`754`
`754`	`755`	`// jump to dispatcher or next block`
`755`	`756`	`if (force_run_events)`
`756`	`757`	`{`
`757`		`- armEmitJmp(armAsm, CodeCache::g_run_events_and_dispatch, false);`
	`758`	`+ armEmitJmp(armAsm, CodeCache::g_recompiler_functions.run_events_and_dispatch, false);`
`758`	`759`	`}`
`759`	`760`	`else if (!newpc.has_value())`
`760`	`761`	`{`
`761`		`- armEmitJmp(armAsm, CodeCache::g_dispatcher, false);`
	`762`	`+ armEmitJmp(armAsm, CodeCache::g_recompiler_functions.dispatcher, false);`
`762`	`763`	`}`
`763`	`764`	`else`
`764`	`765`	`{`
Original file line number	Diff line number	Diff line change
`@@ -455,7 +455,8 @@ u32 CPU::CodeCache::EmitASMFunctions(void* code, u32 code_size)`
`455`	`455`	`Label dispatch;`
`456`	`456`	`Label run_events_and_dispatch;`
`457`	`457`
`458`		`- g_enter_recompiler = armAsm->GetCursorAddress<decltype(g_enter_recompiler)>();`
	`458`	`+ g_recompiler_functions.enter_recompiler =`
	`459`	`+ armAsm->GetCursorAddress<decltype(g_recompiler_functions.enter_recompiler)>();`
`459`	`460`	`{`
`460`	`461`	`#ifdef _WIN32`
`461`	`462`	`// Frame pointer setup is needed on Windows`
`@@ -481,13 +482,13 @@ u32 CPU::CodeCache::EmitASMFunctions(void* code, u32 code_size)`
`481`	`482`	`armAsm->cmp(RWARG1, RWARG2);`
`482`	`483`	`armAsm->b(&dispatch, lt);`
`483`	`484`
`484`		`- g_run_events_and_dispatch = armAsm->GetCursorAddress<const void*>();`
	`485`	`+ g_recompiler_functions.run_events_and_dispatch = armAsm->GetCursorAddress<const void*>();`
`485`	`486`	`armAsm->bind(&run_events_and_dispatch);`
`486`	`487`	`armEmitCall(armAsm, reinterpret_cast<const void*>(&TimingEvents::RunEvents), true);`
`487`	`488`	`}`
`488`	`489`
`489`	`490`	`armAlignCode(armAsm, Recompiler::FUNCTION_ALIGNMENT);`
`490`		`- g_dispatcher = armAsm->GetCursorAddress<const void*>();`
	`491`	`+ g_recompiler_functions.dispatcher = armAsm->GetCursorAddress<const void*>();`
`491`	`492`	`{`
`492`	`493`	`armAsm->bind(&dispatch);`
`493`	`494`
`@@ -504,23 +505,23 @@ u32 CPU::CodeCache::EmitASMFunctions(void* code, u32 code_size)`
`504`	`505`	`}`
`505`	`506`
`506`	`507`	`armAlignCode(armAsm, Recompiler::FUNCTION_ALIGNMENT);`
`507`		`- g_compile_or_revalidate_block = armAsm->GetCursorAddress<const void*>();`
	`508`	`+ g_recompiler_functions.compile_or_revalidate_block = armAsm->GetCursorAddress<const void*>();`
`508`	`509`	`{`
`509`	`510`	`armAsm->ldr(RWARG1, PTR(&g_state.pc));`
`510`	`511`	`armEmitCall(armAsm, reinterpret_cast<const void*>(&CompileOrRevalidateBlock), true);`
`511`	`512`	`armAsm->b(&dispatch);`
`512`	`513`	`}`
`513`	`514`
`514`	`515`	`armAlignCode(armAsm, Recompiler::FUNCTION_ALIGNMENT);`
`515`		`- g_discard_and_recompile_block = armAsm->GetCursorAddress<const void*>();`
	`516`	`+ g_recompiler_functions.discard_and_recompile_block = armAsm->GetCursorAddress<const void*>();`
`516`	`517`	`{`
`517`	`518`	`armAsm->ldr(RWARG1, PTR(&g_state.pc));`
`518`	`519`	`armEmitCall(armAsm, reinterpret_cast<const void*>(&DiscardAndRecompileBlock), true);`
`519`	`520`	`armAsm->b(&dispatch);`
`520`	`521`	`}`
`521`	`522`
`522`	`523`	`armAlignCode(armAsm, Recompiler::FUNCTION_ALIGNMENT);`
`523`		`- g_interpret_block = armAsm->GetCursorAddress<const void*>();`
	`524`	`+ g_recompiler_functions.interpret_block = armAsm->GetCursorAddress<const void*>();`
`524`	`525`	`{`
`525`	`526`	`armEmitCall(armAsm, reinterpret_cast<const void*>(GetInterpretUncachedBlockFunction()), true);`
`526`	`527`	`armAsm->ldr(RWARG1, PTR(&g_state.pending_ticks));`
`@@ -780,7 +781,7 @@ void CPU::ARM64Recompiler::GenerateBlockProtectCheck(const u8* ram_ptr, const u8`
`780`	`781`	`Label block_unchanged;`
`781`	`782`	`armAsm->b(&block_unchanged);`
`782`	`783`	`armAsm->bind(&block_changed);`
`783`		`- armEmitJmp(armAsm, CodeCache::g_discard_and_recompile_block, false);`
	`784`	`+ armEmitJmp(armAsm, CodeCache::g_recompiler_functions.discard_and_recompile_block, false);`
`784`	`785`	`armAsm->bind(&block_unchanged);`
`785`	`786`	`}`
`786`	`787`
`@@ -925,16 +926,16 @@ void CPU::ARM64Recompiler::EndAndLinkBlock(const std::optional<u32>& newpc, bool`
`925`	`926`	`if (cycles > 0)`
`926`	`927`	`armAsm->str(RWARG1, PTR(&g_state.pending_ticks));`
`927`	`928`	`if (do_event_test)`
`928`		`- armEmitCondBranch(armAsm, ge, CodeCache::g_run_events_and_dispatch);`
	`929`	`+ armEmitCondBranch(armAsm, ge, CodeCache::g_recompiler_functions.run_events_and_dispatch);`
`929`	`930`
`930`	`931`	`// jump to dispatcher or next block`
`931`	`932`	`if (force_run_events)`
`932`	`933`	`{`
`933`		`- armEmitJmp(armAsm, CodeCache::g_run_events_and_dispatch, false);`
	`934`	`+ armEmitJmp(armAsm, CodeCache::g_recompiler_functions.run_events_and_dispatch, false);`
`934`	`935`	`}`
`935`	`936`	`else if (!newpc.has_value())`
`936`	`937`	`{`
`937`		`- armEmitJmp(armAsm, CodeCache::g_dispatcher, false);`
	`938`	`+ armEmitJmp(armAsm, CodeCache::g_recompiler_functions.dispatcher, false);`
`938`	`939`	`}`
`939`	`940`	`else`
`940`	`941`	`{`
Original file line number	Diff line number	Diff line change
`@@ -212,7 +212,8 @@ u32 CPU::CodeCache::EmitASMFunctions(void* code, u32 code_size)`
`212`	`212`	`lagoon_label_t dispatch = {};`
`213`	`213`	`lagoon_label_t run_events_and_dispatch = {};`
`214`	`214`
`215`		`- g_enter_recompiler = reinterpret_cast<decltype(g_enter_recompiler)>(laAsm->cursor);`
	`215`	`+ g_recompiler_functions.enter_recompiler =`
	`216`	`+ reinterpret_cast<decltype(g_recompiler_functions.enter_recompiler)>(laAsm->cursor);`
`216`	`217`	`{`
`217`	`218`	`// TODO: reserve some space for saving caller-saved registers`
`218`	`219`
`@@ -233,15 +234,15 @@ u32 CPU::CodeCache::EmitASMFunctions(void* code, u32 code_size)`
`233`	`234`	`la_bltu(laAsm, RARG1, RARG2, la_label(laAsm, &skip_event_check));`
`234`	`235`
`235`	`236`	`la_bind(laAsm, &run_events_and_dispatch);`
`236`		`- g_run_events_and_dispatch = laAsm->cursor;`
	`237`	`+ g_recompiler_functions.run_events_and_dispatch = laAsm->cursor;`
`237`	`238`	`laEmitCall(laAsm, reinterpret_cast<const void*>(&TimingEvents::RunEvents));`
`238`	`239`
`239`	`240`	`la_bind(laAsm, &skip_event_check);`
`240`	`241`	`la_label_free(laAsm, &skip_event_check);`
`241`	`242`	`}`
`242`	`243`
`243`	`244`	`// TODO: align?`
`244`		`- g_dispatcher = laAsm->cursor;`
	`245`	`+ g_recompiler_functions.dispatcher = laAsm->cursor;`
`245`	`246`	`{`
`246`	`247`	`la_bind(laAsm, &dispatch);`
`247`	`248`
`@@ -262,21 +263,21 @@ u32 CPU::CodeCache::EmitASMFunctions(void* code, u32 code_size)`
`262`	`263`	`la_jirl(laAsm, LA_ZERO, RARG1, 0);`
`263`	`264`	`}`
`264`	`265`
`265`		`- g_compile_or_revalidate_block = laAsm->cursor;`
	`266`	`+ g_recompiler_functions.compile_or_revalidate_block = laAsm->cursor;`
`266`	`267`	`{`
`267`	`268`	`la_ld_w(laAsm, RARG1, RSTATE, OFFS(&g_state.pc));`
`268`	`269`	`laEmitCall(laAsm, reinterpret_cast<const void*>(&CompileOrRevalidateBlock));`
`269`	`270`	`la_b(laAsm, la_label(laAsm, &dispatch));`
`270`	`271`	`}`
`271`	`272`
`272`		`- g_discard_and_recompile_block = laAsm->cursor;`
	`273`	`+ g_recompiler_functions.discard_and_recompile_block = laAsm->cursor;`
`273`	`274`	`{`
`274`	`275`	`la_ld_w(laAsm, RARG1, RSTATE, OFFS(&g_state.pc));`
`275`	`276`	`laEmitCall(laAsm, reinterpret_cast<const void*>(&DiscardAndRecompileBlock));`
`276`	`277`	`la_b(laAsm, la_label(laAsm, &dispatch));`
`277`	`278`	`}`
`278`	`279`
`279`		`- g_interpret_block = laAsm->cursor;`
	`280`	`+ g_recompiler_functions.interpret_block = laAsm->cursor;`
`280`	`281`	`{`
`281`	`282`	`laEmitCall(laAsm, CodeCache::GetInterpretUncachedBlockFunction());`
`282`	`283`	`la_ld_w(laAsm, RARG1, RSTATE, OFFS(&g_state.pending_ticks));`
`@@ -547,7 +548,7 @@ void CPU::LoongArch64Recompiler::GenerateBlockProtectCheck(const u8* ram_ptr, co`
`547`	`548`	`lagoon_label_t block_unchanged = {};`
`548`	`549`	`la_b(laAsm, la_label(laAsm, &block_unchanged));`
`549`	`550`	`la_bind(laAsm, &block_changed);`
`550`		`- laEmitJmp(laAsm, CodeCache::g_discard_and_recompile_block);`
	`551`	`+ laEmitJmp(laAsm, CodeCache::g_recompiler_functions.discard_and_recompile_block);`
`551`	`552`	`la_bind(laAsm, &block_unchanged);`
`552`	`553`	`la_label_free(laAsm, &block_changed);`
`553`	`554`	`la_label_free(laAsm, &block_unchanged);`
`@@ -714,19 +715,19 @@ void CPU::LoongArch64Recompiler::EndAndLinkBlock(const std::optional<u32>& newpc`
`714`	`715`	`// TODO: see if we can do a far jump somehow with this..`
`715`	`716`	`lagoon_label_t cont = {};`
`716`	`717`	`la_blt(laAsm, RARG1, RARG2, la_label(laAsm, &cont));`
`717`		`- laEmitJmp(laAsm, CodeCache::g_run_events_and_dispatch);`
	`718`	`+ laEmitJmp(laAsm, CodeCache::g_recompiler_functions.run_events_and_dispatch);`
`718`	`719`	`la_bind(laAsm, &cont);`
`719`	`720`	`la_label_free(laAsm, &cont);`
`720`	`721`	`}`
`721`	`722`
`722`	`723`	`// jump to dispatcher or next block`
`723`	`724`	`if (force_run_events)`
`724`	`725`	`{`
`725`		`- laEmitJmp(laAsm, CodeCache::g_run_events_and_dispatch);`
	`726`	`+ laEmitJmp(laAsm, CodeCache::g_recompiler_functions.run_events_and_dispatch);`
`726`	`727`	`}`
`727`	`728`	`else if (!newpc.has_value())`
`728`	`729`	`{`
`729`		`- laEmitJmp(laAsm, CodeCache::g_dispatcher);`
	`730`	`+ laEmitJmp(laAsm, CodeCache::g_recompiler_functions.dispatcher);`
`730`	`731`	`}`
`731`	`732`	`else`
`732`	`733`	`{`
Original file line number	Diff line number	Diff line change
`@@ -243,7 +243,8 @@ u32 CPU::CodeCache::EmitASMFunctions(void* code, u32 code_size)`
`243`	`243`	`Label dispatch;`
`244`	`244`	`Label run_events_and_dispatch;`
`245`	`245`
`246`		`- g_enter_recompiler = reinterpret_cast<decltype(g_enter_recompiler)>(rvAsm->GetCursorPointer());`
	`246`	`+ g_recompiler_functions.enter_recompiler =`
	`247`	`+ reinterpret_cast<decltype(g_recompiler_functions.enter_recompiler)>(rvAsm->GetCursorPointer());`
`247`	`248`	`{`
`248`	`249`	`// TODO: reserve some space for saving caller-saved registers`
`249`	`250`
`@@ -265,14 +266,14 @@ u32 CPU::CodeCache::EmitASMFunctions(void* code, u32 code_size)`
`265`	`266`	`rvAsm->BLTU(RARG1, RARG2, &skip_event_check);`
`266`	`267`
`267`	`268`	`rvAsm->Bind(&run_events_and_dispatch);`
`268`		`- g_run_events_and_dispatch = rvAsm->GetCursorPointer();`
	`269`	`+ g_recompiler_functions.run_events_and_dispatch = rvAsm->GetCursorPointer();`
`269`	`270`	`rvEmitCall(rvAsm, reinterpret_cast<const void*>(&TimingEvents::RunEvents));`
`270`	`271`
`271`	`272`	`rvAsm->Bind(&skip_event_check);`
`272`	`273`	`}`
`273`	`274`
`274`	`275`	`// TODO: align?`
`275`		`- g_dispatcher = rvAsm->GetCursorPointer();`
	`276`	`+ g_recompiler_functions.dispatcher = rvAsm->GetCursorPointer();`
`276`	`277`	`{`
`277`	`278`	`rvAsm->Bind(&dispatch);`
`278`	`279`
`@@ -293,21 +294,21 @@ u32 CPU::CodeCache::EmitASMFunctions(void* code, u32 code_size)`
`293`	`294`	`rvAsm->JR(RARG1);`
`294`	`295`	`}`
`295`	`296`
`296`		`- g_compile_or_revalidate_block = rvAsm->GetCursorPointer();`
	`297`	`+ g_recompiler_functions.compile_or_revalidate_block = rvAsm->GetCursorPointer();`
`297`	`298`	`{`
`298`	`299`	`rvAsm->LW(RARG1, PTR(&g_state.pc));`
`299`	`300`	`rvEmitCall(rvAsm, reinterpret_cast<const void*>(&CompileOrRevalidateBlock));`
`300`	`301`	`rvAsm->J(&dispatch);`
`301`	`302`	`}`
`302`	`303`
`303`		`- g_discard_and_recompile_block = rvAsm->GetCursorPointer();`
	`304`	`+ g_recompiler_functions.discard_and_recompile_block = rvAsm->GetCursorPointer();`
`304`	`305`	`{`
`305`	`306`	`rvAsm->LW(RARG1, PTR(&g_state.pc));`
`306`	`307`	`rvEmitCall(rvAsm, reinterpret_cast<const void*>(&DiscardAndRecompileBlock));`
`307`	`308`	`rvAsm->J(&dispatch);`
`308`	`309`	`}`
`309`	`310`
`310`		`- g_interpret_block = rvAsm->GetCursorPointer();`
	`311`	`+ g_recompiler_functions.interpret_block = rvAsm->GetCursorPointer();`
`311`	`312`	`{`
`312`	`313`	`rvEmitCall(rvAsm, CodeCache::GetInterpretUncachedBlockFunction());`
`313`	`314`	`rvAsm->LW(RARG1, PTR(&g_state.pending_ticks));`
`@@ -553,7 +554,7 @@ void CPU::RISCV64Recompiler::GenerateBlockProtectCheck(const u8* ram_ptr, const`
`553`	`554`	`Label block_unchanged;`
`554`	`555`	`rvAsm->J(&block_unchanged);`
`555`	`556`	`rvAsm->Bind(&block_changed);`
`556`		`- rvEmitJmp(rvAsm, CodeCache::g_discard_and_recompile_block);`
	`557`	`+ rvEmitJmp(rvAsm, CodeCache::g_recompiler_functions.discard_and_recompile_block);`
`557`	`558`	`rvAsm->Bind(&block_unchanged);`
`558`	`559`	`}`
`559`	`560`
`@@ -716,18 +717,18 @@ void CPU::RISCV64Recompiler::EndAndLinkBlock(const std::optional<u32>& newpc, bo`
`716`	`717`	`// TODO: see if we can do a far jump somehow with this..`
`717`	`718`	`Label cont;`
`718`	`719`	`rvAsm->BLT(RARG1, RARG2, &cont);`
`719`		`- rvEmitJmp(rvAsm, CodeCache::g_run_events_and_dispatch);`
	`720`	`+ rvEmitJmp(rvAsm, CodeCache::g_recompiler_functions.run_events_and_dispatch);`
`720`	`721`	`rvAsm->Bind(&cont);`
`721`	`722`	`}`
`722`	`723`
`723`	`724`	`// jump to dispatcher or next block`
`724`	`725`	`if (force_run_events)`
`725`	`726`	`{`
`726`		`- rvEmitJmp(rvAsm, CodeCache::g_run_events_and_dispatch);`
	`727`	`+ rvEmitJmp(rvAsm, CodeCache::g_recompiler_functions.run_events_and_dispatch);`
`727`	`728`	`}`
`728`	`729`	`else if (!newpc.has_value())`
`729`	`730`	`{`
`730`		`- rvEmitJmp(rvAsm, CodeCache::g_dispatcher);`
	`731`	`+ rvEmitJmp(rvAsm, CodeCache::g_recompiler_functions.dispatcher);`
`731`	`732`	`}`
`732`	`733`	`else`
`733`	`734`	`{`