aaaaaaaaaaarch

fix arm
[dynarmic] Coalesce Write/Read fallback functions
2026-08-29 01:56:06 +00:00 · 2026-08-13 05:34:28 +00:00 · 2026-08-13 05:34:28 +00:00 · 2026-08-13 05:34:28 +00:00
61 changed files with 602 additions and 1358 deletions
@@ -1,92 +0,0 @@
-#!/bin/sh -ex
-
-# SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-# SPDX-License-Identifier: GPL-3.0-or-later
-
-NUM_JOBS=$(nproc 2>/dev/null || getconf _NPROCESSORS_ONLN 2>/dev/null || echo 2)
-
-: "${CCACHE:=false}"
-RETURN=0
-
-usage() {
-    cat <<EOF
-Usage: $0 [-b|--build-type BUILD_TYPE] [-o|--outdir OUTPUT_DIRECTORY]
-
-Build script for Emscripten (using wasm64).
-
-Options:
-    --build-type    Set the CMake build type (Release|RelWithDebInfo|MinSizeRel|Debug)
-                    Default: Release
-    --outdir        Set the output directory
-                    Default: build
-
-EOF
-    exit "$RETURN"
-}
-
-die() {
-	echo "-- ! $*" >&2
-	RETURN=1 usage
-}
-
-type() {
-    [ -z "$1" ] && die "You must specify a valid type."
-    TYPE="$1"
-}
-
-outdir() {
-    [ -z "$1" ] && die "You must specify a valid output directory."
-    OUTDIR="$1"
-}
-
-while true; do
-	case "$1" in
-		-r|--release) DEVEL=false ;;
-		-b|--build-type) type "$2"; shift ;;
-		-o|--outdir) outdir "$2"; shift ;;
-		-h|--help) usage ;;
-		*) break ;;
-	esac
-	shift
-done
-
-: "${TYPE:=Release}"
-: "${DEVEL:=true}"
-: "${OUTDIR:=build}"
-
-# -sMEMORY64 must be specified twice, see below
-# The CMake toolchain file will match against MEMORY64 but will fail to match if:
-# - it's either -sMEMORY64
-# - or it's either -sMEMORY64=1
-# The line in question:
-# if (CMAKE_C_FLAGS MATCHES "MEMORY64")
-# However why need to specify -sMEMORY64=1 then? Oh that's because if you didn't set
-# the =1, it would assume you meant =0, which equates to not specifying it at all
-# This seems to be fixed in later versions but occurs atleast on 4.0.3-git and below.
-emcmake cmake -B "$OUTDIR" -G "Unix Makefiles" \
-    -DCMAKE_BUILD_TYPE=${TYPE} \
-    -DENABLE_OPENGL=OFF \
-    -DENABLE_LTO=OFF \
-    -DENABLE_QT=OFF \
-    -DENABLE_UNITY_BUILD=OFF \
-    -DENABLE_QT_TRANSLATION=OFF \
-    -DENABLE_CUBEB=OFF \
-    -DENABLE_LIBUSB=OFF \
-    -DENABLE_UPDATE_CHECKER=OFF \
-    -DENABLE_WEB_SERVICE=OFF \
-    -DUSE_DISCORD_PRESENCE=OFF \
-    -DENABLE_WIFI_SCAN=OFF \
-    -DUSE_FASTER_LINKER=ON \
-    -DYUZU_STATIC_BUILD=ON \
-    -DYUZU_USE_BUNDLED_OPENSSL=OFF \
-    -DYUZU_USE_EXTERNAL_FFMPEG=ON \
-    -Dzstd_FORCE_BUNDLED=ON \
-    -DOpenSSL_FORCE_BUNDLED=ON \
-    -DEMSCRIPTEN_SYSTEM_PROCESSOR=wasm \
-    -DCMAKE_C_FLAGS="-s MEMORY64 -m64 -pipe -sMEMORY64=1" \
-    -DCMAKE_CXX_FLAGS="-s MEMORY64 -m64 -pipe -sMEMORY64=1" \
-    -DCMAKE_EXE_LINKER_FLAGS="-sMEMORY64=1 -m64 -Wl,-mwasm64 -sASYNCIFY=1" \
-    -DCMAKE_C_LINK_FLAGS="-sMEMORY64=1 -m64 -Wl,-mwasm64 -sASYNCIFY=1" \
-    -DCMAKE_CXX_LINK_FLAGS="-sMEMORY64=1 -m64 -Wl,-mwasm64 -sASYNCIFY=1"
-
-cmake --build "$OUTDIR" -- -j$NUM_JOBS
@@ -1,40 +0,0 @@
-diff --git a/cmake/ConfigureOpenSSL.cmake b/cmake/ConfigureOpenSSL.cmake
-index 3012e05..2ae23ff 100644
--- a/cmake/ConfigureOpenSSL.cmake
-+++ b/cmake/ConfigureOpenSSL.cmake
-@@ -108,7 +108,8 @@ function(configure_openssl)
-     )
- 
-     if(NOT "${CONFIGURE_OPTIONS_OLD}" STREQUAL "")
-        if(CONFIGURE_OPTIONS STREQUAL CONFIGURE_OPTIONS_OLD)
-+        # TODO(lizzie): Emscripten has issues with rebuilding due to the wrapper it uses
-+        if(CMAKE_SYSTEM_NAME MATCHES "Emscripten" OR CONFIGURE_OPTIONS STREQUAL CONFIGURE_OPTIONS_OLD)
-             message(STATUS "Found previous configure results. Don't perform configuration")
-             return()
-         endif()
-@@ -134,10 +135,24 @@ function(configure_openssl)
-         set(VERBOSE_OPTION OUTPUT_QUIET)
-     endif()
- 
-+    if (CMAKE_SYSTEM_NAME MATCHES "Emscripten")
-+        set(EMSCRIPTEN_CMAKE_WRAPPER "emcmake")
-+        find_program(EMCC emcc REQUIRED)
-+        set(EMSCRIPTEN_LINKER ${EMCC})
-+        list(APPEND CONFIGURE_COMMAND wasm64)
-+    else()
-+        set(EMSCRIPTEN_CMAKE_WRAPPER "")
-+        set(EMSCRIPTEN_LINKER ${CMAKE_LINKER})
-+    endif ()
-+
-     execute_process(
-        COMMAND ${CMAKE_COMMAND} -E env
-+        COMMAND ${EMSCRIPTEN_CMAKE_WRAPPER} ${CMAKE_COMMAND} -E env
-             "CFLAGS=${CMAKE_C_FLAGS}"
-             "CXXFLAGS=${CMAKE_CXX_FLAGS}"
-+            "LDFLAGS=${CMAKE_CXX_LINK_FLAGS}"
-+            "CC=${CMAKE_C_COMPILER}"
-+            "CXX=${CMAKE_CXX_COMPILER}"
-+            "LD=${EMSCRIPTEN_LINKER}"
-             ${CONFIGURE_COMMAND}
-         WORKING_DIRECTORY ${CONFIGURE_BUILD_DIR}
-         ${VERBOSE_OPTION}
@@ -1,112 +0,0 @@
-diff --git a/Configurations/10-main.conf b/Configurations/10-main.conf
-index e62721e..243feb4 100644
--- a/Configurations/10-main.conf
-+++ b/Configurations/10-main.conf
-@@ -1970,6 +1970,26 @@ my %targets = (
-         multilib         => "64",
-     },
- 
-+    "wasm32" => {
-+        inherit_from     => [ "BASE_unix" ],
-+        CC               => "emcc",
-+        CXX              => "emc++",
-+        cflags           => combine("--target=wasm32-unknown-emscripten", threads("-pthread")),
-+        cxxflags         => combine("--target=wasm32-unknown-emscripten", threads("-pthread")),
-+        lib_cppflags     => add("-DL_ENDIAN"),
-+        bn_ops           => "THIRTY_TWO_BIT",
-+    },
-+    "wasm64" => {
-+        inherit_from     => [ "BASE_unix" ],
-+        CC               => "emcc",
-+        CXX              => "emc++",
-+        cflags           => combine("--target=wasm64-unknown-emscripten", threads("-pthread")),
-+        cxxflags         => combine("--target=wasm64-unknown-emscripten", threads("-pthread")),
-+        lib_cppflags     => add("-DL_ENDIAN"),
-+        bn_ops           => "SIXTY_FOUR_BIT_LONG",
-+    },
-+
-+
- #### uClinux
-     "uClinux-dist" => {
-         inherit_from     => [ "BASE_unix" ],
-diff --git a/crypto/rand/rand_lib.c b/crypto/rand/rand_lib.c
-index d9e8f02..7faf347 100644
--- a/crypto/rand/rand_lib.c
-+++ b/crypto/rand/rand_lib.c
-@@ -379,17 +379,27 @@ void RAND_add(const void *buf, int num, double randomness)
- #if !defined(OPENSSL_NO_DEPRECATED_1_1_0)
- int RAND_pseudo_bytes(unsigned char *buf, int num)
- {
-+#if defined(__wasi__)
-+    arc4random_buf(buf, num);
-+    return 1;
-+#elif defined(__EMSCRIPTEN__)
-+    return 1;
-+#else
-     const RAND_METHOD *meth = RAND_get_rand_method();
- 
-     if (meth != NULL && meth->pseudorand != NULL)
-         return meth->pseudorand(buf, num);
-     ERR_raise(ERR_LIB_RAND, RAND_R_FUNC_NOT_IMPLEMENTED);
-     return -1;
-+#endif
- }
- #endif
- 
- int RAND_status(void)
- {
-+#if defined(__EMSCRIPTEN__) || defined(__wasi__)
-+    return 1;
-+#else
-     EVP_RAND_CTX *rand;
- #ifndef OPENSSL_NO_DEPRECATED_3_0
-     const RAND_METHOD *meth = RAND_get_rand_method();
-@@ -401,6 +411,7 @@ int RAND_status(void)
-     if ((rand = RAND_get0_primary(NULL)) == NULL)
-         return 0;
-     return EVP_RAND_get_state(rand) == EVP_RAND_STATE_READY;
-+#endif
- }
- #else /* !FIPS_MODULE */
- 
-@@ -420,6 +431,12 @@ const RAND_METHOD *RAND_get_rand_method(void)
- int RAND_priv_bytes_ex(OSSL_LIB_CTX *ctx, unsigned char *buf, size_t num,
-     unsigned int strength)
- {
-+#if defined(__wasi__)
-+    arc4random_buf(buf, num);
-+    return 1;
-+#elif defined(__EMSCRIPTEN__)
-+    return 1;
-+#else
-     RAND_GLOBAL *dgbl;
-     EVP_RAND_CTX *rand;
- #if !defined(OPENSSL_NO_DEPRECATED_3_0) && !defined(FIPS_MODULE)
-@@ -451,6 +468,7 @@ int RAND_priv_bytes_ex(OSSL_LIB_CTX *ctx, unsigned char *buf, size_t num,
-         return EVP_RAND_generate(rand, buf, num, strength, 0, NULL, 0);
- 
-     return 0;
-+#endif
- }
- 
- int RAND_priv_bytes(unsigned char *buf, int num)
-diff --git a/ssl/ssl_cert.c b/ssl/ssl_cert.c
-index 3d21801..e026f8f 100644
--- a/ssl/ssl_cert.c
-+++ b/ssl/ssl_cert.c
-@@ -941,6 +941,7 @@ done:
-     return ret;
- }
- 
-+#ifndef OPENSSL_NO_POSIX_IO
- int SSL_add_dir_cert_subjects_to_stack(STACK_OF(X509_NAME) *stack,
-     const char *dir)
- {
-@@ -1016,6 +1017,7 @@ err:
- 
-     return ret;
- }
-+#endif
- 
- static int add_uris_recursive(STACK_OF(X509_NAME) *stack,
-     const char *uri, int depth)
@@ -375,15 +375,6 @@ set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/bin)
 # Prefer the -pthread flag on Linux.
 set(THREADS_PREFER_PTHREAD_FLAG ON)
 find_package(Threads REQUIRED)
-# It is absolutely promordial to enable on Emscripten
-# Not only this allows to use std::thread and std::jthread without exceptions
-# but it also fixes several issues related to MT operations.
-# ...and CMake doesn't include it by default even when we specify
-# that we prefer the pthread flag; why is that? I don't know.
-if (PLATFORM_EMSCRIPTEN)
-    add_compile_options($<$<COMPILE_LANGUAGE:C,CXX>:-pthread>)
-    add_link_options($<$<COMPILE_LANGUAGE:C,CXX>:-pthread>)
-endif()

 find_package(RenderDoc MODULE)

@@ -412,12 +403,7 @@ set(BUILD_TESTING OFF)
 set(ENABLE_TESTING OFF)

 # boost
-if (PLATFORM_EMSCRIPTEN)
-    set(BOOST_INCLUDE_LIBRARIES algorithm icl pool container heap headers filesystem crc variant)
-    set(BOOST_CONTAINER_HEADER_ONLY ON)
-else()
-    set(BOOST_INCLUDE_LIBRARIES algorithm icl pool container heap asio headers process filesystem crc variant)
-endif()
+set(BOOST_INCLUDE_LIBRARIES algorithm icl pool container heap asio headers process filesystem crc variant)

 AddJsonPackage(boost)

@@ -438,12 +424,10 @@ if (Boost_ADDED)

        target_compile_options(boost_heap INTERFACE $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-shadow>)
        target_compile_options(boost_icl INTERFACE $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-shadow>)
-        # May not exist (i.e emscripten)
-        if (TARGET boost_asio)
-            target_compile_options(boost_asio INTERFACE
-                $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-conversion>
-                $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-implicit-fallthrough>)
-        endif()
+        target_compile_options(boost_asio INTERFACE
+            $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-conversion>
+            $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-implicit-fallthrough>
+        )
    endif()
 endif()

@@ -108,7 +108,7 @@
        "find_args": "MODULE GLOBAL",
        "hash": "159ed94965018f2a371d45a3bfc1961e5fb1549e501ded70a6b4532d7fe99d0579c18b5195aff6e35f96f399b426cea2650ec9fb75ef80d4c9edeccb51f2e6c9",
        "options": [
-            "HTTPLIB_REQUIRE_OPENSSL OFF",
+            "HTTPLIB_REQUIRE_OPENSSL ON",
            "HTTPLIB_DISABLE_MACOSX_AUTOMATIC_ROOT_CERTIFICATES ON"
        ],
        "patches": [
@@ -190,8 +190,7 @@
        "min_version": "3.0.0",
        "package": "OpenSSL",
        "patches": [
-            "0001-add-bundled-cert.patch",
-            "0002-wasm-support.patch"
+            "0001-add-bundled-cert.patch"
        ],
        "repo": "openssl/openssl",
        "version": "openssl-3.6.2"
@@ -214,8 +213,7 @@
            "0001-cpmutil-compat.patch",
            "0002-use-ccache.patch",
            "0003-use-cmake-compiler-flags.patch",
-            "0004-use-shell-wrapper.patch",
-            "0005-wasm-support.patch"
+            "0004-use-shell-wrapper.patch"
        ],
        "repo": "jimmy-park/openssl-cmake",
        "version": "3.6.2"
@@ -12,7 +12,6 @@
 - [NetBSD](#netbsd)
 - [MSYS2](#msys2)
 - [RedoxOS](#redoxos)
- [WebAssembly](#webassembly)
 - [Windows](#windows)
  - [Windows 7, Windows 8 and Windows 8.1](#windows-7-windows-8-and-windows-81)
  - [Windows Vista and below](#windows-vista-and-below)
@@ -246,22 +245,6 @@ The package install may randomly hang at times, in which case it has to be resta

 When CMake invokes certain file syscalls - it may sometimes cause crashes or corruptions on the (kernel?) address space - so reboot the system if there is a "hang" in CMake.

-## WebAssembly
-
-**It doesn't run on a browser yet.**
-
-WebAssembly or "WASM" for short is a *mainly 32-bit* virtual "architecture" which we only bootstrap on 64-bit only. This means not only the program runs 2x slower than it would due to using JS BigInt, it also means we need to go out of our way to enable proper 64-bit support via `-sMEMORY64=1`, however once again, some Emscripten quirks force us to specify `-s MEMORY64` and `-sMEMORY64=1` at the same time: see the [CI build script](../.ci/wasm/build.sh).
-
-The WebAssembly target is very heavy on resources and requires at least 4 times the normal amount of resources that a native build would. Additionally, the only supported environment is Firefox at the moment, node.js and `wasmtime are not supported (PRs welcome!)
-
-If running under Firefox and you hit "out of memory" on dev console, close the entire tab, then open it back again, see [this issue](https://github.com/emscripten-core/emscripten/issues/8126).
-
-To run the binary (after building) you should be fine with `node ./eden-cli.js`. For obvious reasons no Qt frontend is available on WASM, support for Vulkan is done charily via [llvmpipe2wasm](https://github.com/Devsh-Graphics-Programming/llvmpipe2wasm).
-
-If you run into the error "acorn.js can't be found" check [this associated issue](https://github.com/emscripten-core/emscripten/issues/13368), the fix in short is `npm --global install acorn`. On FreeBSD you could run `npm` under root, or you could do the sane thing and do `sudo chown -R $USER /usr/local/lib/node_modules/ /usr/local/bin/` (remember to restore permissions afterwards!) unless you wish to run `npm` under root which is generally a bad idea.
-
-2026-06-09: As of writing, no Dynarmic-based JIT is possible on this target, full interpreted emulation is the only reasonable option. While there is some efforts on making a JIT like [here](https://github.com/wingo/wasm-jit) or [here](https://wingolog.org/archives/2022/08/18/just-in-time-code-generation-within-webassembly), the result is so latency expensive we're better off using an interpreter instead.
-
 ## Windows

 ### Windows 7, Windows 8 and Windows 8.1
@@ -359,14 +359,6 @@ pkgman install git cmake patch libfmt_devel nlohmann_json lz4_devel opus_devel b

 [Caveats](./Caveats.md#haikuos).

-</details>
-<details>
-<summary>WebAssembly</summary>
-
-Emscripten: The default installation should provide enough.
-
-[Caveats](./Caveats.md#wasm).
-
 </details>
 <details>
 <summary>RedoxOS</summary>
@@ -76,45 +76,44 @@ public:
    u64 ticks_left = 0;
    std::array<u8, 2048> memory{};

-    u8 MemoryRead8(u32 vaddr) override {
-        if (vaddr >= memory.size()) {
-            return 0;
+    u64 MemoryRead(u64 vaddr, size_t size) override {
+        switch (size) {
+        case sizeof(u64):
+            return MemoryRead(vaddr, sizeof(u32))
+                | MemoryRead(vaddr + sizeof(u32), sizeof(u32)) << 32;
+        case sizeof(u32):
+            return MemoryRead(vaddr, sizeof(u16))
+                | MemoryRead(vaddr + sizeof(u16), sizeof(u16)) << 16;
+        case sizeof(u16):
+            return MemoryRead(vaddr, sizeof(u8))
+                | MemoryRead(vaddr + sizeof(u8), sizeof(u8)) << 8;
+        case sizeof(u8):
+            return vaddr >= memory.size() ? 0 : memory[vaddr];
+        default:
+            std::abort();
        }
-        return memory[vaddr];
    }

-    u16 MemoryRead16(u32 vaddr) override {
-        return u16(MemoryRead8(vaddr)) | u16(MemoryRead8(vaddr + 1)) << 8;
-    }
-
-    u32 MemoryRead32(u32 vaddr) override {
-        return u32(MemoryRead16(vaddr)) | u32(MemoryRead16(vaddr + 2)) << 16;
-    }
-
-    u64 MemoryRead64(u32 vaddr) override {
-        return u64(MemoryRead32(vaddr)) | u64(MemoryRead32(vaddr + 4)) << 32;
-    }
-
-    void MemoryWrite8(u32 vaddr, u8 value) override {
-        if (vaddr >= memory.size()) {
-            return;
+    void MemoryWrite(Dynarmic::A32::VAddr vaddr, u64 value, size_t size) override {
+        switch (size) {
+        case sizeof(u64):
+            MemoryWrite(vaddr, u32(value), sizeof(u32));
+            MemoryWrite(vaddr + 4, u32(value >> 32), sizeof(u32));
+            break;
+        case sizeof(u32):
+            MemoryWrite(vaddr, u16(value), sizeof(u16));
+            MemoryWrite(vaddr + 2, u16(value >> 16), sizeof(u16));
+            break;
+        case sizeof(u16):
+            MemoryWrite(vaddr, u8(value), sizeof(u8));
+            MemoryWrite(vaddr + 1, u8(value >> 8), sizeof(u8));
+            break;
+        case sizeof(u8):
+            memory[vaddr] = value;
+            break;
+        default:
+            std::abort();
        }
-        memory[vaddr] = value;
-    }
-
-    void MemoryWrite16(u32 vaddr, u16 value) override {
-        MemoryWrite8(vaddr, u8(value));
-        MemoryWrite8(vaddr + 1, u8(value >> 8));
-    }
-
-    void MemoryWrite32(u32 vaddr, u32 value) override {
-        MemoryWrite16(vaddr, u16(value));
-        MemoryWrite16(vaddr + 2, u16(value >> 16));
-    }
-
-    void MemoryWrite64(u32 vaddr, u64 value) override {
-        MemoryWrite32(vaddr, u32(value));
-        MemoryWrite32(vaddr + 4, u32(value >> 32));
    }

    void CallSVC(u32 swi) override {
@@ -149,8 +148,8 @@ int main(int argc, char** argv) {
    env.ticks_left = 1;

    // Write some code to memory.
-    env.MemoryWrite16(0, 0x0088); // lsls r0, r1, #2
-    env.MemoryWrite16(2, 0xE7FE); // b +#0 (infinite loop)
+    env.MemoryWrite(0, 0x0088, 2); // lsls r0, r1, #2
+    env.MemoryWrite(2, 0xE7FE, 2); // b +#0 (infinite loop)

    // Setup registers.
    cpu.Regs()[0] = 1;
@@ -94,10 +94,6 @@ function(detect_architecture_symbols)
 endfunction()

 # arches here are put in a sane default order of importance
-# EXCEPT FOR WASM, which must be probed for FIRST, because some genius
-# decided to also allow the host architecture to be defined when building
-# for the emscripten target, absolutely lovely detail.
-#
 # notably, amd64, arm64, and riscv (in order) are BY FAR the most common
 # mips is pretty popular in embedded
 # ppc64 is pretty popular in supercomputing
@@ -105,11 +101,6 @@ endfunction()
 # ia64 exists
 # the rest exist, but are probably less popular than ia64

-detect_architecture_symbols(
-    ARCH wasm
-    SYMBOLS
-        "__EMSCRIPTEN__")
-
 detect_architecture_symbols(
    ARCH arm64
    SYMBOLS
@@ -212,6 +203,11 @@ detect_architecture_symbols(
        "__loongarch__"
        "__loongarch64")

+detect_architecture_symbols(
+    ARCH wasm
+    SYMBOLS
+        "__EMSCRIPTEN__")
+
 # "generic" target
 # If you have reached this point, you're on some as-of-yet unsupported architecture.
 # See the docs up above for known unsupported architectures
@@ -20,9 +20,6 @@ elseif (${CMAKE_SYSTEM_NAME} STREQUAL "managarm")
    set(MANAGARM ON)
 elseif (${CMAKE_SYSTEM_NAME} STREQUAL "Haiku")
    set(HAIKUOS ON)
-elseif (${CMAKE_SYSTEM_NAME} STREQUAL "Emscripten")
-    set(EMSCRIPTEN ON)
-    message(WARNING "${CMAKE_LIBRARY_ARCHITECTURE} support is highly experimental!!!")
 endif()

 # BSD
@@ -100,25 +97,3 @@ if (MINGW)
    set(CMAKE_EXE_LINKER_FLAGS_RELEASE
        "${CMAKE_EXE_LINKER_FLAGS_RELEASE} ${MINGW_FLAGS}")
 endif()
-
-if (PLATFORM_EMSCRIPTEN)
-    set(EMSCRIPTEN_C_FLAGS "-s MEMORY64 -m64 -pipe -sMEMORY64=1")
-    set(EMSCRIPTEN_LINK_FLAGS "-sMEMORY64=1 -m64 -Wl,-mwasm64 -sASYNCIFY=1")
-
-    # This prevents FFmpeg and other libraries from assuming it's the host's CPU
-    # Additionally some Emscripten installs may not be very good... generally
-    set(EMSCRIPTEN_SYSTEM_PROCESSOR wasm)
-    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EMSCRIPTEN_C_FLAGS}")
-    set(CMAKE_CXX_FLAGS "${CMAKE_C_FLAGS} ${EMSCRIPTEN_C_FLAGS}")
-    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${EMSCRIPTEN_LINK_FLAGS}")
-    set(CMAKE_C_LINK_FLAGS "${CMAKE_C_LINK_FLAGS} ${EMSCRIPTEN_LINK_FLAGS}")
-    set(CMAKE_CXX_LINK_FLAGS "${CMAKE_CXX_LINK_FLAGS} ${EMSCRIPTEN_LINK_FLAGS}")
-
-    unset(EMSCRIPTEN_C_FLAGS)
-    unset(EMSCRIPTEN_LINK_FLAGS)
-endif()
-
-# awesome
-if (PLATFORM_FREEBSD OR PLATFORM_DRAGONFLYBSD)
-    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -L${CMAKE_SYSROOT}/usr/local/lib")
-endif()
@@ -37,39 +37,26 @@ if (NOT YUZU_USE_BUNDLED_FFMPEG)
    elseif (NOT (CMAKE_HOST_SYSTEM_PROCESSOR MATCHES CMAKE_SYSTEM_PROCESSOR
    AND CMAKE_HOST_SYSTEM_NAME MATCHES CMAKE_SYSTEM_NAME))
        string(TOLOWER "${CMAKE_SYSTEM_NAME}" FFmpeg_SYSTEM_NAME)
-        # All of these platforms are supported by ffmpeg as native build OSes
-        # anything else (like Redox or Managarm or PS4) is NOT natively supported
-        # hence, assume the "unix like" is just "none" for the sake of OUR sanity.
-        # If YOUR OS/platform has actual native support:
-        # 1. fucking congrats
-        # 2. feel free to add it on the condition below
-        if (NOT (PLATFORM_NETBSD OR PLATFORM_SUN OR PLATFORM_FREEBSD
-        OR PLATFORM_OPENBSD OR PLATFORM_DRAGONFLYBSD OR PLATFORM_HAIKU
-        OR PLATFORM_LINUX OR PLATFORM_MSYS OR WIN32 OR ANDROID OR APPLE))
+        if (FFmpeg_SYSTEM_NAME STREQUAL "openorbis" OR FFmpeg_SYSTEM_NAME STREQUAL "managarm")
            set(FFmpeg_SYSTEM_NAME "none")
        endif()
        # TODO: Can we really do better? Auto-detection? Something clever?
        list(APPEND FFmpeg_CROSS_COMPILE_FLAGS
            --enable-cross-compile
            --arch="${CMAKE_SYSTEM_PROCESSOR}"
-            --target-os="${FFmpeg_SYSTEM_NAME}")
-        if (PLATFORM_EMSCRIPTEN)
-            # funniest trolling from emscripten, such a classic!
-            # maybe I should PR so they use CMAKE_SYSROOT... y'know?
-            list(APPEND FFmpeg_CROSS_COMPILE_FLAGS --sysroot="${EMSCRIPTEN_SYSROOT}")
-        else()
-            list(APPEND FFmpeg_CROSS_COMPILE_FLAGS --sysroot="${CMAKE_SYSROOT}")
-        endif()
+            --target-os="${FFmpeg_SYSTEM_NAME}"
+            --sysroot="${CMAKE_SYSROOT}"
+        )
        if (DEFINED FFmpeg_CROSS_PREFIX)
            list(APPEND FFmpeg_CROSS_COMPILE_FLAGS --cross-prefix="${FFmpeg_CROSS_PREFIX}")
        else()
-            message(WARNING "Please set FFmpeg_CROSS_PREFIX to your cross toolchain prefix, for example: ${CMAKE_STAGING_PREFIX}/bin/${CMAKE_SYSTEM_PROCESSOR}-${CMAKE_SYSTEM_NAME}")
+            message(WARNING "Please set FFmpeg_CROSS_PREFIX to your cross toolchain prefix, for example: \${CMAKE_STAGING_PREFIX}/bin/${CMAKE_SYSTEM_PROCESSOR}-${CMAKE_SYSTEM_NAME}-")
        endif()
        set(FFmpeg_IS_CROSS_COMPILING TRUE)
    endif()
 endif()

-if (OPENORBIS OR MANAGARM OR EMSCRIPTEN)
+if (OPENORBIS OR MANAGARM)
    # Doesn't support VA-API, don't go thru the embarrassment of trying to enable it
    list(APPEND FFmpeg_HWACCEL_FLAGS --disable-vaapi)
 elseif (ANDROID)
@@ -177,7 +164,8 @@ if (OPENORBIS)
        -lSceUserService
        -lSceSysmodule
        -lSceNet
-        -lSceLibcInternal)
+        -lSceLibcInternal
+    )
    list(APPEND FFmpeg_CROSS_COMPILE_FLAGS
        --disable-pthreads
        --extra-cflags=${CMAKE_SYSROOT}/usr/include
@@ -188,18 +176,8 @@ elseif (MANAGARM)
    # Required for proper stuff
    list(APPEND FFmpeg_CROSS_COMPILE_FLAGS
        --disable-pthreads
-        --extra-libs="${FFmpeg_CROSS_COMPILE_LIBS}")
-endif()
-
-# Usually used by Emscripten
-if (DEFINED CMAKE_AR)
-    list(APPEND FFmpeg_CROSS_COMPILE_FLAGS --ar=${CMAKE_AR})
-endif()
-if (DEFINED CMAKE_NM)
-    list(APPEND FFmpeg_CROSS_COMPILE_FLAGS --nm=${CMAKE_NM})
-endif()
-if (DEFINED CMAKE_RANLIB)
-    list(APPEND FFmpeg_CROSS_COMPILE_FLAGS --ranlib=${CMAKE_RANLIB})
+        --extra-libs="${FFmpeg_CROSS_COMPILE_LIBS}"
+    )
 endif()

 if (YUZU_USE_BUNDLED_FFMPEG)
@@ -229,7 +207,6 @@ else()
    # Build FFmpeg from externals
    message(STATUS "Using FFmpeg from externals")

-    set(FFmpeg_LD ${CMAKE_LINKER})
    if (CMAKE_SYSTEM_PROCESSOR MATCHES "(x86_64|amd64)")
        # FFmpeg has source that requires one of nasm or yasm to assemble it.
        # REQUIRED throws an error if not found here during configuration rather than during compilation.
@@ -238,12 +215,6 @@ else()
            message(FATAL_ERROR "One of either `nasm` or `yasm` not found but is required.")
        endif()
    endif()
-    if (CMAKE_SYSTEM_NAME STREQUAL "Emscripten")
-        # TODO: this is 100% redundant but we need it because CMAKE_LINKER can resolve to ld.lld
-        # which is NOT compatible
-        find_program(EMCC NAMES emcc REQUIRED)
-        set(FFmpeg_LD ${EMCC})
-    endif()

    find_program(AUTOCONF autoconf)
    if ("${AUTOCONF}" STREQUAL "AUTOCONF-NOTFOUND")
@@ -277,13 +248,7 @@ else()
            CACHE PATH "Paths to FFmpeg libraries" FORCE)
    endforeach()

-    # Some SDKs (especially wasm) require us, actually, WANT us to use their "emconfigure"
-    # otherwise they will cry a billion tears
-    if (PLATFORM_EMSCRIPTEN)
-        find_program(FFmpeg_CONFIGURE_WRAPPER emconfigure REQUIRED)
-    else()
-        find_program(FFmpeg_CONFIGURE_WRAPPER bash REQUIRED)
-    endif()
+    find_program(BASH_PROGRAM bash REQUIRED)

    # `configure` parameters builds only exactly what yuzu needs from FFmpeg
    # `--disable-vdpau` is needed to avoid linking issues
@@ -293,7 +258,7 @@ else()
        OUTPUT
            ${FFmpeg_MAKEFILE}
        COMMAND
-            ${FFmpeg_CONFIGURE_WRAPPER} ${FFmpeg_PREFIX}/configure
+            ${BASH_PROGRAM} ${FFmpeg_PREFIX}/configure
                --disable-avdevice
                --disable-avformat
                --disable-doc
@@ -302,10 +267,6 @@ else()
                --disable-ffprobe
                --disable-network
                --disable-swresample
-                --disable-autodetect
-                --disable-runtime-cpudetect
-                --disable-debug
-                --disable-programs
                --enable-decoder=h264
                --enable-decoder=vp8
                --enable-decoder=vp9
@@ -313,7 +274,7 @@ else()
                --enable-pic
                --cc=${FFmpeg_CC}
                --cxx=${FFmpeg_CXX}
-                --ld=${FFmpeg_LD}
+                --ld=${CMAKE_LINKER}
                --extra-cflags=${CMAKE_C_FLAGS}
                --extra-cxxflags=${CMAKE_CXX_FLAGS}
                --extra-ldflags=${CMAKE_C_LINK_FLAGS}
@@ -329,7 +290,11 @@ else()

    # Workaround for Ubuntu 18.04's older version of make not being able to call make as a child
    # with context of the jobserver. Also helps ninja users.
-    cmake_host_system_information(RESULT SYSTEM_THREADS QUERY NUMBER_OF_LOGICAL_CORES)
+    execute_process(
+        COMMAND
+            nproc
+        OUTPUT_VARIABLE
+            SYSTEM_THREADS)

    set(FFmpeg_BUILD_LIBRARIES ${FFmpeg_LIBRARIES})

@@ -337,8 +302,6 @@ else()
    if (LINUX OR ANDROID OR APPLE OR WIN32 OR FREEBSD)
        set(FFmpeg_MAKE_ARGS -j${SYSTEM_THREADS})
    else()
-        # No GNU make implies that this system may be highly non-GNU
-        find_program(MAKE make required)
        set(FFmpeg_MAKE_ARGS "")
    endif()

@@ -346,7 +309,7 @@ else()
        OUTPUT
            ${FFmpeg_BUILD_LIBRARIES}
        COMMAND
-            ${MAKE} ${FFmpeg_MAKE_ARGS}
+            gmake ${FFmpeg_MAKE_ARGS}
        WORKING_DIRECTORY
            ${FFmpeg_BUILD_DIR}
    )
@@ -14,9 +14,7 @@
 namespace Tz {

 namespace {
-#ifndef EINVAL
 #define EINVAL 22
-#endif

 static Rule gmtmem{};
 static Rule* const gmtptr = &gmtmem;
@@ -177,6 +177,7 @@ else()
        $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-invalid-offsetof>
        $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-unused-parameter>
        $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-missing-field-initializers>)
+
    if (CXX_CLANG OR CXX_ICC OR CXX_APPLE) # Clang, AppleClang, or Intel C++
        if (NOT MSVC)
            add_compile_options(
@@ -190,11 +191,7 @@ else()
            $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-nullability-completeness>)
    endif()

-    if (ARCHITECTURE_wasm)
-        # we are evil but fmt is even more evil
-        add_compile_options(
-            $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-shorten-64-to-32>)
-    elseif (ARCHITECTURE_x86_64)
+    if (ARCHITECTURE_x86_64)
        add_compile_options($<$<COMPILE_LANGUAGE:C,CXX>:-mcx16>)
        if (LINUX OR FREEBSD)
            add_compile_options($<$<COMPILE_LANGUAGE:C,CXX>:-mtls-dialect=gnu2>)
@@ -235,11 +235,7 @@ else()
    target_link_libraries(common PUBLIC Boost::headers)
 endif()
 target_link_libraries(common PRIVATE OpenSSL::SSL)
-target_link_libraries(common PUBLIC Boost::filesystem httplib::httplib nlohmann_json::nlohmann_json)
-if (NOT PLATFORM_EMSCRIPTEN)
-    # Emscripten is: "bring your own implementation", boost doesn't add upstream support sadly
-    target_link_libraries(common PRIVATE Boost::context)
-endif()
+target_link_libraries(common PUBLIC Boost::filesystem Boost::context httplib::httplib nlohmann_json::nlohmann_json)

 if (lz4_ADDED)
    target_include_directories(common PRIVATE ${lz4_SOURCE_DIR}/lib)
@@ -11,12 +11,7 @@
 #include "common/fiber.h"
 #include "common/virtual_buffer.h"

-#ifdef __EMSCRIPTEN__
-#include <emscripten.h>
-#include <emscripten/fiber.h>
-#else
 #include <boost/context/detail/fcontext.hpp>
-#endif

 namespace Common {

@@ -27,103 +22,36 @@ constexpr size_t DEFAULT_STACK_SIZE = 512 * 4096;
 #endif
 constexpr u32 CANARY_VALUE = 0xDEADBEEF;

-#ifdef __EMSCRIPTEN__
-struct Fiber::FiberImpl {
-    FiberImpl() {}
-
-    u32 canary_1 = CANARY_VALUE;
-    std::array<u8, DEFAULT_STACK_SIZE> stack{};
-    std::array<u8, DEFAULT_STACK_SIZE> astack{};
-    u32 canary_2 = CANARY_VALUE;
-
-    emscripten_fiber_t* context{nullptr};
-
-    std::mutex guard;
-    std::function<void()> entry_point;
-    std::shared_ptr<Fiber> previous_fiber;
-    bool is_thread_fiber = false;
-    bool released = false;
-};
-
-Fiber::Fiber(std::function<void()>&& entry_point_func) : impl{std::make_unique<FiberImpl>()} {
-    impl->entry_point = std::move(entry_point_func);
-    emscripten_fiber_init(impl->context, [](void *user_data) -> void {
-        auto* fiber = static_cast<Fiber*>(user_data);
-        ASSERT(fiber && fiber->impl && fiber->impl->previous_fiber && fiber->impl->previous_fiber->impl);
-        ASSERT(fiber->impl->canary_1 == CANARY_VALUE);
-        ASSERT(fiber->impl->canary_2 == CANARY_VALUE);
-        fiber->impl->previous_fiber->impl->context = fiber->impl->context;
-        fiber->impl->previous_fiber->impl->guard.unlock();
-        fiber->impl->previous_fiber.reset();
-        fiber->impl->entry_point();
-        UNREACHABLE();
-    }, impl.get(), impl->stack.data(), impl->stack.size(), impl->astack.data(), impl->astack.size());
-}
-
-Fiber::Fiber() : impl{std::make_unique<FiberImpl>()} {}
-
-Fiber::~Fiber() {
-    if (!impl->released) {
-        // Make sure the Fiber is not being used
-        const bool locked = impl->guard.try_lock();
-        ASSERT(locked && "Destroying a fiber that's still running");
-        if (locked) {
-            impl->guard.unlock();
-        }
-    }
-}
-
-void Fiber::Exit() {
-    ASSERT(impl->is_thread_fiber && "Exiting non main thread fiber");
-    if (impl->is_thread_fiber) {
-        impl->guard.unlock();
-        impl->released = true;
-    }
-}
-
-void Fiber::YieldTo(std::weak_ptr<Fiber> weak_from, Fiber& to) {
-    to.impl->guard.lock();
-    to.impl->previous_fiber = weak_from.lock();
-    emscripten_fiber_swap(to.impl->context, to.impl->previous_fiber->impl->context);
-    // "from" might no longer be valid if the thread was killed
-    if (auto from = weak_from.lock()) {
-        if (from->impl->previous_fiber == nullptr) {
-            ASSERT(false && "previous_fiber is nullptr!");
-        } else {
-            from->impl->previous_fiber->impl->guard.unlock();
-            from->impl->previous_fiber.reset();
-        }
-    }
-}
-
-std::shared_ptr<Fiber> Fiber::ThreadToFiber() {
-    std::shared_ptr<Fiber> fiber = std::shared_ptr<Fiber>{new Fiber()};
-    fiber->impl->guard.lock();
-    fiber->impl->is_thread_fiber = true;
-    return fiber;
-}
-#else
 struct Fiber::FiberImpl {
    FiberImpl() {}

    u32 canary_1 = CANARY_VALUE;
    std::array<u8, DEFAULT_STACK_SIZE> stack{};
+    std::array<u8, DEFAULT_STACK_SIZE> rewind_stack{};
    u32 canary_2 = CANARY_VALUE;

    boost::context::detail::fcontext_t context{};
+    boost::context::detail::fcontext_t rewind_context{};

    std::mutex guard;
    std::function<void()> entry_point;
+    std::function<void()> rewind_point;
    std::shared_ptr<Fiber> previous_fiber;

    u8* stack_limit = nullptr;
+    u8* rewind_stack_limit = nullptr;
    bool is_thread_fiber = false;
    bool released = false;
 };

+void Fiber::SetRewindPoint(std::function<void()>&& rewind_func) {
+    impl->rewind_point = std::move(rewind_func);
+}
+
 Fiber::Fiber(std::function<void()>&& entry_point_func) : impl{std::make_unique<FiberImpl>()} {
    impl->entry_point = std::move(entry_point_func);
    impl->stack_limit = impl->stack.data();
+    impl->rewind_stack_limit = impl->rewind_stack.data();
    u8* stack_base = impl->stack_limit + DEFAULT_STACK_SIZE;
    impl->context = boost::context::detail::make_fcontext(stack_base, impl->stack.size(), [](boost::context::detail::transfer_t transfer) -> void {
        auto* fiber = static_cast<Fiber*>(transfer.data);
@@ -144,7 +72,7 @@ Fiber::~Fiber() {
    if (!impl->released) {
        // Make sure the Fiber is not being used
        const bool locked = impl->guard.try_lock();
-        ASSERT(locked && "Destroying a fiber that's still running");
+        ASSERT_MSG(locked, "Destroying a fiber that's still running");
        if (locked) {
            impl->guard.unlock();
        }
@@ -152,7 +80,7 @@ Fiber::~Fiber() {
 }

 void Fiber::Exit() {
-    ASSERT(impl->is_thread_fiber && "Exiting non main thread fiber");
+    ASSERT_MSG(impl->is_thread_fiber, "Exiting non main thread fiber");
    if (impl->is_thread_fiber) {
        impl->guard.unlock();
        impl->released = true;
@@ -182,6 +110,5 @@ std::shared_ptr<Fiber> Fiber::ThreadToFiber() {
    fiber->impl->is_thread_fiber = true;
    return fiber;
 }
-#endif

 } // namespace Common
@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later

 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
@@ -45,6 +45,7 @@ public:
    /// Fiber 'from' must be the currently running fiber.
    static void YieldTo(std::weak_ptr<Fiber> weak_from, Fiber& to);
    [[nodiscard]] static std::shared_ptr<Fiber> ThreadToFiber();
+    void SetRewindPoint(std::function<void()>&& rewind_func);
    /// Only call from main thread's fiber
    void Exit();
 private:
@@ -136,11 +136,6 @@ public:
            eden_path = GetDataDirectory("XDG_DATA_HOME") / EDEN_DIR;
            eden_path_cache = GetDataDirectory("XDG_CACHE_HOME") / EDEN_DIR;
            eden_path_config = GetDataDirectory("XDG_CONFIG_HOME") / EDEN_DIR;
-#if defined(__EMSCRIPTEN__) || defined(__wasi__) || defined(__managarm__)
-            // folders MAY not exist in this distrobution/OS
-            CreateParentDir(GetDataDirectory("XDG_CONFIG_HOME"));
-            CreateParentDir(GetDataDirectory("XDG_CACHE_HOME"));
-#endif
        } else {
            eden_path_cache = eden_path / CACHE_DIR;
            eden_path_config = eden_path / CONFIG_DIR;
@@ -394,7 +394,7 @@ private:
    ankerl::unordered_dense::map<size_t, size_t> placeholder_host_pointers; ///< Placeholder backing offset
 };

-#elif defined(__OPENORBIS__) || defined(__managarm__) || defined(__wasi__) || defined(__EMSCRIPTEN__)
+#elif defined(__OPENORBIS__) || defined(__managarm__)
 // None of the luxuries of POSIX, all of the suffering
 // For managarm: see https://github.com/managarm/managarm/issues/1370
 #else // ^^^ Windows ^^^ vvv POSIX vvv
@@ -689,7 +689,7 @@ HostMemory::HostMemory(size_t backing_size_, size_t virtual_size_)
    : backing_size(backing_size_)
    , virtual_size(virtual_size_)
 {
-#if defined(__OPENORBIS__) || defined(__managarm__) || defined(__wasi__) || defined(__EMSCRIPTEN__)
+#if defined(__OPENORBIS__) || defined(__managarm__)
    LOG_WARNING(HW_Memory, "Platform doesn't support fastmem");
    fallback_buffer.emplace(backing_size);
    backing_base = fallback_buffer->data();
@@ -723,7 +723,7 @@ HostMemory::HostMemory(HostMemory&&) noexcept = default;
 HostMemory& HostMemory::operator=(HostMemory&&) noexcept = default;

 void HostMemory::Map(size_t virtual_offset, size_t host_offset, size_t length, MemoryPermission perms, bool separate_heap) {
-#if !(defined(__OPENORBIS__) || defined(__managarm__) || defined(__wasi__) || defined(__EMSCRIPTEN__))
+#if !(defined(__OPENORBIS__) || defined(__managarm__))
    ASSERT(virtual_offset % PageAlignment == 0);
    ASSERT(host_offset % PageAlignment == 0);
    ASSERT(length % PageAlignment == 0);
@@ -737,7 +737,7 @@ void HostMemory::Map(size_t virtual_offset, size_t host_offset, size_t length, M
 }

 void HostMemory::Unmap(size_t virtual_offset, size_t length, bool separate_heap) {
-#if !(defined(__OPENORBIS__) || defined(__managarm__) || defined(__wasi__) || defined(__EMSCRIPTEN__))
+#if !(defined(__OPENORBIS__) || defined(__managarm__))
    ASSERT(virtual_offset % PageAlignment == 0);
    ASSERT(length % PageAlignment == 0);
    ASSERT(virtual_offset + length <= virtual_size);
@@ -749,7 +749,7 @@ void HostMemory::Unmap(size_t virtual_offset, size_t length, bool separate_heap)
 }

 void HostMemory::Protect(size_t virtual_offset, size_t length, MemoryPermission perm) {
-#if !(defined(__OPENORBIS__) || defined(__managarm__) || defined(__wasi__) || defined(__EMSCRIPTEN__))
+#if !(defined(__OPENORBIS__) || defined(__managarm__))
    ASSERT(virtual_offset % PageAlignment == 0);
    ASSERT(length % PageAlignment == 0);
    ASSERT(virtual_offset + length <= virtual_size);
@@ -768,7 +768,7 @@ void HostMemory::ClearBackingRegion(size_t physical_offset, size_t length, u32 f
 }

 void HostMemory::EnableDirectMappedAddress() {
-#if !(defined(__OPENORBIS__) || defined(__managarm__) || defined(__wasi__) || defined(__EMSCRIPTEN__))
+#if !(defined(__OPENORBIS__) || defined(__managarm__))
    if (impl) {
        impl->EnableDirectMappedAddress();
        virtual_size += reinterpret_cast<uintptr_t>(virtual_base);
@@ -77,7 +77,7 @@ private:
    size_t backing_size{};
    size_t virtual_size{};

-#if !(defined(__OPENORBIS__) || defined(__managarm__) || defined(__wasi__) || defined(__EMSCRIPTEN__))
+#if !(defined(__OPENORBIS__) || defined(__managarm__))
    // Low level handler for the platform dependent memory routines
    class Impl;
    std::unique_ptr<Impl> impl;
@@ -490,8 +490,6 @@ void SetCurrentThreadPriority(ThreadPriority new_priority) {
        LOG_DEBUG(Common, "Could not set thread nice value to {}: {}", nice_value,
                  GetLastErrorMsg());
    }
-#elif defined(__EMSCRIPTEN__)
-    // TODO: set priority?
 #else
    const s32 max_prio = sched_get_priority_max(SCHED_OTHER);
    const s32 min_prio = sched_get_priority_min(SCHED_OTHER);
@@ -536,8 +534,6 @@ void SetCurrentThreadName(const char* name) {
    // See for reference
    // https://gitlab.freedesktop.org/mesa/mesa/-/blame/main/src/util/u_thread.c?ref_type=heads#L75
    (void)name;
-#elif defined(__EMSCRIPTEN__)
-    // TODO: set thread name?
 #else
    pthread_setname_np(pthread_self(), name);
 #endif
@@ -38,6 +38,10 @@ add_library(core STATIC
    debugger/debugger.cpp
    debugger/debugger.h
    debugger/debugger_interface.h
+    debugger/gdbstub.cpp
+    debugger/gdbstub.h
+    debugger/gdbstub_arch.cpp
+    debugger/gdbstub_arch.h
    device_memory.cpp
    device_memory.h
    device_memory_manager.h
@@ -1166,14 +1170,6 @@ add_library(core STATIC
    tools/freezer.h
    tools/renderdoc.cpp
    tools/renderdoc.h)
-if (NOT PLATFORM_EMSCRIPTEN)
-    # incompatible with wasm's async model
-    target_sources(core PRIVATE
-        debugger/gdbstub.cpp
-        debugger/gdbstub.h
-        debugger/gdbstub_arch.cpp
-        debugger/gdbstub_arch.h)
-endif()

 if (ENABLE_WIFI_SCAN)
    target_sources(core PRIVATE internal_network/wifi_scanner.cpp)
@@ -1217,10 +1213,7 @@ target_include_directories(core PRIVATE ${OPUS_INCLUDE_DIRS})
 target_link_libraries(core PUBLIC common PRIVATE audio_core hid_core network video_core nx_tzdb tz)

 if (BOOST_NO_HEADERS)
-    target_link_libraries(core PUBLIC Boost::container Boost::heap Boost::crc)
-    if (NOT PLATFORM_EMSCRIPTEN)
-        target_link_libraries(core PUBLIC Boost::asio Boost::process)
-    endif()
+    target_link_libraries(core PUBLIC Boost::container Boost::heap Boost::asio Boost::process Boost::crc)
 else()
    target_link_libraries(core PUBLIC Boost::headers)
 endif()
@@ -6,20 +6,19 @@

 #pragma once

-#ifndef __EMSCRIPTEN__
 #include <dynarmic/interface/halt_reason.h>
-#endif
+
 #include "core/arm/arm_interface.h"

 namespace Core {

-#ifndef __EMSCRIPTEN__
 constexpr Dynarmic::HaltReason StepThread = Dynarmic::HaltReason::Step;
 constexpr Dynarmic::HaltReason DataAbort = Dynarmic::HaltReason::MemoryAbort;
 constexpr Dynarmic::HaltReason BreakLoop = Dynarmic::HaltReason::UserDefined2;
 constexpr Dynarmic::HaltReason SupervisorCall = Dynarmic::HaltReason::UserDefined3;
 constexpr Dynarmic::HaltReason InstructionBreakpoint = Dynarmic::HaltReason::UserDefined4;
 constexpr Dynarmic::HaltReason PrefetchAbort = Dynarmic::HaltReason::UserDefined6;
+
 constexpr HaltReason TranslateHaltReason(Dynarmic::HaltReason hr) {
    static_assert(u64(HaltReason::StepThread) == u64(StepThread));
    static_assert(u64(HaltReason::DataAbort) == u64(DataAbort));
@@ -29,6 +28,5 @@ constexpr HaltReason TranslateHaltReason(Dynarmic::HaltReason hr) {
    static_assert(u64(HaltReason::PrefetchAbort) == u64(PrefetchAbort));
    return HaltReason(hr);
 }
-#endif

 } // namespace Core
@@ -22,21 +22,15 @@ DynarmicCallbacks32::DynarmicCallbacks32(ArmDynarmic32& parent, Kernel::KProcess
    , m_check_memory_access{m_debugger_enabled || !Settings::values.cpuopt_ignore_memory_aborts.GetValue()}
 {}

-u8 DynarmicCallbacks32::MemoryRead8(u32 vaddr) {
-    CheckMemoryAccess(vaddr, 1, Kernel::DebugWatchpointType::Read);
-    return m_memory.Read8(vaddr);
-}
-u16 DynarmicCallbacks32::MemoryRead16(u32 vaddr) {
-    CheckMemoryAccess(vaddr, 2, Kernel::DebugWatchpointType::Read);
-    return m_memory.Read16(vaddr);
-}
-u32 DynarmicCallbacks32::MemoryRead32(u32 vaddr) {
-    CheckMemoryAccess(vaddr, 4, Kernel::DebugWatchpointType::Read);
-    return m_memory.Read32(vaddr);
-}
-u64 DynarmicCallbacks32::MemoryRead64(u32 vaddr) {
-    CheckMemoryAccess(vaddr, 8, Kernel::DebugWatchpointType::Read);
-    return m_memory.Read64(vaddr);
+u64 DynarmicCallbacks32::MemoryRead(u32 vaddr, size_t size) {
+    CheckMemoryAccess(vaddr, size, Kernel::DebugWatchpointType::Read);
+    switch (size) {
+    case sizeof(u64): return m_memory.Read64(vaddr);
+    case sizeof(u32): return m_memory.Read32(vaddr);
+    case sizeof(u16): return m_memory.Read16(vaddr);
+    case sizeof(u8): return m_memory.Read8(vaddr);
+    default: UNREACHABLE();
+    }
 }

 std::optional<u32> DynarmicCallbacks32::MemoryReadCode(u32 vaddr) {
@@ -50,27 +44,17 @@ std::optional<u32> DynarmicCallbacks32::MemoryReadCode(u32 vaddr) {
    return cached_code_page.inst[(vaddr & Core::Memory::YUZU_PAGEMASK) / sizeof(u32)];
 }

-void DynarmicCallbacks32::MemoryWrite8(u32 vaddr, u8 value) {
-    if (CheckMemoryAccess(vaddr, 1, Kernel::DebugWatchpointType::Write)) {
-        m_memory.Write8(vaddr, value);
+void DynarmicCallbacks32::MemoryWrite(Dynarmic::A32::VAddr vaddr, u64 value, size_t size) {
+    if (CheckMemoryAccess(vaddr, size, Kernel::DebugWatchpointType::Write)) {
+        switch (size) {
+        case sizeof(u64): return m_memory.Write64(vaddr, value);
+        case sizeof(u32): return m_memory.Write32(vaddr, u32(value));
+        case sizeof(u16): return m_memory.Write16(vaddr, u16(value));
+        case sizeof(u8): return m_memory.Write8(vaddr, u8(value));
+        default: UNREACHABLE();
+        }
    }
 }
-void DynarmicCallbacks32::MemoryWrite16(u32 vaddr, u16 value) {
-    if (CheckMemoryAccess(vaddr, 2, Kernel::DebugWatchpointType::Write)) {
-        m_memory.Write16(vaddr, value);
-    }
-}
-void DynarmicCallbacks32::MemoryWrite32(u32 vaddr, u32 value) {
-    if (CheckMemoryAccess(vaddr, 4, Kernel::DebugWatchpointType::Write)) {
-        m_memory.Write32(vaddr, value);
-    }
-}
-void DynarmicCallbacks32::MemoryWrite64(u32 vaddr, u64 value) {
-    if (CheckMemoryAccess(vaddr, 8, Kernel::DebugWatchpointType::Write)) {
-        m_memory.Write64(vaddr, value);
-    }
-}
-
 bool DynarmicCallbacks32::MemoryWriteExclusive8(u32 vaddr, u8 value, u8 expected) {
    return CheckMemoryAccess(vaddr, 1, Kernel::DebugWatchpointType::Write) &&
            m_memory.WriteExclusive8(vaddr, value, expected);
@@ -30,18 +30,12 @@ class System;
 class DynarmicCallbacks32 : public Dynarmic::A32::UserCallbacks {
 public:
    explicit DynarmicCallbacks32(ArmDynarmic32& parent, Kernel::KProcess* process);
-    u8 MemoryRead8(u32 vaddr) override;
-    u16 MemoryRead16(u32 vaddr) override;
-    u32 MemoryRead32(u32 vaddr) override;
-    u64 MemoryRead64(u32 vaddr) override;
+    u64 MemoryRead(u32 vaddr, size_t size) override;
    std::optional<u32> MemoryReadCode(u32 vaddr) override;
    void InstructionSynchronizationBarrierRaised() override {
        last_code_addr = u64(-1); //reset back, force refetch
    }
-    void MemoryWrite8(u32 vaddr, u8 value) override;
-    void MemoryWrite16(u32 vaddr, u16 value) override;
-    void MemoryWrite32(u32 vaddr, u32 value) override;
-    void MemoryWrite64(u32 vaddr, u64 value) override;
+    void MemoryWrite(Dynarmic::A32::VAddr vaddr, u64 value, size_t size) override;
    bool MemoryWriteExclusive8(u32 vaddr, u8 value, u8 expected) override;
    bool MemoryWriteExclusive16(u32 vaddr, u16 value, u16 expected) override;
    bool MemoryWriteExclusive32(u32 vaddr, u32 value, u32 expected) override;
@@ -10,6 +10,7 @@
 #include "core/arm/dynarmic/dynarmic_exclusive_monitor.h"
 #include "core/core_timing.h"
 #include "core/hle/kernel/k_process.h"
+#include "dynarmic/interface/A64/config.h"

 namespace Core {

@@ -21,21 +22,15 @@ DynarmicCallbacks64::DynarmicCallbacks64(ArmDynarmic64& parent, Kernel::KProcess
    , m_check_memory_access{m_debugger_enabled || !Settings::values.cpuopt_ignore_memory_aborts.GetValue()}
 {}

-u8 DynarmicCallbacks64::MemoryRead8(u64 vaddr) {
-    CheckMemoryAccess(vaddr, 1, Kernel::DebugWatchpointType::Read);
-    return m_memory.Read8(vaddr);
-}
-u16 DynarmicCallbacks64::MemoryRead16(u64 vaddr) {
-    CheckMemoryAccess(vaddr, 2, Kernel::DebugWatchpointType::Read);
-    return m_memory.Read16(vaddr);
-}
-u32 DynarmicCallbacks64::MemoryRead32(u64 vaddr) {
-    CheckMemoryAccess(vaddr, 4, Kernel::DebugWatchpointType::Read);
-    return m_memory.Read32(vaddr);
-}
-u64 DynarmicCallbacks64::MemoryRead64(u64 vaddr) {
-    CheckMemoryAccess(vaddr, 8, Kernel::DebugWatchpointType::Read);
-    return m_memory.Read64(vaddr);
+u64 DynarmicCallbacks64::MemoryRead(u64 vaddr, size_t size) {
+    CheckMemoryAccess(vaddr, size, Kernel::DebugWatchpointType::Read);
+    switch (size) {
+    case sizeof(u64): return m_memory.Read64(vaddr);
+    case sizeof(u32): return m_memory.Read32(vaddr);
+    case sizeof(u16): return m_memory.Read16(vaddr);
+    case sizeof(u8): return m_memory.Read8(vaddr);
+    default: UNREACHABLE();
+    }
 }
 Dynarmic::A64::Vector DynarmicCallbacks64::MemoryRead128(u64 vaddr) {
    CheckMemoryAccess(vaddr, 16, Kernel::DebugWatchpointType::Read);
@@ -53,24 +48,15 @@ std::optional<u32> DynarmicCallbacks64::MemoryReadCode(u64 vaddr) {
    return cached_code_page.inst[(vaddr & Core::Memory::YUZU_PAGEMASK) / sizeof(u32)];
 }

-void DynarmicCallbacks64::MemoryWrite8(u64 vaddr, u8 value) {
-    if (CheckMemoryAccess(vaddr, 1, Kernel::DebugWatchpointType::Write)) {
-        m_memory.Write8(vaddr, value);
-    }
-}
-void DynarmicCallbacks64::MemoryWrite16(u64 vaddr, u16 value) {
-    if (CheckMemoryAccess(vaddr, 2, Kernel::DebugWatchpointType::Write)) {
-        m_memory.Write16(vaddr, value);
-    }
-}
-void DynarmicCallbacks64::MemoryWrite32(u64 vaddr, u32 value) {
-    if (CheckMemoryAccess(vaddr, 4, Kernel::DebugWatchpointType::Write)) {
-        m_memory.Write32(vaddr, value);
-    }
-}
-void DynarmicCallbacks64::MemoryWrite64(u64 vaddr, u64 value) {
-    if (CheckMemoryAccess(vaddr, 8, Kernel::DebugWatchpointType::Write)) {
-        m_memory.Write64(vaddr, value);
+void DynarmicCallbacks64::MemoryWrite(Dynarmic::A64::VAddr vaddr, u64 value, std::size_t size) {
+    if (CheckMemoryAccess(vaddr, size, Kernel::DebugWatchpointType::Write)) {
+        switch (size) {
+        case sizeof(u64): return m_memory.Write64(vaddr, u64(value));
+        case sizeof(u32): return m_memory.Write32(vaddr, u32(value));
+        case sizeof(u16): return m_memory.Write16(vaddr, u16(value));
+        case sizeof(u8): return m_memory.Write8(vaddr, u8(value));
+        default: UNREACHABLE();
+        }
    }
 }
 void DynarmicCallbacks64::MemoryWrite128(u64 vaddr, Dynarmic::A64::Vector value) {
@@ -16,6 +16,7 @@
 #include "common/hash.h"
 #include "core/arm/arm_interface.h"
 #include "core/arm/dynarmic/dynarmic_exclusive_monitor.h"
+#include "dynarmic/interface/A64/config.h"

 namespace Core::Memory {
 class Memory;
@@ -36,19 +37,13 @@ class DynarmicCallbacks64 : public Dynarmic::A64::UserCallbacks {
 public:
    explicit DynarmicCallbacks64(ArmDynarmic64& parent, Kernel::KProcess* process);

-    u8 MemoryRead8(u64 vaddr) override;
-    u16 MemoryRead16(u64 vaddr) override;
-    u32 MemoryRead32(u64 vaddr) override;
-    u64 MemoryRead64(u64 vaddr) override;
+    u64 MemoryRead(u64 vaddr, size_t size) override;
    Dynarmic::A64::Vector MemoryRead128(u64 vaddr) override;
    std::optional<u32> MemoryReadCode(u64 vaddr) override;
    void InstructionSynchronizationBarrierRaised() override {
        last_code_addr = u64(-1); //reset back, force refetch
    }
-    void MemoryWrite8(u64 vaddr, u8 value) override;
-    void MemoryWrite16(u64 vaddr, u16 value) override;
-    void MemoryWrite32(u64 vaddr, u32 value) override;
-    void MemoryWrite64(u64 vaddr, u64 value) override;
+    void MemoryWrite(Dynarmic::A64::VAddr vaddr, u64 value, std::size_t size) override;
    void MemoryWrite128(u64 vaddr, Dynarmic::A64::Vector value) override;
    bool MemoryWriteExclusive8(u64 vaddr, std::uint8_t value, std::uint8_t expected) override;
    bool MemoryWriteExclusive16(u64 vaddr, std::uint16_t value, std::uint16_t expected) override;
@@ -6,54 +6,30 @@

 #include <mutex>
 #include <utility>
-
-#if defined(__EMSCRIPTEN__) || defined(__wasi__)
-// TODO: gdb stub compat with emscripten?
-#else
 #include <boost/asio.hpp>
 #include <boost/version.hpp>
+
 #if BOOST_VERSION > 108400 && (!defined(_WINDOWS) && !defined(__ANDROID__)) || defined(YUZU_BOOST_v1)
 #define USE_BOOST_v1
 #endif
+
 #ifdef USE_BOOST_v1
 #include <boost/process/v1/async_pipe.hpp>
 #else
 #include <boost/process/async_pipe.hpp>
 #endif
-#endif

 #include "common/logging.h"
 #include "common/polyfill_thread.h"
 #include "common/thread.h"
 #include "core/core.h"
 #include "core/debugger/debugger.h"
-#if defined(__EMSCRIPTEN__) || defined(__wasi__)
-// TODO: gdbstub with emscripten?
-#else
 #include "core/debugger/debugger_interface.h"
 #include "core/debugger/gdbstub.h"
-#endif
 #include "core/hle/kernel/global_scheduler_context.h"
 #include "core/hle/kernel/k_process.h"
 #include "core/hle/kernel/k_scheduler.h"

-#if defined(__EMSCRIPTEN__) || defined(__wasi__)
-namespace Core {
-// Dummy
-class DebuggerImpl {
-    char pad;
-};
-Debugger::Debugger(Core::System& system, u16 port) {}
-Debugger::~Debugger() = default;
-bool Debugger::NotifyThreadStopped(Kernel::KThread* thread) {
-    return false;
-}
-bool Debugger::NotifyThreadWatchpoint(Kernel::KThread* thread, const Kernel::DebugWatchpoint& watch) {
-    return false;
-}
-void Debugger::NotifyShutdown() {}
-} // namespace Core
-#else
 template <typename Readable, typename Buffer, typename Callback>
 static void AsyncReceiveInto(Readable& r, Buffer& buffer, Callback&& c) {
    static_assert(std::is_trivial_v<Buffer>);
@@ -424,4 +400,3 @@ void Debugger::NotifyShutdown() {
 }

 } // namespace Core
-#endif
@@ -7,14 +7,8 @@
 #include <random>
 #include "common/scope_exit.h"
 #include "common/settings.h"
-
-#include "core/arm/exclusive_monitor.h"
-#ifndef __EMSCRIPTEN__
 #include "core/arm/dynarmic/arm_dynarmic.h"
 #include "core/arm/dynarmic/dynarmic_exclusive_monitor.h"
-#include "core/arm/dynarmic/arm_dynarmic_32.h"
-#include "core/arm/dynarmic/arm_dynarmic_64.h"
-#endif
 #include "core/core.h"
 #include "core/hle/kernel/k_process.h"
 #include "core/hle/kernel/k_scoped_resource_reservation.h"
@@ -24,6 +18,8 @@
 #include "core/hle/kernel/k_thread_queue.h"
 #include "core/hle/kernel/k_worker_task_manager.h"

+#include "core/arm/dynarmic/arm_dynarmic_32.h"
+#include "core/arm/dynarmic/arm_dynarmic_64.h"
 #ifdef HAS_NCE
 #include "core/arm/nce/arm_nce.h"
 #endif
@@ -1304,11 +1300,9 @@ void KProcess::LoadModule(KernelCore& kernel, CodeSet code_set, KProcessAddress
 }

 void KProcess::InitializeInterfaces(KernelCore& kernel) {
-#ifdef __EMSCRIPTEN__
-    ASSERT(false && "unimplemented");
-#else
    m_exclusive_monitor =
        Core::MakeExclusiveMonitor(this->GetMemory(), Core::Hardware::NUM_CPU_CORES);
+
 #ifdef HAS_NCE
    if (this->IsApplication() && Settings::IsNceEnabled()) {
        for (size_t i = 0; i < Core::Hardware::NUM_CPU_CORES; i++)
@@ -1328,7 +1322,6 @@ void KProcess::InitializeInterfaces(KernelCore& kernel) {
                static_cast<Core::DynarmicExclusiveMonitor&>(*m_exclusive_monitor), i);
        }
    }
-#endif
 }

 bool KProcess::InsertWatchpoint(KernelCore& kernel, KProcessAddress addr, u64 size, DebugWatchpointType type) {
@@ -71,17 +71,14 @@ public:
    void InstructionSynchronizationBarrierRaised() override {
        last_code_addr = u64(-1); //reset back, force refetch
    }
-    u8 MemoryRead8(u64 vaddr) override {
-        return ReadMemory<u8>(vaddr);
-    }
-    u16 MemoryRead16(u64 vaddr) override {
-        return ReadMemory<u16>(vaddr);
-    }
-    u32 MemoryRead32(u64 vaddr) override {
-        return ReadMemory<u32>(vaddr);
-    }
-    u64 MemoryRead64(u64 vaddr) override {
-        return ReadMemory<u64>(vaddr);
+    u64 MemoryRead(u64 vaddr, size_t size) override {
+        switch (size) {
+        case sizeof(u64): return ReadMemory<u64>(vaddr);
+        case sizeof(u32): return ReadMemory<u32>(vaddr);
+        case sizeof(u16): return ReadMemory<u16>(vaddr);
+        case sizeof(u8): return ReadMemory<u8>(vaddr);
+        default: UNREACHABLE();
+        }
    }
    u128 MemoryRead128(u64 vaddr) override {
        return ReadMemory<u128>(vaddr);
@@ -89,22 +86,19 @@ public:
    std::string MemoryReadCString(u64 vaddr) {
        std::string result{};
        u8 next;
-        while ((next = MemoryRead8(vaddr++)) != 0)
+        while ((next = u8(MemoryRead(vaddr++, sizeof(u8)))) != 0)
            result += char(next);
        return result;
    }

-    void MemoryWrite8(u64 vaddr, u8 value) override {
-        WriteMemory<u8>(vaddr, value);
-    }
-    void MemoryWrite16(u64 vaddr, u16 value) override {
-        WriteMemory<u16>(vaddr, value);
-    }
-    void MemoryWrite32(u64 vaddr, u32 value) override {
-        WriteMemory<u32>(vaddr, value);
-    }
-    void MemoryWrite64(u64 vaddr, u64 value) override {
-        WriteMemory<u64>(vaddr, value);
+    void MemoryWrite(u64 vaddr, u64 value, size_t size) override {
+        switch (size) {
+        case sizeof(u64): WriteMemory<u64>(vaddr, u64(value)); break;
+        case sizeof(u32): WriteMemory<u32>(vaddr, u32(value)); break;
+        case sizeof(u16): WriteMemory<u16>(vaddr, u16(value)); break;
+        case sizeof(u8): WriteMemory<u8>(vaddr, u8(value)); break;
+        default: UNREACHABLE();
+        }
    }
    void MemoryWrite128(u64 vaddr, u128 value) override {
        WriteMemory<u128>(vaddr, value);
@@ -193,14 +187,14 @@ public:
        // The loaded NRO file has ELF relocations that must be processed before it can run.
        // Normally this would be processed by RTLD, but in HLE context, we don't have
        // the linker available, so we have to do it ourselves.
-        const VAddr mod_offset{callbacks->MemoryRead32(4)};
-        if (callbacks->MemoryRead32(mod_offset) != Common::MakeMagic('M', 'O', 'D', '0'))
+        const VAddr mod_offset{callbacks->MemoryRead(4, sizeof(u32))};
+        if (callbacks->MemoryRead(mod_offset, sizeof(u32)) != Common::MakeMagic('M', 'O', 'D', '0'))
            return false;

        // For more info about dynamic entries, see the ELF ABI specification:
        // https://refspecs.linuxbase.org/elf/gabi4+/ch5.dynamic.html
        // https://refspecs.linuxbase.org/elf/gabi4+/ch4.reloc.html
-        VAddr dynamic_offset{mod_offset + callbacks->MemoryRead32(mod_offset + 4)};
+        VAddr dynamic_offset{mod_offset + callbacks->MemoryRead(mod_offset + 4, sizeof(u32))};
        VAddr rela_dyn = 0, relr_dyn = 0;
        size_t num_rela = 0, num_relr = 0;
        while (true) {
@@ -222,8 +216,8 @@ public:
        for (size_t i = 0; i < num_rela; i++) {
            const auto rela{callbacks->ReadMemory<Elf64_Rela>(rela_dyn + i * sizeof(Elf64_Rela))};
            if (Elf64RelType(rela.r_info) == ElfAArch64Relative) {
-                const VAddr contents{callbacks->MemoryRead64(rela.r_offset)};
-                callbacks->MemoryWrite64(rela.r_offset, contents + rela.r_addend);
+                const VAddr contents{callbacks->MemoryRead(rela.r_offset, sizeof(u64))};
+                callbacks->MemoryWrite(rela.r_offset, contents + rela.r_addend, sizeof(u64));
            }
        }

@@ -231,7 +225,7 @@ public:
        for (size_t i = 0; i < num_relr; i++) {
            const auto relr = callbacks->ReadMemory<Elf64_Relr>(relr_dyn + i * sizeof(Elf64_Relr));
            const auto incr = [&](VAddr where) {
-                callbacks->MemoryWrite64(where, callbacks->MemoryRead64(where) + relocbase);
+                callbacks->MemoryWrite(where, callbacks->MemoryRead(where, sizeof(u64)) + relocbase, sizeof(u64));
            };
            if ((relr & 1) == 0) {
                // where pointer
@@ -294,7 +288,7 @@ public:
        if (argument_stack.size() > 8) {
            const VAddr new_sp = Common::AlignDown(top_of_stack - (argument_stack.size() - 8) * sizeof(u64), STACK_ALIGN);
            for (size_t i = 8; i < argument_stack.size(); i++)
-                callbacks->MemoryWrite64(new_sp + (i - 8) * sizeof(u64), argument_stack[i]);
+                callbacks->MemoryWrite(new_sp + (i - 8) * sizeof(u64), argument_stack[i], sizeof(u64));
            jit->SetSP(new_sp);
        }
        // Reset the call state for the next invocation
@@ -385,17 +379,17 @@ void DynarmicCallbacks64::CallSVC(u32 swi) {

        if (dest < src) {
            for (size_t i = 0; i < n; i++)
-                MemoryWrite8(dest + i, MemoryRead8(src + i));
+                MemoryWrite(dest + i, u8(MemoryRead(src + i, sizeof(u8))), sizeof(u8));
        } else {
            for (size_t i = n; i > 0; i--)
-                MemoryWrite8(dest + i - 1, MemoryRead8(src + i - 1));
+                MemoryWrite(dest + i - 1, u8(MemoryRead(src + i - 1, sizeof(u8))), sizeof(u8));
        }
    } else if (pc == parent.helpers[size_t(HelperFn::Memset)]) {
        const VAddr dest{parent.jit->GetRegister(0)};
        const u64 c{parent.jit->GetRegister(1)};
        const size_t n{parent.jit->GetRegister(2)};
        for (size_t i = 0; i < n; i++)
-            MemoryWrite8(dest + i, u8(c));
+            MemoryWrite(dest + i, u8(c), sizeof(u8));
    } else if (pc == parent.helpers[size_t(HelperFn::Resolve)]) {
        // X0 contains a char* for a symbol to resolve
        const auto name{MemoryReadCString(parent.jit->GetRegister(0))};
@@ -422,7 +416,7 @@ void DynarmicCallbacks64::CallSVC(u32 swi) {
 }

 void DynarmicCallbacks64::ExceptionRaised(u64 pc, Dynarmic::A64::Exception exception) {
-    auto const inst = MemoryRead32(pc);
+    auto const inst = MemoryRead(pc, sizeof(u32));
    LOG_CRITICAL(Service_JIT, "{} PC @ {:08x}, data = {:08x}", exception, pc, inst);
    parent.jit->HaltExecution();
 }
@@ -86,22 +86,15 @@ Services::Services(std::shared_ptr<SM::ServiceManager>& sm, Core::System& system

    // BEGONE cold clones of lambdas, for I have merged you all into a SINGLE lambda instead of
    // spamming lambdas like it's some kind of lambda calculus class
-    std::vector<std::pair<std::string_view, void (*)(Core::System&)>> rt_services{
+    for (auto const& e : std::vector<std::pair<std::string_view, void (*)(Core::System&)>>{
        {"audio",      &Audio::LoopProcess},
        {"FS",         &FileSystem::LoopProcess},
        {"ldn",        &LDN::LoopProcess},
        {"nvservices", &Nvidia::LoopProcess},
        {"bsdsocket",  &Sockets::LoopProcess},
-    };
-#if defined(__EMSCRIPTEN__) || defined(__wasi__) || defined(__OPENORBIS__)
-    for (auto const& e : rt_services)
-        kernel.RunOnGuestCoreProcess(std::string(e.first), [&system, f = e.second] { f(system); });
-    kernel.RunOnGuestCoreProcess("vi", [&, token] { VI::LoopProcess(system, token); });
-#else
-    for (auto const& e : rt_services)
+    })
        kernel.RunOnHostCoreProcess(std::string(e.first), [&system, f = e.second] { f(system); }).detach();
-    kernel.RunOnHostCoreProcess("vi", [&, token] { VI::LoopProcess(system, token); }).detach();
-#endif
+    kernel.RunOnHostCoreProcess("vi",         [&, token] { VI::LoopProcess(system, token); }).detach();
    // Avoid cold clones of lambdas -- succintly
    for (auto const& e : std::vector<std::pair<std::string_view, void (*)(Core::System&)>>{
        {"sm",         &SM::LoopProcess},
@@ -125,10 +118,7 @@ Services::Services(std::shared_ptr<SM::ServiceManager>& sm, Core::System& system
        {"glue",       &Glue::LoopProcess},
        {"grc",        &GRC::LoopProcess},
        {"hid",        &HID::LoopProcess},
-// Must match with src/core/CMakeLists.txt for target_source of jit.cpp
-#if defined(ARCHITECTURE_x86_64) || defined(ARCHITECTURE_arm64) || defined(ARCHITECTURE_riscv64) || defined(ARCHITECTURE_loongarch64)
        {"jit",        &JIT::LoopProcess},
-#endif
        {"lbl",        &LBL::LoopProcess},
        {"Loader",     &LDR::LoopProcess},
        {"LogManager.Prod", &LM::LoopProcess},
@@ -33,18 +33,10 @@ u64 MemoryReadWidth(Core::Memory::Memory& memory, u32 width, VAddr addr) {

 void MemoryWriteWidth(Core::Memory::Memory& memory, u32 width, VAddr addr, u64 value) {
    switch (width) {
-    case 1:
-        memory.Write8(addr, static_cast<u8>(value));
-        break;
-    case 2:
-        memory.Write16(addr, static_cast<u16>(value));
-        break;
-    case 4:
-        memory.Write32(addr, static_cast<u32>(value));
-        break;
-    case 8:
-        memory.Write64(addr, value);
-        break;
+    case sizeof(u64): return memory.Write64(addr, value);
+    case sizeof(u32): return memory.Write32(addr, u32(value));
+    case sizeof(u16): return memory.Write16(addr, u16(value));
+    case sizeof(u8): return memory.Write8(addr, u8(value));
    default:
        UNREACHABLE();
    }
@@ -82,7 +82,7 @@ static void* EmitExclusiveReadCallTrampoline(oaknut::CodeGenerator& code, const

    auto fn = [](const A32::UserConfig& conf, A32::VAddr vaddr) -> T {
        return conf.global_monitor->ReadAndMark<T>(conf.processor_id, vaddr, [&]() -> T {
-            return (conf.callbacks->*callback)(vaddr);
+            return (conf.callbacks->*callback)(vaddr, sizeof(T));
        });
    };

@@ -136,12 +136,9 @@ static void* EmitExclusiveWriteCallTrampoline(oaknut::CodeGenerator& code, const
    oaknut::Label l_addr, l_this;

    auto fn = [](const A32::UserConfig& conf, A32::VAddr vaddr, T value) -> u32 {
-        return conf.global_monitor->DoExclusiveOperation<T>(conf.processor_id, vaddr,
-                                                            [&](T expected) -> bool {
-                                                                return (conf.callbacks->*callback)(vaddr, value, expected);
-                                                            })
-                 ? 0
-                 : 1;
+        return conf.global_monitor->DoExclusiveOperation<T>(conf.processor_id, vaddr, [&](T expected) -> bool {
+            return (conf.callbacks->*callback)(vaddr, value, expected);
+        }) ? 0 : 1;
    };

    void* target = code.xptr<void*>();
@@ -179,26 +176,14 @@ void A32AddressSpace::EmitPrelude() {

    UnprotectCodeMemory();

-    prelude_info.read_memory_8 = EmitCallTrampoline<&A32::UserCallbacks::MemoryRead8>(code, conf.callbacks);
-    prelude_info.read_memory_16 = EmitCallTrampoline<&A32::UserCallbacks::MemoryRead16>(code, conf.callbacks);
-    prelude_info.read_memory_32 = EmitCallTrampoline<&A32::UserCallbacks::MemoryRead32>(code, conf.callbacks);
-    prelude_info.read_memory_64 = EmitCallTrampoline<&A32::UserCallbacks::MemoryRead64>(code, conf.callbacks);
-    prelude_info.wrapped_read_memory_8 = EmitWrappedReadCallTrampoline<&A32::UserCallbacks::MemoryRead8>(code, conf.callbacks);
-    prelude_info.wrapped_read_memory_16 = EmitWrappedReadCallTrampoline<&A32::UserCallbacks::MemoryRead16>(code, conf.callbacks);
-    prelude_info.wrapped_read_memory_32 = EmitWrappedReadCallTrampoline<&A32::UserCallbacks::MemoryRead32>(code, conf.callbacks);
-    prelude_info.wrapped_read_memory_64 = EmitWrappedReadCallTrampoline<&A32::UserCallbacks::MemoryRead64>(code, conf.callbacks);
-    prelude_info.exclusive_read_memory_8 = EmitExclusiveReadCallTrampoline<&A32::UserCallbacks::MemoryRead8, u8>(code, conf);
-    prelude_info.exclusive_read_memory_16 = EmitExclusiveReadCallTrampoline<&A32::UserCallbacks::MemoryRead16, u16>(code, conf);
-    prelude_info.exclusive_read_memory_32 = EmitExclusiveReadCallTrampoline<&A32::UserCallbacks::MemoryRead32, u32>(code, conf);
-    prelude_info.exclusive_read_memory_64 = EmitExclusiveReadCallTrampoline<&A32::UserCallbacks::MemoryRead64, u64>(code, conf);
-    prelude_info.write_memory_8 = EmitCallTrampoline<&A32::UserCallbacks::MemoryWrite8>(code, conf.callbacks);
-    prelude_info.write_memory_16 = EmitCallTrampoline<&A32::UserCallbacks::MemoryWrite16>(code, conf.callbacks);
-    prelude_info.write_memory_32 = EmitCallTrampoline<&A32::UserCallbacks::MemoryWrite32>(code, conf.callbacks);
-    prelude_info.write_memory_64 = EmitCallTrampoline<&A32::UserCallbacks::MemoryWrite64>(code, conf.callbacks);
-    prelude_info.wrapped_write_memory_8 = EmitWrappedWriteCallTrampoline<&A32::UserCallbacks::MemoryWrite8>(code, conf.callbacks);
-    prelude_info.wrapped_write_memory_16 = EmitWrappedWriteCallTrampoline<&A32::UserCallbacks::MemoryWrite16>(code, conf.callbacks);
-    prelude_info.wrapped_write_memory_32 = EmitWrappedWriteCallTrampoline<&A32::UserCallbacks::MemoryWrite32>(code, conf.callbacks);
-    prelude_info.wrapped_write_memory_64 = EmitWrappedWriteCallTrampoline<&A32::UserCallbacks::MemoryWrite64>(code, conf.callbacks);
+    prelude_info.read_memory = EmitCallTrampoline<&A32::UserCallbacks::MemoryRead>(code, conf.callbacks);
+    prelude_info.wrapped_read_memory = EmitWrappedReadCallTrampoline<&A32::UserCallbacks::MemoryRead>(code, conf.callbacks);
+    prelude_info.exclusive_read_memory_8 = EmitExclusiveReadCallTrampoline<&A32::UserCallbacks::MemoryRead, u8>(code, conf);
+    prelude_info.exclusive_read_memory_16 = EmitExclusiveReadCallTrampoline<&A32::UserCallbacks::MemoryRead, u16>(code, conf);
+    prelude_info.exclusive_read_memory_32 = EmitExclusiveReadCallTrampoline<&A32::UserCallbacks::MemoryRead, u32>(code, conf);
+    prelude_info.exclusive_read_memory_64 = EmitExclusiveReadCallTrampoline<&A32::UserCallbacks::MemoryRead, u64>(code, conf);
+    prelude_info.write_memory = EmitCallTrampoline<&A32::UserCallbacks::MemoryWrite>(code, conf.callbacks);
+    prelude_info.wrapped_write_memory = EmitWrappedWriteCallTrampoline<&A32::UserCallbacks::MemoryWrite>(code, conf.callbacks);
    prelude_info.exclusive_write_memory_8 = EmitExclusiveWriteCallTrampoline<&A32::UserCallbacks::MemoryWriteExclusive8, u8>(code, conf);
    prelude_info.exclusive_write_memory_16 = EmitExclusiveWriteCallTrampoline<&A32::UserCallbacks::MemoryWriteExclusive16, u16>(code, conf);
    prelude_info.exclusive_write_memory_32 = EmitExclusiveWriteCallTrampoline<&A32::UserCallbacks::MemoryWriteExclusive32, u32>(code, conf);
@@ -81,7 +81,7 @@ static void* EmitExclusiveReadCallTrampoline(oaknut::CodeGenerator& code, const

    auto fn = [](const A64::UserConfig& conf, A64::VAddr vaddr) -> T {
        return conf.global_monitor->ReadAndMark<T>(conf.processor_id, vaddr, [&]() -> T {
-            return (conf.callbacks->*callback)(vaddr);
+            return (conf.callbacks->*callback)(vaddr, sizeof(T));
        });
    };

@@ -133,14 +133,10 @@ static void* EmitExclusiveWriteCallTrampoline(oaknut::CodeGenerator& code, const
    using namespace oaknut::util;

    oaknut::Label l_addr, l_this;
-
    auto fn = [](const A64::UserConfig& conf, A64::VAddr vaddr, T value) -> u32 {
-        return conf.global_monitor->DoExclusiveOperation<T>(conf.processor_id, vaddr,
-                                                            [&](T expected) -> bool {
-                                                                return (conf.callbacks->*callback)(vaddr, value, expected);
-                                                            })
-                 ? 0
-                 : 1;
+        return conf.global_monitor->DoExclusiveOperation<T>(conf.processor_id, vaddr, [&](T expected) -> bool {
+            return (conf.callbacks->*callback)(vaddr, value, expected);
+        }) ? 0 : 1;
    };

    void* target = code.xptr<void*>();
@@ -346,30 +342,18 @@ void A64AddressSpace::EmitPrelude() {

    UnprotectCodeMemory();

-    prelude_info.read_memory_8 = EmitCallTrampoline<&A64::UserCallbacks::MemoryRead8>(code, conf.callbacks);
-    prelude_info.read_memory_16 = EmitCallTrampoline<&A64::UserCallbacks::MemoryRead16>(code, conf.callbacks);
-    prelude_info.read_memory_32 = EmitCallTrampoline<&A64::UserCallbacks::MemoryRead32>(code, conf.callbacks);
-    prelude_info.read_memory_64 = EmitCallTrampoline<&A64::UserCallbacks::MemoryRead64>(code, conf.callbacks);
+    prelude_info.read_memory = EmitCallTrampoline<&A64::UserCallbacks::MemoryRead>(code, conf.callbacks);
    prelude_info.read_memory_128 = EmitRead128CallTrampoline(code, conf.callbacks);
-    prelude_info.wrapped_read_memory_8 = EmitWrappedReadCallTrampoline<&A64::UserCallbacks::MemoryRead8>(code, conf.callbacks);
-    prelude_info.wrapped_read_memory_16 = EmitWrappedReadCallTrampoline<&A64::UserCallbacks::MemoryRead16>(code, conf.callbacks);
-    prelude_info.wrapped_read_memory_32 = EmitWrappedReadCallTrampoline<&A64::UserCallbacks::MemoryRead32>(code, conf.callbacks);
-    prelude_info.wrapped_read_memory_64 = EmitWrappedReadCallTrampoline<&A64::UserCallbacks::MemoryRead64>(code, conf.callbacks);
+    prelude_info.wrapped_read_memory = EmitWrappedReadCallTrampoline<&A64::UserCallbacks::MemoryRead>(code, conf.callbacks);
    prelude_info.wrapped_read_memory_128 = EmitWrappedRead128CallTrampoline(code, conf.callbacks);
-    prelude_info.exclusive_read_memory_8 = EmitExclusiveReadCallTrampoline<&A64::UserCallbacks::MemoryRead8, u8>(code, conf);
-    prelude_info.exclusive_read_memory_16 = EmitExclusiveReadCallTrampoline<&A64::UserCallbacks::MemoryRead16, u16>(code, conf);
-    prelude_info.exclusive_read_memory_32 = EmitExclusiveReadCallTrampoline<&A64::UserCallbacks::MemoryRead32, u32>(code, conf);
-    prelude_info.exclusive_read_memory_64 = EmitExclusiveReadCallTrampoline<&A64::UserCallbacks::MemoryRead64, u64>(code, conf);
+    prelude_info.exclusive_read_memory_8 = EmitExclusiveReadCallTrampoline<&A64::UserCallbacks::MemoryRead, u8>(code, conf);
+    prelude_info.exclusive_read_memory_16 = EmitExclusiveReadCallTrampoline<&A64::UserCallbacks::MemoryRead, u16>(code, conf);
+    prelude_info.exclusive_read_memory_32 = EmitExclusiveReadCallTrampoline<&A64::UserCallbacks::MemoryRead, u32>(code, conf);
+    prelude_info.exclusive_read_memory_64 = EmitExclusiveReadCallTrampoline<&A64::UserCallbacks::MemoryRead, u64>(code, conf);
    prelude_info.exclusive_read_memory_128 = EmitExclusiveRead128CallTrampoline(code, conf);
-    prelude_info.write_memory_8 = EmitCallTrampoline<&A64::UserCallbacks::MemoryWrite8>(code, conf.callbacks);
-    prelude_info.write_memory_16 = EmitCallTrampoline<&A64::UserCallbacks::MemoryWrite16>(code, conf.callbacks);
-    prelude_info.write_memory_32 = EmitCallTrampoline<&A64::UserCallbacks::MemoryWrite32>(code, conf.callbacks);
-    prelude_info.write_memory_64 = EmitCallTrampoline<&A64::UserCallbacks::MemoryWrite64>(code, conf.callbacks);
+    prelude_info.write_memory = EmitCallTrampoline<&A64::UserCallbacks::MemoryWrite>(code, conf.callbacks);
    prelude_info.write_memory_128 = EmitWrite128CallTrampoline(code, conf.callbacks);
-    prelude_info.wrapped_write_memory_8 = EmitWrappedWriteCallTrampoline<&A64::UserCallbacks::MemoryWrite8>(code, conf.callbacks);
-    prelude_info.wrapped_write_memory_16 = EmitWrappedWriteCallTrampoline<&A64::UserCallbacks::MemoryWrite16>(code, conf.callbacks);
-    prelude_info.wrapped_write_memory_32 = EmitWrappedWriteCallTrampoline<&A64::UserCallbacks::MemoryWrite32>(code, conf.callbacks);
-    prelude_info.wrapped_write_memory_64 = EmitWrappedWriteCallTrampoline<&A64::UserCallbacks::MemoryWrite64>(code, conf.callbacks);
+    prelude_info.wrapped_write_memory = EmitWrappedWriteCallTrampoline<&A64::UserCallbacks::MemoryWrite>(code, conf.callbacks);
    prelude_info.wrapped_write_memory_128 = EmitWrappedWrite128CallTrampoline(code, conf.callbacks);
    prelude_info.exclusive_write_memory_8 = EmitExclusiveWriteCallTrampoline<&A64::UserCallbacks::MemoryWriteExclusive8, u8>(code, conf);
    prelude_info.exclusive_write_memory_16 = EmitExclusiveWriteCallTrampoline<&A64::UserCallbacks::MemoryWriteExclusive16, u16>(code, conf);
@@ -145,32 +145,42 @@ void AddressSpace::Link(EmittedBlockInfo& block_info) {
        case LinkTarget::ReturnFromRunCode:
            c.B(prelude_info.return_from_run_code);
            break;
+        // { this, vaddr, size }
        case LinkTarget::ReadMemory8:
-            c.BL(prelude_info.read_memory_8);
+            c.LDR(X2, 1);
+            c.BL(prelude_info.read_memory);
            break;
        case LinkTarget::ReadMemory16:
-            c.BL(prelude_info.read_memory_16);
+            c.LDR(X2, 2);
+            c.BL(prelude_info.read_memory);
            break;
        case LinkTarget::ReadMemory32:
-            c.BL(prelude_info.read_memory_32);
+            c.LDR(X2, 4);
+            c.BL(prelude_info.read_memory);
            break;
        case LinkTarget::ReadMemory64:
-            c.BL(prelude_info.read_memory_64);
+            c.LDR(X2, 8);
+            c.BL(prelude_info.read_memory);
            break;
        case LinkTarget::ReadMemory128:
            c.BL(prelude_info.read_memory_128);
            break;
+        // { this, vaddr, size }
        case LinkTarget::WrappedReadMemory8:
-            c.BL(prelude_info.wrapped_read_memory_8);
+            c.LDR(X2, 1);
+            c.BL(prelude_info.wrapped_read_memory);
            break;
        case LinkTarget::WrappedReadMemory16:
-            c.BL(prelude_info.wrapped_read_memory_16);
+            c.LDR(X2, 2);
+            c.BL(prelude_info.wrapped_read_memory);
            break;
        case LinkTarget::WrappedReadMemory32:
-            c.BL(prelude_info.wrapped_read_memory_32);
+            c.LDR(X2, 4);
+            c.BL(prelude_info.wrapped_read_memory);
            break;
        case LinkTarget::WrappedReadMemory64:
-            c.BL(prelude_info.wrapped_read_memory_64);
+            c.LDR(X2, 8);
+            c.BL(prelude_info.wrapped_read_memory);
            break;
        case LinkTarget::WrappedReadMemory128:
            c.BL(prelude_info.wrapped_read_memory_128);
@@ -190,32 +200,41 @@ void AddressSpace::Link(EmittedBlockInfo& block_info) {
        case LinkTarget::ExclusiveReadMemory128:
            c.BL(prelude_info.exclusive_read_memory_128);
            break;
+        // { this, vaddr, value, size }
        case LinkTarget::WriteMemory8:
-            c.BL(prelude_info.write_memory_8);
+            c.LDR(X3, 1);
+            c.BL(prelude_info.write_memory);
            break;
        case LinkTarget::WriteMemory16:
-            c.BL(prelude_info.write_memory_16);
+            c.LDR(X3, 2);
+            c.BL(prelude_info.write_memory);
            break;
        case LinkTarget::WriteMemory32:
-            c.BL(prelude_info.write_memory_32);
+            c.LDR(X3, 4);
+            c.BL(prelude_info.write_memory);
            break;
        case LinkTarget::WriteMemory64:
-            c.BL(prelude_info.write_memory_64);
+            c.LDR(X3, 8);
+            c.BL(prelude_info.write_memory);
            break;
        case LinkTarget::WriteMemory128:
            c.BL(prelude_info.write_memory_128);
            break;
        case LinkTarget::WrappedWriteMemory8:
-            c.BL(prelude_info.wrapped_write_memory_8);
+            c.LDR(X3, 1);
+            c.BL(prelude_info.wrapped_write_memory);
            break;
        case LinkTarget::WrappedWriteMemory16:
-            c.BL(prelude_info.wrapped_write_memory_16);
+            c.LDR(X3, 2);
+            c.BL(prelude_info.wrapped_write_memory);
            break;
        case LinkTarget::WrappedWriteMemory32:
-            c.BL(prelude_info.wrapped_write_memory_32);
+            c.LDR(X3, 4);
+            c.BL(prelude_info.wrapped_write_memory);
            break;
        case LinkTarget::WrappedWriteMemory64:
-            c.BL(prelude_info.wrapped_write_memory_64);
+            c.LDR(X3, 8);
+            c.BL(prelude_info.wrapped_write_memory);
            break;
        case LinkTarget::WrappedWriteMemory128:
            c.BL(prelude_info.wrapped_write_memory_128);
@@ -92,30 +92,18 @@ protected:
        void* return_to_dispatcher;
        void* return_from_run_code;

-        void* read_memory_8;
-        void* read_memory_16;
-        void* read_memory_32;
-        void* read_memory_64;
+        void* read_memory;
        void* read_memory_128;
-        void* wrapped_read_memory_8;
-        void* wrapped_read_memory_16;
-        void* wrapped_read_memory_32;
-        void* wrapped_read_memory_64;
+        void* wrapped_read_memory;
        void* wrapped_read_memory_128;
        void* exclusive_read_memory_8;
        void* exclusive_read_memory_16;
        void* exclusive_read_memory_32;
        void* exclusive_read_memory_64;
        void* exclusive_read_memory_128;
-        void* write_memory_8;
-        void* write_memory_16;
-        void* write_memory_32;
-        void* write_memory_64;
+        void* write_memory;
        void* write_memory_128;
-        void* wrapped_write_memory_8;
-        void* wrapped_write_memory_16;
-        void* wrapped_write_memory_32;
-        void* wrapped_write_memory_64;
+        void* wrapped_write_memory;
        void* wrapped_write_memory_128;
        void* exclusive_write_memory_8;
        void* exclusive_write_memory_16;
@@ -31,16 +31,16 @@ using namespace Xbyak::util;
 void A32EmitX64::GenFastmemFallbacks() {
    const std::initializer_list<int> idxes{0, 1, 2, 3, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14};
    const std::array<std::pair<size_t, ArgCallback>, 4> read_callbacks{{
-        {8, Devirtualize<&A32::UserCallbacks::MemoryRead8>(conf.callbacks)},
-        {16, Devirtualize<&A32::UserCallbacks::MemoryRead16>(conf.callbacks)},
-        {32, Devirtualize<&A32::UserCallbacks::MemoryRead32>(conf.callbacks)},
-        {64, Devirtualize<&A32::UserCallbacks::MemoryRead64>(conf.callbacks)},
+        {8, Devirtualize<&A32::UserCallbacks::MemoryRead>(conf.callbacks)},
+        {16, Devirtualize<&A32::UserCallbacks::MemoryRead>(conf.callbacks)},
+        {32, Devirtualize<&A32::UserCallbacks::MemoryRead>(conf.callbacks)},
+        {64, Devirtualize<&A32::UserCallbacks::MemoryRead>(conf.callbacks)},
    }};
    const std::array<std::pair<size_t, ArgCallback>, 4> write_callbacks{{
-        {8, Devirtualize<&A32::UserCallbacks::MemoryWrite8>(conf.callbacks)},
-        {16, Devirtualize<&A32::UserCallbacks::MemoryWrite16>(conf.callbacks)},
-        {32, Devirtualize<&A32::UserCallbacks::MemoryWrite32>(conf.callbacks)},
-        {64, Devirtualize<&A32::UserCallbacks::MemoryWrite64>(conf.callbacks)},
+        {8, Devirtualize<&A32::UserCallbacks::MemoryWrite>(conf.callbacks)},
+        {16, Devirtualize<&A32::UserCallbacks::MemoryWrite>(conf.callbacks)},
+        {32, Devirtualize<&A32::UserCallbacks::MemoryWrite>(conf.callbacks)},
+        {64, Devirtualize<&A32::UserCallbacks::MemoryWrite>(conf.callbacks)},
    }};
    const std::array<std::pair<size_t, ArgCallback>, 4> exclusive_write_callbacks{{
        {8, Devirtualize<&A32::UserCallbacks::MemoryWriteExclusive8>(conf.callbacks)},
@@ -56,12 +56,12 @@ void A32EmitX64::GenFastmemFallbacks() {
                    code.align();
                    read_fallbacks[std::make_tuple(ordered, bitsize, vaddr_idx, value_idx)] = code.getCurr<void (*)()>();
                    ABI_PushCallerSaveRegistersAndAdjustStackExcept(code, HostLocRegIdx(value_idx));
+                    // params = { this, vaddr, size }
                    if (vaddr_idx != code.ABI_PARAM2.getIdx()) {
                        code.mov(code.ABI_PARAM2, Xbyak::Reg64{vaddr_idx});
                    }
-                    if (ordered) {
-                        code.mfence();
-                    }
+                    code.mov(code.ABI_PARAM3, bitsize / CHAR_BIT);
+                    if (ordered) code.mfence();
                    callback.EmitCall(code);
                    if (value_idx != code.ABI_RETURN.getIdx()) {
                        code.mov(Xbyak::Reg64{value_idx}, code.ABI_RETURN);
@@ -76,6 +76,7 @@ void A32EmitX64::GenFastmemFallbacks() {
                    code.align();
                    write_fallbacks[std::make_tuple(ordered, bitsize, vaddr_idx, value_idx)] = code.getCurr<void (*)()>();
                    ABI_PushCallerSaveRegistersAndAdjustStack(code);
+                    // params = { this, vaddr, value, size }
                    if (vaddr_idx == code.ABI_PARAM3.getIdx() && value_idx == code.ABI_PARAM2.getIdx()) {
                        code.xchg(code.ABI_PARAM2, code.ABI_PARAM3);
                    } else if (vaddr_idx == code.ABI_PARAM3.getIdx()) {
@@ -92,10 +93,9 @@ void A32EmitX64::GenFastmemFallbacks() {
                        }
                    }
                    code.ZeroExtendFrom(bitsize, code.ABI_PARAM3);
+                    code.mov(code.ABI_PARAM4, bitsize / CHAR_BIT);
                    callback.EmitCall(code);
-                    if (ordered) {
-                        code.mfence();
-                    }
+                    if (ordered) code.mfence();
                    ABI_PopCallerSaveRegistersAndAdjustStack(code);
                    code.ret();
                    PerfMapRegister(write_fallbacks[std::make_tuple(ordered, bitsize, vaddr_idx, value_idx)], code.getCurr(), fmt::format("a32_write_fallback_{}", bitsize));
@@ -138,35 +138,35 @@ void A32EmitX64::GenFastmemFallbacks() {
 #undef Axx

 void A32EmitX64::EmitA32ReadMemory8(A32EmitContext& ctx, IR::Inst* inst) {
-    EmitMemoryRead<8, &A32::UserCallbacks::MemoryRead8>(ctx, inst);
+    EmitMemoryRead<8, &A32::UserCallbacks::MemoryRead>(ctx, inst);
 }

 void A32EmitX64::EmitA32ReadMemory16(A32EmitContext& ctx, IR::Inst* inst) {
-    EmitMemoryRead<16, &A32::UserCallbacks::MemoryRead16>(ctx, inst);
+    EmitMemoryRead<16, &A32::UserCallbacks::MemoryRead>(ctx, inst);
 }

 void A32EmitX64::EmitA32ReadMemory32(A32EmitContext& ctx, IR::Inst* inst) {
-    EmitMemoryRead<32, &A32::UserCallbacks::MemoryRead32>(ctx, inst);
+    EmitMemoryRead<32, &A32::UserCallbacks::MemoryRead>(ctx, inst);
 }

 void A32EmitX64::EmitA32ReadMemory64(A32EmitContext& ctx, IR::Inst* inst) {
-    EmitMemoryRead<64, &A32::UserCallbacks::MemoryRead64>(ctx, inst);
+    EmitMemoryRead<64, &A32::UserCallbacks::MemoryRead>(ctx, inst);
 }

 void A32EmitX64::EmitA32WriteMemory8(A32EmitContext& ctx, IR::Inst* inst) {
-    EmitMemoryWrite<8, &A32::UserCallbacks::MemoryWrite8>(ctx, inst);
+    EmitMemoryWrite<8, &A32::UserCallbacks::MemoryWrite>(ctx, inst);
 }

 void A32EmitX64::EmitA32WriteMemory16(A32EmitContext& ctx, IR::Inst* inst) {
-    EmitMemoryWrite<16, &A32::UserCallbacks::MemoryWrite16>(ctx, inst);
+    EmitMemoryWrite<16, &A32::UserCallbacks::MemoryWrite>(ctx, inst);
 }

 void A32EmitX64::EmitA32WriteMemory32(A32EmitContext& ctx, IR::Inst* inst) {
-    EmitMemoryWrite<32, &A32::UserCallbacks::MemoryWrite32>(ctx, inst);
+    EmitMemoryWrite<32, &A32::UserCallbacks::MemoryWrite>(ctx, inst);
 }

 void A32EmitX64::EmitA32WriteMemory64(A32EmitContext& ctx, IR::Inst* inst) {
-    EmitMemoryWrite<64, &A32::UserCallbacks::MemoryWrite64>(ctx, inst);
+    EmitMemoryWrite<64, &A32::UserCallbacks::MemoryWrite>(ctx, inst);
 }

 void A32EmitX64::EmitA32ClearExclusive(A32EmitContext&, IR::Inst*) {
@@ -175,33 +175,33 @@ void A32EmitX64::EmitA32ClearExclusive(A32EmitContext&, IR::Inst*) {

 void A32EmitX64::EmitA32ExclusiveReadMemory8(A32EmitContext& ctx, IR::Inst* inst) {
    if (conf.fastmem_exclusive_access) {
-        EmitExclusiveReadMemoryInline<8, &A32::UserCallbacks::MemoryRead8>(ctx, inst);
+        EmitExclusiveReadMemoryInline<8, &A32::UserCallbacks::MemoryRead>(ctx, inst);
    } else {
-        EmitExclusiveReadMemory<8, &A32::UserCallbacks::MemoryRead8>(ctx, inst);
+        EmitExclusiveReadMemory<8, &A32::UserCallbacks::MemoryRead>(ctx, inst);
    }
 }

 void A32EmitX64::EmitA32ExclusiveReadMemory16(A32EmitContext& ctx, IR::Inst* inst) {
    if (conf.fastmem_exclusive_access) {
-        EmitExclusiveReadMemoryInline<16, &A32::UserCallbacks::MemoryRead16>(ctx, inst);
+        EmitExclusiveReadMemoryInline<16, &A32::UserCallbacks::MemoryRead>(ctx, inst);
    } else {
-        EmitExclusiveReadMemory<16, &A32::UserCallbacks::MemoryRead16>(ctx, inst);
+        EmitExclusiveReadMemory<16, &A32::UserCallbacks::MemoryRead>(ctx, inst);
    }
 }

 void A32EmitX64::EmitA32ExclusiveReadMemory32(A32EmitContext& ctx, IR::Inst* inst) {
    if (conf.fastmem_exclusive_access) {
-        EmitExclusiveReadMemoryInline<32, &A32::UserCallbacks::MemoryRead32>(ctx, inst);
+        EmitExclusiveReadMemoryInline<32, &A32::UserCallbacks::MemoryRead>(ctx, inst);
    } else {
-        EmitExclusiveReadMemory<32, &A32::UserCallbacks::MemoryRead32>(ctx, inst);
+        EmitExclusiveReadMemory<32, &A32::UserCallbacks::MemoryRead>(ctx, inst);
    }
 }

 void A32EmitX64::EmitA32ExclusiveReadMemory64(A32EmitContext& ctx, IR::Inst* inst) {
    if (conf.fastmem_exclusive_access) {
-        EmitExclusiveReadMemoryInline<64, &A32::UserCallbacks::MemoryRead64>(ctx, inst);
+        EmitExclusiveReadMemoryInline<64, &A32::UserCallbacks::MemoryRead>(ctx, inst);
    } else {
-        EmitExclusiveReadMemory<64, &A32::UserCallbacks::MemoryRead64>(ctx, inst);
+        EmitExclusiveReadMemory<64, &A32::UserCallbacks::MemoryRead>(ctx, inst);
    }
 }

@@ -115,16 +115,16 @@ void A64EmitX64::GenMemory128Accessors() {
 void A64EmitX64::GenFastmemFallbacks() {
    const std::initializer_list<int> idxes{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
    const std::array<std::pair<size_t, ArgCallback>, 4> read_callbacks{{
-        {8, Devirtualize<&A64::UserCallbacks::MemoryRead8>(conf.callbacks)},
-        {16, Devirtualize<&A64::UserCallbacks::MemoryRead16>(conf.callbacks)},
-        {32, Devirtualize<&A64::UserCallbacks::MemoryRead32>(conf.callbacks)},
-        {64, Devirtualize<&A64::UserCallbacks::MemoryRead64>(conf.callbacks)},
+        {8, Devirtualize<&A64::UserCallbacks::MemoryRead>(conf.callbacks)},
+        {16, Devirtualize<&A64::UserCallbacks::MemoryRead>(conf.callbacks)},
+        {32, Devirtualize<&A64::UserCallbacks::MemoryRead>(conf.callbacks)},
+        {64, Devirtualize<&A64::UserCallbacks::MemoryRead>(conf.callbacks)},
    }};
    const std::array<std::pair<size_t, ArgCallback>, 4> write_callbacks{{
-        {8, Devirtualize<&A64::UserCallbacks::MemoryWrite8>(conf.callbacks)},
-        {16, Devirtualize<&A64::UserCallbacks::MemoryWrite16>(conf.callbacks)},
-        {32, Devirtualize<&A64::UserCallbacks::MemoryWrite32>(conf.callbacks)},
-        {64, Devirtualize<&A64::UserCallbacks::MemoryWrite64>(conf.callbacks)},
+        {8, Devirtualize<&A64::UserCallbacks::MemoryWrite>(conf.callbacks)},
+        {16, Devirtualize<&A64::UserCallbacks::MemoryWrite>(conf.callbacks)},
+        {32, Devirtualize<&A64::UserCallbacks::MemoryWrite>(conf.callbacks)},
+        {64, Devirtualize<&A64::UserCallbacks::MemoryWrite>(conf.callbacks)},
    }};
    const std::array<std::pair<size_t, ArgCallback>, 4> exclusive_write_callbacks{{
        {8, Devirtualize<&A64::UserCallbacks::MemoryWriteExclusive8>(conf.callbacks)},
@@ -204,12 +204,12 @@ void A64EmitX64::GenFastmemFallbacks() {
                    code.align();
                    read_fallbacks[std::make_tuple(ordered, bitsize, vaddr_idx, value_idx)] = code.getCurr<void (*)()>();
                    ABI_PushCallerSaveRegistersAndAdjustStackExcept(code, HostLocRegIdx(value_idx));
+                    // params = { this, vaddr, size }
                    if (vaddr_idx != code.ABI_PARAM2.getIdx()) {
                        code.mov(code.ABI_PARAM2, Xbyak::Reg64{vaddr_idx});
                    }
-                    if (ordered) {
-                        code.mfence();
-                    }
+                    code.mov(code.ABI_PARAM3, bitsize / CHAR_BIT);
+                    if (ordered) code.mfence();
                    callback.EmitCall(code);
                    if (value_idx != code.ABI_RETURN.getIdx()) {
                        code.mov(Xbyak::Reg64{value_idx}, code.ABI_RETURN);
@@ -224,6 +224,7 @@ void A64EmitX64::GenFastmemFallbacks() {
                    code.align();
                    write_fallbacks[std::make_tuple(ordered, bitsize, vaddr_idx, value_idx)] = code.getCurr<void (*)()>();
                    ABI_PushCallerSaveRegistersAndAdjustStack(code);
+                    // params = { this, vaddr, value, size }
                    if (vaddr_idx == code.ABI_PARAM3.getIdx() && value_idx == code.ABI_PARAM2.getIdx()) {
                        code.xchg(code.ABI_PARAM2, code.ABI_PARAM3);
                    } else if (vaddr_idx == code.ABI_PARAM3.getIdx()) {
@@ -240,10 +241,9 @@ void A64EmitX64::GenFastmemFallbacks() {
                        }
                    }
                    code.ZeroExtendFrom(bitsize, code.ABI_PARAM3);
+                    code.mov(code.ABI_PARAM4, bitsize / CHAR_BIT);
                    callback.EmitCall(code);
-                    if (ordered) {
-                        code.mfence();
-                    }
+                    if (ordered) code.mfence();
                    ABI_PopCallerSaveRegistersAndAdjustStack(code);
                    code.ret();
                    PerfMapRegister(write_fallbacks[std::make_tuple(ordered, bitsize, vaddr_idx, value_idx)], code.getCurr(), fmt::format("a64_write_fallback_{}", bitsize));
@@ -286,19 +286,19 @@ void A64EmitX64::GenFastmemFallbacks() {
 #undef Axx

 void A64EmitX64::EmitA64ReadMemory8(A64EmitContext& ctx, IR::Inst* inst) {
-    EmitMemoryRead<8, &A64::UserCallbacks::MemoryRead8>(ctx, inst);
+    EmitMemoryRead<8, &A64::UserCallbacks::MemoryRead>(ctx, inst);
 }

 void A64EmitX64::EmitA64ReadMemory16(A64EmitContext& ctx, IR::Inst* inst) {
-    EmitMemoryRead<16, &A64::UserCallbacks::MemoryRead16>(ctx, inst);
+    EmitMemoryRead<16, &A64::UserCallbacks::MemoryRead>(ctx, inst);
 }

 void A64EmitX64::EmitA64ReadMemory32(A64EmitContext& ctx, IR::Inst* inst) {
-    EmitMemoryRead<32, &A64::UserCallbacks::MemoryRead32>(ctx, inst);
+    EmitMemoryRead<32, &A64::UserCallbacks::MemoryRead>(ctx, inst);
 }

 void A64EmitX64::EmitA64ReadMemory64(A64EmitContext& ctx, IR::Inst* inst) {
-    EmitMemoryRead<64, &A64::UserCallbacks::MemoryRead64>(ctx, inst);
+    EmitMemoryRead<64, &A64::UserCallbacks::MemoryRead>(ctx, inst);
 }

 void A64EmitX64::EmitA64ReadMemory128(A64EmitContext& ctx, IR::Inst* inst) {
@@ -306,23 +306,23 @@ void A64EmitX64::EmitA64ReadMemory128(A64EmitContext& ctx, IR::Inst* inst) {
 }

 void A64EmitX64::EmitA64WriteMemory8(A64EmitContext& ctx, IR::Inst* inst) {
-    EmitMemoryWrite<8, &A64::UserCallbacks::MemoryWrite8>(ctx, inst);
+    EmitMemoryWrite<8, &A64::UserCallbacks::MemoryWrite>(ctx, inst);
 }

 void A64EmitX64::EmitA64WriteMemory16(A64EmitContext& ctx, IR::Inst* inst) {
-    EmitMemoryWrite<16, &A64::UserCallbacks::MemoryWrite16>(ctx, inst);
+    EmitMemoryWrite<16, &A64::UserCallbacks::MemoryWrite>(ctx, inst);
 }

 void A64EmitX64::EmitA64WriteMemory32(A64EmitContext& ctx, IR::Inst* inst) {
-    EmitMemoryWrite<32, &A64::UserCallbacks::MemoryWrite32>(ctx, inst);
+    EmitMemoryWrite<32, &A64::UserCallbacks::MemoryWrite>(ctx, inst);
 }

 void A64EmitX64::EmitA64WriteMemory64(A64EmitContext& ctx, IR::Inst* inst) {
-    EmitMemoryWrite<64, &A64::UserCallbacks::MemoryWrite64>(ctx, inst);
+    EmitMemoryWrite<64, &A64::UserCallbacks::MemoryWrite>(ctx, inst);
 }

 void A64EmitX64::EmitA64WriteMemory128(A64EmitContext& ctx, IR::Inst* inst) {
-    EmitMemoryWrite<128, &A64::UserCallbacks::MemoryWrite64>(ctx, inst);
+    EmitMemoryWrite<128, &A64::UserCallbacks::MemoryWrite>(ctx, inst);
 }

 void A64EmitX64::EmitA64ClearExclusive(A64EmitContext&, IR::Inst*) {
@@ -331,33 +331,33 @@ void A64EmitX64::EmitA64ClearExclusive(A64EmitContext&, IR::Inst*) {

 void A64EmitX64::EmitA64ExclusiveReadMemory8(A64EmitContext& ctx, IR::Inst* inst) {
    if (conf.fastmem_exclusive_access) {
-        EmitExclusiveReadMemoryInline<8, &A64::UserCallbacks::MemoryRead8>(ctx, inst);
+        EmitExclusiveReadMemoryInline<8, &A64::UserCallbacks::MemoryRead>(ctx, inst);
    } else {
-        EmitExclusiveReadMemory<8, &A64::UserCallbacks::MemoryRead8>(ctx, inst);
+        EmitExclusiveReadMemory<8, &A64::UserCallbacks::MemoryRead>(ctx, inst);
    }
 }

 void A64EmitX64::EmitA64ExclusiveReadMemory16(A64EmitContext& ctx, IR::Inst* inst) {
    if (conf.fastmem_exclusive_access) {
-        EmitExclusiveReadMemoryInline<16, &A64::UserCallbacks::MemoryRead16>(ctx, inst);
+        EmitExclusiveReadMemoryInline<16, &A64::UserCallbacks::MemoryRead>(ctx, inst);
    } else {
-        EmitExclusiveReadMemory<16, &A64::UserCallbacks::MemoryRead16>(ctx, inst);
+        EmitExclusiveReadMemory<16, &A64::UserCallbacks::MemoryRead>(ctx, inst);
    }
 }

 void A64EmitX64::EmitA64ExclusiveReadMemory32(A64EmitContext& ctx, IR::Inst* inst) {
    if (conf.fastmem_exclusive_access) {
-        EmitExclusiveReadMemoryInline<32, &A64::UserCallbacks::MemoryRead32>(ctx, inst);
+        EmitExclusiveReadMemoryInline<32, &A64::UserCallbacks::MemoryRead>(ctx, inst);
    } else {
-        EmitExclusiveReadMemory<32, &A64::UserCallbacks::MemoryRead32>(ctx, inst);
+        EmitExclusiveReadMemory<32, &A64::UserCallbacks::MemoryRead>(ctx, inst);
    }
 }

 void A64EmitX64::EmitA64ExclusiveReadMemory64(A64EmitContext& ctx, IR::Inst* inst) {
    if (conf.fastmem_exclusive_access) {
-        EmitExclusiveReadMemoryInline<64, &A64::UserCallbacks::MemoryRead64>(ctx, inst);
+        EmitExclusiveReadMemoryInline<64, &A64::UserCallbacks::MemoryRead>(ctx, inst);
    } else {
-        EmitExclusiveReadMemory<64, &A64::UserCallbacks::MemoryRead64>(ctx, inst);
+        EmitExclusiveReadMemory<64, &A64::UserCallbacks::MemoryRead>(ctx, inst);
    }
 }

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 /* This file is part of the dynarmic project.
 * Copyright (c) 2022 MerryMage
 * SPDX-License-Identifier: 0BSD
@@ -56,16 +59,13 @@ void AxxEmitX64::EmitMemoryRead(AxxEmitContext& ctx, IR::Inst* inst) {
        // Neither fastmem nor page table: Use callbacks
        if constexpr (bitsize == 128) {
            ctx.reg_alloc.HostCall(code, nullptr, {}, args[1]);
-            if (ordered) {
-                code.mfence();
-            }
+            if (ordered) code.mfence();
            code.CallFunction(memory_read_128);
            ctx.reg_alloc.DefineValue(code, inst, xmm1);
        } else {
            ctx.reg_alloc.HostCall(code, inst, {}, args[1]);
-            if (ordered) {
-                code.mfence();
-            }
+            code.mov(code.ABI_PARAM3.cvt32(), bitsize / CHAR_BIT);
+            if (ordered) code.mfence();
            Devirtualize<callback>(conf.callbacks).EmitCall(code);
            code.ZeroExtendFrom(bitsize, code.ABI_RETURN);
        }
@@ -148,12 +148,12 @@ void AxxEmitX64::EmitMemoryWrite(AxxEmitContext& ctx, IR::Inst* inst) {
            ctx.reg_alloc.HostCall(code, nullptr);
            code.CallFunction(memory_write_128);
        } else {
+            // { this, vaddr, value, size }
            ctx.reg_alloc.HostCall(code, nullptr, {}, args[1], args[2]);
+            code.mov(code.ABI_PARAM4.cvt32(), bitsize / CHAR_BIT);
            Devirtualize<callback>(conf.callbacks).EmitCall(code);
        }
-        if (ordered) {
-            code.mfence();
-        }
+        if (ordered) code.mfence();
        EmitCheckMemoryAbort(ctx, inst);
        return;
    }
@@ -230,12 +230,11 @@ void AxxEmitX64::EmitExclusiveReadMemory(AxxEmitContext& ctx, IR::Inst* inst) {
        if (ordered) {
            code.mfence();
        }
-        code.CallLambda(
-            [](AxxUserConfig& conf, Axx::VAddr vaddr) -> T {
-                return conf.global_monitor->ReadAndMark<T>(conf.processor_id, vaddr, [&]() -> T {
-                    return (conf.callbacks->*callback)(vaddr);
-                });
+        code.CallLambda([](AxxUserConfig& conf, Axx::VAddr vaddr) -> T {
+            return conf.global_monitor->ReadAndMark<T>(conf.processor_id, vaddr, [&]() -> T {
+                return (conf.callbacks->*callback)(vaddr, bitsize / CHAR_BIT);
            });
+        });
        code.ZeroExtendFrom(bitsize, code.ABI_RETURN);
    } else {
        const Xbyak::Xmm result = ctx.reg_alloc.ScratchXmm(code);
@@ -250,12 +249,11 @@ void AxxEmitX64::EmitExclusiveReadMemory(AxxEmitContext& ctx, IR::Inst* inst) {
        if (ordered) {
            code.mfence();
        }
-        code.CallLambda(
-            [](AxxUserConfig& conf, Axx::VAddr vaddr, Vector& ret) {
-                ret = conf.global_monitor->ReadAndMark<Vector>(conf.processor_id, vaddr, [&]() -> Vector {
-                    return (conf.callbacks->*callback)(vaddr);
-                });
+        code.CallLambda([](AxxUserConfig& conf, Axx::VAddr vaddr, Vector& ret) {
+            ret = conf.global_monitor->ReadAndMark<Vector>(conf.processor_id, vaddr, [&]() -> Vector {
+                return (conf.callbacks->*callback)(vaddr);
            });
+        });
        code.movups(result, xword[rsp + ABI_SHADOW_SPACE]);
        ctx.reg_alloc.ReleaseStackSpace(code, 16 + ABI_SHADOW_SPACE);

@@ -66,7 +66,9 @@ struct UserCallbacks : public TranslateCallbacks {

    // All reads through this callback are 4-byte aligned.
    // Memory must be interpreted as little endian.
-    std::optional<std::uint32_t> MemoryReadCode(VAddr vaddr) override { return MemoryRead32(vaddr); }
+    std::optional<std::uint32_t> MemoryReadCode(VAddr vaddr) override {
+        return std::uint32_t(MemoryRead(vaddr, sizeof(std::uint32_t)));
+    }

    // This function is called before the instruction at pc is read.
    // IR code can be emitted by the callee prior to instruction handling.
@@ -80,16 +82,10 @@ struct UserCallbacks : public TranslateCallbacks {

    // Reads through these callbacks may not be aligned.
    // Memory must be interpreted as if ENDIANSTATE == 0, endianness will be corrected by the JIT.
-    virtual std::uint8_t MemoryRead8(VAddr vaddr) = 0;
-    virtual std::uint16_t MemoryRead16(VAddr vaddr) = 0;
-    virtual std::uint32_t MemoryRead32(VAddr vaddr) = 0;
-    virtual std::uint64_t MemoryRead64(VAddr vaddr) = 0;
+    virtual std::uint64_t MemoryRead(VAddr vaddr, std::size_t size) = 0;

    // Writes through these callbacks may not be aligned.
-    virtual void MemoryWrite8(VAddr vaddr, std::uint8_t value) = 0;
-    virtual void MemoryWrite16(VAddr vaddr, std::uint16_t value) = 0;
-    virtual void MemoryWrite32(VAddr vaddr, std::uint32_t value) = 0;
-    virtual void MemoryWrite64(VAddr vaddr, std::uint64_t value) = 0;
+    virtual void MemoryWrite(VAddr vaddr, std::uint64_t value, std::size_t size) = 0;

    // Writes through these callbacks may not be aligned.
    virtual bool MemoryWriteExclusive8(VAddr /*vaddr*/, std::uint8_t /*value*/, std::uint8_t /*expected*/) { return false; }
@@ -89,20 +89,16 @@ struct UserCallbacks {

    // All reads through this callback are 4-byte aligned.
    // Memory must be interpreted as little endian.
-    virtual std::optional<std::uint32_t> MemoryReadCode(VAddr vaddr) { return MemoryRead32(vaddr); }
+    virtual std::optional<std::uint32_t> MemoryReadCode(VAddr vaddr) {
+        return std::uint32_t(MemoryRead(vaddr, sizeof(std::uint32_t)));
+    }

    // Reads through these callbacks may not be aligned.
-    virtual std::uint8_t MemoryRead8(VAddr vaddr) = 0;
-    virtual std::uint16_t MemoryRead16(VAddr vaddr) = 0;
-    virtual std::uint32_t MemoryRead32(VAddr vaddr) = 0;
-    virtual std::uint64_t MemoryRead64(VAddr vaddr) = 0;
+    virtual std::uint64_t MemoryRead(VAddr vaddr, std::size_t size) = 0;
    virtual Vector MemoryRead128(VAddr vaddr) = 0;

    // Writes through these callbacks may not be aligned.
-    virtual void MemoryWrite8(VAddr vaddr, std::uint8_t value) = 0;
-    virtual void MemoryWrite16(VAddr vaddr, std::uint16_t value) = 0;
-    virtual void MemoryWrite32(VAddr vaddr, std::uint32_t value) = 0;
-    virtual void MemoryWrite64(VAddr vaddr, std::uint64_t value) = 0;
+    virtual void MemoryWrite(VAddr vaddr, std::uint64_t value, std::size_t size) = 0;
    virtual void MemoryWrite128(VAddr vaddr, Vector value) = 0;

    // Writes through these callbacks may not be aligned.
@@ -40,7 +40,7 @@ static void ConstantMemoryReads(IR::Block& block, A32::UserCallbacks* cb) {
            if (inst.AreAllArgsImmediates()) {
                const u32 vaddr = inst.GetArg(1).GetU32();
                if (cb->IsReadOnlyMemory(vaddr)) {
-                    const u8 value_from_memory = cb->MemoryRead8(vaddr);
+                    const u8 value_from_memory = u8(cb->MemoryRead(vaddr, sizeof(u8)));
                    inst.ReplaceUsesWith(IR::Value{value_from_memory});
                }
            }
@@ -51,7 +51,7 @@ static void ConstantMemoryReads(IR::Block& block, A32::UserCallbacks* cb) {
            if (inst.AreAllArgsImmediates()) {
                const u32 vaddr = inst.GetArg(1).GetU32();
                if (cb->IsReadOnlyMemory(vaddr)) {
-                    const u16 value_from_memory = cb->MemoryRead16(vaddr);
+                    const u16 value_from_memory = u16(cb->MemoryRead(vaddr, sizeof(u16)));
                    inst.ReplaceUsesWith(IR::Value{value_from_memory});
                }
            }
@@ -62,7 +62,7 @@ static void ConstantMemoryReads(IR::Block& block, A32::UserCallbacks* cb) {
            if (inst.AreAllArgsImmediates()) {
                const u32 vaddr = inst.GetArg(1).GetU32();
                if (cb->IsReadOnlyMemory(vaddr)) {
-                    const u32 value_from_memory = cb->MemoryRead32(vaddr);
+                    const u32 value_from_memory = u32(cb->MemoryRead(vaddr, sizeof(u32)));
                    inst.ReplaceUsesWith(IR::Value{value_from_memory});
                }
            }
@@ -73,7 +73,7 @@ static void ConstantMemoryReads(IR::Block& block, A32::UserCallbacks* cb) {
            if (inst.AreAllArgsImmediates()) {
                const u32 vaddr = inst.GetArg(1).GetU32();
                if (cb->IsReadOnlyMemory(vaddr)) {
-                    const u64 value_from_memory = cb->MemoryRead64(vaddr);
+                    const u64 value_from_memory = u64(cb->MemoryRead(vaddr, sizeof(u64)));
                    inst.ReplaceUsesWith(IR::Value{value_from_memory});
                }
            }
@@ -503,7 +503,7 @@ TEST_CASE("Fuzz Thumb32 instructions set", "[JitX64][Thumb][Thumb32]") {
    }
 }

-TEST_CASE("Verify fix for off by one error in MemoryRead32 worked", "[Thumb][Thumb16]") {
+TEST_CASE("Verify fix for off by one error in MemoryRead<32> worked", "[Thumb][Thumb16]") {
    ThumbTestEnv test_env;

    // Prepare test subjects
@@ -553,9 +553,9 @@ TEST_CASE("arm: Memory access (fastmem)", "[arm][A32]") {
    memset(backing_memory, 0, memory_size);
    memcpy(backing_memory + 0x100, "Lorem ipsum dolor sit amet, consectetur adipiscing elit.", 57);

-    env.MemoryWrite32(0, 0xE5904000);  // LDR R4, [R0]
-    env.MemoryWrite32(4, 0xE5814000);  // STR R4, [R1]
-    env.MemoryWrite32(8, 0xEAFFFFFE);  // B .
+    env.MemoryWrite(0, 0xE5904000, sizeof(u32));  // LDR R4, [R0]
+    env.MemoryWrite(4, 0xE5814000, sizeof(u32));  // STR R4, [R1]
+    env.MemoryWrite(8, 0xEAFFFFFE, sizeof(u32));  // B .
    jit.Regs()[0] = 0x100;
    jit.Regs()[1] = 0x1F0;
    jit.Regs()[15] = 0;       // PC = 0
@@ -16,6 +16,7 @@

 #include "common/assert.h"
 #include "common/common_types.h"
+#include "dynarmic/frontend/A32/translate/translate_callbacks.h"
 #include "dynarmic/interface/A32/a32.h"

 template<typename InstructionType_, u32 infinite_loop_u32>
@@ -59,42 +60,51 @@ public:
        return infinite_loop_u32;  // B .
    }

-    std::uint8_t MemoryRead8(u32 vaddr) override {
-        if (IsInCodeMem(vaddr)) {
-            return reinterpret_cast<u8*>(code_mem.data())[vaddr];
+    u64 MemoryRead(u32 vaddr, size_t size) override {
+        switch (size) {
+        case sizeof(u64):
+            return MemoryRead(vaddr, sizeof(u32))
+                | MemoryRead(vaddr + sizeof(u32), sizeof(u32)) << 32;
+        case sizeof(u32):
+            return MemoryRead(vaddr, sizeof(u16))
+                | MemoryRead(vaddr + sizeof(u16), sizeof(u16)) << 16;
+        case sizeof(u16):
+            return MemoryRead(vaddr, sizeof(u8))
+                | MemoryRead(vaddr + sizeof(u8), sizeof(u8)) << 8;
+        case sizeof(u8): {
+            if (IsInCodeMem(vaddr))
+                return reinterpret_cast<u8*>(code_mem.data())[vaddr];
+            if (auto iter = modified_memory.find(vaddr); iter != modified_memory.end())
+                return iter->second;
+            return u8(vaddr);
        }
-        if (auto iter = modified_memory.find(vaddr); iter != modified_memory.end()) {
-            return iter->second;
+        default:
+            std::abort();
        }
-        return static_cast<u8>(vaddr);
-    }
-    std::uint16_t MemoryRead16(u32 vaddr) override {
-        return u16(MemoryRead8(vaddr)) | u16(MemoryRead8(vaddr + 1)) << 8;
-    }
-    std::uint32_t MemoryRead32(u32 vaddr) override {
-        return u32(MemoryRead16(vaddr)) | u32(MemoryRead16(vaddr + 2)) << 16;
-    }
-    std::uint64_t MemoryRead64(u32 vaddr) override {
-        return u64(MemoryRead32(vaddr)) | u64(MemoryRead32(vaddr + 4)) << 32;
    }

-    void MemoryWrite8(u32 vaddr, std::uint8_t value) override {
-        if (vaddr < code_mem.size() * sizeof(u32)) {
-            code_mem_modified_by_guest = true;
+    void MemoryWrite(Dynarmic::A32::VAddr vaddr, u64 value, size_t size) override {
+        switch (size) {
+        case sizeof(u64):
+            MemoryWrite(vaddr, u32(value), sizeof(u32));
+            MemoryWrite(vaddr + 4, u32(value >> 32), sizeof(u32));
+            break;
+        case sizeof(u32):
+            MemoryWrite(vaddr, u16(value), sizeof(u16));
+            MemoryWrite(vaddr + 2, u16(value >> 16), sizeof(u16));
+            break;
+        case sizeof(u16):
+            MemoryWrite(vaddr, u8(value), sizeof(u8));
+            MemoryWrite(vaddr + 1, u8(value >> 8), sizeof(u8));
+            break;
+        case sizeof(u8):
+            if (vaddr < code_mem.size() * sizeof(u32))
+                code_mem_modified_by_guest = true;
+            modified_memory[vaddr] = value;
+            break;
+        default:
+            std::abort();
        }
-        modified_memory[vaddr] = value;
-    }
-    void MemoryWrite16(u32 vaddr, std::uint16_t value) override {
-        MemoryWrite8(vaddr, static_cast<u8>(value));
-        MemoryWrite8(vaddr + 1, static_cast<u8>(value >> 8));
-    }
-    void MemoryWrite32(u32 vaddr, std::uint32_t value) override {
-        MemoryWrite16(vaddr, static_cast<u16>(value));
-        MemoryWrite16(vaddr + 2, static_cast<u16>(value >> 16));
-    }
-    void MemoryWrite64(u32 vaddr, std::uint64_t value) override {
-        MemoryWrite32(vaddr, static_cast<u32>(value));
-        MemoryWrite32(vaddr + 4, static_cast<u32>(value >> 32));
    }

    void CallSVC(std::uint32_t swi) override {
@@ -143,46 +153,41 @@ public:
        return read<std::uint32_t>(vaddr);
    }

-    std::uint8_t MemoryRead8(std::uint32_t vaddr) override {
-        return read<std::uint8_t>(vaddr);
-    }
-    std::uint16_t MemoryRead16(std::uint32_t vaddr) override {
-        return read<std::uint16_t>(vaddr);
-    }
-    std::uint32_t MemoryRead32(std::uint32_t vaddr) override {
-        return read<std::uint32_t>(vaddr);
-    }
-    std::uint64_t MemoryRead64(std::uint32_t vaddr) override {
-        return read<std::uint64_t>(vaddr);
+    u64 MemoryRead(u32 vaddr, size_t size) override {
+        switch (size) {
+        case sizeof(u64): return read<u64>(vaddr);
+        case sizeof(u32): return read<u32>(vaddr);
+        case sizeof(u16): return read<u16>(vaddr);
+        case sizeof(u8): return read<u8>(vaddr);
+        default:
+            std::abort();
+        }
    }

-    void MemoryWrite8(std::uint32_t vaddr, std::uint8_t value) override {
-        write(vaddr, value);
-    }
-    void MemoryWrite16(std::uint32_t vaddr, std::uint16_t value) override {
-        write(vaddr, value);
-    }
-    void MemoryWrite32(std::uint32_t vaddr, std::uint32_t value) override {
-        write(vaddr, value);
-    }
-    void MemoryWrite64(std::uint32_t vaddr, std::uint64_t value) override {
-        write(vaddr, value);
+    void MemoryWrite(Dynarmic::A32::VAddr vaddr, std::uint64_t value, size_t size) override {
+        switch (size) {
+        case sizeof(u64): return write<u64>(vaddr, u64(value));
+        case sizeof(u32): return write<u32>(vaddr, u32(value));
+        case sizeof(u16): return write<u16>(vaddr, u16(value));
+        case sizeof(u8): return write<u8>(vaddr, u8(value));
+        default: std::abort();
+        }
    }

-    bool MemoryWriteExclusive8(std::uint32_t vaddr, std::uint8_t value, [[maybe_unused]] std::uint8_t expected) override {
-        MemoryWrite8(vaddr, value);
+    bool MemoryWriteExclusive8(Dynarmic::A32::VAddr vaddr, std::uint8_t value, [[maybe_unused]] std::uint8_t expected) override {
+        MemoryWrite(vaddr, value, sizeof(u8));
        return true;
    }
-    bool MemoryWriteExclusive16(std::uint32_t vaddr, std::uint16_t value, [[maybe_unused]] std::uint16_t expected) override {
-        MemoryWrite16(vaddr, value);
+    bool MemoryWriteExclusive16(Dynarmic::A32::VAddr vaddr, std::uint16_t value, [[maybe_unused]] std::uint16_t expected) override {
+        MemoryWrite(vaddr, value, sizeof(u16));
        return true;
    }
-    bool MemoryWriteExclusive32(std::uint32_t vaddr, std::uint32_t value, [[maybe_unused]] std::uint32_t expected) override {
-        MemoryWrite32(vaddr, value);
+    bool MemoryWriteExclusive32(Dynarmic::A32::VAddr vaddr, std::uint32_t value, [[maybe_unused]] std::uint32_t expected) override {
+        MemoryWrite(vaddr, value, sizeof(u32));
        return true;
    }
-    bool MemoryWriteExclusive64(std::uint32_t vaddr, std::uint64_t value, [[maybe_unused]] std::uint64_t expected) override {
-        MemoryWrite64(vaddr, value);
+    bool MemoryWriteExclusive64(Dynarmic::A32::VAddr vaddr, std::uint64_t value, [[maybe_unused]] std::uint64_t expected) override {
+        MemoryWrite(vaddr, value, sizeof(u64));
        return true;
    }

@@ -25,48 +25,55 @@ public:
    u64 ticks_left = 0;
    ankerl::unordered_dense::map<u64, u8> memory{};

-    u8 MemoryRead8(u64 vaddr) override {
-        return memory[vaddr];
-    }
-
-    u16 MemoryRead16(u64 vaddr) override {
-        return u16(MemoryRead8(vaddr)) | u16(MemoryRead8(vaddr + 1)) << 8;
-    }
-
-    u32 MemoryRead32(u64 vaddr) override {
-        return u32(MemoryRead16(vaddr)) | u32(MemoryRead16(vaddr + 2)) << 16;
-    }
-
-    u64 MemoryRead64(u64 vaddr) override {
-        return u64(MemoryRead32(vaddr)) | u64(MemoryRead32(vaddr + 4)) << 32;
+    u64 MemoryRead(u64 vaddr, size_t size) override {
+        switch (size) {
+        case sizeof(u64):
+            return MemoryRead(vaddr, sizeof(u32))
+                | MemoryRead(vaddr + sizeof(u32), sizeof(u32)) << 32;
+        case sizeof(u32):
+            return MemoryRead(vaddr, sizeof(u16))
+                | MemoryRead(vaddr + sizeof(u16), sizeof(u16)) << 16;
+        case sizeof(u16):
+            return MemoryRead(vaddr, sizeof(u8))
+                | MemoryRead(vaddr + sizeof(u8), sizeof(u8)) << 8;
+        case sizeof(u8):
+            return memory[vaddr];
+        default:
+            std::abort();
+        }
    }

    std::array<u64, 2> MemoryRead128(u64 vaddr) override {
-        return {MemoryRead64(vaddr), MemoryRead64(vaddr + 8)};
+        return {
+            MemoryRead(vaddr, sizeof(u64)),
+            MemoryRead(vaddr + sizeof(u64), sizeof(u64))
+        };
    }

-    void MemoryWrite8(u64 vaddr, u8 value) override {
-        memory[vaddr] = value;
+    void MemoryWrite(Dynarmic::A64::VAddr vaddr, u64 value, size_t size) override {
+        switch (size) {
+        case sizeof(u64):
+            MemoryWrite(vaddr, u32(value), sizeof(u32));
+            MemoryWrite(vaddr + 4, u32(value >> 32), sizeof(u32));
+            break;
+        case sizeof(u32):
+            MemoryWrite(vaddr, u16(value), sizeof(u16));
+            MemoryWrite(vaddr + 2, u16(value >> 16), sizeof(u16));
+            break;
+        case sizeof(u16):
+            MemoryWrite(vaddr, u8(value), sizeof(u8));
+            MemoryWrite(vaddr + 1, u8(value >> 8), sizeof(u8));
+            break;
+        case sizeof(u8):
+            memory[vaddr] = value;
+            break;
+        default:
+            std::abort();
+        }
    }
-
-    void MemoryWrite16(u64 vaddr, u16 value) override {
-        MemoryWrite8(vaddr, u8(value));
-        MemoryWrite8(vaddr + 1, u8(value >> 8));
-    }
-
-    void MemoryWrite32(u64 vaddr, u32 value) override {
-        MemoryWrite16(vaddr, u16(value));
-        MemoryWrite16(vaddr + 2, u16(value >> 16));
-    }
-
-    void MemoryWrite64(u64 vaddr, u64 value) override {
-        MemoryWrite32(vaddr, u32(value));
-        MemoryWrite32(vaddr + 4, u32(value >> 32));
-    }
-
    void MemoryWrite128(u64 vaddr, std::array<u64, 2> value) override {
-        MemoryWrite64(vaddr, value[0]);
-        MemoryWrite64(vaddr + 8, value[1]);
+        MemoryWrite(vaddr, value[0], sizeof(u64));
+        MemoryWrite(vaddr + 8, value[1], sizeof(u64));
    }

    void CallSVC(u32) override {
@@ -135,9 +142,9 @@ TEST_CASE("A64: fibonacci", "[a64]") {
    code.RET();

    for (size_t i = 0; i < 1024; i++) {
-        env.MemoryWrite32(i * 4, instructions[i]);
+        env.MemoryWrite(i * 4, instructions[i], sizeof(u32));
    }
-    env.MemoryWrite32(8888, 0xd4200000);
+    env.MemoryWrite(8888, 0xd4200000, sizeof(u32));
    cpu.SetRegister(30, 8888);

    cpu.SetRegister(0, 10);
@@ -12,6 +12,7 @@
 #include "common/assert.h"
 #include "common/common_types.h"
 #include "dynarmic/interface/A64/a64.h"
+#include "dynarmic/interface/A64/config.h"

 using Vector = Dynarmic::A64::Vector;

@@ -34,64 +35,79 @@ public:
        return code_mem[index];
    }

-    std::uint8_t MemoryRead8(u64 vaddr) override {
-        if (IsInCodeMem(vaddr)) {
-            return reinterpret_cast<u8*>(code_mem.data())[vaddr - code_mem_start_address];
+    u64 MemoryRead(u64 vaddr, size_t size) override {
+        switch (size) {
+        case sizeof(u64):
+            return MemoryRead(vaddr, sizeof(u32))
+                | MemoryRead(vaddr + sizeof(u32), sizeof(u32)) << 32;
+        case sizeof(u32):
+            return MemoryRead(vaddr, sizeof(u16))
+                | MemoryRead(vaddr + sizeof(u16), sizeof(u16)) << 16;
+        case sizeof(u16):
+            return MemoryRead(vaddr, sizeof(u8))
+                | MemoryRead(vaddr + sizeof(u8), sizeof(u8)) << 8;
+        case sizeof(u8): {
+            if (IsInCodeMem(vaddr))
+                return reinterpret_cast<u8*>(code_mem.data())[vaddr - code_mem_start_address];
+            if (auto const it = modified_memory.find(vaddr); it != modified_memory.end())
+                return it->second;
+            return u8(vaddr);
+        }
+        default:
+            std::abort();
        }
-        if (auto const it = modified_memory.find(vaddr); it != modified_memory.end())
-            return it->second;
-        return u8(vaddr);
-    }
-    std::uint16_t MemoryRead16(u64 vaddr) override {
-        return u16(MemoryRead8(vaddr)) | u16(MemoryRead8(vaddr + 1)) << 8;
-    }
-    std::uint32_t MemoryRead32(u64 vaddr) override {
-        return u32(MemoryRead16(vaddr)) | u32(MemoryRead16(vaddr + 2)) << 16;
-    }
-    std::uint64_t MemoryRead64(u64 vaddr) override {
-        return u64(MemoryRead32(vaddr)) | u64(MemoryRead32(vaddr + 4)) << 32;
-    }
-    Vector MemoryRead128(u64 vaddr) override {
-        return {MemoryRead64(vaddr), MemoryRead64(vaddr + 8)};
    }

-    void MemoryWrite8(u64 vaddr, std::uint8_t value) override {
-        if (IsInCodeMem(vaddr)) {
-            code_mem_modified_by_guest = true;
+    Vector MemoryRead128(u64 vaddr) override {
+        return {
+            MemoryRead(vaddr, sizeof(u64)),
+            MemoryRead(vaddr + 8, sizeof(u64))
+        };
+    }
+
+    void MemoryWrite(Dynarmic::A64::VAddr vaddr, u64 value, size_t size) override {
+        switch (size) {
+        case sizeof(u64):
+            MemoryWrite(vaddr, u32(value), sizeof(u32));
+            MemoryWrite(vaddr + 4, u32(value >> 32), sizeof(u32));
+            break;
+        case sizeof(u32):
+            MemoryWrite(vaddr, u16(value), sizeof(u16));
+            MemoryWrite(vaddr + 2, u16(value >> 16), sizeof(u16));
+            break;
+        case sizeof(u16):
+            MemoryWrite(vaddr, u8(value), sizeof(u8));
+            MemoryWrite(vaddr + 1, u8(value >> 8), sizeof(u8));
+            break;
+        case sizeof(u8):
+            if (IsInCodeMem(vaddr)) {
+                code_mem_modified_by_guest = true;
+            }
+            modified_memory[vaddr] = value;
+            break;
+        default:
+            std::abort();
        }
-        modified_memory[vaddr] = value;
-    }
-    void MemoryWrite16(u64 vaddr, std::uint16_t value) override {
-        MemoryWrite8(vaddr, u8(value));
-        MemoryWrite8(vaddr + 1, u8(value >> 8));
-    }
-    void MemoryWrite32(u64 vaddr, std::uint32_t value) override {
-        MemoryWrite16(vaddr, u16(value));
-        MemoryWrite16(vaddr + 2, u16(value >> 16));
-    }
-    void MemoryWrite64(u64 vaddr, std::uint64_t value) override {
-        MemoryWrite32(vaddr, u32(value));
-        MemoryWrite32(vaddr + 4, u32(value >> 32));
    }
    void MemoryWrite128(u64 vaddr, Vector value) override {
-        MemoryWrite64(vaddr, value[0]);
-        MemoryWrite64(vaddr + 8, value[1]);
+        MemoryWrite(vaddr, value[0], sizeof(u64));
+        MemoryWrite(vaddr + 8, value[1], sizeof(u64));
    }

    bool MemoryWriteExclusive8(u64 vaddr, std::uint8_t value, [[maybe_unused]] std::uint8_t expected) override {
-        MemoryWrite8(vaddr, value);
+        MemoryWrite(vaddr, value, sizeof(u8));
        return true;
    }
    bool MemoryWriteExclusive16(u64 vaddr, std::uint16_t value, [[maybe_unused]] std::uint16_t expected) override {
-        MemoryWrite16(vaddr, value);
+        MemoryWrite(vaddr, value, sizeof(u16));
        return true;
    }
    bool MemoryWriteExclusive32(u64 vaddr, std::uint32_t value, [[maybe_unused]] std::uint32_t expected) override {
-        MemoryWrite32(vaddr, value);
+        MemoryWrite(vaddr, value, sizeof(u32));
        return true;
    }
    bool MemoryWriteExclusive64(u64 vaddr, std::uint64_t value, [[maybe_unused]] std::uint64_t expected) override {
-        MemoryWrite64(vaddr, value);
+        MemoryWrite(vaddr, value, sizeof(u64));
        return true;
    }
    bool MemoryWriteExclusive128(u64 vaddr, Vector value, [[maybe_unused]] Vector expected) override {
@@ -145,52 +161,46 @@ public:
        return read<std::uint32_t>(vaddr);
    }

-    std::uint8_t MemoryRead8(u64 vaddr) override {
-        return read<std::uint8_t>(vaddr);
-    }
-    std::uint16_t MemoryRead16(u64 vaddr) override {
-        return read<std::uint16_t>(vaddr);
-    }
-    std::uint32_t MemoryRead32(u64 vaddr) override {
-        return read<std::uint32_t>(vaddr);
-    }
-    std::uint64_t MemoryRead64(u64 vaddr) override {
-        return read<std::uint64_t>(vaddr);
+    u64 MemoryRead(u64 vaddr, size_t size) override {
+        switch (size) {
+        case sizeof(u64): return read<u64>(vaddr);
+        case sizeof(u32): return read<u32>(vaddr);
+        case sizeof(u16): return read<u16>(vaddr);
+        case sizeof(u8): return read<u8>(vaddr);
+        default: std::abort();
+        }
    }
    Vector MemoryRead128(u64 vaddr) override {
        return read<Vector>(vaddr);
    }

-    void MemoryWrite8(u64 vaddr, std::uint8_t value) override {
-        write(vaddr, value);
-    }
-    void MemoryWrite16(u64 vaddr, std::uint16_t value) override {
-        write(vaddr, value);
-    }
-    void MemoryWrite32(u64 vaddr, std::uint32_t value) override {
-        write(vaddr, value);
-    }
-    void MemoryWrite64(u64 vaddr, std::uint64_t value) override {
-        write(vaddr, value);
+    void MemoryWrite(u64 vaddr, std::uint64_t value, size_t size) override {
+        switch (size) {
+        case sizeof(u64): return write<u64>(vaddr, u64(value));
+        case sizeof(u32): return write<u32>(vaddr, u32(value));
+        case sizeof(u16): return write<u16>(vaddr, u16(value));
+        case sizeof(u8): return write<u8>(vaddr, u8(value));
+        default: std::abort();
+        }
    }
    void MemoryWrite128(u64 vaddr, Vector value) override {
        write(vaddr, value);
    }

    bool MemoryWriteExclusive8(u64 vaddr, std::uint8_t value, [[maybe_unused]] std::uint8_t expected) override {
-        MemoryWrite8(vaddr, value);
+        MemoryWrite(vaddr, value, sizeof(u8));
        return true;
    }
    bool MemoryWriteExclusive16(u64 vaddr, std::uint16_t value, [[maybe_unused]] std::uint16_t expected) override {
-        MemoryWrite16(vaddr, value);
+        MemoryWrite(vaddr, value, sizeof(u16));
        return true;
    }
    bool MemoryWriteExclusive32(u64 vaddr, std::uint32_t value, [[maybe_unused]] std::uint32_t expected) override {
-        MemoryWrite32(vaddr, value);
+        MemoryWrite(vaddr, value, sizeof(u32));
        return true;
    }
    bool MemoryWriteExclusive64(u64 vaddr, std::uint64_t value, [[maybe_unused]] std::uint64_t expected) override {
-        MemoryWrite64(vaddr, value);
+        MemoryWrite(vaddr, value, sizeof(u64));
        return true;
    }
    bool MemoryWriteExclusive128(u64 vaddr, Vector value, [[maybe_unused]] Vector expected) override {
@@ -18,6 +18,7 @@
 #include <fmt/format.h>
 #include <fmt/ostream.h>
 #include <fmt/ranges.h>
+#include "dynarmic/frontend/A32/translate/translate_callbacks.h"
 #include "dynarmic/mcl/bit.hpp"
 #include "common/common_types.h"

@@ -118,36 +119,47 @@ public:
    u64 ticks_left = 0;
    std::map<u32, u8> memory;

-    std::uint8_t MemoryRead8(u32 vaddr) override {
-        if (auto iter = memory.find(vaddr); iter != memory.end()) {
-            return iter->second;
+    u64 MemoryRead(Dynarmic::A32::VAddr vaddr, size_t size) override {
+        switch (size) {
+        case sizeof(u64):
+            return MemoryRead(vaddr, sizeof(u32))
+                | MemoryRead(vaddr + sizeof(u32), sizeof(u32)) << 32;
+        case sizeof(u32):
+            return MemoryRead(vaddr, sizeof(u16))
+                | MemoryRead(vaddr + sizeof(u16), sizeof(u16)) << 16;
+        case sizeof(u16):
+            return MemoryRead(vaddr, sizeof(u8))
+                | MemoryRead(vaddr + sizeof(u8), sizeof(u8)) << 8;
+        case sizeof(u8): {
+            if (auto const it = memory.find(vaddr); it != memory.end())
+                return it->second;
+            return 0;
+        }
+        default:
+            std::abort();
        }
-        return 0;
-    }
-    std::uint16_t MemoryRead16(u32 vaddr) override {
-        return u16(MemoryRead8(vaddr)) | u16(MemoryRead8(vaddr + 1)) << 8;
-    }
-    std::uint32_t MemoryRead32(u32 vaddr) override {
-        return u32(MemoryRead16(vaddr)) | u32(MemoryRead16(vaddr + 2)) << 16;
-    }
-    std::uint64_t MemoryRead64(u32 vaddr) override {
-        return u64(MemoryRead32(vaddr)) | u64(MemoryRead32(vaddr + 4)) << 32;
    }

-    void MemoryWrite8(u32 vaddr, std::uint8_t value) override {
-        memory[vaddr] = value;
-    }
-    void MemoryWrite16(u32 vaddr, std::uint16_t value) override {
-        MemoryWrite8(vaddr, static_cast<u8>(value));
-        MemoryWrite8(vaddr + 1, static_cast<u8>(value >> 8));
-    }
-    void MemoryWrite32(u32 vaddr, std::uint32_t value) override {
-        MemoryWrite16(vaddr, static_cast<u16>(value));
-        MemoryWrite16(vaddr + 2, static_cast<u16>(value >> 16));
-    }
-    void MemoryWrite64(u32 vaddr, std::uint64_t value) override {
-        MemoryWrite32(vaddr, static_cast<u32>(value));
-        MemoryWrite32(vaddr + 4, static_cast<u32>(value >> 32));
+    void MemoryWrite(Dynarmic::A32::VAddr vaddr, u64 value, size_t size) override {
+        switch (size) {
+        case sizeof(u64):
+            MemoryWrite(vaddr, u32(value), sizeof(u32));
+            MemoryWrite(vaddr + 4, u32(value >> 32), sizeof(u32));
+            break;
+        case sizeof(u32):
+            MemoryWrite(vaddr, u16(value), sizeof(u16));
+            MemoryWrite(vaddr + 2, u16(value >> 16), sizeof(u16));
+            break;
+        case sizeof(u16):
+            MemoryWrite(vaddr, u8(value), sizeof(u8));
+            MemoryWrite(vaddr + 1, u8(value >> 8), sizeof(u8));
+            break;
+        case sizeof(u8):
+            memory[vaddr] = value;
+            break;
+        default:
+            std::abort();
+        }
    }

    void CallSVC(std::uint32_t swi) override {
@@ -231,7 +243,7 @@ void ExecuteA32Instruction(u32 instruction) {
            if (const auto address = get_value()) {
                fmt::print("value: ");
                if (const auto value = get_value()) {
-                    env.MemoryWrite32(*address, *value);
+                    env.MemoryWrite(*address, *value, sizeof(u32));
                    fmt::print("> mem[{:#08x}] = {:#08x}\n", *address, *value);
                }
            }
@@ -247,8 +259,8 @@ void ExecuteA32Instruction(u32 instruction) {
    cpu.SetFpscr(fpscr);

    const u32 initial_pc = regs[15];
-    env.MemoryWrite32(initial_pc + 0, instruction);
-    env.MemoryWrite32(initial_pc + 4, 0xEAFFFFFE);  // B +0
+    env.MemoryWrite(initial_pc + 0, instruction, sizeof(u32));
+    env.MemoryWrite(initial_pc + 4, 0xEAFFFFFE, sizeof(u32));  // B +0

    cpu.Run();
    fmt::print("{}", fmt::join(cpu.Disassemble(), "\n"));
@@ -290,7 +290,7 @@ bool A32Unicorn<TestEnvironment>::UnmappedMemoryHook(uc_engine* uc, uc_mem_type
        auto page = std::make_unique<Page>();
        page->address = base_address;
        for (size_t i = 0; i < page->data.size(); ++i)
-            page->data[i] = this_->testenv.MemoryRead8(static_cast<u32>(base_address + i));
+            page->data[i] = u8(this_->testenv.MemoryRead(u32(base_address + i), sizeof(u8)));

        uc_err err = uc_mem_map_ptr(uc, base_address, page->data.size(), permissions, page->data.data());
        if (err == UC_ERR_MAP)
@@ -321,24 +321,7 @@ bool A32Unicorn<TestEnvironment>::UnmappedMemoryHook(uc_engine* uc, uc_mem_type
 template<class TestEnvironment>
 bool A32Unicorn<TestEnvironment>::MemoryWriteHook(uc_engine* /*uc*/, uc_mem_type /*type*/, u32 start_address, int size, u64 value, void* user_data) {
    auto* this_ = static_cast<A32Unicorn*>(user_data);
-
-    switch (size) {
-    case 1:
-        this_->testenv.MemoryWrite8(start_address, static_cast<u8>(value));
-        break;
-    case 2:
-        this_->testenv.MemoryWrite16(start_address, static_cast<u16>(value));
-        break;
-    case 4:
-        this_->testenv.MemoryWrite32(start_address, static_cast<u32>(value));
-        break;
-    case 8:
-        this_->testenv.MemoryWrite64(start_address, value);
-        break;
-    default:
-        UNREACHABLE();
-    }
-
+    this_->testenv.MemoryWrite(start_address, value, size);
    return true;
 }

@@ -197,7 +197,7 @@ bool A64Unicorn::UnmappedMemoryHook(uc_engine* uc, uc_mem_type /*type*/, u64 sta
        auto page = std::make_unique<Page>();
        page->address = base_address;
        for (size_t i = 0; i < page->data.size(); ++i)
-            page->data[i] = this_->testenv.MemoryRead8(base_address + i);
+            page->data[i] = u8(this_->testenv.MemoryRead(base_address + i, sizeof(u8)));

        uc_err err = uc_mem_map_ptr(uc, base_address, page->data.size(), permissions, page->data.data());
        if (err == UC_ERR_MAP)
@@ -227,23 +227,6 @@ bool A64Unicorn::UnmappedMemoryHook(uc_engine* uc, uc_mem_type /*type*/, u64 sta

 bool A64Unicorn::MemoryWriteHook(uc_engine* /*uc*/, uc_mem_type /*type*/, u64 start_address, int size, u64 value, void* user_data) {
    auto* this_ = static_cast<A64Unicorn*>(user_data);
-
-    switch (size) {
-    case 1:
-        this_->testenv.MemoryWrite8(start_address, static_cast<u8>(value));
-        break;
-    case 2:
-        this_->testenv.MemoryWrite16(start_address, static_cast<u16>(value));
-        break;
-    case 4:
-        this_->testenv.MemoryWrite32(start_address, static_cast<u32>(value));
-        break;
-    case 8:
-        this_->testenv.MemoryWrite64(start_address, value);
-        break;
-    default:
-        UNREACHABLE();
-    }
-
+    this_->testenv.MemoryWrite(start_address, value, size);
    return true;
 }
@@ -28,10 +28,7 @@ enum class NpadMcuState : u32 {
 struct NpadMcuHolder {
    NpadMcuState state;
    INSERT_PADDING_BYTES(0x4);
-    union {
-        IAbstractedPad* abstracted_pad;
-        u64 abstracted_pad_raw;
-    };
+    IAbstractedPad* abstracted_pad;
 };
 static_assert(sizeof(NpadMcuHolder) == 0x10, "NpadMcuHolder is an invalid size");

@@ -33,15 +33,9 @@ public:
    bool is_created{};
    bool is_mapped{};
    INSERT_PADDING_BYTES(0x5);
-    union {
-        Kernel::KSharedMemory* shared_memory = nullptr;
-        u64 shared_memory_raw;
-    };
+    Kernel::KSharedMemory* shared_memory;
    INSERT_PADDING_BYTES(0x38);
-    union {
-        SharedMemoryFormat* address = nullptr;
-        u64 address_raw;
-    };
+    SharedMemoryFormat* address = nullptr;
 };
 // Correct size is 0x50 bytes
 static_assert(sizeof(SharedMemoryHolder) == 0x50, "SharedMemoryHolder is an invalid size");
@@ -15,6 +15,8 @@ add_library(input_common STATIC
    drivers/tas_input.h
    drivers/touch_screen.cpp
    drivers/touch_screen.h
+    drivers/udp_client.cpp
+    drivers/udp_client.h
    drivers/virtual_amiibo.cpp
    drivers/virtual_amiibo.h
    drivers/virtual_gamepad.cpp
@@ -32,12 +34,8 @@ add_library(input_common STATIC
    input_poller.cpp
    input_poller.h
    main.cpp
-    main.h)
-if (NOT PLATFORM_EMSCRIPTEN)
-    target_sources(input_common PRIVATE
-        drivers/udp_client.cpp
-        drivers/udp_client.h)
-endif()
+    main.h
+)

 if (MSVC)
    target_compile_options(input_common PRIVATE
@@ -12,6 +12,7 @@
 #include "input_common/drivers/mouse.h"
 #include "input_common/drivers/tas_input.h"
 #include "input_common/drivers/touch_screen.h"
+#include "input_common/drivers/udp_client.h"
 #include "input_common/drivers/virtual_amiibo.h"
 #include "input_common/drivers/virtual_gamepad.h"
 #include "input_common/helpers/stick_from_buttons.h"
@@ -20,9 +21,6 @@
 #include "input_common/input_mapping.h"
 #include "input_common/input_poller.h"
 #include "input_common/main.h"
-#ifndef __EMSCRIPTEN__
-#include "input_common/drivers/udp_client.h"
-#endif

 #ifdef ENABLE_LIBUSB
 #include "input_common/drivers/gc_adapter.h"
@@ -84,9 +82,7 @@ struct InputSubsystem::Impl {
 #ifdef ENABLE_LIBUSB
        RegisterEngine("gcpad", gcadapter);
 #endif
-#ifndef __EMSCRIPTEN__
        RegisterEngine("cemuhookudp", udp_client);
-#endif
        RegisterEngine("tas", tas_input);
        RegisterEngine("camera", camera);
 #ifdef __ANDROID__
@@ -120,9 +116,7 @@ struct InputSubsystem::Impl {
 #ifdef ENABLE_LIBUSB
        UnregisterEngine(gcadapter);
 #endif
-#ifndef __EMSCRIPTEN__
        UnregisterEngine(udp_client);
-#endif
        UnregisterEngine(tas_input);
        UnregisterEngine(camera);
 #ifdef __ANDROID__
@@ -158,10 +152,8 @@ struct InputSubsystem::Impl {
        auto gcadapter_devices = gcadapter->GetInputDevices();
        devices.insert(devices.end(), gcadapter_devices.begin(), gcadapter_devices.end());
 #endif
-#ifndef __EMSCRIPTEN__
        auto udp_devices = udp_client->GetInputDevices();
        devices.insert(devices.end(), udp_devices.begin(), udp_devices.end());
-#endif
 #ifdef HAVE_SDL3
        auto joycon_devices = joycon->GetInputDevices();
        devices.insert(devices.end(), joycon_devices.begin(), joycon_devices.end());
@@ -194,11 +186,9 @@ struct InputSubsystem::Impl {
            return gcadapter;
        }
 #endif
-#ifndef __EMSCRIPTEN__
        if (engine == udp_client->GetEngineName()) {
            return udp_client;
        }
-#endif
 #ifdef HAVE_SDL3
        if (engine == sdl->GetEngineName()) {
            return sdl;
@@ -281,11 +271,9 @@ struct InputSubsystem::Impl {
            return true;
        }
 #endif
-#ifndef __EMSCRIPTEN__
        if (engine == udp_client->GetEngineName()) {
            return true;
        }
-#endif
        if (engine == tas_input->GetEngineName()) {
            return true;
        }
@@ -312,9 +300,7 @@ struct InputSubsystem::Impl {
 #ifdef ENABLE_LIBUSB
        gcadapter->BeginConfiguration();
 #endif
-#ifndef __EMSCRIPTEN__
        udp_client->BeginConfiguration();
-#endif
 #ifdef HAVE_SDL3
        sdl->BeginConfiguration();
        joycon->BeginConfiguration();
@@ -330,9 +316,7 @@ struct InputSubsystem::Impl {
 #ifdef ENABLE_LIBUSB
        gcadapter->EndConfiguration();
 #endif
-#ifndef __EMSCRIPTEN__
        udp_client->EndConfiguration();
-#endif
 #ifdef HAVE_SDL3
        sdl->EndConfiguration();
        joycon->EndConfiguration();
@@ -357,9 +341,7 @@ struct InputSubsystem::Impl {
    std::shared_ptr<Mouse> mouse;
    std::shared_ptr<TouchScreen> touch_screen;
    std::shared_ptr<TasInput::Tas> tas_input;
-#ifndef __EMSCRIPTEN__
    std::shared_ptr<CemuhookUDP::UDPClient> udp_client;
-#endif
    std::shared_ptr<Camera> camera;
    std::shared_ptr<VirtualAmiibo> virtual_amiibo;
    std::shared_ptr<VirtualGamepad> virtual_gamepad;
@@ -488,9 +470,7 @@ bool InputSubsystem::IsStickInverted(const Common::ParamPackage& params) const {
 }

 void InputSubsystem::ReloadInputDevices() {
-#ifndef __EMSCRIPTEN__
    impl->udp_client.get()->ReloadSockets();
-#endif
 }

 void InputSubsystem::BeginMapping(Polling::InputType type) {
@@ -257,7 +257,8 @@ else()
        # Bracket depth determines maximum size of a fold expression in Clang since 9c9974c3ccb6.
        # And this in turns limits the size of a std::array.
        $<$<CXX_COMPILER_ID:Clang>:-fbracket-depth=1024>
-        $<$<CXX_COMPILER_ID:AppleClang>:-fbracket-depth=1024>)
+        $<$<CXX_COMPILER_ID:AppleClang>:-fbracket-depth=1024>
+    )
 endif()

 create_target_directory_groups(shader_recompiler)
@@ -31,7 +31,7 @@ struct CbufWordKey {

 struct CbufWordKeyHash {
    constexpr size_t operator()(const CbufWordKey& k) const noexcept {
-        return size_t((u64(k.index) << 32) ^ u64(k.offset));
+        return (size_t(k.index) << 32) ^ k.offset;
    }
 };

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

@@ -160,14 +157,16 @@ IR::Value Sample(TranslatorVisitor& v, u64 insn) {

 unsigned Swizzle(u64 insn) {
    const Encoding texs{insn};
-    u8 const encoding = u8(texs.swizzle);
+    const size_t encoding{texs.swizzle};
    if (texs.dest_reg_b == IR::Reg::RZ) {
-        if (encoding >= RG_LUT.size())
+        if (encoding >= RG_LUT.size()) {
            throw NotImplementedException("Illegal RG encoding {}", encoding);
+        }
        return RG_LUT[encoding];
    } else {
-        if (encoding >= RGBA_LUT.size())
+        if (encoding >= RGBA_LUT.size()) {
            throw NotImplementedException("Illegal RGBA encoding {}", encoding);
+        }
        return RGBA_LUT[encoding];
    }
 }
@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

@@ -145,14 +142,16 @@ IR::Value Sample(TranslatorVisitor& v, u64 insn) {

 unsigned Swizzle(u64 insn) {
    const Encoding tlds{insn};
-    u8 const encoding = u8(tlds.swizzle);
+    const size_t encoding{tlds.swizzle};
    if (tlds.dest_reg_b == IR::Reg::RZ) {
-        if (encoding >= RG_LUT.size())
+        if (encoding >= RG_LUT.size()) {
            throw NotImplementedException("Illegal RG encoding {}", encoding);
+        }
        return RG_LUT[encoding];
    } else {
-        if (encoding >= RGBA_LUT.size())
+        if (encoding >= RGBA_LUT.size()) {
            throw NotImplementedException("Illegal RGBA encoding {}", encoding);
+        }
        return RGBA_LUT[encoding];
    }
 }
@@ -75,15 +75,3 @@ if (NOT MSVC)
        $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-unused-parameter>
        $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-missing-field-initializers>)
 endif()
-
-if (PLATFORM_EMSCRIPTEN)
-    # 10GB is required at max... yikes!
-    target_link_options(yuzu-cmd PRIVATE
-        -sALLOW_MEMORY_GROWTH=1
-        -sINITIAL_MEMORY=33554432
-        -sMAXIMUM_MEMORY=10737418240
-        -sGLOBAL_BASE=16777216
-        -sEXPORTED_RUNTIME_METHODS=['FS']
-        -sPTHREAD_POOL_SIZE_STRICT=0
-        -sPTHREAD_POOL_SIZE=navigator.hardwareConcurrency)
-endif()
@@ -30,7 +30,6 @@ Tools for Eden and other subprojects. When adding new scripts please use `#!/bin
 - `find-unused-strings.sh`: Find any unused strings in the Android app (XML -> Kotlin).
 - `cpp-lint.sh`: Homemade dumb C++ linter.
 - `fuzzsettings.cpp`: Fuzz settings files.
- `miniserver.js`: Make a quick server that serves a page with the WASM on it, takes a single argument which is the path to the build directory containing *both* `eden-cli.js` and `eden-cli.wasm`. Run via `node.js`, `wasmtime` isn't supported.

 ## Android
 It's recommended to run these scritps after almost any Android change, as they are relatively fast and important both for APK bloat and CI.
@@ -1,127 +0,0 @@
-#!/usr/bin/env node
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-import { createServer } from 'http';
-import { readFile } from 'fs';
-import { join } from 'path';
-console.log(`dont forget to run: "npm --global install @jdmichaud/dwarf-2-sourcemap" for better debugging!`);
-const server = createServer((req, res) => {
-    console.log(`get ${req.url}`);
-    if (req.url === '/') {
-        // https://developer.mozilla.org/en-US/docs/WebAssembly/Guides/Loading_and_running
-        // If your browser doesn't support fetch... HAHA GET FUCKED
-        res.writeHead(200, {
-            'Content-Type': 'text/html',
-            'Cross-Origin-Opener-Policy': 'same-origin',
-            'Cross-Origin-Embedder-Policy': 'require-corp'
-        });
-        res.end(`<!DOCTYPE html>
-<html>
-<head>
-<title>eden-cli</title>
-</head>
-<body style="margin:0;padding:0;background-color:black;color:white;font-family:Monospace,Tahoma,Arial;">
-<div style="display:grid;grid-template-columns:1fr 1fr;gap:2px;width:100%;height:100vh;">
-    <canvas id="canvas" oncontextmenu="event.preventDefault()" style="width:100%;height:100%;background-color:gray;"></canvas>
-    <div id="tty-stdout"></div>
-</div>
-<script>
-var Module = { //do not prepend var
-    mainScriptUrlOrBlob: 'eden-cli.js',
-    arguments: ['--null-render', '--singlecore', '--filter', '*:Trace', '/home/web_user/game.nro'],
-    canvas: document.getElementById('canvas'),
-    print: (e) => {
-        e = e.replace('[1;31m', '<span style="color:red;font-weight:bold;">');
-        e = e.replace('[0;37m', '<span style="color:white;font-weight:bold;">');
-        e = e.replace('[1;35m', '<span style="color:pink;font-weight:bold;">');
-        e = e.replace('[1;33m', '<span style="color:yellow;font-weight:bold;">');
-        e = e.replace('[0;36m', '<span style="color:white;font-weight:bold;">');
-        e = e.replace('[0m', '</span>');
-        document.getElementById('tty-stdout').innerHTML += \`\${e}</br>\`;
-    },
-    printErr: (e) => {
-        document.getElementById('tty-stdout').innerHTML += \`<span style="color:red">\${e}</span></br>\`;
-    },
-    // not a wasm func but idc
-    printInternal: (e) => {
-        document.getElementById('tty-stdout').innerHTML += \`<span style="color:white">Internal WASM: \${e}</span></br>\`;
-    },
-    preInit: [
-        () => {
-            // copy just most relevant :)
-            Module.FS.mkdir('/home/web_user/.local');
-            Module.FS.mkdir('/home/web_user/.local/share');
-            Module.FS.mkdir('/home/web_user/.local/share/eden');
-            Module.FS.mkdir('/home/web_user/.config');
-            Module.FS.mkdir('/home/web_user/.config/eden');
-            Module.FS.createDataFile('/home/web_user', 'game.nro', gameNroFileBuffer, true, false, true);
-        }
-    ],
-    onRuntimeInitialized: () => { Module.printInternal("runtime ok"); },
-    setStatus: (e) => { Module.printInternal(e); },
-    monitorRunDependencies: (e) => { Module.printInternal("monitor deps: " + e); },
-    __wasm_call_ctors: () => { Module.printInternal("ctors beep"); },
-};
-var gameNroFileBuffer = {};
-Module.printInternal(\`Atomics: \${window.Atomics}, SharedArrayBuffer: \${window.SharedArrayBuffer}\`);
-Module.printInternal("trying to load script (if it hangs here check console)");
-fetch('game.nro').then((resp) => {
-    if (!resp.ok)
-        throw Error(\`\${resp.status}\`);
-    return resp.bytes();
-}).then((buffer) => {
-    gameNroFileBuffer = buffer;
-    // load the thingy AFTER loading the nro
-    Module.printInternal(\`loading from ${build_dir}/\${Module.mainScriptUrlOrBlob}\`);
-    var script = document.createElement('script');
-    script.src = '/eden-cli.js';
-    script.onload = (e) => Module.printInternal(\`loaded WASMy script \${e}!!\`);
-    document.head.appendChild(script);
-}).catch(Module.printErr);
-</script>
-</body>
-</html>`);
-    } else if (req.url === '/eden-cli.js') {
-        readFile(join(build_dir, 'eden-cli.js'), (err, content) => {
-            res.writeHead(200, {
-                'Content-Type': 'application/javascript',
-                'Cross-Origin-Opener-Policy': 'same-origin',
-                'Cross-Origin-Embedder-Policy': 'require-corp'
-            });
-            res.end(content, 'utf-8');
-        });
-    } else if (req.url === '/eden-cli.wasm') {
-        readFile(join(build_dir, 'eden-cli.wasm'), (err, content) => {
-            res.writeHead(200, {
-                'Content-Type': 'application/wasm',
-                'Cross-Origin-Opener-Policy': 'same-origin',
-                'Cross-Origin-Embedder-Policy': 'require-corp'
-            });
-            res.end(content);
-        });
-    } else if (req.url === '/game.nro') {
-        readFile(nro_file, (err, content) => {
-            res.writeHead(200, {
-                'Content-Type': 'application/octet-stream',
-                'Cross-Origin-Opener-Policy': 'same-origin',
-                'Cross-Origin-Embedder-Policy': 'require-corp'
-            });
-            res.end(content);
-        });
-    } else {
-        res.writeHead(404, {});
-        res.end('', 'utf-8');
-    }
-});
-
-const build_dir = process.argv[2];
-const nro_file = process.argv[3];
-if (typeof build_dir == "undefined" || typeof nro_file == "undefined") {
-    console.log(`Usage: ${process.argv[0]} ${process.argv[1]} [build directory] [NRO file]`);
-} else {
-    server.listen(2210, () => {
-        console.log(`${process.argv[0]} ${process.argv[1]} http://localhost:2210`);
-        console.log(`build dir = ${build_dir}`);
-    });
-}
Author	SHA1	Message	Date
lizzie	a8d38a0fce	aaaaaaaaaaarch	2026-08-13 05:34:28 +00:00
lizzie	450c69d873	fix arm	2026-08-13 05:34:28 +00:00
lizzie	e62d67e1a0	[dynarmic] Coalesce Write/Read fallback functions Signed-off-by: lizzie <lizzie@eden-emu.dev>	2026-08-13 05:34:28 +00:00