Host platform abstraction layer for the execution engine (#181)

* [Host] Introduce host platform abstraction with IHostMemory Add SharpEmu.HLE/Host with IHostPlatform/IHostMemory interfaces, neutral page-protection/region enums, and a HostPlatform.Current factory that resolves the Windows backend (or throws PlatformNotSupportedException on other OSes, matching today's de-facto behavior). WindowsHostMemory wraps the exact VirtualAlloc/VirtualFree/VirtualProtect/VirtualQuery calls used across the engine today, with identical MEM_*/PAGE_* constants. Migrate StubManager as the first consumer: its private kernel32 P/Invokes and enums are replaced by IHostMemory calls that issue the same two native operations (RWX commit+reserve of the PLT arena, release on Dispose). No behavior change. This is the first step toward supporting non-Windows hosts; subsequent commits move the remaining direct P/Invokes in Core and Libs behind the same seam. * [Host] Route PhysicalVirtualMemory through IHostMemory Replace the class's private VirtualAlloc/VirtualFree/VirtualProtect/ VirtualQuery P/Invokes with IHostMemory calls. Every site maps 1:1 onto the exact native call it issued before: MEM_COMMIT|MEM_RESERVE -> Allocate, MEM_RESERVE -> Reserve, fault-path commits -> Commit, and MEM_RELEASE -> Free, with identical protection values produced by the Windows backend. IHostMemory gains ProtectRaw so the save/restore protection sequences in TryWriteExclusive and TryTemporarilyProtectForRead round-trip the raw OS protection word (including modifier bits the neutral enum cannot represent) exactly as before. Raw PAGE_* constants remain only for the internal region-classification helpers, which only ever see values this class itself assigned. The exact-address free-on-mismatch, lazy reserve-only threshold, prime loop, and all trace strings are unchanged. * [Host] Add IGuestAddressSpace and retire the reflection-based allocator lookup Introduce IGuestAddressSpace in SharpEmu.HLE (fixed-address AllocateAt / TryAllocateAtOrAbove and guest mprotect via TryProtect) with signatures copied from PhysicalVirtualMemory, which now implements it. TryProtect reproduces the read/write/execute decomposition that KernelMemoryCompatExports.ResolveHostProtection performs, yielding the same PAGE_* values through the Windows backend. KernelVirtualRangeAllocator previously located AllocateAt via cached MethodInfo reflection (because SharpEmu.Libs cannot see Core types) and walked wrapper memories through an untyped 'Inner' property. Both are now typed: ICpuMemoryWrapper exposes the decorated memory (implemented by TrackedCpuMemory, whose Inner property already existed) and the allocator type-tests for IGuestAddressSpace with the same bounded unwrap depth. Failure paths keep the exact [LOADER][TRACE] strings. * [Host] Move Kernel HLE memory exports off direct kernel32 P/Invokes KernelMemoryCompatExports loses its private VirtualQuery/VirtualProtect/ VirtualAlloc/VirtualFree declarations and MemoryBasicInformation struct: - Guest mprotect (sceKernelMprotect/sceKernelMtypeprotect) now routes through IGuestAddressSpace.TryProtect resolved from ctx.Memory. The orbis read/write/execute decomposition moves into a GuestPageProtection conversion whose mapping is value-identical to the removed ResolveHostProtection. - The guarded libc heap and host-page accessibility checks go through IHostMemory (same commit+reserve/protect/free sequence; guard-page and protection-mask checks compare HostRegionInfo.RawProtection against the same PAGE_* literals as before). - HostMemory is exposed as a property so merely loading the type never resolves the platform backend on non-Windows hosts. KernelRuntimeCompatExports' RDTSC stub allocates its 16-byte RWX page via IHostMemory.Allocate; the OperatingSystem.IsWindows() gate returning null is unchanged. * [Host] Abstract thread, TLS, and symbol primitives in the execution backend Add IHostThreading (native TLS slots, current-thread id, affinity, raw thread create/join, diagnostic register capture) and IHostSymbolResolver (enum-keyed host function addresses baked into emitted stubs), with Windows implementations wrapping the exact kernel32 calls the backend made directly before. DirectExecutionBackend takes an optional IHostPlatform (defaulting to HostPlatform.Current) and routes every TlsAlloc/TlsFree/TlsSet/GetValue, GetCurrentThreadId, SetThreadAffinityMask, GetModuleHandle/GetProcAddress and the suspend+GetThreadContext diagnostic snapshot through it. The snapshot moves wholesale into WindowsHostThreading (including the Win64 CONTEXT size/flags/offsets, which are Windows-specific by nature) and returns a neutral HostCapturedRegisters. NativeGuestExecutor resolves WaitForSingleObject/SetEvent/ExitThread via the symbol resolver — the same addresses end up in the emitted run loop, so stub bytes are unchanged — and creates/joins its raw worker thread through IHostThreading with the same stack-reservation semantics. The run-loop emitter itself does not move. Marshal.GetLastWin32Error() in the affinity-failure log still observes SetThreadAffinityMask's error because the wrapper makes no intervening SetLastError call. * [Host] Move fault handling and remaining backend memory ops behind the seam Add IHostFaultHandling (handler-thunk creation, first-chance handler install/remove, unhandled-filter set) with WindowsFaultHandling in a new Cpu/Native/Windows/ folder. The exception-handler trampoline emitter moves there whole — same pre-filtered NTSTATUS codes, same TEB gs:[8]/ gs:[0x10] stack-limit reads, same host-RSP TLS switch — parameterized only by (managed callback, TLS slot, TlsGetValue address), which is exactly what SetupExceptionHandler passed it before. Handler installation order, the AddVectoredExceptionHandler(first=1) flag, the SHARPEMU_DISABLE_RAW_HANDLER gate, and all install/teardown log strings are unchanged. Every remaining VirtualAlloc/VirtualProtect/VirtualFree/VirtualQuery/ FlushInstructionCache in the backend partials routes through IHostMemory with 1:1 call mapping (RWX emit -> RX downgrade -> flush for stub emission, reserve/commit for the PRT aperture and lazy-commit fault path, raw-protection round-trips via ProtectRaw). HostRegionInfo gains RawState/RawAllocationProtection so the lazy-commit trace lines and protection-mask checks keep printing and comparing the exact native values. Windows semantics leaked as bare literals become named constants with identical values: NTSTATUS codes (WindowsFaultCodes) and Win64 CONTEXT byte offsets (Win64ContextOffsets, with the existing CTX_* constants aliased to it and handler-local numeric offsets replaced by the names). * [Host] Resolve the host platform explicitly at the composition root SharpEmuRuntime.CreateDefault() now resolves HostPlatform.Current once and passes it explicitly to PhysicalVirtualMemory and (via a new optional CpuDispatcher parameter) to DirectExecutionBackend, replacing the implicit default-argument fallbacks. On unsupported OSes boot now fails at the root with PlatformNotSupportedException and a clear message instead of on the first native call. A future Linux/macOS backend plugs in by returning a different IHostPlatform here. * [Host] Convert the platform backends to source-generated P/Invokes Replace [DllImport] with [LibraryImport] in the four Windows backend files added by this branch (WindowsHostMemory, WindowsHostThreading, WindowsHostSymbolResolver, WindowsFaultHandling). Marshalling stubs are now generated at compile time instead of JIT-emitted at runtime, which fits the pre-JIT-everything boot model and keeps the backends NativeAOT/trimming ready. Interop stays zero-copy: all signatures are blittable, GetModuleHandleW now pins the managed string via Utf16 marshalling instead of copying, and GetProcAddress names marshal through a stack-allocated Utf8 buffer. Implicit contracts become explicit where LibraryImport requires it: TlsFree/TlsSetValue gain [MarshalAs(UnmanagedType.Bool)] (the 4-byte Win32 BOOL DllImport assumed silently), and GetModuleHandle targets the W entry point directly since LibraryImport never probes suffixes. The CONTEXT snapshot buffer stays a NativeMemory allocation rather than stackalloc: CONTEXT requires 16-byte alignment, now documented at the call site. Native call sequences are unchanged. * [Host] Address Copilot review: harden failure paths, honor injected platform - Free the handler thunk page when the RX protection downgrade fails (the leak predates this branch, but the failure path is boot-fatal so releasing the page is unobservable). - TraceThreadMode and the static diagnostics helpers now resolve host primitives through the backend bound to the current thread, falling back to HostPlatform.Current only when no run is active (identical on supported configs, honors injection everywhere a backend exists). - HostPlatform.Create additionally requires an x64 process so native Windows ARM64 fails with the promised PlatformNotSupportedException instead of emitting x86-64 stubs into an ARM64 process.
2026-07-22 19:06:15 +08:00 · 2026-07-15 01:15:36 +01:00
parent 081760be3f
commit f23161be9a
34 changed files with 1394 additions and 810 deletions
@@ -7,6 +7,7 @@ using SharpEmu.Core.Cpu.Native;
 using SharpEmu.Core.Loader;
 using SharpEmu.Core.Memory;
 using SharpEmu.HLE;
 using SharpEmu.HLE.Host;
 using SharpEmu.Logging;
 namespace SharpEmu.Core.Cpu;
@@ -41,16 +42,19 @@ public sealed class CpuDispatcher : ICpuDispatcher, IDisposable
    ];
    private readonly IVirtualMemory _virtualMemory;
    private readonly IModuleManager _moduleManager;
    private readonly IHostPlatform? _hostPlatform;
    private INativeCpuBackend? _nativeCpuBackend;
    public CpuDispatcher(
        IVirtualMemory virtualMemory,
        IModuleManager moduleManager,
-        INativeCpuBackend? nativeCpuBackend = null)
+        INativeCpuBackend? nativeCpuBackend = null,
        IHostPlatform? hostPlatform = null)
    {
        _virtualMemory = virtualMemory ?? throw new ArgumentNullException(nameof(virtualMemory));
        _moduleManager = moduleManager ?? throw new ArgumentNullException(nameof(moduleManager));
        _nativeCpuBackend = nativeCpuBackend;
        _hostPlatform = hostPlatform;
    }
    public ulong? LastEntryPoint { get; private set; }
@@ -266,7 +270,7 @@ public sealed class CpuDispatcher : ICpuDispatcher, IDisposable
            entryFrameDiagnostic,
            Environment.NewLine,
            "CpuEngine: native-only");
-        _nativeCpuBackend ??= new DirectExecutionBackend(_moduleManager);
+        _nativeCpuBackend ??= new DirectExecutionBackend(_moduleManager, _hostPlatform);
        if (_nativeCpuBackend.TryExecute(
                context,
                entryPoint,
@@ -8,6 +8,7 @@ using System.Linq;
 using System.Runtime.InteropServices;
 using System.Threading;
 using SharpEmu.HLE;
 using SharpEmu.HLE.Host;
 using SharpEmu.Logging;
 namespace SharpEmu.Core.Cpu.Native;
@@ -134,8 +135,9 @@ public sealed partial class DirectExecutionBackend
 		int num2 = 0;
 		List<ulong> list = new List<ulong>(16);
 		ulong num3 = scanStart;
-		MEMORY_BASIC_INFORMATION64 lpBuffer;
+		var hostMemory = ResolveDiagnosticsHostMemory();
-		while (num3 < scanEnd && VirtualQuery((void*)num3, out lpBuffer, (nuint)sizeof(MEMORY_BASIC_INFORMATION64)) != 0)
+		HostRegionInfo lpBuffer;
 		while (num3 < scanEnd && hostMemory.Query(num3, out lpBuffer))
 		{
 			ulong baseAddress = lpBuffer.BaseAddress;
 			ulong num4 = baseAddress + lpBuffer.RegionSize;
@@ -145,7 +147,7 @@ public sealed partial class DirectExecutionBackend
 			}
 			ulong value = Math.Max(num3, baseAddress);
 			ulong num5 = Math.Min(num4, scanEnd);
-			if (lpBuffer.State == 4096 && IsReadableProtection(lpBuffer.Protect) && !IsExecutableProtection(lpBuffer.Protect))
+			if (lpBuffer.State == HostRegionState.Committed && IsReadableProtection(lpBuffer.RawProtection) && !IsExecutableProtection(lpBuffer.RawProtection))
 			{
 				ulong num6 = AlignUp(value, 8uL);
 				for (ulong num7 = num6; num7 + 8 <= num5; num7 += 8)
@@ -350,7 +352,7 @@ public sealed partial class DirectExecutionBackend
 		{
 			return false;
 		}
-		if (VirtualQuery((void*)address, out var lpBuffer, (nuint)sizeof(MEMORY_BASIC_INFORMATION64)) == 0)
+		if (!ResolveDiagnosticsHostMemory().Query(address, out var lpBuffer))
 		{
 			return false;
 		}
@@ -359,7 +361,7 @@ public sealed partial class DirectExecutionBackend
 		{
 			return false;
 		}
-		if (lpBuffer.State != 4096 || !IsReadableProtection(lpBuffer.Protect))
+		if (lpBuffer.State != HostRegionState.Committed || !IsReadableProtection(lpBuffer.RawProtection))
 		{
 			return false;
 		}
@@ -391,12 +393,12 @@ public sealed partial class DirectExecutionBackend
 			return true;
 		}
-		if (VirtualQuery((void*)address, out var lpBuffer, (nuint)sizeof(MEMORY_BASIC_INFORMATION64)) == 0)
+		if (!ResolveDiagnosticsHostMemory().Query(address, out var lpBuffer))
 		{
 			return false;
 		}
-		var executable = lpBuffer.State == 4096 && IsExecutableProtection(lpBuffer.Protect);
+		var executable = lpBuffer.State == HostRegionState.Committed && IsExecutableProtection(lpBuffer.RawProtection);
 		if (executable)
 		{
 			_knownExecutablePages.TryAdd(pageAddress, 0);
@@ -415,6 +417,14 @@ public sealed partial class DirectExecutionBackend
 		return (value + num) & ~num;
 	}
 	// Diagnostics helpers are static (reachable from static handler paths), so
 	// they use the platform injected into the backend active on this thread and
 	// fall back to the process-wide singleton only when no run is bound.
 	private static IHostMemory ResolveDiagnosticsHostMemory()
 	{
 		return _activeExecutionBackend?._hostMemory ?? HostPlatform.Current.Memory;
 	}
 	private static bool IsReadableProtection(uint protect)
 	{
 		if ((protect & 0x100) != 0 || (protect & 1) != 0)
@@ -9,7 +9,9 @@ using System.Reflection;
 using System.Runtime.InteropServices;
 using System.Threading;
 using SharpEmu.Core.Cpu.Disasm;
 using SharpEmu.Core.Cpu.Native.Windows;
 using SharpEmu.HLE;
 using SharpEmu.HLE.Host;
 namespace SharpEmu.Core.Cpu.Native;
@@ -22,12 +24,12 @@ public sealed partial class DirectExecutionBackend
 	{
 		if (!string.Equals(Environment.GetEnvironmentVariable("SHARPEMU_DISABLE_RAW_HANDLER"), "1", StringComparison.Ordinal))
 		{
-			_rawExceptionHandlerStub = CreateExceptionHandlerTrampoline(RawVectoredHandlerPtrManaged);
+			_rawExceptionHandlerStub = _faultHandling.CreateHandlerThunk(RawVectoredHandlerPtrManaged, _hostRspSlotTlsIndex, _tlsGetValueAddress);
 			if (_rawExceptionHandlerStub == 0)
 			{
 				throw new InvalidOperationException("Failed to create raw exception handler trampoline");
 			}
-			_rawExceptionHandler = (nint)AddVectoredExceptionHandler(1u, _rawExceptionHandlerStub);
+			_rawExceptionHandler = _faultHandling.AddFirstChanceHandler(_rawExceptionHandlerStub);
 			Console.Error.WriteLine($"[LOADER][INFO] Raw exception handler installed: 0x{_rawExceptionHandler:X16}");
 		}
 		else
@@ -37,22 +39,22 @@ public sealed partial class DirectExecutionBackend
 		_handlerDelegate = VectoredHandler;
 		_handlerHandle = GCHandle.Alloc(_handlerDelegate);
-		_exceptionHandlerStub = CreateExceptionHandlerTrampoline(Marshal.GetFunctionPointerForDelegate(_handlerDelegate));
+		_exceptionHandlerStub = _faultHandling.CreateHandlerThunk(Marshal.GetFunctionPointerForDelegate(_handlerDelegate), _hostRspSlotTlsIndex, _tlsGetValueAddress);
 		if (_exceptionHandlerStub == 0)
 		{
 			throw new InvalidOperationException("Failed to create exception handler trampoline");
 		}
-		_exceptionHandler = (nint)AddVectoredExceptionHandler(1u, _exceptionHandlerStub);
+		_exceptionHandler = _faultHandling.AddFirstChanceHandler(_exceptionHandlerStub);
 		Console.Error.WriteLine($"[LOADER][INFO] Exception handler installed: 0x{_exceptionHandler:X16}");
 		_unhandledFilterDelegate = UnhandledExceptionFilter;
 		_unhandledFilterHandle = GCHandle.Alloc(_unhandledFilterDelegate);
-		_unhandledFilterStub = CreateExceptionHandlerTrampoline(Marshal.GetFunctionPointerForDelegate(_unhandledFilterDelegate));
+		_unhandledFilterStub = _faultHandling.CreateHandlerThunk(Marshal.GetFunctionPointerForDelegate(_unhandledFilterDelegate), _hostRspSlotTlsIndex, _tlsGetValueAddress);
 		if (_unhandledFilterStub == 0)
 		{
 			throw new InvalidOperationException("Failed to create unhandled exception filter trampoline");
 		}
-		SetUnhandledExceptionFilter(_unhandledFilterStub);
+		_faultHandling.SetUnhandledFilter(_unhandledFilterStub);
 	}
 	private unsafe int UnhandledExceptionFilter(void* exceptionInfo)
@@ -60,8 +62,8 @@ public sealed partial class DirectExecutionBackend
 		try
 		{
 			EXCEPTION_RECORD* exceptionRecord = ((EXCEPTION_POINTERS*)exceptionInfo)->ExceptionRecord;
-			ulong rip = ReadCtxU64(((EXCEPTION_POINTERS*)exceptionInfo)->ContextRecord, 248);
+			ulong rip = ReadCtxU64(((EXCEPTION_POINTERS*)exceptionInfo)->ContextRecord, CTX_RIP);
-			ulong rsp = ReadCtxU64(((EXCEPTION_POINTERS*)exceptionInfo)->ContextRecord, 152);
+			ulong rsp = ReadCtxU64(((EXCEPTION_POINTERS*)exceptionInfo)->ContextRecord, CTX_RSP);
 			Console.Error.WriteLine("[LOADER][FATAL] Unhandled exception filter fired.");
 			Console.Error.WriteLine($"[LOADER][FATAL]   Code: 0x{exceptionRecord->ExceptionCode:X8}");
 			Console.Error.WriteLine($"[LOADER][FATAL]   Exception Address: 0x{(ulong)(nint)exceptionRecord->ExceptionAddress:X16}");
@@ -100,8 +102,8 @@ public sealed partial class DirectExecutionBackend
 				return 0;
 			}
-			ulong rip = ReadCtxU64(contextRecord, 248);
+			ulong rip = ReadCtxU64(contextRecord, CTX_RIP);
-			ulong rsp = ReadCtxU64(contextRecord, 152);
+			ulong rsp = ReadCtxU64(contextRecord, CTX_RSP);
 			// Thread-mode probe: a hardware exception raised while this thread is inside
 			// the managed import gateway means the VEH->managed reentry happened from
@@ -112,7 +114,7 @@ public sealed partial class DirectExecutionBackend
 					$"veh_in_gateway code=0x{exceptionCode:X8} rip=0x{rip:X16} gateway_depth={_threadModeGatewayDepth}");
 			}
-			if (exceptionCode == 3221225477u && TryHandleLazyCommittedPage(exceptionRecord, rip, rsp))
+			if (exceptionCode == WindowsFaultCodes.AccessViolation && TryHandleLazyCommittedPage(exceptionRecord, rip, rsp))
 			{
 				return -1;
 			}
@@ -127,10 +129,10 @@ public sealed partial class DirectExecutionBackend
 			switch (exceptionCode)
 			{
-				case 3221225477u:
+				case WindowsFaultCodes.AccessViolation:
 					LogAccessViolationTrace(exceptionAddress, exceptionRecord);
 					break;
-				case 3221226505u:
+				case WindowsFaultCodes.FastFail:
 					{
 						ulong p0 = exceptionRecord->NumberParameters >= 1 ? (*exceptionRecord->ExceptionInformation) : 0;
 						ulong p1 = exceptionRecord->NumberParameters >= 2 ? exceptionRecord->ExceptionInformation[1] : 0;
@@ -140,21 +142,21 @@ public sealed partial class DirectExecutionBackend
 					}
 			}
-			ulong rax = ReadCtxU64(contextRecord, 120);
+			ulong rax = ReadCtxU64(contextRecord, CTX_RAX);
-			ulong rbx = ReadCtxU64(contextRecord, 144);
+			ulong rbx = ReadCtxU64(contextRecord, CTX_RBX);
-			ulong rcx = ReadCtxU64(contextRecord, 128);
+			ulong rcx = ReadCtxU64(contextRecord, CTX_RCX);
-			ulong rdx = ReadCtxU64(contextRecord, 136);
+			ulong rdx = ReadCtxU64(contextRecord, CTX_RDX);
-			ulong rsi = ReadCtxU64(contextRecord, 168);
+			ulong rsi = ReadCtxU64(contextRecord, CTX_RSI);
-			ulong rdi = ReadCtxU64(contextRecord, 176);
+			ulong rdi = ReadCtxU64(contextRecord, CTX_RDI);
-			ulong rbp = ReadCtxU64(contextRecord, 160);
+			ulong rbp = ReadCtxU64(contextRecord, CTX_RBP);
-			ulong r8 = ReadCtxU64(contextRecord, 184);
+			ulong r8 = ReadCtxU64(contextRecord, CTX_R8);
-			ulong r9 = ReadCtxU64(contextRecord, 192);
+			ulong r9 = ReadCtxU64(contextRecord, CTX_R9);
-			ulong r10 = ReadCtxU64(contextRecord, 200);
+			ulong r10 = ReadCtxU64(contextRecord, CTX_R10);
-			ulong r11 = ReadCtxU64(contextRecord, 208);
+			ulong r11 = ReadCtxU64(contextRecord, CTX_R11);
-			ulong r12 = ReadCtxU64(contextRecord, 216);
+			ulong r12 = ReadCtxU64(contextRecord, CTX_R12);
-			ulong r13 = ReadCtxU64(contextRecord, 224);
+			ulong r13 = ReadCtxU64(contextRecord, CTX_R13);
-			ulong r14 = ReadCtxU64(contextRecord, 232);
+			ulong r14 = ReadCtxU64(contextRecord, CTX_R14);
-			ulong r15 = ReadCtxU64(contextRecord, 240);
+			ulong r15 = ReadCtxU64(contextRecord, CTX_R15);
 			Console.Error.WriteLine("[LOADER][INFO] =========================================");
 			Console.Error.WriteLine("[LOADER][INFO] NATIVE EXCEPTION CAUGHT!");
@@ -185,7 +187,7 @@ public sealed partial class DirectExecutionBackend
 			ulong accessType = 0;
 			ulong target = 0;
-			if (exceptionCode == 3221225477u && exceptionRecord->NumberParameters >= 2)
+			if (exceptionCode == WindowsFaultCodes.AccessViolation && exceptionRecord->NumberParameters >= 2)
 			{
 				accessType = *exceptionRecord->ExceptionInformation;
 				target = exceptionRecord->ExceptionInformation[1];
@@ -198,9 +200,9 @@ public sealed partial class DirectExecutionBackend
 				};
 				Console.Error.WriteLine("[LOADER][INFO]   AV access: " + accessText);
 				Console.Error.WriteLine($"[LOADER][INFO]   AV target: 0x{target:X16}");
-				if (VirtualQuery((void*)target, out var mbi, (nuint)sizeof(MEMORY_BASIC_INFORMATION64)) != 0)
+				if (_hostMemory.Query(target, out var mbi))
 				{
-					Console.Error.WriteLine($"[LOADER][INFO]   AV target region: base=0x{mbi.BaseAddress:X16} size=0x{mbi.RegionSize:X16} state=0x{mbi.State:X08} protect=0x{mbi.Protect:X08}");
+					Console.Error.WriteLine($"[LOADER][INFO]   AV target region: base=0x{mbi.BaseAddress:X16} size=0x{mbi.RegionSize:X16} state=0x{mbi.RawState:X08} protect=0x{mbi.RawProtection:X08}");
 				}
 			}
@@ -248,7 +250,7 @@ public sealed partial class DirectExecutionBackend
 			switch (exceptionCode)
 			{
-				case 3221225477u:
+				case WindowsFaultCodes.AccessViolation:
 					Console.Error.WriteLine("[LOADER][ERROR]   Type: Access Violation");
 					Console.Error.WriteLine("[LOADER][ERROR]   This usually means:");
 					Console.Error.WriteLine("[LOADER][ERROR]     - Guest code called an unmapped import");
@@ -295,11 +297,11 @@ public sealed partial class DirectExecutionBackend
 					DumpGuestReferenceDiagnostics();
 					DumpGuestPointerWindowDiagnostics();
 					break;
-				case 2147483651u:
+				case WindowsFaultCodes.Breakpoint:
 					Console.Error.WriteLine("[LOADER][WARNING]   Type: Breakpoint (int3)");
 					Console.Error.WriteLine("[LOADER][WARNING]   Unexpected breakpoint in direct-bridge mode");
 					break;
-				case 3221225501u:
+				case WindowsFaultCodes.IllegalInstruction:
 					Console.Error.WriteLine("[LOADER][INFO]   Type: Illegal Instruction");
 					break;
 			}
@@ -332,8 +334,8 @@ public sealed partial class DirectExecutionBackend
 			EXCEPTION_POINTERS* pointers = (EXCEPTION_POINTERS*)exceptionInfo;
 			EXCEPTION_RECORD* record = pointers->ExceptionRecord;
 			void* contextRecord = pointers->ContextRecord;
-			ulong rip = contextRecord != null ? ReadCtxU64(contextRecord, 248) : 0;
+			ulong rip = contextRecord != null ? ReadCtxU64(contextRecord, CTX_RIP) : 0;
-			ulong rsp = contextRecord != null ? ReadCtxU64(contextRecord, 152) : 0;
+			ulong rsp = contextRecord != null ? ReadCtxU64(contextRecord, CTX_RSP) : 0;
 			ulong accessType = record->NumberParameters >= 1 ? *record->ExceptionInformation : 0;
 			ulong target = record->NumberParameters >= 2 ? record->ExceptionInformation[1] : 0;
 			Console.Error.WriteLine(
@@ -479,7 +481,7 @@ public sealed partial class DirectExecutionBackend
 		ulong address = scanBase;
 		while (address < scanEnd)
 		{
-			if (VirtualQuery((void*)address, out var mbi, (nuint)sizeof(MEMORY_BASIC_INFORMATION64)) == 0)
+			if (!_hostMemory.Query(address, out var mbi))
 			{
 				break;
 			}
@@ -491,9 +493,9 @@ public sealed partial class DirectExecutionBackend
 				break;
 			}
-			if (mbi.State == MEM_COMMIT &&
+			if (mbi.State == HostRegionState.Committed &&
-				IsReadableProtection(mbi.Protect) &&
+				IsReadableProtection(mbi.RawProtection) &&
-				IsExecutableProtection(mbi.Protect))
+				IsExecutableProtection(mbi.RawProtection))
 			{
 				ScanExecutableRegionForTargetReferences(regionBase, regionEnd, targetList, hitCounts, maxHitsPerTarget);
 			}
@@ -798,13 +800,13 @@ public sealed partial class DirectExecutionBackend
 			return false;
 		}
-		if (VirtualQuery((void*)address, out var mbi, (nuint)sizeof(MEMORY_BASIC_INFORMATION64)) == 0)
+		if (!_hostMemory.Query(address, out var mbi))
 		{
 			return false;
 		}
 		ulong regionEnd = mbi.BaseAddress + mbi.RegionSize;
-		if (mbi.State != MEM_COMMIT || !IsReadableProtection(mbi.Protect) || regionEnd <= address || address > regionEnd - 8)
+		if (mbi.State != HostRegionState.Committed || !IsReadableProtection(mbi.RawProtection) || regionEnd <= address || address > regionEnd - 8)
 		{
 			return false;
 		}
@@ -916,25 +918,25 @@ public sealed partial class DirectExecutionBackend
 		{
 			return false;
 		}
-		if (VirtualQuery((void*)faultAddress, out var mbi, (nuint)sizeof(MEMORY_BASIC_INFORMATION64)) == 0)
+		if (!_hostMemory.Query(faultAddress, out var mbi))
 		{
 			return false;
 		}
 		ulong pageBase = faultAddress & 0xFFFFFFFFFFFFF000uL;
-		uint commitProtect = ResolveLazyCommitProtection(accessType, mbi.AllocationProtect);
+		uint commitProtect = ResolveLazyCommitProtection(accessType, mbi.RawAllocationProtection);
 		int traceIndex = Interlocked.Increment(ref _lazyCommitTraceCount);
 		bool traceLazyCommit = ShouldTraceLazyCommit(traceIndex);
 		if (traceLazyCommit)
 		{
-			Console.Error.WriteLine($"[LOADER][TRACE] lazy-query#{traceIndex}: fault=0x{faultAddress:X16} owner={owner} rip=0x{rip:X16} rsp=0x{rsp:X16} state=0x{mbi.State:X08} base=0x{mbi.BaseAddress:X16} size=0x{mbi.RegionSize:X16} alloc=0x{mbi.AllocationProtect:X08} prot=0x{mbi.Protect:X08}");
+			Console.Error.WriteLine($"[LOADER][TRACE] lazy-query#{traceIndex}: fault=0x{faultAddress:X16} owner={owner} rip=0x{rip:X16} rsp=0x{rsp:X16} state=0x{mbi.RawState:X08} base=0x{mbi.BaseAddress:X16} size=0x{mbi.RegionSize:X16} alloc=0x{mbi.RawAllocationProtection:X08} prot=0x{mbi.RawProtection:X08}");
 		}
-		if (mbi.State == 4096 && IsAccessCompatible(accessType, mbi.Protect))
+		if (mbi.State == HostRegionState.Committed && IsAccessCompatible(accessType, mbi.RawProtection))
 		{
 			if (traceLazyCommit)
 			{
-				Console.Error.WriteLine($"[LOADER][TRACE] lazy-commit-race#{traceIndex}: fault=0x{faultAddress:X16} protect=0x{mbi.Protect:X08}");
+				Console.Error.WriteLine($"[LOADER][TRACE] lazy-commit-race#{traceIndex}: fault=0x{faultAddress:X16} protect=0x{mbi.RawProtection:X08}");
 			}
 			return true;
 		}
@@ -943,10 +945,10 @@ public sealed partial class DirectExecutionBackend
 		ulong committedBase = 0;
 		ulong committedSize = 0;
-		if (mbi.State == 65536)
+		if (mbi.State == HostRegionState.Free)
 		{
 			if (TryGetLazyCommitWindow(faultAddress, mbi.BaseAddress, mbi.RegionSize, out var windowBase, out var windowSize) &&
-				TryReserveThenCommit(windowBase, windowSize, windowBase, windowSize, commitProtect))
+				TryReserveThenCommit(_hostMemory, windowBase, windowSize, windowBase, windowSize, commitProtect))
 			{
 				committed = true;
 				committedBase = windowBase;
@@ -955,7 +957,7 @@ public sealed partial class DirectExecutionBackend
 			else
 			{
 				ulong largeBase = faultAddress & 0xFFFFFFFFFFE00000uL;
-				if (TryReserveThenCommit(largeBase, 2097152uL, largeBase, 2097152uL, commitProtect))
+				if (TryReserveThenCommit(_hostMemory, largeBase, 2097152uL, largeBase, 2097152uL, commitProtect))
 				{
 					committed = true;
 					committedBase = largeBase;
@@ -966,13 +968,13 @@ public sealed partial class DirectExecutionBackend
 			if (!committed)
 			{
 				ulong region64kBase = faultAddress & 0xFFFFFFFFFFFF0000uL;
-				if (TryReserveThenCommit(region64kBase, 65536uL, region64kBase, 65536uL, commitProtect))
+				if (TryReserveThenCommit(_hostMemory, region64kBase, 65536uL, region64kBase, 65536uL, commitProtect))
 				{
 					committed = true;
 					committedBase = region64kBase;
 					committedSize = 65536uL;
 				}
-				else if (TryReserveThenCommit(pageBase, 4096uL, pageBase, 4096uL, commitProtect))
+				else if (TryReserveThenCommit(_hostMemory, pageBase, 4096uL, pageBase, 4096uL, commitProtect))
 				{
 					committed = true;
 					committedBase = pageBase;
@@ -985,7 +987,7 @@ public sealed partial class DirectExecutionBackend
 				return false;
 			}
-			TryCommitRange(pageBase + 4096, 4096uL, commitProtect);
+			TryCommitRange(_hostMemory, pageBase + 4096, 4096uL, commitProtect);
 			if (traceLazyCommit)
 			{
 				Console.Error.WriteLine($"[LOADER][TRACE] lazy-reserve-commit#{traceIndex}: addr=0x{committedBase:X16} size=0x{committedSize:X16} access={accessType} protect=0x{commitProtect:X8}");
@@ -993,13 +995,13 @@ public sealed partial class DirectExecutionBackend
 			return true;
 		}
-		if (mbi.State != 8192)
+		if (mbi.State != HostRegionState.Reserved)
 		{
 			return false;
 		}
 		if (TryGetLazyCommitWindow(faultAddress, mbi.BaseAddress, mbi.RegionSize, out var commitWindowBase, out var commitWindowSize) &&
-			TryCommitRange(commitWindowBase, commitWindowSize, commitProtect))
+			TryCommitRange(_hostMemory, commitWindowBase, commitWindowSize, commitProtect))
 		{
 			committed = true;
 			committedBase = commitWindowBase;
@@ -1008,7 +1010,7 @@ public sealed partial class DirectExecutionBackend
 		else
 		{
 			ulong largeCommitBase = faultAddress & 0xFFFFFFFFFFE00000uL;
-			if (TryCommitRange(largeCommitBase, 2097152uL, commitProtect))
+			if (TryCommitRange(_hostMemory, largeCommitBase, 2097152uL, commitProtect))
 			{
 				committed = true;
 				committedBase = largeCommitBase;
@@ -1019,19 +1021,19 @@ public sealed partial class DirectExecutionBackend
 		if (!committed)
 		{
 			ulong region64kBase = faultAddress & 0xFFFFFFFFFFFF0000uL;
-			if (TryCommitRange(region64kBase, 65536uL, commitProtect))
+			if (TryCommitRange(_hostMemory, region64kBase, 65536uL, commitProtect))
 			{
 				committed = true;
 				committedBase = region64kBase;
 				committedSize = 65536uL;
 			}
-			else if (TryCommitRange(pageBase, 8192uL, commitProtect))
+			else if (TryCommitRange(_hostMemory, pageBase, 8192uL, commitProtect))
 			{
 				committed = true;
 				committedBase = pageBase;
 				committedSize = 8192uL;
 			}
-			else if (TryCommitRange(pageBase, 4096uL, commitProtect))
+			else if (TryCommitRange(_hostMemory, pageBase, 4096uL, commitProtect))
 			{
 				committed = true;
 				committedBase = pageBase;
@@ -1044,7 +1046,7 @@ public sealed partial class DirectExecutionBackend
 			return false;
 		}
-		TryCommitRange(pageBase + 4096, 4096uL, commitProtect);
+		TryCommitRange(_hostMemory, pageBase + 4096, 4096uL, commitProtect);
 		if (traceLazyCommit)
 		{
 			Console.Error.WriteLine($"[LOADER][TRACE] lazy-commit#{traceIndex}: addr=0x{committedBase:X16} size=0x{committedSize:X16} access={accessType} protect=0x{commitProtect:X8}");
@@ -1085,31 +1087,33 @@ public sealed partial class DirectExecutionBackend
 			return true;
 		}
-		static unsafe bool TryCommitRange(ulong baseAddress, ulong length, uint protection)
+		// The commit protection is one of the two raw values ResolveLazyCommitProtection
 		// produces (0x40 RWX / 0x04 RW); the enum mapping reproduces those exactly.
 		static bool TryCommitRange(IHostMemory hostMemory, ulong baseAddress, ulong length, uint protection)
 		{
 			if (length == 0)
 			{
 				return false;
 			}
-			return VirtualAlloc((void*)baseAddress, (nuint)length, 4096u, protection) != null;
+			return hostMemory.Commit(baseAddress, length, protection == 64u ? HostPageProtection.ReadWriteExecute : HostPageProtection.ReadWrite);
 		}
-		static unsafe bool TryReserveRange(ulong baseAddress, ulong length)
+		static bool TryReserveRange(IHostMemory hostMemory, ulong baseAddress, ulong length)
 		{
 			if (length == 0)
 			{
 				return false;
 			}
-			return VirtualAlloc((void*)baseAddress, (nuint)length, 8192u, 4u) != null;
+			return hostMemory.Reserve(baseAddress, length, HostPageProtection.ReadWrite) != 0;
 		}
-		static bool TryReserveThenCommit(ulong reserveAddress, ulong reserveSize, ulong commitAddress, ulong commitSize, uint protection)
+		static bool TryReserveThenCommit(IHostMemory hostMemory, ulong reserveAddress, ulong reserveSize, ulong commitAddress, ulong commitSize, uint protection)
 		{
-			if (!TryReserveRange(reserveAddress, reserveSize))
+			if (!TryReserveRange(hostMemory, reserveAddress, reserveSize))
 			{
 				return false;
 			}
-			return TryCommitRange(commitAddress, commitSize, protection);
+			return TryCommitRange(hostMemory, commitAddress, commitSize, protection);
 		}
 		static bool IsAccessCompatible(ulong accessType, uint protection)
@@ -8,8 +8,10 @@ using System.Linq;
 using System.Runtime.InteropServices;
 using System.Threading;
 using SharpEmu.Core.Cpu;
 using SharpEmu.Core.Cpu.Native.Windows;
 using SharpEmu.Core.Loader;
 using SharpEmu.HLE;
 using SharpEmu.HLE.Host;
 namespace SharpEmu.Core.Cpu.Native;
@@ -69,23 +71,23 @@ public sealed partial class DirectExecutionBackend
 	private unsafe static int TryRecoverUnresolvedSentinel(void* exceptionInfo)
 	{
 		EXCEPTION_RECORD* exceptionRecord = ((EXCEPTION_POINTERS*)exceptionInfo)->ExceptionRecord;
-		if (exceptionRecord->ExceptionCode != 3221225477u)
+		if (exceptionRecord->ExceptionCode != WindowsFaultCodes.AccessViolation)
 		{
 			return 0;
 		}
 		void* contextRecord = ((EXCEPTION_POINTERS*)exceptionInfo)->ContextRecord;
-		ulong value = ReadCtxU64(contextRecord, 248);
+		ulong value = ReadCtxU64(contextRecord, CTX_RIP);
 		ulong value2 = (ulong)exceptionRecord->ExceptionAddress;
 		if (!IsUnresolvedSentinel(value) && !IsUnresolvedSentinel(value2))
 		{
 			return 0;
 		}
-		ulong rsp = ReadCtxU64(contextRecord, 152);
+		ulong rsp = ReadCtxU64(contextRecord, CTX_RSP);
-		WriteCtxU64(contextRecord, 120, 0uL);
+		WriteCtxU64(contextRecord, CTX_RAX, 0uL);
 		if (TryGetPlausibleReturnFromStack(rsp, out var returnRip, out var nextRsp))
 		{
-			WriteCtxU64(contextRecord, 152, nextRsp);
+			WriteCtxU64(contextRecord, CTX_RSP, nextRsp);
-			WriteCtxU64(contextRecord, 248, returnRip);
+			WriteCtxU64(contextRecord, CTX_RIP, returnRip);
 			Interlocked.Increment(ref _rawSentinelRecoveries);
 			if (LogThreadMode)
 			{
@@ -1725,9 +1727,9 @@ public sealed partial class DirectExecutionBackend
 		{
 			var candidateBase = ImportStubRegionCanonicalBase -
 				(ulong)candidateIndex * ImportStubRegionAddressStride;
-			if (VirtualQuery((void*)candidateBase, out var memoryInfo, (nuint)sizeof(MEMORY_BASIC_INFORMATION64)) == 0 ||
+			if (!_hostMemory.Query(candidateBase, out var memoryInfo) ||
 				memoryInfo.RegionSize == 0 ||
-				memoryInfo.State != 4096)
+				memoryInfo.State != HostRegionState.Committed)
 			{
 				continue;
 			}
@@ -2066,7 +2068,7 @@ public sealed partial class DirectExecutionBackend
 		uint flNewProtect = default(uint);
 		try
 		{
-			if (Marshal.ReadByte(num2) != 232 || !VirtualProtect((void*)num, 5u, 64u, &flNewProtect))
+			if (Marshal.ReadByte(num2) != 232 || !_hostMemory.Protect((ulong)(void*)num, 5u, HostPageProtection.ReadWriteExecute, out flNewProtect))
 			{
 				return;
 			}
@@ -2074,7 +2076,7 @@ public sealed partial class DirectExecutionBackend
 			{
 				Marshal.WriteByte(num2 + i, 144);
 			}
-			FlushInstructionCache(GetCurrentProcess(), (void*)num, 5u);
+			_hostMemory.FlushInstructionCache((ulong)(void*)num, 5u);
 			_patchedEa020eLookupCall = true;
 			Console.Error.WriteLine($"[LOADER][WARNING] Import#{dispatchIndex}: patched hash-lookup call at 0x{num:X16} -> NOP*5");
 		}
@@ -2085,7 +2087,7 @@ public sealed partial class DirectExecutionBackend
 		{
 			if (flNewProtect != 0)
 			{
-				VirtualProtect((void*)num, 5u, flNewProtect, &flNewProtect);
+				_hostMemory.ProtectRaw((ulong)(void*)num, 5u, flNewProtect, out flNewProtect);
 			}
 		}
 	}
@@ -6,6 +6,7 @@ using System.Collections.Generic;
 using System.Runtime.InteropServices;
 using System.Threading;
 using SharpEmu.HLE;
 using SharpEmu.HLE.Host;
 namespace SharpEmu.Core.Cpu.Native;
@@ -35,20 +36,6 @@ public sealed partial class DirectExecutionBackend
 	private bool _nativeWorkersDisposed;
 	private int _nativeWorkerCreationFailedLogged;
 	private const uint StackSizeParamIsAReservation = 0x00010000u;
 	[DllImport("kernel32.dll", SetLastError = true)]
 	private static extern nint CreateThread(
 		nint lpThreadAttributes,
 		nuint dwStackSize,
 		nint lpStartAddress,
 		nint lpParameter,
 		uint dwCreationFlags,
 		out uint lpThreadId);
 	[DllImport("kernel32.dll", SetLastError = true)]
 	private static extern uint WaitForSingleObject(nint hHandle, uint dwMilliseconds);
 	// Runs an emitted guest entry stub. Preferred path is a pooled native worker
 	// thread; falls back to the historical inline calli (guest frames above this
 	// thread's managed frames) when workers are disabled or unavailable.
@@ -61,7 +48,7 @@ public sealed partial class DirectExecutionBackend
 		var worker = RentNativeGuestExecutor();
 		if (worker is null)
 		{
-			TlsSetValue(_hostRspSlotTlsIndex, (nint)hostRspSlot);
+			_hostThreading.SetTlsValue(_hostRspSlotTlsIndex, (nint)hostRspSlot);
 			return CallNativeEntry(entryStub);
 		}
 		try
@@ -229,7 +216,7 @@ public sealed partial class DirectExecutionBackend
 		public static NativeGuestExecutor? TryCreate(DirectExecutionBackend backend)
 		{
-			if (!EnsureKernel32Exports())
+			if (!EnsureHostRuntimeExports(backend._hostSymbols))
 			{
 				return null;
 			}
@@ -242,32 +229,27 @@ public sealed partial class DirectExecutionBackend
 			return executor;
 		}
-		private static bool EnsureKernel32Exports()
+		private static bool EnsureHostRuntimeExports(IHostSymbolResolver symbols)
 		{
 			if (_exitThreadAddress != 0)
 			{
 				return _waitForSingleObjectAddress != 0 && _setEventAddress != 0;
 			}
-			nint kernel32 = GetModuleHandle("kernel32.dll");
+			_waitForSingleObjectAddress = symbols.GetAddress(HostRuntimeFunction.WaitForSingleObject);
-			if (kernel32 == 0)
+			_setEventAddress = symbols.GetAddress(HostRuntimeFunction.SetEvent);
-			{
+			_exitThreadAddress = symbols.GetAddress(HostRuntimeFunction.ExitThread);
 				return false;
 			}
 			_waitForSingleObjectAddress = GetProcAddress(kernel32, "WaitForSingleObject");
 			_setEventAddress = GetProcAddress(kernel32, "SetEvent");
 			_exitThreadAddress = GetProcAddress(kernel32, "ExitThread");
 			return _waitForSingleObjectAddress != 0 && _setEventAddress != 0 && _exitThreadAddress != 0;
 		}
 		private bool Initialize()
 		{
 			_selfHandle = GCHandle.Alloc(this);
-			_controlBlock = VirtualAlloc(null, 4096u, 12288u, 4u);
+			_controlBlock = (void*)_backend._hostMemory.Allocate(0, 4096u, HostPageProtection.ReadWrite);
 			if (_controlBlock == null)
 			{
 				return false;
 			}
-			_loopStub = VirtualAlloc(null, LoopStubSize, 12288u, 64u);
+			_loopStub = (void*)_backend._hostMemory.Allocate(0, LoopStubSize, HostPageProtection.ReadWriteExecute);
 			if (_loopStub == null)
 			{
 				return false;
@@ -349,17 +331,15 @@ public sealed partial class DirectExecutionBackend
 			*(int*)(code + skipJump) = skipEntryOffset - (skipJump + sizeof(int));
 			uint oldProtect = 0;
-			if (!VirtualProtect(_loopStub, LoopStubSize, 32u, &oldProtect))
+			if (!_backend._hostMemory.Protect((ulong)_loopStub, LoopStubSize, HostPageProtection.ReadExecute, out oldProtect))
 			{
 				return false;
 			}
-			FlushInstructionCache(GetCurrentProcess(), _loopStub, LoopStubSize);
+			_backend._hostMemory.FlushInstructionCache((ulong)_loopStub, LoopStubSize);
-			_threadHandle = CreateThread(
+			_threadHandle = _backend._hostThreading.CreateNativeThread(
 				0,
 				WorkerStackReservation,
 				(nint)_loopStub,
 				0,
-				StackSizeParamIsAReservation,
+				WorkerStackReservation,
 				out _nativeThreadId);
 			if (_threadHandle == 0)
 			{
@@ -465,7 +445,7 @@ public sealed partial class DirectExecutionBackend
 			_prevYieldRequested = _activeGuestThreadYieldRequested;
 			_prevYieldReason = _activeGuestThreadYieldReason;
 			_prevState = _activeGuestThreadState;
-			_prevHostRspSlot = TlsGetValue(backend._hostRspSlotTlsIndex);
+			_prevHostRspSlot = backend._hostThreading.GetTlsValue(backend._hostRspSlotTlsIndex);
 			_prevGuestThreadHandle = GuestThreadExecution.EnterGuestThread(_runGuestThreadHandle);
 			_entered = true;
 			_activeExecutionBackend = backend;
@@ -477,11 +457,11 @@ public sealed partial class DirectExecutionBackend
 			_activeGuestThreadYieldReason = null;
 			_activeGuestThreadState = _runState;
 			backend.BindTlsBase(_runContext!);
-			TlsSetValue(backend._hostRspSlotTlsIndex, _runHostRspSlot);
+			backend._hostThreading.SetTlsValue(backend._hostRspSlotTlsIndex, _runHostRspSlot);
 			if (_runState is { } state)
 			{
 				_prevHostThreadId = Volatile.Read(ref state.HostThreadId);
-				Volatile.Write(ref state.HostThreadId, unchecked((int)GetCurrentThreadId()));
+				Volatile.Write(ref state.HostThreadId, unchecked((int)backend._hostThreading.CurrentThreadId));
 			}
 			if (_runAffinityMask != 0)
 			{
@@ -511,7 +491,7 @@ public sealed partial class DirectExecutionBackend
 			{
 				Volatile.Write(ref state.HostThreadId, _prevHostThreadId);
 			}
-			TlsSetValue(_backend._hostRspSlotTlsIndex, _prevHostRspSlot);
+			_backend._hostThreading.SetTlsValue(_backend._hostRspSlotTlsIndex, _prevHostRspSlot);
 			GuestThreadExecution.RestoreGuestThread(_prevGuestThreadHandle);
 			_activeExecutionBackend = _prevBackend;
 			_activeCpuContext = _prevContext;
@@ -548,8 +528,8 @@ public sealed partial class DirectExecutionBackend
 			var exited = _threadHandle == 0;
 			if (_threadHandle != 0)
 			{
-				exited = WaitForSingleObject(_threadHandle, 1000u) == 0u;
+				exited = _backend._hostThreading.WaitForThreadExit(_threadHandle, 1000u);
-				CloseHandle(_threadHandle);
+				_backend._hostThreading.CloseThreadHandle(_threadHandle);
 				_threadHandle = 0;
 			}
 			if (!exited)
@@ -563,12 +543,12 @@ public sealed partial class DirectExecutionBackend
 			}
 			if (_loopStub != null)
 			{
-				VirtualFree(_loopStub, 0u, 32768u);
+				_backend._hostMemory.Free((ulong)_loopStub);
 				_loopStub = null;
 			}
 			if (_controlBlock != null)
 			{
-				VirtualFree(_controlBlock, 0u, 32768u);
+				_backend._hostMemory.Free((ulong)_controlBlock);
 				_controlBlock = null;
 			}
 			if (_selfHandle.IsAllocated)
@@ -3,6 +3,7 @@
 using System.Runtime.InteropServices;
 using SharpEmu.HLE;
 using SharpEmu.HLE.Host;
 namespace SharpEmu.Core.Cpu.Native;
@@ -11,17 +12,15 @@ public sealed unsafe class StubManager : IDisposable
    private readonly List<nint> _allocatedStubs = new();
    private readonly Dictionary<string, nint> _importHandlers = new();
    private readonly Dictionary<ulong, nint> _stubAddresses = new();
    private readonly IHostMemory _hostMemory;
    private byte* _pltMemory;
    private int _pltOffset;
    private const int PltMemorySize = 1024 * 1024; // 1MB for stubs
-    public StubManager()
+    public StubManager(IHostMemory? hostMemory = null)
    {
-        _pltMemory = (byte*)VirtualAlloc(
+        _hostMemory = hostMemory ?? HostPlatform.Current.Memory;
-            null,
+        _pltMemory = (byte*)_hostMemory.Allocate(0, PltMemorySize, HostPageProtection.ReadWriteExecute);
            (nuint)PltMemorySize,
            AllocationType.Reserve | AllocationType.Commit,
            MemoryProtection.ExecuteReadWrite);
        if (_pltMemory == null)
        {
@@ -185,7 +184,7 @@ public sealed unsafe class StubManager : IDisposable
    {
        if (_pltMemory != null)
        {
-            VirtualFree(_pltMemory, 0, FreeType.Release);
+            _hostMemory.Free((ulong)_pltMemory);
            _pltMemory = null;
        }
@@ -194,29 +193,5 @@ public sealed unsafe class StubManager : IDisposable
        _stubAddresses.Clear();
    }
    [DllImport("kernel32.dll", SetLastError = true)]
    private static extern void* VirtualAlloc(void* lpAddress, nuint dwSize, AllocationType flAllocationType, MemoryProtection flProtect);
    [DllImport("kernel32.dll", SetLastError = true)]
    private static extern bool VirtualFree(void* lpAddress, nuint dwSize, FreeType dwFreeType);
    [Flags]
    private enum AllocationType : uint
    {
        Commit = 0x1000,
        Reserve = 0x2000,
    }
    [Flags]
    private enum MemoryProtection : uint
    {
        ExecuteReadWrite = 0x40,
    }
    private enum FreeType : uint
    {
        Release = 0x8000,
    }
    public delegate void ImportHandler(CpuContext context);
 }
@@ -0,0 +1,32 @@
 // Copyright (C) 2026 SharpEmu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 namespace SharpEmu.Core.Cpu.Native.Windows;
 /// <summary>
 /// Byte offsets into the Win64 CONTEXT record delivered to vectored exception
 /// handlers. The handlers read/write guest registers directly at these offsets
 /// (no managed CONTEXT struct exists); a future POSIX backend gets a sibling
 /// class for its mcontext layout.
 /// </summary>
 internal static class Win64ContextOffsets
 {
    public const int Mxcsr = 52;
    public const int Rax = 120;
    public const int Rcx = 128;
    public const int Rdx = 136;
    public const int Rbx = 144;
    public const int Rsp = 152;
    public const int Rbp = 160;
    public const int Rsi = 168;
    public const int Rdi = 176;
    public const int R8 = 184;
    public const int R9 = 192;
    public const int R10 = 200;
    public const int R11 = 208;
    public const int R12 = 216;
    public const int R13 = 224;
    public const int R14 = 232;
    public const int R15 = 240;
    public const int Rip = 248;
 }
@@ -0,0 +1,24 @@
 // Copyright (C) 2026 SharpEmu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 namespace SharpEmu.Core.Cpu.Native.Windows;
 /// <summary>
 /// Windows NTSTATUS exception codes and EXCEPTION_RECORD access-type values the
 /// fault handlers filter on. Values are the same numbers the handlers previously
 /// compared as bare literals; only the spelling changed.
 /// </summary>
 internal static class WindowsFaultCodes
 {
    public const uint AccessViolation = 0xC0000005u;         // 3221225477
    public const uint Breakpoint = 0x80000003u;              // 2147483651
    public const uint IllegalInstruction = 0xC000001Du;      // 3221225501
    public const uint FastFail = 0xC0000409u;                // 3221226505
    public const uint StackOverflow = 0xC00000FDu;
    public const uint ClrManagedException = 0xE0434352u;
    // EXCEPTION_RECORD.ExceptionInformation[0] for access violations.
    public const ulong AccessRead = 0;
    public const ulong AccessWrite = 1;
    public const ulong AccessExecute = 8;
 }
@@ -0,0 +1,191 @@
 // Copyright (C) 2026 SharpEmu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 using System.Runtime.InteropServices;
 using SharpEmu.HLE.Host;
 namespace SharpEmu.Core.Cpu.Native.Windows;
 /// <summary>
 /// Vectored-exception-handler installation and the handler pre-filter thunk.
 /// The thunk is inherently Windows-shaped (TEB stack-limit reads via gs:,
 /// NTSTATUS pre-filtering, Win64 calling convention) and moved here whole from
 /// DirectExecutionBackend; a POSIX backend supplies a sibling built around
 /// sigaction/sigaltstack instead.
 /// </summary>
 internal sealed unsafe partial class WindowsFaultHandling : IHostFaultHandling
 {
    private readonly IHostMemory _memory;
    public WindowsFaultHandling(IHostMemory memory)
    {
        _memory = memory;
    }
    public nint CreateHandlerThunk(nint managedCallback, uint hostRspSwitchTlsSlot, nint tlsGetValueAddress)
    {
        const uint stubSize = 256u;
        void* ptr = (void*)_memory.Allocate(0, stubSize, HostPageProtection.ReadWriteExecute);
        if (ptr == null)
        {
            return 0;
        }
        byte* code = (byte*)ptr;
        int offset = 0;
        // Native pre-filter: these exception codes are raised while the thread can be in
        // cooperative GC mode (a C# throw is RaiseException(0xE0434352) on the throwing
        // thread; FailFast/stack-overflow arrive mid-runtime-failure). Entering the managed
        // handler then trips the CLR's reverse-P/Invoke check and kills the process with
        // "Invalid Program: attempted to call a UnmanagedCallersOnly method from managed
        // code" — this is why no managed throw (even one with a catch handler) ever
        // survived inside the emulator. Continue the handler search without touching
        // managed code; the CLR's own VEH handles its exceptions. MSVC C++ exceptions
        // (Vulkan drivers, host CRT) are excluded too: the managed handler only ever
        // returned CONTINUE_SEARCH for them.
        ReadOnlySpan<uint> nonManagedExceptionCodes =
            [WindowsFaultCodes.ClrManagedException, 0xE06D7363u, WindowsFaultCodes.FastFail, WindowsFaultCodes.StackOverflow];
        EmitByte(code, ref offset, 0x48); EmitByte(code, ref offset, 0x8B); EmitByte(code, ref offset, 0x01); // mov rax, [rcx] (ExceptionRecord*)
        EmitByte(code, ref offset, 0x8B); EmitByte(code, ref offset, 0x00);                                   // mov eax, [rax] (ExceptionCode)
        var passJumpOffsets = stackalloc int[nonManagedExceptionCodes.Length];
        for (int i = 0; i < nonManagedExceptionCodes.Length; i++)
        {
            EmitByte(code, ref offset, 0x3D);                                                                 // cmp eax, imm32
            EmitUInt32(code, ref offset, nonManagedExceptionCodes[i]);
            EmitByte(code, ref offset, 0x74);                                                                 // je pass
            passJumpOffsets[i] = offset;
            EmitByte(code, ref offset, 0x00);
        }
        EmitByte(code, ref offset, 0xEB); EmitByte(code, ref offset, 0x03);                                   // jmp over pass block
        int passOffset = offset;
        EmitByte(code, ref offset, 0x31); EmitByte(code, ref offset, 0xC0);                                   // pass: xor eax, eax (EXCEPTION_CONTINUE_SEARCH)
        EmitByte(code, ref offset, 0xC3);                                                                     // ret
        for (int i = 0; i < nonManagedExceptionCodes.Length; i++)
        {
            code[passJumpOffsets[i]] = checked((byte)(passOffset - (passJumpOffsets[i] + 1)));
        }
        EmitByte(code, ref offset, 0x41); EmitByte(code, ref offset, 0x54); // push r12
        EmitByte(code, ref offset, 0x41); EmitByte(code, ref offset, 0x55); // push r13
        EmitByte(code, ref offset, 0x49); EmitByte(code, ref offset, 0x89); EmitByte(code, ref offset, 0xE4); // mov r12, rsp
        EmitByte(code, ref offset, 0x49); EmitByte(code, ref offset, 0x89); EmitByte(code, ref offset, 0xCD); // mov r13, rcx
        EmitByte(code, ref offset, 0x65); EmitByte(code, ref offset, 0x48); // mov rax, gs:[8]
        EmitByte(code, ref offset, 0x8B); EmitByte(code, ref offset, 0x04); EmitByte(code, ref offset, 0x25);
        EmitUInt32(code, ref offset, 8u);
        EmitByte(code, ref offset, 0x49); EmitByte(code, ref offset, 0x39); EmitByte(code, ref offset, 0xC4); // cmp r12, rax
        EmitByte(code, ref offset, 0x0F); EmitByte(code, ref offset, 0x83); // jae guestStack
        int aboveStackJump = offset;
        EmitUInt32(code, ref offset, 0u);
        EmitByte(code, ref offset, 0x65); EmitByte(code, ref offset, 0x48); // mov rax, gs:[0x10]
        EmitByte(code, ref offset, 0x8B); EmitByte(code, ref offset, 0x04); EmitByte(code, ref offset, 0x25);
        EmitUInt32(code, ref offset, 0x10u);
        EmitByte(code, ref offset, 0x49); EmitByte(code, ref offset, 0x39); EmitByte(code, ref offset, 0xC4); // cmp r12, rax
        EmitByte(code, ref offset, 0x0F); EmitByte(code, ref offset, 0x82); // jb guestStack
        int belowStackJump = offset;
        EmitUInt32(code, ref offset, 0u);
        EmitByte(code, ref offset, 0x48); EmitByte(code, ref offset, 0x83); EmitByte(code, ref offset, 0xEC); EmitByte(code, ref offset, 0x28);
        EmitByte(code, ref offset, 0x4C); EmitByte(code, ref offset, 0x89); EmitByte(code, ref offset, 0xE9); // mov rcx, r13
        EmitByte(code, ref offset, 0x48); EmitByte(code, ref offset, 0xB8);
        *(nint*)(code + offset) = managedCallback;
        offset += sizeof(nint);
        EmitByte(code, ref offset, 0xFF); EmitByte(code, ref offset, 0xD0);
        EmitByte(code, ref offset, 0x48); EmitByte(code, ref offset, 0x83); EmitByte(code, ref offset, 0xC4); EmitByte(code, ref offset, 0x28);
        EmitByte(code, ref offset, 0xE9);
        int hostRestoreJump = offset;
        EmitUInt32(code, ref offset, 0u);
        int guestStackOffset = offset;
        EmitByte(code, ref offset, 0x48); EmitByte(code, ref offset, 0x83); EmitByte(code, ref offset, 0xEC); EmitByte(code, ref offset, 0x28);
        EmitByte(code, ref offset, 0xB9);
        EmitUInt32(code, ref offset, hostRspSwitchTlsSlot);
        EmitByte(code, ref offset, 0x48); EmitByte(code, ref offset, 0xB8);
        *(nint*)(code + offset) = tlsGetValueAddress;
        offset += sizeof(nint);
        EmitByte(code, ref offset, 0xFF); EmitByte(code, ref offset, 0xD0);
        EmitByte(code, ref offset, 0x48); EmitByte(code, ref offset, 0x83); EmitByte(code, ref offset, 0xC4); EmitByte(code, ref offset, 0x28);
        EmitByte(code, ref offset, 0x48); EmitByte(code, ref offset, 0x85); EmitByte(code, ref offset, 0xC0); // test rax, rax
        EmitByte(code, ref offset, 0x0F); EmitByte(code, ref offset, 0x84);
        int missingTlsJump = offset;
        EmitUInt32(code, ref offset, 0u);
        EmitByte(code, ref offset, 0x4C); EmitByte(code, ref offset, 0x8B); EmitByte(code, ref offset, 0x18); // mov r11, [rax]
        EmitByte(code, ref offset, 0x4D); EmitByte(code, ref offset, 0x85); EmitByte(code, ref offset, 0xDB); // test r11, r11
        EmitByte(code, ref offset, 0x0F); EmitByte(code, ref offset, 0x84);
        int missingHostStackJump = offset;
        EmitUInt32(code, ref offset, 0u);
        EmitByte(code, ref offset, 0x4C); EmitByte(code, ref offset, 0x89); EmitByte(code, ref offset, 0xDC); // mov rsp, r11
        EmitByte(code, ref offset, 0x48); EmitByte(code, ref offset, 0x83); EmitByte(code, ref offset, 0xEC); EmitByte(code, ref offset, 0x28);
        EmitByte(code, ref offset, 0x4C); EmitByte(code, ref offset, 0x89); EmitByte(code, ref offset, 0xE9); // mov rcx, r13
        EmitByte(code, ref offset, 0x48); EmitByte(code, ref offset, 0xB8);
        *(nint*)(code + offset) = managedCallback;
        offset += sizeof(nint);
        EmitByte(code, ref offset, 0xFF); EmitByte(code, ref offset, 0xD0);
        EmitByte(code, ref offset, 0x48); EmitByte(code, ref offset, 0x83); EmitByte(code, ref offset, 0xC4); EmitByte(code, ref offset, 0x28);
        EmitByte(code, ref offset, 0xE9);
        int guestRestoreJump = offset;
        EmitUInt32(code, ref offset, 0u);
        int passThroughOffset = offset;
        EmitByte(code, ref offset, 0x31); EmitByte(code, ref offset, 0xC0); // xor eax, eax
        int restoreOffset = offset;
        EmitByte(code, ref offset, 0x4C); EmitByte(code, ref offset, 0x89); EmitByte(code, ref offset, 0xE4); // mov rsp, r12
        EmitByte(code, ref offset, 0x41); EmitByte(code, ref offset, 0x5D);
        EmitByte(code, ref offset, 0x41); EmitByte(code, ref offset, 0x5C);
        EmitByte(code, ref offset, 0xC3);
        *(int*)(code + aboveStackJump) = guestStackOffset - (aboveStackJump + sizeof(int));
        *(int*)(code + belowStackJump) = guestStackOffset - (belowStackJump + sizeof(int));
        *(int*)(code + hostRestoreJump) = restoreOffset - (hostRestoreJump + sizeof(int));
        *(int*)(code + missingTlsJump) = passThroughOffset - (missingTlsJump + sizeof(int));
        *(int*)(code + missingHostStackJump) = passThroughOffset - (missingHostStackJump + sizeof(int));
        *(int*)(code + guestRestoreJump) = restoreOffset - (guestRestoreJump + sizeof(int));
        if (!_memory.Protect((ulong)ptr, stubSize, HostPageProtection.ReadExecute, out _))
        {
            Console.Error.WriteLine($"[LOADER][ERROR] VirtualProtect failed for exception handler trampoline at 0x{(nint)ptr:X16}");
            _ = _memory.Free((ulong)ptr);
            return 0;
        }
        _memory.FlushInstructionCache((ulong)ptr, (ulong)offset);
        return (nint)ptr;
    }
    public void FreeThunk(nint thunk)
    {
        _ = _memory.Free((ulong)thunk);
    }
    public nint AddFirstChanceHandler(nint thunk)
    {
        return (nint)AddVectoredExceptionHandler(1u, thunk);
    }
    public void RemoveHandler(nint handle)
    {
        _ = RemoveVectoredExceptionHandler((void*)handle);
    }
    public void SetUnhandledFilter(nint thunk)
    {
        _ = SetUnhandledExceptionFilter(thunk);
    }
    private static void EmitByte(byte* code, ref int offset, byte value)
    {
        code[offset++] = value;
    }
    private static void EmitUInt32(byte* code, ref int offset, uint value)
    {
        *(uint*)(code + offset) = value;
        offset += sizeof(uint);
    }
    [LibraryImport("kernel32.dll")]
    private static partial void* AddVectoredExceptionHandler(uint first, IntPtr handler);
    [LibraryImport("kernel32.dll")]
    private static partial uint RemoveVectoredExceptionHandler(void* handle);
    [LibraryImport("kernel32.dll")]
    private static partial IntPtr SetUnhandledExceptionFilter(IntPtr lpTopLevelExceptionFilter);
 }
@@ -5,7 +5,7 @@ using SharpEmu.HLE;
 namespace SharpEmu.Core.Cpu;
-public sealed class TrackedCpuMemory : ICpuMemory, ITrackedCpuMemory, IGuestMemoryAllocator
+public sealed class TrackedCpuMemory : ICpuMemory, ITrackedCpuMemory, IGuestMemoryAllocator, ICpuMemoryWrapper
 {
    private readonly ICpuMemory _inner;
@@ -4,11 +4,12 @@
 using System.Runtime.InteropServices;
 using SharpEmu.Core.Loader;
 using SharpEmu.HLE;
 using SharpEmu.HLE.Host;
 using SharpEmu.Logging;
 namespace SharpEmu.Core.Memory;
-public sealed unsafe class PhysicalVirtualMemory : IVirtualMemory, IGuestMemoryAllocator, IDisposable
+public sealed unsafe class PhysicalVirtualMemory : IVirtualMemory, IGuestMemoryAllocator, IGuestAddressSpace, IDisposable
 {
    private static readonly SharpEmuLogger Log = SharpEmuLog.For("VMEM");
@@ -28,41 +29,26 @@ public sealed unsafe class PhysicalVirtualMemory : IVirtualMemory, IGuestMemoryA
    private const ulong DefaultLazyReservePrimeBytes = 0x0400_0000UL; // 64 MiB
    private const ulong LazyReservePrimeChunkBytes = 0x0200_0000UL; // 32 MiB
-    private const uint MEM_COMMIT = 0x1000;
+    // Raw Windows PAGE_* values retained for the internal region/protection
-    private const uint MEM_RESERVE = 0x2000;
+    // bookkeeping: regions and saved old-protection values always carry the raw
-    private const uint MEM_RELEASE = 0x8000;
+    // value of the host platform in use, and these classification helpers only
    // ever see values this class itself assigned (see IHostMemory.ProtectRaw).
    private const uint PAGE_EXECUTE_READ = 0x20;
    private const uint PAGE_EXECUTE_READWRITE = 0x40;
    private const uint PAGE_EXECUTE = 0x10;
    private const uint PAGE_EXECUTE_WRITECOPY = 0x80;
    private const uint PAGE_NOACCESS = 0x01;
    private const uint PAGE_READWRITE = 0x04;
    private const uint PAGE_READONLY = 0x02;
    private readonly IHostMemory _hostMemory;
    private ulong _guestAllocationArenaBase;
    private ulong _guestAllocationOffset;
    private static readonly ulong LazyReservePrimeBytes = ResolveLazyReservePrimeBytes();
-    [DllImport("kernel32.dll", SetLastError = true)]
+    public PhysicalVirtualMemory(IHostMemory? hostMemory = null)
-    private static extern void* VirtualAlloc(void* lpAddress, nuint dwSize, uint flAllocationType, uint flProtect);
+    {
-
+        _hostMemory = hostMemory ?? HostPlatform.Current.Memory;
-    [DllImport("kernel32.dll", SetLastError = true)]
+    }
    [return: MarshalAs(UnmanagedType.Bool)]
    private static extern bool VirtualFree(void* lpAddress, nuint dwSize, uint dwFreeType);
    [DllImport("kernel32.dll", SetLastError = true)]
    [return: MarshalAs(UnmanagedType.Bool)]
    private static extern bool VirtualProtect(void* lpAddress, nuint dwSize, uint flNewProtect, out uint lpflOldProtect);
    [DllImport("kernel32.dll")]
    private static extern nuint VirtualQuery(void* lpAddress, out MemoryBasicInformation64 lpBuffer, nuint dwLength);
    [DllImport("kernel32.dll")]
    private static extern void* GetCurrentProcess();
    [DllImport("kernel32.dll", SetLastError = true)]
    [return: MarshalAs(UnmanagedType.Bool)]
    private static extern bool FlushInstructionCache(void* hProcess, void* lpBaseAddress, nuint dwSize);
    public bool TryAllocateAtExact(ulong desiredAddress, ulong size, bool executable, out ulong actualAddress)
    {
@@ -74,17 +60,17 @@ public sealed unsafe class PhysicalVirtualMemory : IVirtualMemory, IGuestMemoryA
        var alignedSize = (size + 0xFFF) & ~0xFFFUL;
        var protection = executable ? PAGE_EXECUTE_READWRITE : PAGE_READWRITE;
-        var allocationType = MEM_COMMIT | MEM_RESERVE;
+        var hostProtection = executable ? HostPageProtection.ReadWriteExecute : HostPageProtection.ReadWrite;
-        var result = VirtualAlloc((void*)desiredAddress, (nuint)alignedSize, allocationType, protection);
+        var result = _hostMemory.Allocate(desiredAddress, alignedSize, hostProtection);
-        if (result == null)
+        if (result == 0)
        {
            return false;
        }
-        actualAddress = (ulong)result;
+        actualAddress = result;
        if (actualAddress != desiredAddress)
        {
-            VirtualFree(result, 0, MEM_RELEASE);
+            _hostMemory.Free(result);
            actualAddress = 0;
            return false;
        }
@@ -119,33 +105,33 @@ public sealed unsafe class PhysicalVirtualMemory : IVirtualMemory, IGuestMemoryA
        var alignedSize = (size + 0xFFF) & ~0xFFFUL;
        var protection = executable ? PAGE_EXECUTE_READWRITE : PAGE_READWRITE;
-        var allocationType = MEM_COMMIT | MEM_RESERVE;
+        var hostProtection = executable ? HostPageProtection.ReadWriteExecute : HostPageProtection.ReadWrite;
        var reservedOnly = false;
        var preferReserveOnly = !executable &&
            alignedSize >= LargeDataReserveThreshold &&
            alignedSize > FullCommitRegionLimit;
-        void* result = null;
+        ulong result = 0;
        if (preferReserveOnly)
        {
-            result = VirtualAlloc((void*)desiredAddress, (nuint)alignedSize, MEM_RESERVE, PAGE_READWRITE);
+            result = _hostMemory.Reserve(desiredAddress, alignedSize, HostPageProtection.ReadWrite);
-            if (result == null && allowAlternative)
+            if (result == 0 && allowAlternative)
            {
-                result = VirtualAlloc(null, (nuint)alignedSize, MEM_RESERVE, PAGE_READWRITE);
+                result = _hostMemory.Reserve(0, alignedSize, HostPageProtection.ReadWrite);
            }
-            if (result != null)
+            if (result != 0)
            {
                reservedOnly = true;
            }
        }
-        if (result == null)
+        if (result == 0)
        {
-            result = VirtualAlloc((void*)desiredAddress, (nuint)alignedSize, allocationType, protection);
+            result = _hostMemory.Allocate(desiredAddress, alignedSize, hostProtection);
        }
-        if (result == null)
+        if (result == 0)
        {
            if (!allowAlternative)
            {
@@ -153,32 +139,32 @@ public sealed unsafe class PhysicalVirtualMemory : IVirtualMemory, IGuestMemoryA
            }
            TraceVmem($"Could not allocate at 0x{desiredAddress:X16}, trying any address...");
-            result = VirtualAlloc(null, (nuint)alignedSize, allocationType, protection);
+            result = _hostMemory.Allocate(0, alignedSize, hostProtection);
-            if (result == null)
+            if (result == 0)
            {
                if (!executable)
                {
-                    result = VirtualAlloc((void*)desiredAddress, (nuint)alignedSize, MEM_RESERVE, PAGE_READWRITE);
+                    result = _hostMemory.Reserve(desiredAddress, alignedSize, HostPageProtection.ReadWrite);
-                    if (result == null && allowAlternative)
+                    if (result == 0 && allowAlternative)
                    {
-                        result = VirtualAlloc(null, (nuint)alignedSize, MEM_RESERVE, PAGE_READWRITE);
+                        result = _hostMemory.Reserve(0, alignedSize, HostPageProtection.ReadWrite);
                    }
-                    if (result != null)
+                    if (result != 0)
                    {
                        reservedOnly = true;
                    }
                }
-                if (result == null)
+                if (result == 0)
                {
                    throw new OutOfMemoryException($"Failed to allocate {alignedSize} bytes of virtual memory");
                }
            }
        }
-        var actualAddress = (ulong)result;
+        var actualAddress = result;
        var lazyPrimeState = "n/a";
        if (reservedOnly)
@@ -191,9 +177,8 @@ public sealed unsafe class PhysicalVirtualMemory : IVirtualMemory, IGuestMemoryA
                {
                    var remaining = primeBytes - committedBytes;
                    var chunkBytes = Math.Min(remaining, LazyReservePrimeChunkBytes);
-                    var commitAddress = (void*)(actualAddress + committedBytes);
+                    var commitAddress = actualAddress + committedBytes;
-                    var committed = VirtualAlloc(commitAddress, (nuint)chunkBytes, MEM_COMMIT, PAGE_READWRITE);
+                    if (!_hostMemory.Commit(commitAddress, chunkBytes, HostPageProtection.ReadWrite))
                    if (committed == null)
                    {
                        break;
                    }
@@ -336,6 +321,41 @@ public sealed unsafe class PhysicalVirtualMemory : IVirtualMemory, IGuestMemoryA
        }
    }
    public bool TryProtect(ulong address, ulong size, GuestPageProtection protection)
    {
        if (size == 0)
        {
            return false;
        }
        return _hostMemory.Protect(address, size, ResolveProtection(protection), out _);
    }
    // Reproduces the decomposition KernelMemoryCompatExports.ResolveHostProtection
    // performed before this seam existed; the Windows backend maps each case back
    // to the identical PAGE_* value.
    private static HostPageProtection ResolveProtection(GuestPageProtection protection)
    {
        var read = (protection & GuestPageProtection.Read) != 0;
        var write = (protection & GuestPageProtection.Write) != 0;
        var execute = (protection & GuestPageProtection.Execute) != 0;
        if (execute)
        {
            return write
                ? HostPageProtection.ReadWriteExecute
                : read
                    ? HostPageProtection.ReadExecute
                    : HostPageProtection.Execute;
        }
        return write
            ? HostPageProtection.ReadWrite
            : read
                ? HostPageProtection.ReadOnly
                : HostPageProtection.NoAccess;
    }
    public void Clear()
    {
        lock (_guestAllocationGate)
@@ -345,7 +365,7 @@ public sealed unsafe class PhysicalVirtualMemory : IVirtualMemory, IGuestMemoryA
            {
                foreach (var region in _regions)
                {
-                    VirtualFree((void*)region.VirtualAddress, 0, MEM_RELEASE);
+                    _hostMemory.Free(region.VirtualAddress);
                }
                _regions.Clear();
                _pageProtections.Clear();
@@ -430,35 +450,35 @@ public sealed unsafe class PhysicalVirtualMemory : IVirtualMemory, IGuestMemoryA
    private void SetProtection(ulong address, ulong size, ProgramHeaderFlags flags)
    {
-        uint protection;
+        HostPageProtection protection;
        if (flags == ProgramHeaderFlags.None)
        {
-            protection = PAGE_NOACCESS;
+            protection = HostPageProtection.NoAccess;
        }
        else if ((flags & ProgramHeaderFlags.Execute) != 0)
        {
            protection = (flags & ProgramHeaderFlags.Write) != 0
-                ? PAGE_EXECUTE_READWRITE
+                ? HostPageProtection.ReadWriteExecute
-                : PAGE_EXECUTE_READ;
+                : HostPageProtection.ReadExecute;
        }
        else if ((flags & ProgramHeaderFlags.Write) != 0)
        {
-            protection = PAGE_READWRITE;
+            protection = HostPageProtection.ReadWrite;
        }
        else
        {
-            protection = PAGE_READONLY;
+            protection = HostPageProtection.ReadOnly;
        }
-        if (!VirtualProtect((void*)address, (nuint)size, protection, out _))
+        if (!_hostMemory.Protect(address, size, protection, out _))
        {
            throw new InvalidOperationException($"Failed to set memory protection at 0x{address:X16}");
        }
        if ((flags & ProgramHeaderFlags.Execute) != 0)
        {
-            FlushInstructionCache(GetCurrentProcess(), (void*)address, (nuint)size);
+            _hostMemory.FlushInstructionCache(address, size);
        }
    }
@@ -730,7 +750,7 @@ public sealed unsafe class PhysicalVirtualMemory : IVirtualMemory, IGuestMemoryA
                return true;
            }
-            if (!VirtualProtect(destPtr, (nuint)source.Length, PAGE_EXECUTE_READWRITE, out var oldProtect))
+            if (!_hostMemory.Protect((ulong)destPtr, (ulong)source.Length, HostPageProtection.ReadWriteExecute, out var oldProtect))
            {
                return false;
            }
@@ -744,10 +764,10 @@ public sealed unsafe class PhysicalVirtualMemory : IVirtualMemory, IGuestMemoryA
            }
            finally
            {
-                VirtualProtect(destPtr, (nuint)source.Length, oldProtect, out _);
+                _hostMemory.ProtectRaw((ulong)destPtr, (ulong)source.Length, oldProtect, out _);
                if (IsExecutableProtection(oldProtect))
                {
-                    FlushInstructionCache(GetCurrentProcess(), destPtr, (nuint)source.Length);
+                    _hostMemory.FlushInstructionCache((ulong)destPtr, (ulong)source.Length);
                }
            }
@@ -973,12 +993,12 @@ public sealed unsafe class PhysicalVirtualMemory : IVirtualMemory, IGuestMemoryA
        return protection is PAGE_READWRITE or PAGE_EXECUTE_READWRITE;
    }
-    private static uint GetCommitProtection(MemoryRegion region)
+    private static HostPageProtection GetCommitProtection(MemoryRegion region)
    {
-        return region.IsExecutable ? PAGE_EXECUTE_READWRITE : PAGE_READWRITE;
+        return region.IsExecutable ? HostPageProtection.ReadWriteExecute : HostPageProtection.ReadWrite;
    }
-    private static unsafe bool EnsureRangeCommitted(ulong address, ulong size, MemoryRegion region)
+    private bool EnsureRangeCommitted(ulong address, ulong size, MemoryRegion region)
    {
        if (size == 0 || !region.IsReservedOnly)
        {
@@ -992,7 +1012,7 @@ public sealed unsafe class PhysicalVirtualMemory : IVirtualMemory, IGuestMemoryA
        var pageAddress = startPage;
        while (pageAddress < endPage)
        {
-            if (VirtualQuery((void*)pageAddress, out var info, (nuint)sizeof(MemoryBasicInformation64)) == 0)
+            if (!_hostMemory.Query(pageAddress, out var info))
            {
                return false;
            }
@@ -1006,19 +1026,19 @@ public sealed unsafe class PhysicalVirtualMemory : IVirtualMemory, IGuestMemoryA
                return false;
            }
-            if (info.State == MEM_COMMIT)
+            if (info.State == HostRegionState.Committed)
            {
                pageAddress = rangeEnd;
                continue;
            }
-            if (info.State != MEM_RESERVE)
+            if (info.State != HostRegionState.Reserved)
            {
                return false;
            }
            var commitSize = rangeEnd - pageAddress;
-            if (VirtualAlloc((void*)pageAddress, (nuint)commitSize, MEM_COMMIT, commitProtection) == null)
+            if (!_hostMemory.Commit(pageAddress, commitSize, commitProtection))
            {
                return false;
            }
@@ -1039,11 +1059,11 @@ public sealed unsafe class PhysicalVirtualMemory : IVirtualMemory, IGuestMemoryA
        var startPage = AlignDown(address, PageSize);
        var endPage = AlignUp(address + size, PageSize);
-        var temporaryProtection = region.IsExecutable ? PAGE_EXECUTE_READWRITE : PAGE_READWRITE;
+        var temporaryProtection = region.IsExecutable ? HostPageProtection.ReadWriteExecute : HostPageProtection.ReadWrite;
        for (var pageAddress = startPage; pageAddress < endPage; pageAddress += PageSize)
        {
-            if (!VirtualProtect((void*)pageAddress, (nuint)PageSize, temporaryProtection, out var oldProtection))
+            if (!_hostMemory.Protect(pageAddress, PageSize, temporaryProtection, out var oldProtection))
            {
                RestorePageProtections(touchedPages);
                touchedPages.Clear();
@@ -1056,11 +1076,11 @@ public sealed unsafe class PhysicalVirtualMemory : IVirtualMemory, IGuestMemoryA
        return true;
    }
-    private static void RestorePageProtections(List<(ulong Address, uint Protection)> touchedPages)
+    private void RestorePageProtections(List<(ulong Address, uint Protection)> touchedPages)
    {
        foreach (var (pageAddress, protection) in touchedPages)
        {
-            VirtualProtect((void*)pageAddress, (nuint)PageSize, protection, out _);
+            _hostMemory.ProtectRaw(pageAddress, PageSize, protection, out _);
        }
    }
@@ -1117,16 +1137,4 @@ public sealed unsafe class PhysicalVirtualMemory : IVirtualMemory, IGuestMemoryA
        public uint Protection { get; set; }
    }
    private struct MemoryBasicInformation64
    {
        public ulong BaseAddress;
        public ulong AllocationBase;
        public uint AllocationProtect;
        public uint Alignment1;
        public ulong RegionSize;
        public uint State;
        public uint Protect;
        public uint Type;
        public uint Alignment2;
    }
 }
@@ -7,6 +7,7 @@ using SharpEmu.Core.Cpu.Disasm;
 using SharpEmu.Core.Loader;
 using SharpEmu.Core.Memory;
 using SharpEmu.HLE;
 using SharpEmu.HLE.Host;
 using SharpEmu.Libs.VideoOut;
 using SharpEmu.Libs.Kernel;
 using SharpEmu.Libs.AppContent;
@@ -86,14 +87,19 @@ public sealed class SharpEmuRuntime : ISharpEmuRuntime
        moduleManager.RegisterFromAssembly(typeof(KernelExports).Assembly, Generation.Gen4 | Generation.Gen5, Aerolib.Instance);
        moduleManager.Freeze();
-        var virtualMemory = new PhysicalVirtualMemory();
+        // Resolve the host platform once at the composition root; on unsupported
        // OSes this throws PlatformNotSupportedException with a clear message
        // instead of failing on the first native call.
        var hostPlatform = HostPlatform.Current;
        var virtualMemory = new PhysicalVirtualMemory(hostPlatform.Memory);
        var fileSystem = new PhysicalFileSystem();
        return new SharpEmuRuntime(
            new SelfLoader(),
            virtualMemory,
-            new CpuDispatcher(virtualMemory, moduleManager),
+            new CpuDispatcher(virtualMemory, moduleManager, hostPlatform: hostPlatform),
            moduleManager,
            Aerolib.Instance,
            cpuExecutionOptions,
@@ -0,0 +1,13 @@
 // Copyright (C) 2026 SharpEmu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 namespace SharpEmu.HLE;
 [Flags]
 public enum GuestPageProtection
 {
    None = 0,
    Read = 1,
    Write = 2,
    Execute = 4,
 }
@@ -0,0 +1,18 @@
 // Copyright (C) 2026 SharpEmu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 namespace SharpEmu.HLE.Host;
 /// <summary>
 /// General-purpose register snapshot of a suspended thread, produced by
 /// <see cref="IHostThreading.TryCaptureThreadRegisters"/>. Registers are named
 /// after the guest ISA (x86-64), which every supported host executes natively.
 /// </summary>
 public readonly record struct HostCapturedRegisters(
    ulong Rip,
    ulong Rsp,
    ulong Rbp,
    ulong Rax,
    ulong Rbx,
    ulong Rcx,
    ulong Rdx);
@@ -0,0 +1,20 @@
 // Copyright (C) 2026 SharpEmu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 namespace SharpEmu.HLE.Host;
 /// <summary>
 /// Platform-neutral page protection. Values intentionally enumerate the exact
 /// combinations the emulator uses today so each maps 1:1 onto a single native
 /// protection constant (PAGE_* on Windows, PROT_* elsewhere).
 /// </summary>
 public enum HostPageProtection
 {
    NoAccess,
    ReadOnly,
    ReadWrite,
    Execute,
    ReadExecute,
    ReadWriteExecute,
    ExecuteWriteCopy,
 }
@@ -0,0 +1,34 @@
 // Copyright (C) 2026 SharpEmu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 using System.Runtime.InteropServices;
 using SharpEmu.HLE.Host.Windows;
 namespace SharpEmu.HLE.Host;
 /// <summary>
 /// Process-wide access point for the host platform backend. Static HLE export
 /// classes (which cannot receive constructor injection) resolve host primitives
 /// through <see cref="Current"/>; injectable components should instead accept an
 /// <see cref="IHostPlatform"/> and merely default to this.
 /// </summary>
 public static class HostPlatform
 {
    private static readonly Lazy<IHostPlatform> Instance = new(Create);
    public static IHostPlatform Current => Instance.Value;
    private static IHostPlatform Create()
    {
        // The Windows backend executes guest x86-64 natively and emits x86-64
        // stubs, so a native ARM64 process must be rejected here rather than
        // crash undefined later (x64 processes under emulation report X64).
        if (OperatingSystem.IsWindows() && RuntimeInformation.ProcessArchitecture == Architecture.X64)
        {
            return new WindowsHostPlatform();
        }
        throw new PlatformNotSupportedException(
            "SharpEmu native guest execution requires a host platform backend and none exists for this OS/architecture yet (currently Windows x64 only).");
    }
 }
@@ -0,0 +1,20 @@
 // Copyright (C) 2026 SharpEmu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 namespace SharpEmu.HLE.Host;
 /// <summary>
 /// Result of <see cref="IHostMemory.Query"/>. The Raw* fields carry the
 /// untranslated OS values so call sites migrated from direct VirtualQuery use
 /// keep comparing (and logging) the exact native words they did before;
 /// <see cref="State"/> and <see cref="Protection"/> are neutral views.
 /// </summary>
 public readonly record struct HostRegionInfo(
    ulong BaseAddress,
    ulong AllocationBase,
    ulong RegionSize,
    HostRegionState State,
    uint RawState,
    HostPageProtection Protection,
    uint RawProtection,
    uint RawAllocationProtection);
@@ -0,0 +1,11 @@
 // Copyright (C) 2026 SharpEmu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 namespace SharpEmu.HLE.Host;
 public enum HostRegionState
 {
    Free,
    Reserved,
    Committed,
 }
@@ -0,0 +1,21 @@
 // Copyright (C) 2026 SharpEmu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 namespace SharpEmu.HLE.Host;
 /// <summary>
 /// Host functions whose addresses the execution engine bakes into emitted
 /// stubs (spin-waits, worker run loops, TLS reads). Enum-keyed rather than a
 /// free-form name lookup: each platform's emitters need their own specific
 /// functions, and this set is exactly what the current emitters consume.
 /// </summary>
 public enum HostRuntimeFunction
 {
    TlsGetValue,
    QueryPerformanceCounter,
    SwitchToThread,
    Sleep,
    WaitForSingleObject,
    SetEvent,
    ExitThread,
 }
@@ -0,0 +1,32 @@
 // Copyright (C) 2026 SharpEmu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 namespace SharpEmu.HLE.Host;
 /// <summary>
 /// Installation mechanics for the process-wide fault interception the execution
 /// engine relies on to catch guest faults. Deliberately thin: the managed
 /// handlers keep receiving the platform's raw exception data, and the emitted
 /// pre-filter thunk is an opaque per-platform unit. Implementations live next
 /// to the execution backend (SharpEmu.Core), not behind HostPlatform.Current.
 /// </summary>
 public interface IHostFaultHandling
 {
    /// <summary>
    /// Emits the native thunk that wraps a managed fault handler: it pre-filters
    /// exception codes that must never enter managed code and, when the fault
    /// happened on a guest stack, switches to the host stack saved in
    /// <paramref name="hostRspSwitchTlsSlot"/> before the call. Returns 0 on failure.
    /// </summary>
    nint CreateHandlerThunk(nint managedCallback, uint hostRspSwitchTlsSlot, nint tlsGetValueAddress);
    void FreeThunk(nint thunk);
    /// <summary>Installs a first-chance handler ahead of existing ones; returns a removal handle (0 on failure).</summary>
    nint AddFirstChanceHandler(nint thunk);
    void RemoveHandler(nint handle);
    /// <summary>Installs the last-resort filter; pass 0 to clear.</summary>
    void SetUnhandledFilter(nint thunk);
 }
@@ -0,0 +1,48 @@
 // Copyright (C) 2026 SharpEmu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 namespace SharpEmu.HLE.Host;
 /// <summary>
 /// Host page-allocation primitives used by the native execution engine.
 /// Allocate/Reserve/Commit are deliberately separate members (rather than a
 /// flags parameter) so every call site maps 1:1 onto the exact native call it
 /// replaced, keeping the Windows behavior byte-for-byte identical.
 /// </summary>
 public interface IHostMemory
 {
    /// <summary>
    /// Reserves and commits pages in one step. <paramref name="desiredAddress"/> of 0
    /// lets the OS choose the address. Returns the base address, or 0 on failure.
    /// The OS may satisfy the request at a different address than desired; callers
    /// that require an exact placement must check the result themselves.
    /// </summary>
    ulong Allocate(ulong desiredAddress, ulong size, HostPageProtection protection);
    /// <summary>Reserves address space without committing pages (lazy regions).</summary>
    ulong Reserve(ulong desiredAddress, ulong size, HostPageProtection protection);
    /// <summary>Commits pages inside a previously reserved range (fault-path lazy commit).</summary>
    bool Commit(ulong address, ulong size, HostPageProtection protection);
    /// <summary>Releases an entire allocation or reservation by its base address.</summary>
    bool Free(ulong address);
    /// <summary>
    /// Changes protection on committed pages. <paramref name="rawOldProtection"/> is the
    /// untranslated previous OS protection value (see <see cref="HostRegionInfo.RawProtection"/>).
    /// </summary>
    bool Protect(ulong address, ulong size, HostPageProtection protection, out uint rawOldProtection);
    /// <summary>
    /// Restores a raw protection value previously returned by <see cref="Protect"/> or
    /// <see cref="Query"/> on this same platform. Raw values are opaque to callers and
    /// must never cross platforms; this exists so save/restore protection sequences
    /// round-trip OS-specific modifier bits the neutral enum cannot represent.
    /// </summary>
    bool ProtectRaw(ulong address, ulong size, uint rawProtection, out uint rawOldProtection);
    bool Query(ulong address, out HostRegionInfo info);
    void FlushInstructionCache(ulong address, ulong size);
 }
@@ -0,0 +1,19 @@
 // Copyright (C) 2026 SharpEmu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 namespace SharpEmu.HLE.Host;
 /// <summary>
 /// Aggregates the host-OS primitives the native execution engine depends on.
 /// Each supported platform provides one implementation; consumers reach the
 /// process-wide instance through <see cref="HostPlatform.Current"/> or accept
 /// one by injection.
 /// </summary>
 public interface IHostPlatform
 {
    IHostMemory Memory { get; }
    IHostThreading Threading { get; }
    IHostSymbolResolver Symbols { get; }
 }
@@ -0,0 +1,10 @@
 // Copyright (C) 2026 SharpEmu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 namespace SharpEmu.HLE.Host;
 public interface IHostSymbolResolver
 {
    /// <summary>Returns the native address of the function, or 0 if unavailable.</summary>
    nint GetAddress(HostRuntimeFunction function);
 }
@@ -0,0 +1,45 @@
 // Copyright (C) 2026 SharpEmu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 namespace SharpEmu.HLE.Host;
 /// <summary>
 /// Raw host thread and native-TLS primitives for the execution engine. Guest
 /// code must run on threads the CLR did not create (no managed frames below
 /// guest frames), so thread creation takes a native entry point and is not
 /// expressible with managed threads.
 /// </summary>
 public interface IHostThreading
 {
    /// <summary>Allocates a native TLS slot; returns <see cref="uint.MaxValue"/> on failure.</summary>
    uint AllocateTlsSlot();
    bool FreeTlsSlot(uint slot);
    bool SetTlsValue(uint slot, nint value);
    nint GetTlsValue(uint slot);
    uint CurrentThreadId { get; }
    bool TrySetCurrentThreadAffinity(nuint affinityMask);
    /// <summary>
    /// Creates a raw OS thread executing native code at <paramref name="entry"/> with
    /// <paramref name="stackReserveBytes"/> of reserved (not committed) stack.
    /// Returns the thread handle, or 0 on failure.
    /// </summary>
    nint CreateNativeThread(nint entry, nint parameter, nuint stackReserveBytes, out uint threadId);
    /// <summary>Waits for the thread to exit; true when it did within the timeout.</summary>
    bool WaitForThreadExit(nint threadHandle, uint timeoutMilliseconds);
    void CloseThreadHandle(nint threadHandle);
    /// <summary>
    /// Suspends the thread, snapshots its general-purpose registers, and resumes it —
    /// one indivisible operation (diagnostics only). The caller must not pass the
    /// current thread. Returns false if the thread cannot be opened or suspended.
    /// </summary>
    bool TryCaptureThreadRegisters(uint threadId, out HostCapturedRegisters registers);
 }
@@ -0,0 +1,153 @@
 // Copyright (C) 2026 SharpEmu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 using System.Runtime.InteropServices;
 namespace SharpEmu.HLE.Host.Windows;
 /// <summary>
 /// Windows implementation over VirtualAlloc/VirtualFree/VirtualProtect/VirtualQuery.
 /// Sealed so the JIT can devirtualize interface calls on fault-handling hot paths.
 /// </summary>
 internal sealed unsafe partial class WindowsHostMemory : IHostMemory
 {
    private const uint MEM_COMMIT = 0x1000;
    private const uint MEM_RESERVE = 0x2000;
    private const uint MEM_RELEASE = 0x8000;
    private const uint MEM_FREE = 0x10000;
    private const uint PAGE_NOACCESS = 0x01;
    private const uint PAGE_READONLY = 0x02;
    private const uint PAGE_READWRITE = 0x04;
    private const uint PAGE_WRITECOPY = 0x08;
    private const uint PAGE_EXECUTE = 0x10;
    private const uint PAGE_EXECUTE_READ = 0x20;
    private const uint PAGE_EXECUTE_READWRITE = 0x40;
    private const uint PAGE_EXECUTE_WRITECOPY = 0x80;
    public ulong Allocate(ulong desiredAddress, ulong size, HostPageProtection protection)
    {
        return (ulong)VirtualAlloc((void*)desiredAddress, (nuint)size, MEM_COMMIT | MEM_RESERVE, ToNativeProtection(protection));
    }
    public ulong Reserve(ulong desiredAddress, ulong size, HostPageProtection protection)
    {
        return (ulong)VirtualAlloc((void*)desiredAddress, (nuint)size, MEM_RESERVE, ToNativeProtection(protection));
    }
    public bool Commit(ulong address, ulong size, HostPageProtection protection)
    {
        return VirtualAlloc((void*)address, (nuint)size, MEM_COMMIT, ToNativeProtection(protection)) != null;
    }
    public bool Free(ulong address)
    {
        return VirtualFree((void*)address, 0, MEM_RELEASE);
    }
    public bool Protect(ulong address, ulong size, HostPageProtection protection, out uint rawOldProtection)
    {
        return VirtualProtect((void*)address, (nuint)size, ToNativeProtection(protection), out rawOldProtection);
    }
    public bool ProtectRaw(ulong address, ulong size, uint rawProtection, out uint rawOldProtection)
    {
        return VirtualProtect((void*)address, (nuint)size, rawProtection, out rawOldProtection);
    }
    public bool Query(ulong address, out HostRegionInfo info)
    {
        if (VirtualQuery((void*)address, out var mbi, (nuint)sizeof(MemoryBasicInformation64)) == 0)
        {
            info = default;
            return false;
        }
        info = new HostRegionInfo(
            mbi.BaseAddress,
            mbi.AllocationBase,
            mbi.RegionSize,
            ToRegionState(mbi.State),
            mbi.State,
            ToHostProtection(mbi.Protect),
            mbi.Protect,
            mbi.AllocationProtect);
        return true;
    }
    public void FlushInstructionCache(ulong address, ulong size)
    {
        FlushInstructionCache(GetCurrentProcess(), (void*)address, (nuint)size);
    }
    private static uint ToNativeProtection(HostPageProtection protection) => protection switch
    {
        HostPageProtection.NoAccess => PAGE_NOACCESS,
        HostPageProtection.ReadOnly => PAGE_READONLY,
        HostPageProtection.ReadWrite => PAGE_READWRITE,
        HostPageProtection.Execute => PAGE_EXECUTE,
        HostPageProtection.ReadExecute => PAGE_EXECUTE_READ,
        HostPageProtection.ReadWriteExecute => PAGE_EXECUTE_READWRITE,
        HostPageProtection.ExecuteWriteCopy => PAGE_EXECUTE_WRITECOPY,
        _ => throw new ArgumentOutOfRangeException(nameof(protection), protection, null),
    };
    private static HostRegionState ToRegionState(uint state) => state switch
    {
        MEM_COMMIT => HostRegionState.Committed,
        MEM_RESERVE => HostRegionState.Reserved,
        MEM_FREE => HostRegionState.Free,
        _ => HostRegionState.Free,
    };
    private static HostPageProtection ToHostProtection(uint rawProtection)
    {
        // Strip PAGE_GUARD/PAGE_NOCACHE/PAGE_WRITECOMBINE modifiers; callers needing
        // them compare HostRegionInfo.RawProtection directly.
        return (rawProtection & 0xFF) switch
        {
            PAGE_READONLY => HostPageProtection.ReadOnly,
            PAGE_READWRITE => HostPageProtection.ReadWrite,
            PAGE_WRITECOPY => HostPageProtection.ReadWrite,
            PAGE_EXECUTE => HostPageProtection.Execute,
            PAGE_EXECUTE_READ => HostPageProtection.ReadExecute,
            PAGE_EXECUTE_READWRITE => HostPageProtection.ReadWriteExecute,
            PAGE_EXECUTE_WRITECOPY => HostPageProtection.ExecuteWriteCopy,
            _ => HostPageProtection.NoAccess,
        };
    }
    [LibraryImport("kernel32.dll", SetLastError = true)]
    private static partial void* VirtualAlloc(void* lpAddress, nuint dwSize, uint flAllocationType, uint flProtect);
    [LibraryImport("kernel32.dll", SetLastError = true)]
    [return: MarshalAs(UnmanagedType.Bool)]
    private static partial bool VirtualFree(void* lpAddress, nuint dwSize, uint dwFreeType);
    [LibraryImport("kernel32.dll", SetLastError = true)]
    [return: MarshalAs(UnmanagedType.Bool)]
    private static partial bool VirtualProtect(void* lpAddress, nuint dwSize, uint flNewProtect, out uint lpflOldProtect);
    [LibraryImport("kernel32.dll")]
    private static partial nuint VirtualQuery(void* lpAddress, out MemoryBasicInformation64 lpBuffer, nuint dwLength);
    [LibraryImport("kernel32.dll")]
    private static partial void* GetCurrentProcess();
    [LibraryImport("kernel32.dll", SetLastError = true)]
    [return: MarshalAs(UnmanagedType.Bool)]
    private static partial bool FlushInstructionCache(void* hProcess, void* lpBaseAddress, nuint dwSize);
    private struct MemoryBasicInformation64
    {
        public ulong BaseAddress;
        public ulong AllocationBase;
        public uint AllocationProtect;
        public uint Alignment1;
        public ulong RegionSize;
        public uint State;
        public uint Protect;
        public uint Type;
        public uint Alignment2;
    }
 }
@@ -0,0 +1,13 @@
 // Copyright (C) 2026 SharpEmu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 namespace SharpEmu.HLE.Host.Windows;
 internal sealed class WindowsHostPlatform : IHostPlatform
 {
    public IHostMemory Memory { get; } = new WindowsHostMemory();
    public IHostThreading Threading { get; } = new WindowsHostThreading();
    public IHostSymbolResolver Symbols { get; } = new WindowsHostSymbolResolver();
 }
@@ -0,0 +1,39 @@
 // Copyright (C) 2026 SharpEmu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 using System.Runtime.InteropServices;
 namespace SharpEmu.HLE.Host.Windows;
 internal sealed partial class WindowsHostSymbolResolver : IHostSymbolResolver
 {
    public nint GetAddress(HostRuntimeFunction function)
    {
        var kernel32 = GetModuleHandle("kernel32.dll");
        if (kernel32 == 0)
        {
            return 0;
        }
        return GetProcAddress(kernel32, function switch
        {
            HostRuntimeFunction.TlsGetValue => "TlsGetValue",
            HostRuntimeFunction.QueryPerformanceCounter => "QueryPerformanceCounter",
            HostRuntimeFunction.SwitchToThread => "SwitchToThread",
            HostRuntimeFunction.Sleep => "Sleep",
            HostRuntimeFunction.WaitForSingleObject => "WaitForSingleObject",
            HostRuntimeFunction.SetEvent => "SetEvent",
            HostRuntimeFunction.ExitThread => "ExitThread",
            _ => throw new ArgumentOutOfRangeException(nameof(function), function, null),
        });
    }
    // Utf16 marshalling pins the managed string and passes its address directly
    // (no copy); Utf8 stack-allocates the transient buffer for these short
    // ASCII export names. LibraryImport is exact-spelling, hence the W entry point.
    [LibraryImport("kernel32.dll", EntryPoint = "GetModuleHandleW", StringMarshalling = StringMarshalling.Utf16)]
    private static partial nint GetModuleHandle(string lpModuleName);
    [LibraryImport("kernel32.dll", StringMarshalling = StringMarshalling.Utf8)]
    private static partial nint GetProcAddress(nint hModule, string procName);
 }
@@ -0,0 +1,165 @@
 // Copyright (C) 2026 SharpEmu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 using System.Runtime.InteropServices;
 namespace SharpEmu.HLE.Host.Windows;
 internal sealed unsafe partial class WindowsHostThreading : IHostThreading
 {
    private const uint StackSizeParamIsAReservation = 0x00010000u;
    private const uint ThreadGetContext = 0x0008u;
    private const uint ThreadSuspendResume = 0x0002u;
    // Win64 CONTEXT layout (CONTROL | INTEGER only — no XMM state is requested).
    private const int Win64ContextSize = 0x4D0;
    private const int Win64ContextFlagsOffset = 0x30;
    private const uint ContextAmd64ControlInteger = 0x00100003u;
    private const int CtxRax = 120;
    private const int CtxRcx = 128;
    private const int CtxRdx = 136;
    private const int CtxRbx = 144;
    private const int CtxRsp = 152;
    private const int CtxRbp = 160;
    private const int CtxRip = 248;
    public uint AllocateTlsSlot() => TlsAlloc();
    public bool FreeTlsSlot(uint slot) => TlsFree(slot);
    public bool SetTlsValue(uint slot, nint value) => TlsSetValue(slot, value);
    public nint GetTlsValue(uint slot) => TlsGetValue(slot);
    public uint CurrentThreadId => GetCurrentThreadId();
    public bool TrySetCurrentThreadAffinity(nuint affinityMask)
    {
        return SetThreadAffinityMask(GetCurrentThread(), affinityMask) != 0;
    }
    public nint CreateNativeThread(nint entry, nint parameter, nuint stackReserveBytes, out uint threadId)
    {
        return CreateThread(0, stackReserveBytes, entry, parameter, StackSizeParamIsAReservation, out threadId);
    }
    public bool WaitForThreadExit(nint threadHandle, uint timeoutMilliseconds)
    {
        return WaitForSingleObject(threadHandle, timeoutMilliseconds) == 0u;
    }
    public void CloseThreadHandle(nint threadHandle)
    {
        _ = CloseHandle(threadHandle);
    }
    public bool TryCaptureThreadRegisters(uint threadId, out HostCapturedRegisters registers)
    {
        registers = default;
        var threadHandle = OpenThread(ThreadGetContext | ThreadSuspendResume, false, threadId);
        if (threadHandle == 0)
        {
            return false;
        }
        void* contextRecord = null;
        var suspended = false;
        try
        {
            if (SuspendThread(threadHandle) == uint.MaxValue)
            {
                return false;
            }
            suspended = true;
            // CONTEXT requires 16-byte alignment (it embeds M128A fields);
            // NativeMemory.AllocZeroed guarantees max_align_t, stackalloc only
            // pointer-size — so this stays a native allocation.
            contextRecord = NativeMemory.AllocZeroed((nuint)Win64ContextSize);
            *(uint*)((byte*)contextRecord + Win64ContextFlagsOffset) = ContextAmd64ControlInteger;
            if (!GetThreadContext(threadHandle, contextRecord))
            {
                return false;
            }
            registers = new HostCapturedRegisters(
                ReadU64(contextRecord, CtxRip),
                ReadU64(contextRecord, CtxRsp),
                ReadU64(contextRecord, CtxRbp),
                ReadU64(contextRecord, CtxRax),
                ReadU64(contextRecord, CtxRbx),
                ReadU64(contextRecord, CtxRcx),
                ReadU64(contextRecord, CtxRdx));
            return true;
        }
        finally
        {
            if (contextRecord != null)
            {
                NativeMemory.Free(contextRecord);
            }
            if (suspended)
            {
                _ = ResumeThread(threadHandle);
            }
            _ = CloseHandle(threadHandle);
        }
    }
    private static ulong ReadU64(void* contextRecord, int offset)
    {
        return *(ulong*)((byte*)contextRecord + offset);
    }
    [LibraryImport("kernel32.dll")]
    private static partial uint TlsAlloc();
    [LibraryImport("kernel32.dll")]
    [return: MarshalAs(UnmanagedType.Bool)]
    private static partial bool TlsFree(uint dwTlsIndex);
    [LibraryImport("kernel32.dll")]
    [return: MarshalAs(UnmanagedType.Bool)]
    private static partial bool TlsSetValue(uint dwTlsIndex, nint lpTlsValue);
    [LibraryImport("kernel32.dll")]
    private static partial nint TlsGetValue(uint dwTlsIndex);
    [LibraryImport("kernel32.dll")]
    private static partial uint GetCurrentThreadId();
    [LibraryImport("kernel32.dll")]
    private static partial nint GetCurrentThread();
    [LibraryImport("kernel32.dll", SetLastError = true)]
    private static partial nuint SetThreadAffinityMask(nint hThread, nuint dwThreadAffinityMask);
    [LibraryImport("kernel32.dll", SetLastError = true)]
    private static partial nint CreateThread(
        nint lpThreadAttributes,
        nuint dwStackSize,
        nint lpStartAddress,
        nint lpParameter,
        uint dwCreationFlags,
        out uint lpThreadId);
    [LibraryImport("kernel32.dll", SetLastError = true)]
    private static partial uint WaitForSingleObject(nint hHandle, uint dwMilliseconds);
    [LibraryImport("kernel32.dll", SetLastError = true)]
    private static partial nint OpenThread(uint dwDesiredAccess, [MarshalAs(UnmanagedType.Bool)] bool bInheritHandle, uint dwThreadId);
    [LibraryImport("kernel32.dll", SetLastError = true)]
    private static partial uint SuspendThread(nint hThread);
    [LibraryImport("kernel32.dll", SetLastError = true)]
    private static partial uint ResumeThread(nint hThread);
    [LibraryImport("kernel32.dll", SetLastError = true)]
    [return: MarshalAs(UnmanagedType.Bool)]
    private static partial bool GetThreadContext(nint hThread, void* lpContext);
    [LibraryImport("kernel32.dll", SetLastError = true)]
    [return: MarshalAs(UnmanagedType.Bool)]
    private static partial bool CloseHandle(nint hObject);
 }
@@ -0,0 +1,14 @@
 // Copyright (C) 2026 SharpEmu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 namespace SharpEmu.HLE;
 /// <summary>
 /// Implemented by memories that decorate another <see cref="ICpuMemory"/>
 /// (e.g. access trackers) so capability lookups can unwrap to the real
 /// implementation without reflection.
 /// </summary>
 public interface ICpuMemoryWrapper
 {
    ICpuMemory Inner { get; }
 }
@@ -0,0 +1,21 @@
 // Copyright (C) 2026 SharpEmu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 namespace SharpEmu.HLE;
 /// <summary>
 /// Guest address-space manipulation beyond plain allocation: fixed-address
 /// mapping and page-protection changes. Guest addresses are identity-mapped
 /// onto host pages by the implementing memory, so HLE exports (mmap, mprotect)
 /// reach these operations through <c>ctx.Memory</c> instead of calling host
 /// APIs directly. Member signatures deliberately mirror the implementation in
 /// SharpEmu.Core so existing call sites migrate call-for-call.
 /// </summary>
 public interface IGuestAddressSpace : IGuestMemoryAllocator
 {
    ulong AllocateAt(ulong desiredAddress, ulong size, bool executable = true, bool allowAlternative = true);
    bool TryAllocateAtOrAbove(ulong desiredAddress, ulong size, bool executable, ulong alignment, out ulong actualAddress);
    bool TryProtect(ulong address, ulong size, GuestPageProtection protection);
 }
@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 using SharpEmu.HLE;
 using SharpEmu.HLE.Host;
 using SharpEmu.Libs.Ampr;
 using System.Buffers;
 using System.Buffers.Binary;
@@ -52,14 +53,13 @@ public static class KernelMemoryCompatExports
    private const ulong FlexibleMemorySizeBytes = 448UL * 1024 * 1024;
    private const int OrbisVirtualQueryInfoSize = 72;
    private const int OrbisKernelMaximumNameLength = 32;
-    private const uint MemCommit = 0x1000;
+    // Raw Windows PAGE_* values used only against HostRegionInfo.RawProtection,
-    private const uint MemReserve = 0x2000;
+    // which by contract carries the untranslated protection word of the host
-    private const uint MemRelease = 0x8000;
+    // platform in use (see IHostMemory).
    private const uint HostPageNoAccess = 0x01;
    private const uint HostPageReadOnly = 0x02;
    private const uint HostPageReadWrite = 0x04;
    private const uint HostPageWriteCopy = 0x08;
    private const uint HostPageExecute = 0x10;
    private const uint HostPageExecuteRead = 0x20;
    private const uint HostPageExecuteReadWrite = 0x40;
    private const uint HostPageExecuteWriteCopy = 0x80;
@@ -136,31 +136,9 @@ public static class KernelMemoryCompatExports
    private static string? _cachedApp0Root;
    private static string? _cachedDownload0Root;
-    [StructLayout(LayoutKind.Sequential)]
+    // Property (not a cached field) so merely touching this type never resolves
-    private struct MemoryBasicInformation
+    // the platform backend; non-Windows hosts only throw if a call is reached.
-    {
+    private static IHostMemory HostMemory => HostPlatform.Current.Memory;
        public nint BaseAddress;
        public nint AllocationBase;
        public uint AllocationProtect;
        public nuint RegionSize;
        public uint State;
        public uint Protect;
        public uint Type;
    }
    [DllImport("kernel32.dll", SetLastError = true)]
    private static extern nuint VirtualQuery(nint lpAddress, out MemoryBasicInformation lpBuffer, nuint dwLength);
    [DllImport("kernel32.dll", SetLastError = true)]
    [return: MarshalAs(UnmanagedType.Bool)]
    private static extern bool VirtualProtect(nint lpAddress, nuint dwSize, uint flNewProtect, out uint lpflOldProtect);
    [DllImport("kernel32.dll", SetLastError = true)]
    private static extern nint VirtualAlloc(nint lpAddress, nuint dwSize, uint flAllocationType, uint flProtect);
    [DllImport("kernel32.dll", SetLastError = true)]
    [return: MarshalAs(UnmanagedType.Bool)]
    private static extern bool VirtualFree(nint lpAddress, nuint dwSize, uint dwFreeType);
    private sealed class OpenDirectory
    {
@@ -3563,7 +3541,7 @@ public static class KernelMemoryCompatExports
            return (int)OrbisGen2Result.ORBIS_GEN2_ERROR_INVALID_ARGUMENT;
        }
-        if (!TryProtectHostRange(alignedAddress, alignedLength, protection))
+        if (!TryProtectHostRange(ctx, alignedAddress, alignedLength, protection))
        {
            return (int)OrbisGen2Result.ORBIS_GEN2_ERROR_NOT_FOUND;
        }
@@ -3597,7 +3575,7 @@ public static class KernelMemoryCompatExports
            return (int)OrbisGen2Result.ORBIS_GEN2_ERROR_INVALID_ARGUMENT;
        }
-        if (!TryProtectHostRange(alignedAddress, alignedLength, protection))
+        if (!TryProtectHostRange(ctx, alignedAddress, alignedLength, protection))
        {
            return (int)OrbisGen2Result.ORBIS_GEN2_ERROR_NOT_FOUND;
        }
@@ -5797,42 +5775,40 @@ public static class KernelMemoryCompatExports
        return alignedLength != 0;
    }
-    private static bool TryProtectHostRange(ulong address, ulong length, int orbisProtection)
+    private static bool TryProtectHostRange(CpuContext ctx, ulong address, ulong length, int orbisProtection)
    {
        if (length == 0 || length > nuint.MaxValue)
        {
            return false;
        }
-        var hostProtection = ResolveHostProtection(orbisProtection);
+        if (!KernelVirtualRangeAllocator.TryResolveAddressSpace(ctx.Memory, out var addressSpace))
        if (!VirtualProtect((nint)address, (nuint)length, hostProtection, out _))
        {
            return false;
        }
-        return true;
+        return addressSpace.TryProtect(address, length, ResolveGuestProtection(orbisProtection));
    }
-    private static uint ResolveHostProtection(int orbisProtection)
+    private static GuestPageProtection ResolveGuestProtection(int orbisProtection)
    {
-        var read = (orbisProtection & (OrbisProtCpuRead | OrbisProtGpuRead)) != 0;
+        var protection = GuestPageProtection.None;
-        var write = (orbisProtection & (OrbisProtCpuWrite | OrbisProtGpuWrite)) != 0;
+        if ((orbisProtection & (OrbisProtCpuRead | OrbisProtGpuRead)) != 0)
        var execute = (orbisProtection & OrbisProtCpuExec) != 0;
        if (execute)
        {
-            return write
+            protection |= GuestPageProtection.Read;
                ? HostPageExecuteReadWrite
                : read
                    ? HostPageExecuteRead
                    : HostPageExecute;
        }
-        return write
+        if ((orbisProtection & (OrbisProtCpuWrite | OrbisProtGpuWrite)) != 0)
-            ? HostPageReadWrite
+        {
-            : read
+            protection |= GuestPageProtection.Write;
-                ? HostPageReadOnly
+        }
-                : HostPageNoAccess;
+
        if ((orbisProtection & OrbisProtCpuExec) != 0)
        {
            protection |= GuestPageProtection.Execute;
        }
        return protection;
    }
    private static bool TryFindVirtualQueryRegionLocked(ulong queryAddress, bool findNext, out MappedRegion region)
@@ -6218,7 +6194,7 @@ public static class KernelMemoryCompatExports
            var effectiveAlignment = Math.Max(alignment, pageSize);
            var usableSize = checked((nuint)AlignUp((ulong)actualSize, (ulong)pageSize));
            var reservationSize = checked(pageSize + effectiveAlignment - 1 + usableSize + pageSize);
-            var baseAddress = VirtualAlloc(0, reservationSize, MemCommit | MemReserve, HostPageReadWrite);
+            var baseAddress = unchecked((nint)HostMemory.Allocate(0, reservationSize, HostPageProtection.ReadWrite));
            if (baseAddress == 0)
            {
                return false;
@@ -6226,9 +6202,9 @@ public static class KernelMemoryCompatExports
            var alignedAddress = AlignUp(unchecked((ulong)baseAddress) + (ulong)pageSize, (ulong)effectiveAlignment);
            var guardAddress = alignedAddress + (ulong)usableSize;
-            if (!VirtualProtect((nint)guardAddress, pageSize, HostPageNoAccess, out _))
+            if (!HostMemory.Protect(guardAddress, pageSize, HostPageProtection.NoAccess, out _))
            {
-                _ = VirtualFree(baseAddress, 0, MemRelease);
+                _ = HostMemory.Free(unchecked((ulong)baseAddress));
                return false;
            }
@@ -6363,7 +6339,7 @@ public static class KernelMemoryCompatExports
        if (allocation.IsGuarded)
        {
-            _ = VirtualFree(allocation.BaseAddress, 0, MemRelease);
+            _ = HostMemory.Free(unchecked((ulong)allocation.BaseAddress));
        }
        else
        {
@@ -6459,7 +6435,7 @@ public static class KernelMemoryCompatExports
            return false;
        }
-        if (!TryQueryHostPage(address, out var startInfo) || !HasRequiredProtection(startInfo.Protect, writeAccess))
+        if (!TryQueryHostPage(address, out var startInfo) || !HasRequiredProtection(startInfo.RawProtection, writeAccess))
        {
            return false;
        }
@@ -6470,7 +6446,7 @@ public static class KernelMemoryCompatExports
            return true;
        }
-        if (!TryQueryHostPage(endAddress, out var endInfo) || !HasRequiredProtection(endInfo.Protect, writeAccess))
+        if (!TryQueryHostPage(endAddress, out var endInfo) || !HasRequiredProtection(endInfo.RawProtection, writeAccess))
        {
            return false;
        }
@@ -6478,16 +6454,14 @@ public static class KernelMemoryCompatExports
        return true;
    }
-    private static bool TryQueryHostPage(ulong address, out MemoryBasicInformation info)
+    private static bool TryQueryHostPage(ulong address, out HostRegionInfo info)
    {
-        info = default;
+        if (!HostMemory.Query(address, out info))
        var size = (nuint)Marshal.SizeOf<MemoryBasicInformation>();
        if (VirtualQuery((nint)address, out info, size) == 0)
        {
            return false;
        }
-        return info.State == MemCommit;
+        return info.State == HostRegionState.Committed;
    }
    private static bool HasRequiredProtection(uint protect, bool writeAccess)
@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 using SharpEmu.HLE;
 using SharpEmu.HLE.Host;
 using SharpEmu.Libs.Fiber;
 using System.Buffers.Binary;
 using System.Diagnostics;
@@ -48,9 +49,6 @@ public static class KernelRuntimeCompatExports
    private const int MapFlagFixed = 0x10;
    private const ulong DefaultVirtualRangeAlignment = 0x4000UL;
    private const int AioInitParamSize = 0x3C;
    private const uint MemCommit = 0x1000;
    private const uint MemReserve = 0x2000;
    private const uint PageExecuteReadWrite = 0x40;
    private static readonly object _stateGate = new();
    private static readonly long _processStartCounter = Stopwatch.GetTimestamp();
    private static readonly RdtscDelegate? _rdtscReader = CreateRdtscReader();
@@ -1893,7 +1891,7 @@ public static class KernelRuntimeCompatExports
        try
        {
-            nint stubAddress = VirtualAlloc(nint.Zero, (nuint)16, MemCommit | MemReserve, PageExecuteReadWrite);
+            nint stubAddress = unchecked((nint)HostPlatform.Current.Memory.Allocate(0, 16, HostPageProtection.ReadWriteExecute));
            if (stubAddress == 0)
            {
                return null;
@@ -1923,9 +1921,6 @@ public static class KernelRuntimeCompatExports
        }
    }
    [DllImport("kernel32.dll", SetLastError = true)]
    private static extern nint VirtualAlloc(nint lpAddress, nuint dwSize, uint flAllocationType, uint flProtect);
    private static bool TryReserveVirtualRange(
        CpuContext ctx,
        ulong desiredAddress,
@@ -3,15 +3,12 @@
 using SharpEmu.HLE;
 using System;
-using System.Collections.Concurrent;
+using System.Diagnostics.CodeAnalysis;
 using System.Reflection;
 namespace SharpEmu.Libs.Kernel;
 internal static class KernelVirtualRangeAllocator
 {
    private static readonly ConcurrentDictionary<Type, Accessor> _accessors = new();
    public static bool TryReserve(
        CpuContext ctx,
        ulong desiredAddress,
@@ -31,38 +28,24 @@ internal static class KernelVirtualRangeAllocator
        try
        {
-            if (!TryResolveAccessor(ctx.Memory, out var target, out var accessor))
+            if (!TryResolveAddressSpace(ctx.Memory, out var addressSpace))
            {
                Console.Error.WriteLine($"[LOADER][TRACE] {traceName}: AllocateAt missing on {ctx.Memory.GetType().FullName}");
                return false;
            }
-            if (allowSearch && accessor.AllocateAtOrAbove is not null)
+            if (allowSearch &&
                addressSpace.TryAllocateAtOrAbove(desiredAddress, length, executable, alignment, out var searchedAddress) &&
                searchedAddress != 0)
            {
-                var searchArgs = new object[] { desiredAddress, length, executable, alignment, 0UL };
+                mappedAddress = searchedAddress;
-                var searchResult = accessor.AllocateAtOrAbove.Invoke(target, searchArgs);
+                return true;
                if (searchResult is bool trueValue && trueValue &&
                    searchArgs[4] is ulong searchedAddress && searchedAddress != 0)
                {
                    mappedAddress = searchedAddress;
                    return true;
                }
            }
-            if (accessor.AllocateAt is null)
+            var allocated = addressSpace.AllocateAt(desiredAddress, length, executable, allowAllocateAtAlternative);
            if (allocated == 0)
            {
-                Console.Error.WriteLine($"[LOADER][TRACE] {traceName}: AllocateAt missing on {target.GetType().FullName}");
+                Console.Error.WriteLine($"[LOADER][TRACE] {traceName}: AllocateAt returned {typeof(ulong).FullName} value=0");
                return false;
            }
            var invokeArgs = accessor.AllocateAtHasAllowAlternativeArg
                ? new object[] { desiredAddress, length, executable, allowAllocateAtAlternative }
                : new object[] { desiredAddress, length, executable };
            var result = accessor.AllocateAt.Invoke(target, invokeArgs);
            if (result is not ulong allocated || allocated == 0)
            {
                var resultType = result?.GetType().FullName ?? "null";
                Console.Error.WriteLine($"[LOADER][TRACE] {traceName}: AllocateAt returned {resultType} value={result ?? "null"}");
                return false;
            }
@@ -76,84 +59,36 @@ internal static class KernelVirtualRangeAllocator
        }
    }
-    private static bool TryResolveAccessor(object rootMemory, out object target, out Accessor accessor)
+    /// <summary>
    /// Finds the <see cref="IGuestAddressSpace"/> behind <paramref name="rootMemory"/>,
    /// unwrapping decorators (bounded, like the reflection walker this replaced).
    /// </summary>
    public static bool TryResolveAddressSpace(ICpuMemory rootMemory, [NotNullWhen(true)] out IGuestAddressSpace? addressSpace)
    {
-        target = rootMemory;
+        var target = rootMemory;
        accessor = default;
        for (var depth = 0; depth < 4; depth++)
        {
-            accessor = _accessors.GetOrAdd(target.GetType(), DiscoverAccessor);
+            if (target is IGuestAddressSpace resolved)
            if (accessor.AllocateAt is not null || accessor.AllocateAtOrAbove is not null)
            {
                addressSpace = resolved;
                return true;
            }
-            if (accessor.InnerProperty is null)
+            if (target is not ICpuMemoryWrapper wrapper)
            {
                break;
            }
-            var innerValue = accessor.InnerProperty.GetValue(target);
+            var inner = wrapper.Inner;
-            if (innerValue is null || ReferenceEquals(innerValue, target))
+            if (inner is null || ReferenceEquals(inner, target))
            {
                break;
            }
-            target = innerValue;
+            target = inner;
        }
        addressSpace = null;
        return false;
    }
    private static Accessor DiscoverAccessor(Type type)
    {
        MethodInfo? allocateAt = null;
        MethodInfo? allocateAtOrAbove = null;
        var allocateAtHasAllowAlternativeArg = false;
        foreach (var candidate in type.GetMethods(BindingFlags.Public | BindingFlags.Instance))
        {
            var parameters = candidate.GetParameters();
            if (string.Equals(candidate.Name, "TryAllocateAtOrAbove", StringComparison.Ordinal) &&
                parameters.Length == 5 &&
                parameters[0].ParameterType == typeof(ulong) &&
                parameters[1].ParameterType == typeof(ulong) &&
                parameters[2].ParameterType == typeof(bool) &&
                parameters[3].ParameterType == typeof(ulong) &&
                parameters[4].ParameterType == typeof(ulong).MakeByRefType())
            {
                allocateAtOrAbove = candidate;
            }
            else if (string.Equals(candidate.Name, "AllocateAt", StringComparison.Ordinal))
            {
                if (parameters.Length == 3 &&
                    parameters[0].ParameterType == typeof(ulong) &&
                    parameters[1].ParameterType == typeof(ulong) &&
                    parameters[2].ParameterType == typeof(bool))
                {
                    allocateAt = candidate;
                    allocateAtHasAllowAlternativeArg = false;
                }
                else if (parameters.Length == 4 &&
                    parameters[0].ParameterType == typeof(ulong) &&
                    parameters[1].ParameterType == typeof(ulong) &&
                    parameters[2].ParameterType == typeof(bool) &&
                    parameters[3].ParameterType == typeof(bool))
                {
                    allocateAt = candidate;
                    allocateAtHasAllowAlternativeArg = true;
                }
            }
        }
        var innerProperty = type.GetProperty("Inner", BindingFlags.Public | BindingFlags.Instance);
        return new Accessor(allocateAt, allocateAtOrAbove, allocateAtHasAllowAlternativeArg, innerProperty);
    }
    private readonly record struct Accessor(
        MethodInfo? AllocateAt,
        MethodInfo? AllocateAtOrAbove,
        bool AllocateAtHasAllowAlternativeArg,
        PropertyInfo? InnerProperty);
 }