Update ja_JP.ts

Fixed uncomfortable sentences and added some translations.
2022-06-08 20:52:25 +09:00
397 changed files with 11256 additions and 16769 deletions
@@ -3,12 +3,14 @@
 # Exit on error, rather than continuing with the rest of the script.
 set -e

+cd /yuzu
+
 ccache -s

 mkdir build || true && cd build
-cmake .. -GNinja -DDISPLAY_VERSION=$1 -DCMAKE_BUILD_TYPE=Release -DCMAKE_C_COMPILER=/usr/lib/ccache/clang -DCMAKE_CXX_COMPILER=/usr/lib/ccache/clang++ -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${ENABLE_COMPATIBILITY_REPORTING:-"OFF"} -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DUSE_DISCORD_PRESENCE=ON -DENABLE_QT_TRANSLATION=ON -DCMAKE_INSTALL_PREFIX="/usr"
+cmake .. -DDISPLAY_VERSION=$1 -DCMAKE_BUILD_TYPE=Release -DCMAKE_C_COMPILER=/usr/lib/ccache/clang -DCMAKE_CXX_COMPILER=/usr/lib/ccache/clang++ -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${ENABLE_COMPATIBILITY_REPORTING:-"OFF"} -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DUSE_DISCORD_PRESENCE=ON -DENABLE_QT_TRANSLATION=ON -DCMAKE_INSTALL_PREFIX="/usr"

-ninja
+make -j$(nproc)

 ccache -s

@@ -4,5 +4,5 @@ mkdir -p "ccache"  || true
 chmod a+x ./.ci/scripts/clang/docker.sh
 # the UID for the container yuzu user is 1027
 sudo chown -R 1027 ./
-docker run -e ENABLE_COMPATIBILITY_REPORTING -e CCACHE_DIR=/yuzu/ccache -v "$(pwd):/yuzu" -w /yuzu yuzuemu/build-environments:linux-fresh /bin/bash /yuzu/.ci/scripts/clang/docker.sh "$1"
+docker run -e ENABLE_COMPATIBILITY_REPORTING -e CCACHE_DIR=/yuzu/ccache -v $(pwd):/yuzu yuzuemu/build-environments:linux-fresh /bin/bash /yuzu/.ci/scripts/clang/docker.sh $1
 sudo chown -R $UID ./
@@ -4,10 +4,8 @@
 cp license.txt "$DIR_NAME"
 cp README.md "$DIR_NAME"

-if [[ -z "${NO_SOURCE_PACK}" ]]; then
-  tar -cJvf "${REV_NAME}-source.tar.xz" src externals CMakeLists.txt README.md license.txt
-  cp -v "${REV_NAME}-source.tar.xz" "$DIR_NAME"
-fi
+tar -cJvf "${REV_NAME}-source.tar.xz" src externals CMakeLists.txt README.md license.txt
+cp "${REV_NAME}-source.tar.xz" "$DIR_NAME"

 tar $COMPRESSION_FLAGS "$ARCHIVE_NAME" "$DIR_NAME"

@@ -3,5 +3,5 @@
 chmod a+x ./.ci/scripts/format/docker.sh
 # the UID for the container yuzu user is 1027
 sudo chown -R 1027 ./
-docker run -v "$(pwd):/yuzu" -w /yuzu yuzuemu/build-environments:linux-clang-format /bin/bash -ex /yuzu/.ci/scripts/format/docker.sh
+docker run -v $(pwd):/yuzu yuzuemu/build-environments:linux-clang-format /bin/bash -ex /yuzu/.ci/scripts/format/docker.sh
 sudo chown -R $UID ./
@@ -3,6 +3,8 @@
 # Exit on error, rather than continuing with the rest of the script.
 set -e

+cd /yuzu
+
 ccache -s

 mkdir build || true && cd build
@@ -17,16 +19,15 @@ cmake .. \
      -DENABLE_QT_TRANSLATION=ON \
      -DUSE_DISCORD_PRESENCE=ON \
      -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${ENABLE_COMPATIBILITY_REPORTING:-"OFF"} \
-      -DYUZU_USE_BUNDLED_FFMPEG=ON \
-      -GNinja
+      -DYUZU_USE_BUNDLED_FFMPEG=ON

-ninja
+make -j$(nproc)

 ccache -s

 ctest -VV -C Release

-DESTDIR="$PWD/AppDir" ninja install
+make install DESTDIR=AppDir
 rm -vf AppDir/usr/bin/yuzu-cmd AppDir/usr/bin/yuzu-tester

 # Download tools needed to build an AppImage
@@ -4,5 +4,5 @@ mkdir -p "ccache"  || true
 chmod a+x ./.ci/scripts/linux/docker.sh
 # the UID for the container yuzu user is 1027
 sudo chown -R 1027 ./
-docker run -e ENABLE_COMPATIBILITY_REPORTING -e CCACHE_DIR=/yuzu/ccache -v "$(pwd):/yuzu" -w /yuzu yuzuemu/build-environments:linux-fresh /bin/bash /yuzu/.ci/scripts/linux/docker.sh "$1"
+docker run -e ENABLE_COMPATIBILITY_REPORTING -e CCACHE_DIR=/yuzu/ccache -v $(pwd):/yuzu yuzuemu/build-environments:linux-fresh /bin/bash /yuzu/.ci/scripts/linux/docker.sh $1
 sudo chown -R $UID ./
@@ -24,11 +24,6 @@ cd build
 wget -nc https://github.com/yuzu-emu/ext-linux-bin/raw/main/appimage/appimagetool-x86_64.AppImage
 chmod 755 appimagetool-x86_64.AppImage

-# if FUSE is not available, then fallback to extract and run
-if ! ./appimagetool-x86_64.AppImage --version; then
-    export APPIMAGE_EXTRACT_AND_RUN=1
-fi
-
 if [ "${RELEASE_NAME}" = "mainline" ]; then
    # Generate update information if releasing to mainline
    ./appimagetool-x86_64.AppImage -u "gh-releases-zsync|yuzu-emu|yuzu-${RELEASE_NAME}|latest|yuzu-*.AppImage.zsync" AppDir "${APPIMAGE_NAME}"
@@ -1,33 +1,14 @@
 #!/bin/bash -ex

-set -e
+cd /yuzu

-#cd /yuzu
+ccache -s

-ccache -sv
+mkdir build || true && cd build
+cmake .. -G Ninja -DDISPLAY_VERSION=$1 -DCMAKE_TOOLCHAIN_FILE="$(pwd)/../CMakeModules/MinGWCross.cmake" -DUSE_CCACHE=ON -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DCMAKE_BUILD_TYPE=Release -DENABLE_QT_TRANSLATION=ON
+ninja

-mkdir -p "$HOME/.conan/profiles"
-wget -c "https://github.com/yuzu-emu/build-environments/raw/master/linux-mingw/default" -O "$HOME/.conan/profiles/default"
-wget -c "https://github.com/yuzu-emu/build-environments/raw/master/linux-mingw/settings.yml" -O "$HOME/.conan/settings.yml"
-
-mkdir -p build && cd build
-export LDFLAGS="-fuse-ld=lld"
-# -femulated-tls required due to an incompatibility between GCC and Clang
-# TODO(lat9nq): If this is widespread, we probably need to add this to CMakeLists where appropriate
-export CXXFLAGS="-femulated-tls"
-cmake .. \
-    -DCMAKE_BUILD_TYPE=Release \
-    -DCMAKE_TOOLCHAIN_FILE="${PWD}/../CMakeModules/MinGWClangCross.cmake" \
-    -DDISPLAY_VERSION="$1" \
-    -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON \
-    -DENABLE_QT_TRANSLATION=ON \
-    -DUSE_CCACHE=ON \
-    -DYUZU_USE_BUNDLED_SDL2=OFF \
-    -DYUZU_USE_EXTERNAL_SDL2=OFF \
-    -GNinja
-ninja yuzu yuzu-cmd
-
-ccache -sv
+ccache -s

 echo "Tests skipped"
 #ctest -VV -C Release
@@ -4,5 +4,5 @@ mkdir -p "ccache" || true
 chmod a+x ./.ci/scripts/windows/docker.sh
 # the UID for the container yuzu user is 1027
 sudo chown -R 1027 ./
-docker run -e CCACHE_DIR=/yuzu/ccache -v "$(pwd):/yuzu" -w /yuzu yuzuemu/build-environments:linux-mingw /bin/bash -ex /yuzu/.ci/scripts/windows/docker.sh "$1"
+docker run -e CCACHE_DIR=/yuzu/ccache -v $(pwd):/yuzu yuzuemu/build-environments:linux-mingw /bin/bash -ex /yuzu/.ci/scripts/windows/docker.sh $1
 sudo chown -R $UID ./
@@ -1,115 +0,0 @@
-name: 'yuzu verify'
-
-on:
-  pull_request:
-    branches: [ master ]
-
-jobs:
-  format:
-    name: 'verify format'
-    runs-on: ubuntu-latest
-    container:
-      image: yuzuemu/build-environments:linux-clang-format
-      options: -u 1001
-    steps:
-      - uses: actions/checkout@v2
-        with:
-          submodules: false
-      - name: 'Verify Formatting'
-        run: bash -ex ./.ci/scripts/format/script.sh
-  build:
-    name: 'test build'
-    needs: format
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - type: clang
-            image: linux-fresh
-          - type: linux
-            image: linux-fresh
-          - type: windows
-            image: linux-mingw
-    container:
-      image: yuzuemu/build-environments:${{ matrix.image }}
-      options: -u 1001
-    steps:
-      - uses: actions/checkout@v2
-        with:
-          submodules: recursive
-          fetch-depth: 0
-      - name: Set up cache
-        uses: actions/cache@v2
-        id: ccache-restore
-        with:
-          path: ~/.ccache
-          key: ${{ runner.os }}-${{ matrix.type }}-${{ github.sha }}
-          restore-keys: |
-            ${{ runner.os }}-${{ matrix.type }}-
-      - name: Create ccache directory
-        if: steps.ccache-restore.outputs.cache-hit != 'true'
-        run: mkdir -p ~/.ccache
-      - name: Build
-        run: ./.ci/scripts/${{ matrix.type }}/docker.sh
-        env:
-          ENABLE_COMPATIBILITY_REPORTING: "ON"
-      - name: Pack
-        run: ./.ci/scripts/${{ matrix.type }}/upload.sh
-        env:
-          NO_SOURCE_PACK: "YES"
-      - name: Upload
-        uses: actions/upload-artifact@v3
-        with:
-          name: ${{ matrix.type }}
-          path: artifacts/
-  build-msvc:
-    name: 'test build (windows, msvc)'
-    needs: format
-    runs-on: windows-2019
-    steps:
-      - name: Set up cache
-        uses: actions/cache@v2
-        with:
-          path: ~/.buildcache
-          key: ${{ runner.os }}-msvc-${{ github.sha }}
-          restore-keys: |
-            ${{ runner.os }}-msvc-
-      - name: Install dependencies
-        # due to how chocolatey works, only cmd.exe is supported here
-        shell: cmd
-        run: |
-          choco install vulkan-sdk wget
-          python -m pip install --upgrade pip conan
-          call refreshenv
-          wget https://github.com/mbitsnbites/buildcache/releases/download/v0.27.6/buildcache-windows.zip
-          7z x buildcache-windows.zip
-          copy buildcache\bin\buildcache.exe C:\ProgramData\chocolatey\bin
-          rmdir buildcache
-          echo %PATH% >> %GITHUB_PATH%
-      - name: Set up MSVC
-        uses: ilammy/msvc-dev-cmd@v1
-      - uses: actions/checkout@v2
-        with:
-          submodules: recursive
-          fetch-depth: 0
-      - name: Configure
-        env:
-          CC: cl.exe
-          CXX: cl.exe
-        run: |
-          glslangValidator --version
-          mkdir build
-          cmake . -B build -GNinja -DCMAKE_TOOLCHAIN_FILE="CMakeModules/MSVCCache.cmake" -DUSE_CCACHE=ON -DYUZU_USE_BUNDLED_QT=1 -DYUZU_USE_BUNDLED_SDL2=1 -DYUZU_USE_QT_WEB_ENGINE=ON -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DYUZU_ENABLE_COMPATIBILITY_REPORTING=ON -DUSE_DISCORD_PRESENCE=ON -DENABLE_QT_TRANSLATION=ON -DCMAKE_BUILD_TYPE=Release
-      - name: Build
-        run: cmake --build build
-      - name: Cache Summary
-        run: buildcache -s
-      - name: Pack
-        shell: pwsh
-        run: .\.ci\scripts\windows\upload.ps1
-      - name: Upload
-        uses: actions/upload-artifact@v3
-        with:
-          name: msvc
-          path: artifacts/
@@ -627,14 +627,6 @@ add_definitions(-DBOOST_ERROR_CODE_HEADER_ONLY
    -DBOOST_DATE_TIME_NO_LIB
    -DBOOST_REGEX_NO_LIB
 )
-# Adjustments for MSVC + Ninja
-if (MSVC AND CMAKE_GENERATOR STREQUAL "Ninja")
-    add_compile_options(
-        /wd4711 # function 'function' selected for automatic inline expansion
-        /wd4464 # relative include path contains '..'
-        /wd4820 # 'identifier1': '4' bytes padding added after data member 'identifier2'
-    )
-endif()

 enable_testing()
 add_subdirectory(externals)
@@ -2,6 +2,5 @@ function(copy_yuzu_FFmpeg_deps target_dir)
    include(WindowsCopyFiles)
    set(DLL_DEST "${CMAKE_BINARY_DIR}/bin/$<CONFIG>/")
    file(READ "${FFmpeg_PATH}/requirements.txt" FFmpeg_REQUIRED_DLLS)
-    string(STRIP "${FFmpeg_REQUIRED_DLLS}" FFmpeg_REQUIRED_DLLS)
    windows_copy_files(${target_dir} ${FFmpeg_DLL_DIR} ${DLL_DEST} ${FFmpeg_REQUIRED_DLLS})
 endfunction(copy_yuzu_FFmpeg_deps)
@@ -1,12 +0,0 @@
-# buildcache wrapper
-OPTION(USE_CCACHE "Use buildcache for compilation" OFF)
-IF(USE_CCACHE)
-    FIND_PROGRAM(CCACHE buildcache)
-    IF (CCACHE)
-        MESSAGE(STATUS "Using buildcache found in PATH")
-        SET_PROPERTY(GLOBAL PROPERTY RULE_LAUNCH_COMPILE ${CCACHE})
-        SET_PROPERTY(GLOBAL PROPERTY RULE_LAUNCH_LINK ${CCACHE})
-    ELSE(CCACHE)
-        MESSAGE(WARNING "USE_CCACHE enabled, but no buildcache executable found")
-    ENDIF(CCACHE)
-ENDIF(USE_CCACHE)
@@ -1,55 +0,0 @@
-set(MINGW_PREFIX                /usr/x86_64-w64-mingw32/)
-set(CMAKE_SYSTEM_NAME           Windows)
-set(CMAKE_SYSTEM_PROCESSOR      x86_64)
-
-set(CMAKE_FIND_ROOT_PATH        ${MINGW_PREFIX})
-set(SDL2_PATH                   ${MINGW_PREFIX})
-set(MINGW_TOOL_PREFIX           ${CMAKE_SYSTEM_PROCESSOR}-w64-mingw32-)
-
-# Specify the cross compiler
-set(CMAKE_C_COMPILER            ${MINGW_TOOL_PREFIX}clang)
-set(CMAKE_CXX_COMPILER          ${MINGW_TOOL_PREFIX}clang++)
-set(CMAKE_RC_COMPILER           ${MINGW_TOOL_PREFIX}windres)
-set(CMAKE_C_COMPILER_AR         ${MINGW_TOOL_PREFIX}ar)
-set(CMAKE_CXX_COMPILER_AR       ${MINGW_TOOL_PREFIX}ar)
-set(CMAKE_C_COMPILER_RANLIB     ${MINGW_TOOL_PREFIX}ranlib)
-set(CMAKE_CXX_COMPILER_RANLIB   ${MINGW_TOOL_PREFIX}ranlib)
-
-# Mingw tools
-set(STRIP                       ${MINGW_TOOL_PREFIX}strip)
-set(WINDRES                     ${MINGW_TOOL_PREFIX}windres)
-set(ENV{PKG_CONFIG}             ${MINGW_TOOL_PREFIX}pkg-config)
-
-# ccache wrapper
-option(USE_CCACHE "Use ccache for compilation" OFF)
-if(USE_CCACHE)
-    find_program(CCACHE ccache)
-    if(CCACHE)
-        message(STATUS "Using ccache found in PATH")
-        set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE ${CCACHE})
-        set_property(GLOBAL PROPERTY RULE_LAUNCH_LINK ${CCACHE})
-    else(CCACHE)
-        message(WARNING "USE_CCACHE enabled, but no ccache found")
-    endif(CCACHE)
-endif(USE_CCACHE)
-
-# Search for programs in the build host directories
-set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
-
-
-# Echo modified cmake vars to screen for debugging purposes
-if(NOT DEFINED ENV{MINGW_DEBUG_INFO})
-        message("")
-        message("Custom cmake vars: (blank = system default)")
-        message("-----------------------------------------")
-        message("* CMAKE_C_COMPILER                     : ${CMAKE_C_COMPILER}")
-        message("* CMAKE_CXX_COMPILER                   : ${CMAKE_CXX_COMPILER}")
-        message("* CMAKE_RC_COMPILER                    : ${CMAKE_RC_COMPILER}")
-        message("* WINDRES                              : ${WINDRES}")
-        message("* ENV{PKG_CONFIG}                      : $ENV{PKG_CONFIG}")
-        message("* STRIP                                : ${STRIP}")
-        message("* USE_CCACHE                           : ${USE_CCACHE}")
-        message("")
-        # So that the debug info only appears once
-        set(ENV{MINGW_DEBUG_INFO} SHOWN)
-endif()
@@ -58,19 +58,6 @@ QPushButton#GPUStatusBarButton:!checked {
    color: #109010;
 }

-QPushButton#DockingStatusBarButton {
-    min-width: 0px;
-    color: #000000;
-    border: 1px solid transparent;
-    background-color: transparent;
-    padding: 0px 3px 0px 3px;
-    text-align: center;
-}
-
-QPushButton#DockingStatusBarButton:hover {
-    border: 1px solid #76797C;
-}
-
 QPushButton#buttonRefreshDevices {
    min-width: 21px;
    min-height: 21px;
@@ -1304,19 +1304,6 @@ QPushButton#GPUStatusBarButton:!checked {
    color: #40dd40;
 }

-QPushButton#DockingStatusBarButton {
-    min-width: 0px;
-    color: #ffffff;
-    border: 1px solid transparent;
-    background-color: transparent;
-    padding: 0px 3px 0px 3px;
-    text-align: center;
-}
-
-QPushButton#DockingStatusBarButton:hover {
-    border: 1px solid #76797C;
-}
-
 QPushButton#buttonRefreshDevices {
    min-width: 23px;
    min-height: 23px;
@@ -2207,19 +2207,6 @@ QPushButton#GPUStatusBarButton:!checked {
  color: #40dd40;
 }

-QPushButton#DockingStatusBarButton {
-    min-width: 0px;
-    color: #ffffff;
-    border: 1px solid transparent;
-    background-color: transparent;
-    padding: 0px 3px 0px 3px;
-    text-align: center;
-}
-
-QPushButton#DockingStatusBarButton:hover {
-    border: 1px solid #76797C;
-}
-
 QPushButton#buttonRefreshDevices {
  min-width: 19px;
  min-height: 19px;
@@ -40,11 +40,6 @@ target_include_directories(mbedtls PUBLIC ./mbedtls/include)
 add_library(microprofile INTERFACE)
 target_include_directories(microprofile INTERFACE ./microprofile)

-# GCC bugs
-if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL "12" AND CMAKE_CXX_COMPILER_ID STREQUAL "GNU" AND MINGW)
-    target_compile_options(microprofile INTERFACE "-Wno-array-bounds")
-endif()
-
 # libusb
 if (NOT LIBUSB_FOUND OR YUZU_USE_BUNDLED_LIBUSB)
    add_subdirectory(libusb)
@@ -1246,7 +1246,7 @@ struct MicroProfileScopeLock
 {
    bool bUseLock;
    std::recursive_mutex& m;
-    MicroProfileScopeLock(std::recursive_mutex& m_) : bUseLock(g_bUseLock), m(m_)
+    MicroProfileScopeLock(std::recursive_mutex& m) : bUseLock(g_bUseLock), m(m)
    {
        if(bUseLock)
            m.lock();
@@ -213,8 +213,8 @@ struct MicroProfileCustom

 struct SOptionDesc
 {
-    SOptionDesc()=default;
-    SOptionDesc(uint8_t nSubType_, uint8_t nIndex_, const char* fmt, ...):nSubType(nSubType_), nIndex(nIndex_)
+    SOptionDesc(){}
+    SOptionDesc(uint8_t nSubType, uint8_t nIndex, const char* fmt, ...):nSubType(nSubType), nIndex(nIndex)
    {
        va_list args;
        va_start (args, fmt);
@@ -573,10 +573,10 @@ inline void MicroProfileToolTipMeta(MicroProfileStringArray* pToolTip)
                    }
                    else
                    {
-                        for(int k = 0; k < MICROPROFILE_META_MAX; ++k)
+                        for(int i = 0; i < MICROPROFILE_META_MAX; ++i)
                        {
-                            nMetaSumInclusive[k] += nMetaSum[k];
-                            nMetaSum[k] = 0;
+                            nMetaSumInclusive[i] += nMetaSum[i];
+                            nMetaSum[i] = 0;
                        }
                    }
                    break;
@@ -708,10 +708,10 @@ inline void MicroProfileDrawFloatTooltip(uint32_t nX, uint32_t nY, uint32_t nTok

    if(UI.nMouseLeftMod)
    {
-        int nToolTipIndex = (g_MicroProfileUI.LockedToolTipFront + MICROPROFILE_TOOLTIP_MAX_LOCKED - 1) % MICROPROFILE_TOOLTIP_MAX_LOCKED;
-        g_MicroProfileUI.nLockedToolTipColor[nToolTipIndex] = S.TimerInfo[nTimerId].nColor;
-        MicroProfileStringArrayCopy(&g_MicroProfileUI.LockedToolTips[nToolTipIndex], &ToolTip);
-        g_MicroProfileUI.LockedToolTipFront = nToolTipIndex;
+        int nIndex = (g_MicroProfileUI.LockedToolTipFront + MICROPROFILE_TOOLTIP_MAX_LOCKED - 1) % MICROPROFILE_TOOLTIP_MAX_LOCKED;
+        g_MicroProfileUI.nLockedToolTipColor[nIndex] = S.TimerInfo[nTimerId].nColor;
+        MicroProfileStringArrayCopy(&g_MicroProfileUI.LockedToolTips[nIndex], &ToolTip);
+        g_MicroProfileUI.LockedToolTipFront = nIndex;

    }
 }
@@ -917,8 +917,9 @@ inline void MicroProfileDrawDetailedBars(uint32_t nWidth, uint32_t nHeight, int
        float fStart = floor(fMsBase*fRcpStep) * fStep;
        for(float f = fStart; f < fMsEnd; )
        {
+            float fStart = f;
            float fNext = f + fStep;
-            MicroProfileDrawBox(((f-fMsBase) * fMsToScreen), nBaseY, (fNext-fMsBase) * fMsToScreen+1, nBaseY + nHeight, UI.nOpacityBackground | g_nMicroProfileBackColors[nColorIndex++ & 1]);
+            MicroProfileDrawBox(((fStart-fMsBase) * fMsToScreen), nBaseY, (fNext-fMsBase) * fMsToScreen+1, nBaseY + nHeight, UI.nOpacityBackground | g_nMicroProfileBackColors[nColorIndex++ & 1]);
            f = fNext;
        }
    }
@@ -1115,9 +1116,9 @@ inline void MicroProfileDrawDetailedBars(uint32_t nWidth, uint32_t nHeight, int

                        nMaxStackDepth = MicroProfileMax(nMaxStackDepth, nStackPos);
                        float fMsStart = fToMs * MicroProfileLogTickDifference(nBaseTicks, nTickStart);
-                        float fMsEnd2 = fToMs * MicroProfileLogTickDifference(nBaseTicks, nTickEnd);
+                        float fMsEnd = fToMs * MicroProfileLogTickDifference(nBaseTicks, nTickEnd);
                        float fXStart = fMsStart * fMsToScreen;
-                        float fXEnd = fMsEnd2 * fMsToScreen;
+                        float fXEnd = fMsEnd * fMsToScreen;
                        float fYStart = (float)(nY + nStackPos * nYDelta);
                        float fYEnd = fYStart + (MICROPROFILE_DETAILED_BAR_HEIGHT);
                        float fXDist = MicroProfileMax(fXStart - fMouseX, fMouseX - fXEnd);
@@ -1268,22 +1269,22 @@ inline void MicroProfileDrawDetailedBars(uint32_t nWidth, uint32_t nHeight, int
        if(UI.nRangeBegin != UI.nRangeEnd)
        {
            float fMsStart = fToMsCpu * MicroProfileLogTickDifference(nBaseTicksCpu, UI.nRangeBegin);
-            float fMsEnd3 = fToMsCpu * MicroProfileLogTickDifference(nBaseTicksCpu, UI.nRangeEnd);
+            float fMsEnd = fToMsCpu * MicroProfileLogTickDifference(nBaseTicksCpu, UI.nRangeEnd);
            float fXStart = fMsStart * fMsToScreen;
-            float fXEnd = fMsEnd3 * fMsToScreen;
+            float fXEnd = fMsEnd * fMsToScreen;
            MicroProfileDrawBox(fXStart, nBaseY, fXEnd, nHeight, MICROPROFILE_FRAME_COLOR_HIGHTLIGHT, MicroProfileBoxTypeFlat);
            MicroProfileDrawLineVertical(fXStart, nBaseY, nHeight, MICROPROFILE_FRAME_COLOR_HIGHTLIGHT | 0x44000000);
            MicroProfileDrawLineVertical(fXEnd, nBaseY, nHeight, MICROPROFILE_FRAME_COLOR_HIGHTLIGHT | 0x44000000);

            fMsStart += fDetailedOffset;
-            fMsEnd3 += fDetailedOffset;
+            fMsEnd += fDetailedOffset;
            char sBuffer[32];
            uint32_t nLenStart = snprintf(sBuffer, sizeof(sBuffer)-1, "%.2fms", fMsStart);
            float fStartTextWidth = (float)((1+MICROPROFILE_TEXT_WIDTH) * nLenStart);
            float fStartTextX = fXStart - fStartTextWidth - 2;
            MicroProfileDrawBox(fStartTextX, nBaseY, fStartTextX + fStartTextWidth + 2, MICROPROFILE_TEXT_HEIGHT + 2 + nBaseY, 0x33000000, MicroProfileBoxTypeFlat);
            MicroProfileDrawText(fStartTextX+1, nBaseY, UINT32_MAX, sBuffer, nLenStart);
-            uint32_t nLenEnd = snprintf(sBuffer, sizeof(sBuffer)-1, "%.2fms", fMsEnd3);
+            uint32_t nLenEnd = snprintf(sBuffer, sizeof(sBuffer)-1, "%.2fms", fMsEnd);
            MicroProfileDrawBox(fXEnd+1, nBaseY, fXEnd+1+(1+MICROPROFILE_TEXT_WIDTH) * nLenEnd + 3, MICROPROFILE_TEXT_HEIGHT + 2 + nBaseY, 0x33000000, MicroProfileBoxTypeFlat);
            MicroProfileDrawText(fXEnd+2, nBaseY+1, UINT32_MAX, sBuffer, nLenEnd);

@@ -1296,9 +1297,9 @@ inline void MicroProfileDrawDetailedBars(uint32_t nWidth, uint32_t nHeight, int
        if(UI.nRangeBeginGpu != UI.nRangeEndGpu)
        {
            float fMsStart = fToMsGpu * MicroProfileLogTickDifference(nBaseTicksGpu, UI.nRangeBeginGpu);
-            float fMsEnd4 = fToMsGpu * MicroProfileLogTickDifference(nBaseTicksGpu, UI.nRangeEndGpu);
+            float fMsEnd = fToMsGpu * MicroProfileLogTickDifference(nBaseTicksGpu, UI.nRangeEndGpu);
            float fXStart = fMsStart * fMsToScreen;
-            float fXEnd = fMsEnd4 * fMsToScreen;
+            float fXEnd = fMsEnd * fMsToScreen;
            MicroProfileDrawBox(fXStart, nBaseY, fXEnd, nHeight, MICROPROFILE_FRAME_COLOR_HIGHTLIGHT_GPU, MicroProfileBoxTypeFlat);
            MicroProfileDrawLineVertical(fXStart, nBaseY, nHeight, MICROPROFILE_FRAME_COLOR_HIGHTLIGHT_GPU | 0x44000000);
            MicroProfileDrawLineVertical(fXEnd, nBaseY, nHeight, MICROPROFILE_FRAME_COLOR_HIGHTLIGHT_GPU | 0x44000000);
@@ -1306,14 +1307,14 @@ inline void MicroProfileDrawDetailedBars(uint32_t nWidth, uint32_t nHeight, int
            nBaseY += MICROPROFILE_TEXT_HEIGHT+1;

            fMsStart += fDetailedOffset;
-            fMsEnd4 += fDetailedOffset;
+            fMsEnd += fDetailedOffset;
            char sBuffer[32];
            uint32_t nLenStart = snprintf(sBuffer, sizeof(sBuffer)-1, "%.2fms", fMsStart);
            float fStartTextWidth = (float)((1+MICROPROFILE_TEXT_WIDTH) * nLenStart);
            float fStartTextX = fXStart - fStartTextWidth - 2;
            MicroProfileDrawBox(fStartTextX, nBaseY, fStartTextX + fStartTextWidth + 2, MICROPROFILE_TEXT_HEIGHT + 2 + nBaseY, 0x33000000, MicroProfileBoxTypeFlat);
            MicroProfileDrawText(fStartTextX+1, nBaseY, UINT32_MAX, sBuffer, nLenStart);
-            uint32_t nLenEnd = snprintf(sBuffer, sizeof(sBuffer)-1, "%.2fms", fMsEnd4);
+            uint32_t nLenEnd = snprintf(sBuffer, sizeof(sBuffer)-1, "%.2fms", fMsEnd);
            MicroProfileDrawBox(fXEnd+1, nBaseY, fXEnd+1+(1+MICROPROFILE_TEXT_WIDTH) * nLenEnd + 3, MICROPROFILE_TEXT_HEIGHT + 2 + nBaseY, 0x33000000, MicroProfileBoxTypeFlat);
            MicroProfileDrawText(fXEnd+2, nBaseY+1, UINT32_MAX, sBuffer, nLenEnd);
        }
@@ -1715,8 +1716,8 @@ bool MicroProfileDrawGraph(uint32_t nScreenWidth, uint32_t nScreenHeight)
        uint32_t nTextCount = 0;
        uint32_t nGraphIndex = (S.nGraphPut + MICROPROFILE_GRAPH_HISTORY - int(MICROPROFILE_GRAPH_HISTORY*(1.f - fMouseXPrc))) % MICROPROFILE_GRAPH_HISTORY;

-        uint32_t nMouseX = UI.nMouseX;
-        uint32_t nMouseY = UI.nMouseY + 20;
+        uint32_t nX = UI.nMouseX;
+        uint32_t nY = UI.nMouseY + 20;

        for(uint32_t i = 0; i < MICROPROFILE_MAX_GRAPHS; ++i)
        {
@@ -1735,7 +1736,7 @@ bool MicroProfileDrawGraph(uint32_t nScreenWidth, uint32_t nScreenHeight)
        }
        if(nTextCount)
        {
-            MicroProfileDrawFloatWindow(nMouseX, nMouseY, Strings.ppStrings, Strings.nNumStrings, 0, pColors);
+            MicroProfileDrawFloatWindow(nX, nY, Strings.ppStrings, Strings.nNumStrings, 0, pColors);
        }

        if(UI.nMouseRight)
@@ -2320,8 +2321,8 @@ inline void MicroProfileDrawMenu(uint32_t nWidth, uint32_t nHeight)
    uint32_t    nMenuX[MICROPROFILE_MENU_MAX] = {0};
    uint32_t nNumMenuItems = 0;

-    int nMPTextLen = snprintf(buffer, 127, "MicroProfile");
-    MicroProfileDrawText(nX, nY, UINT32_MAX, buffer, nMPTextLen);
+    int nLen = snprintf(buffer, 127, "MicroProfile");
+    MicroProfileDrawText(nX, nY, UINT32_MAX, buffer, nLen);
    nX += (sizeof("MicroProfile")+2) * (MICROPROFILE_TEXT_WIDTH+1);
    pMenuText[nNumMenuItems++] = "Mode";
    pMenuText[nNumMenuItems++] = "Groups";
@@ -2437,16 +2438,16 @@ inline void MicroProfileDrawMenu(uint32_t nWidth, uint32_t nHeight)
        int nNumLines = 0;
        bool bSelected = false;
        const char* pString = CB(nNumLines, &bSelected);
-        uint32_t nTextWidth = 0, nTextHeight = 0;
+        uint32_t nWidth = 0, nHeight = 0;
        while(pString)
        {
-            nTextWidth = MicroProfileMax<int>(nTextWidth, (int)strlen(pString));
+            nWidth = MicroProfileMax<int>(nWidth, (int)strlen(pString));
            nNumLines++;
            pString = CB(nNumLines, &bSelected);
        }
-        nTextWidth = (2+nTextWidth) * (MICROPROFILE_TEXT_WIDTH+1);
-        nTextHeight = nNumLines * (MICROPROFILE_TEXT_HEIGHT+1);
-        if(UI.nMouseY <= nY + nTextHeight+0 && UI.nMouseY >= nY-0 && UI.nMouseX <= nX + nTextWidth + 0 && UI.nMouseX >= nX - 0)
+        nWidth = (2+nWidth) * (MICROPROFILE_TEXT_WIDTH+1);
+        nHeight = nNumLines * (MICROPROFILE_TEXT_HEIGHT+1);
+        if(UI.nMouseY <= nY + nHeight+0 && UI.nMouseY >= nY-0 && UI.nMouseX <= nX + nWidth + 0 && UI.nMouseX >= nX - 0)
        {
            UI.nActiveMenu = nMenu;
        }
@@ -2454,21 +2455,21 @@ inline void MicroProfileDrawMenu(uint32_t nWidth, uint32_t nHeight)
        {
            UI.nActiveMenu = UINT32_MAX;
        }
-        MicroProfileDrawBox(nX, nY, nX + nTextWidth, nY + nTextHeight, 0xff000000|g_nMicroProfileBackColors[1]);
+        MicroProfileDrawBox(nX, nY, nX + nWidth, nY + nHeight, 0xff000000|g_nMicroProfileBackColors[1]);
        for(int i = 0; i < nNumLines; ++i)
        {
-            bool bSelected2 = false;
-            const char* pString2 = CB(i, &bSelected2);
+            bool bSelected = false;
+            const char* pString = CB(i, &bSelected);
            if(UI.nMouseY >= nY && UI.nMouseY < nY + MICROPROFILE_TEXT_HEIGHT + 1)
            {
                if(UI.nMouseLeft || UI.nMouseRight)
                {
                    CBClick[nMenu](i);
                }
-                MicroProfileDrawBox(nX, nY, nX + nTextWidth, nY + MICROPROFILE_TEXT_HEIGHT + 1, 0xff888888);
+                MicroProfileDrawBox(nX, nY, nX + nWidth, nY + MICROPROFILE_TEXT_HEIGHT + 1, 0xff888888);
            }
-            int nTextLen = snprintf(buffer, SBUF_SIZE-1, "%c %s", bSelected2 ? '*' : ' ' ,pString2);
-            MicroProfileDrawText(nX, nY, UINT32_MAX, buffer, nTextLen);
+            int nLen = snprintf(buffer, SBUF_SIZE-1, "%c %s", bSelected ? '*' : ' ' ,pString);
+            MicroProfileDrawText(nX, nY, UINT32_MAX, buffer, nLen);
            nY += MICROPROFILE_TEXT_HEIGHT+1;
        }
    }
@@ -2604,7 +2605,7 @@ inline void MicroProfileDrawCustom(uint32_t nWidth, uint32_t nHeight)
            for(uint32_t i = 0; i < nCount; ++i)
            {
                nOffsetY += (1+MICROPROFILE_TEXT_HEIGHT);
-                nWidth = MicroProfileMin(nMaxWidth, (uint32_t)(nMaxWidth * pMs[i] * fRcpReference));
+                uint32_t nWidth = MicroProfileMin(nMaxWidth, (uint32_t)(nMaxWidth * pMs[i] * fRcpReference));
                MicroProfileDrawBox(nMaxOffsetX, nOffsetY, nMaxOffsetX+nWidth, nOffsetY+MICROPROFILE_TEXT_HEIGHT, pColors[i]|0xff000000);
            }
        }
@@ -36,6 +36,7 @@ if (MSVC)
    # /GT                 - Supports fiber safety for data allocated using static thread-local storage
    add_compile_options(
        /MP
+        /Zi
        /Zm200
        /Zo
        /permissive-
@@ -64,10 +65,6 @@ if (MSVC)
        /we4305 # 'context': truncation from 'type1' to 'type2'
        /we4388 # 'expression': signed/unsigned mismatch
        /we4389 # 'operator': signed/unsigned mismatch
-        /we4456 # Declaration of 'identifier' hides previous local declaration
-        /we4457 # Declaration of 'identifier' hides function parameter
-        /we4458 # Declaration of 'identifier' hides class member
-        /we4459 # Declaration of 'identifier' hides global declaration
        /we4505 # 'function': unreferenced local function has been removed
        /we4547 # 'operator': operator before comma has no effect; expected operator with side-effect
        /we4549 # 'operator1': operator before comma has no effect; did you intend 'operator2'?
@@ -78,13 +75,6 @@ if (MSVC)
        /we5245 # 'function': unreferenced function with internal linkage has been removed
    )

-    if (USE_CCACHE)
-    # when caching, we need to use /Z7 to downgrade debug info to use an older but more cachable format
-        add_compile_options(/Z7)
-    else()
-        add_compile_options(/Zi)
-    endif()
-
    if (ARCHITECTURE_x86_64)
        add_compile_options(/QIntel-jcc-erratum)
    endif()
@@ -102,7 +92,6 @@ else()
        -Werror=missing-declarations
        -Werror=missing-field-initializers
        -Werror=reorder
-        -Werror=shadow
        -Werror=sign-compare
        -Werror=switch
        -Werror=uninitialized
@@ -49,6 +49,9 @@ if (NOT MSVC)
    target_compile_options(audio_core PRIVATE
        -Werror=conversion
        -Werror=ignored-qualifiers
+        -Werror=shadow
+        -Werror=unused-parameter
+        -Werror=unused-variable

        $<$<CXX_COMPILER_ID:GNU>:-Werror=unused-but-set-parameter>
        $<$<CXX_COMPILER_ID:GNU>:-Werror=unused-but-set-variable>
@@ -2,7 +2,6 @@
 // SPDX-License-Identifier: GPL-2.0-or-later

 #include <limits>
-#include <optional>
 #include <vector>

 #include "audio_core/audio_out.h"
@@ -89,12 +88,9 @@ AudioRenderer::AudioRenderer(Core::Timing::CoreTiming& core_timing_, Core::Memor
    stream = audio_out->OpenStream(
        core_timing, params.sample_rate, AudioCommon::STREAM_NUM_CHANNELS,
        fmt::format("AudioRenderer-Instance{}", instance_number), std::move(release_callback));
-    process_event =
-        Core::Timing::CreateEvent(fmt::format("AudioRenderer-Instance{}-Process", instance_number),
-                                  [this](std::uintptr_t, s64, std::chrono::nanoseconds) {
-                                      ReleaseAndQueueBuffers();
-                                      return std::nullopt;
-                                  });
+    process_event = Core::Timing::CreateEvent(
+        fmt::format("AudioRenderer-Instance{}-Process", instance_number),
+        [this](std::uintptr_t, std::chrono::nanoseconds) { ReleaseAndQueueBuffers(); });
    for (s32 i = 0; i < NUM_BUFFERS; ++i) {
        QueueMixedBuffer(i);
    }
@@ -102,13 +98,13 @@ AudioRenderer::AudioRenderer(Core::Timing::CoreTiming& core_timing_, Core::Memor

 AudioRenderer::~AudioRenderer() = default;

-Result AudioRenderer::Start() {
+ResultCode AudioRenderer::Start() {
    audio_out->StartStream(stream);
    ReleaseAndQueueBuffers();
    return ResultSuccess;
 }

-Result AudioRenderer::Stop() {
+ResultCode AudioRenderer::Stop() {
    audio_out->StopStream(stream);
    return ResultSuccess;
 }
@@ -129,8 +125,8 @@ Stream::State AudioRenderer::GetStreamState() const {
    return stream->GetState();
 }

-Result AudioRenderer::UpdateAudioRenderer(const std::vector<u8>& input_params,
-                                          std::vector<u8>& output_params) {
+ResultCode AudioRenderer::UpdateAudioRenderer(const std::vector<u8>& input_params,
+                                              std::vector<u8>& output_params) {
    std::scoped_lock lock{mutex};
    InfoUpdater info_updater{input_params, output_params, behavior_info};

@@ -43,10 +43,10 @@ public:
                  Stream::ReleaseCallback&& release_callback, std::size_t instance_number);
    ~AudioRenderer();

-    [[nodiscard]] Result UpdateAudioRenderer(const std::vector<u8>& input_params,
-                                             std::vector<u8>& output_params);
-    [[nodiscard]] Result Start();
-    [[nodiscard]] Result Stop();
+    [[nodiscard]] ResultCode UpdateAudioRenderer(const std::vector<u8>& input_params,
+                                                 std::vector<u8>& output_params);
+    [[nodiscard]] ResultCode Start();
+    [[nodiscard]] ResultCode Stop();
    void QueueMixedBuffer(Buffer::Tag tag);
    void ReleaseAndQueueBuffers();
    [[nodiscard]] u32 GetSampleRate() const;
@@ -429,7 +429,7 @@ void CommandGenerator::GenerateDataSourceCommand(ServerVoiceInfo& voice_info, Vo
                                  in_params.node_id);
            break;
        default:
-            ASSERT_MSG(false, "Unimplemented sample format={}", in_params.sample_format);
+            UNREACHABLE_MSG("Unimplemented sample format={}", in_params.sample_format);
        }
    }
 }
@@ -1312,7 +1312,7 @@ void CommandGenerator::DecodeFromWaveBuffers(ServerVoiceInfo& voice_info, std::s
                                samples_to_read - samples_read, channel, temp_mix_offset);
                break;
            default:
-                ASSERT_MSG(false, "Unimplemented sample format={}", in_params.sample_format);
+                UNREACHABLE_MSG("Unimplemented sample format={}", in_params.sample_format);
            }

            temp_mix_offset += samples_decoded;
@@ -10,8 +10,8 @@

 namespace AudioCommon {
 namespace Audren {
-constexpr Result ERR_INVALID_PARAMETERS{ErrorModule::Audio, 41};
-constexpr Result ERR_SPLITTER_SORT_FAILED{ErrorModule::Audio, 43};
+constexpr ResultCode ERR_INVALID_PARAMETERS{ErrorModule::Audio, 41};
+constexpr ResultCode ERR_SPLITTER_SORT_FAILED{ErrorModule::Audio, 43};
 } // namespace Audren

 constexpr u8 BASE_REVISION = '0';
@@ -50,7 +50,7 @@ EffectBase* EffectContext::RetargetEffect(std::size_t i, EffectType effect) {
        effects[i] = std::make_unique<EffectBiquadFilter>();
        break;
    default:
-        ASSERT_MSG(false, "Unimplemented effect {}", effect);
+        UNREACHABLE_MSG("Unimplemented effect {}", effect);
        effects[i] = std::make_unique<EffectStubbed>();
    }
    return GetInfo(i);
@@ -104,7 +104,7 @@ void EffectI3dl2Reverb::Update(EffectInfo::InParams& in_params) {
    auto& params = GetParams();
    const auto* reverb_params = reinterpret_cast<I3dl2ReverbParams*>(in_params.raw.data());
    if (!ValidChannelCountForEffect(reverb_params->max_channels)) {
-        ASSERT_MSG(false, "Invalid reverb max channel count {}", reverb_params->max_channels);
+        UNREACHABLE_MSG("Invalid reverb max channel count {}", reverb_params->max_channels);
        return;
    }

@@ -285,8 +285,9 @@ bool InfoUpdater::UpdateSplitterInfo(SplitterContext& splitter_context) {
    return true;
 }

-Result InfoUpdater::UpdateMixes(MixContext& mix_context, std::size_t mix_buffer_count,
-                                SplitterContext& splitter_context, EffectContext& effect_context) {
+ResultCode InfoUpdater::UpdateMixes(MixContext& mix_context, std::size_t mix_buffer_count,
+                                    SplitterContext& splitter_context,
+                                    EffectContext& effect_context) {
    std::vector<MixInfo::InParams> mix_in_params;

    if (!behavior_info.IsMixInParameterDirtyOnlyUpdateSupported()) {
@@ -32,8 +32,8 @@ public:
                      VAddr audio_codec_dsp_addr);
    bool UpdateEffects(EffectContext& effect_context, bool is_active);
    bool UpdateSplitterInfo(SplitterContext& splitter_context);
-    Result UpdateMixes(MixContext& mix_context, std::size_t mix_buffer_count,
-                       SplitterContext& splitter_context, EffectContext& effect_context);
+    ResultCode UpdateMixes(MixContext& mix_context, std::size_t mix_buffer_count,
+                           SplitterContext& splitter_context, EffectContext& effect_context);
    bool UpdateSinks(SinkContext& sink_context);
    bool UpdatePerformanceBuffer();
    bool UpdateErrorInfo(BehaviorInfo& in_behavior_info);
@@ -483,7 +483,7 @@ bool NodeStates::DepthFirstSearch(EdgeMatrix& edge_matrix) {
                    // Add more work
                    index_stack.push(j);
                } else if (node_state == NodeStates::State::InFound) {
-                    ASSERT_MSG(false, "Node start marked as found");
+                    UNREACHABLE_MSG("Node start marked as found");
                    ResetState();
                    return false;
                }
@@ -34,10 +34,9 @@ Stream::Stream(Core::Timing::CoreTiming& core_timing_, u32 sample_rate_, Format
               ReleaseCallback&& release_callback_, SinkStream& sink_stream_, std::string&& name_)
    : sample_rate{sample_rate_}, format{format_}, release_callback{std::move(release_callback_)},
      sink_stream{sink_stream_}, core_timing{core_timing_}, name{std::move(name_)} {
-    release_event = Core::Timing::CreateEvent(
-        name, [this](std::uintptr_t, s64 time, std::chrono::nanoseconds ns_late) {
+    release_event =
+        Core::Timing::CreateEvent(name, [this](std::uintptr_t, std::chrono::nanoseconds ns_late) {
            ReleaseActiveBuffer(ns_late);
-            return std::nullopt;
        });
 }

@@ -114,7 +114,7 @@ void ServerVoiceInfo::UpdateParameters(const VoiceInfo::InParams& voice_in,
        in_params.current_playstate = ServerPlayState::Play;
        break;
    default:
-        ASSERT_MSG(false, "Unknown playstate {}", voice_in.play_state);
+        UNREACHABLE_MSG("Unknown playstate {}", voice_in.play_state);
        break;
    }

@@ -410,7 +410,7 @@ bool ServerVoiceInfo::UpdateParametersForCommandGeneration(
        return in_params.should_depop;
    }
    default:
-        ASSERT_MSG(false, "Invalid playstate {}", in_params.current_playstate);
+        UNREACHABLE_MSG("Invalid playstate {}", in_params.current_playstate);
    }

    return false;
@@ -6,13 +6,8 @@

 #include "common/settings.h"

-void assert_fail_impl() {
+void assert_handle_failure() {
    if (Settings::values.use_debug_asserts) {
        Crash();
    }
 }
-
-[[noreturn]] void unreachable_impl() {
-    Crash();
-    throw std::runtime_error("Unreachable code");
-}
@@ -9,43 +9,44 @@
 // Sometimes we want to try to continue even after hitting an assert.
 // However touching this file yields a global recompilation as this header is included almost
 // everywhere. So let's just move the handling of the failed assert to a single cpp file.
+void assert_handle_failure();

-void assert_fail_impl();
-[[noreturn]] void unreachable_impl();
-
-#ifdef _MSC_VER
-#define YUZU_NO_INLINE __declspec(noinline)
-#else
-#define YUZU_NO_INLINE __attribute__((noinline))
+// For asserts we'd like to keep all the junk executed when an assert happens away from the
+// important code in the function. One way of doing this is to put all the relevant code inside a
+// lambda and force the compiler to not inline it. Unfortunately, MSVC seems to have no syntax to
+// specify __declspec on lambda functions, so what we do instead is define a noinline wrapper
+// template that calls the lambda. This seems to generate an extra instruction at the call-site
+// compared to the ideal implementation (which wouldn't support ASSERT_MSG parameters), but is good
+// enough for our purposes.
+template <typename Fn>
+#if defined(_MSC_VER)
+[[msvc::noinline]]
+#elif defined(__GNUC__)
+[[gnu::cold, gnu::noinline]]
 #endif
+static void
+assert_noinline_call(const Fn& fn) {
+    fn();
+    assert_handle_failure();
+}

 #define ASSERT(_a_)                                                                                \
-    ([&]() YUZU_NO_INLINE {                                                                        \
-        if (!(_a_)) [[unlikely]] {                                                                 \
-            LOG_CRITICAL(Debug, "Assertion Failed!");                                              \
-            assert_fail_impl();                                                                    \
+    do                                                                                             \
+        if (!(_a_)) {                                                                              \
+            assert_noinline_call([] { LOG_CRITICAL(Debug, "Assertion Failed!"); });                \
        }                                                                                          \
-    }())
+    while (0)

 #define ASSERT_MSG(_a_, ...)                                                                       \
-    ([&]() YUZU_NO_INLINE {                                                                        \
-        if (!(_a_)) [[unlikely]] {                                                                 \
-            LOG_CRITICAL(Debug, "Assertion Failed!\n" __VA_ARGS__);                                \
-            assert_fail_impl();                                                                    \
+    do                                                                                             \
+        if (!(_a_)) {                                                                              \
+            assert_noinline_call([&] { LOG_CRITICAL(Debug, "Assertion Failed!\n" __VA_ARGS__); }); \
        }                                                                                          \
-    }())
-
-#define UNREACHABLE()                                                                              \
-    do {                                                                                           \
-        LOG_CRITICAL(Debug, "Unreachable code!");                                                  \
-        unreachable_impl();                                                                        \
-    } while (0)
+    while (0)

+#define UNREACHABLE() assert_noinline_call([] { LOG_CRITICAL(Debug, "Unreachable code!"); })
 #define UNREACHABLE_MSG(...)                                                                       \
-    do {                                                                                           \
-        LOG_CRITICAL(Debug, "Unreachable code!\n" __VA_ARGS__);                                    \
-        unreachable_impl();                                                                        \
-    } while (0)
+    assert_noinline_call([&] { LOG_CRITICAL(Debug, "Unreachable code!\n" __VA_ARGS__); })

 #ifdef _DEBUG
 #define DEBUG_ASSERT(_a_) ASSERT(_a_)
@@ -1,167 +0,0 @@
-// SPDX-FileCopyrightText: Copyright (c) 2020 Erik Rigtorp <erik@rigtorp.se>
-// SPDX-License-Identifier: MIT
-
-#pragma once
-
-#include <atomic>
-#include <bit>
-#include <condition_variable>
-#include <memory>
-#include <mutex>
-#include <new>
-#include <stop_token>
-#include <type_traits>
-#include <utility>
-
-namespace Common {
-
-#if defined(__cpp_lib_hardware_interference_size)
-constexpr size_t hardware_interference_size = std::hardware_destructive_interference_size;
-#else
-constexpr size_t hardware_interference_size = 64;
-#endif
-
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable : 4324)
-#endif
-
-template <typename T, size_t capacity = 0x400>
-class MPSCQueue {
-public:
-    explicit MPSCQueue() : allocator{std::allocator<Slot<T>>()} {
-        // Allocate one extra slot to prevent false sharing on the last slot
-        slots = allocator.allocate(capacity + 1);
-        // Allocators are not required to honor alignment for over-aligned types
-        // (see http://eel.is/c++draft/allocator.requirements#10) so we verify
-        // alignment here
-        if (reinterpret_cast<uintptr_t>(slots) % alignof(Slot<T>) != 0) {
-            allocator.deallocate(slots, capacity + 1);
-            throw std::bad_alloc();
-        }
-        for (size_t i = 0; i < capacity; ++i) {
-            std::construct_at(&slots[i]);
-        }
-        static_assert(std::has_single_bit(capacity), "capacity must be an integer power of 2");
-        static_assert(alignof(Slot<T>) == hardware_interference_size,
-                      "Slot must be aligned to cache line boundary to prevent false sharing");
-        static_assert(sizeof(Slot<T>) % hardware_interference_size == 0,
-                      "Slot size must be a multiple of cache line size to prevent "
-                      "false sharing between adjacent slots");
-        static_assert(sizeof(MPSCQueue) % hardware_interference_size == 0,
-                      "Queue size must be a multiple of cache line size to "
-                      "prevent false sharing between adjacent queues");
-    }
-
-    ~MPSCQueue() noexcept {
-        for (size_t i = 0; i < capacity; ++i) {
-            std::destroy_at(&slots[i]);
-        }
-        allocator.deallocate(slots, capacity + 1);
-    }
-
-    // The queue must be both non-copyable and non-movable
-    MPSCQueue(const MPSCQueue&) = delete;
-    MPSCQueue& operator=(const MPSCQueue&) = delete;
-
-    MPSCQueue(MPSCQueue&&) = delete;
-    MPSCQueue& operator=(MPSCQueue&&) = delete;
-
-    void Push(const T& v) noexcept {
-        static_assert(std::is_nothrow_copy_constructible_v<T>,
-                      "T must be nothrow copy constructible");
-        emplace(v);
-    }
-
-    template <typename P, typename = std::enable_if_t<std::is_nothrow_constructible_v<T, P&&>>>
-    void Push(P&& v) noexcept {
-        emplace(std::forward<P>(v));
-    }
-
-    void Pop(T& v, std::stop_token stop) noexcept {
-        auto const tail = tail_.fetch_add(1);
-        auto& slot = slots[idx(tail)];
-        if (!slot.turn.test()) {
-            std::unique_lock lock{cv_mutex};
-            cv.wait(lock, stop, [&slot] { return slot.turn.test(); });
-        }
-        v = slot.move();
-        slot.destroy();
-        slot.turn.clear();
-        slot.turn.notify_one();
-    }
-
-private:
-    template <typename U = T>
-    struct Slot {
-        ~Slot() noexcept {
-            if (turn.test()) {
-                destroy();
-            }
-        }
-
-        template <typename... Args>
-        void construct(Args&&... args) noexcept {
-            static_assert(std::is_nothrow_constructible_v<U, Args&&...>,
-                          "T must be nothrow constructible with Args&&...");
-            std::construct_at(reinterpret_cast<U*>(&storage), std::forward<Args>(args)...);
-        }
-
-        void destroy() noexcept {
-            static_assert(std::is_nothrow_destructible_v<U>, "T must be nothrow destructible");
-            std::destroy_at(reinterpret_cast<U*>(&storage));
-        }
-
-        U&& move() noexcept {
-            return reinterpret_cast<U&&>(storage);
-        }
-
-        // Align to avoid false sharing between adjacent slots
-        alignas(hardware_interference_size) std::atomic_flag turn{};
-        struct aligned_store {
-            struct type {
-                alignas(U) unsigned char data[sizeof(U)];
-            };
-        };
-        typename aligned_store::type storage;
-    };
-
-    template <typename... Args>
-    void emplace(Args&&... args) noexcept {
-        static_assert(std::is_nothrow_constructible_v<T, Args&&...>,
-                      "T must be nothrow constructible with Args&&...");
-        auto const head = head_.fetch_add(1);
-        auto& slot = slots[idx(head)];
-        slot.turn.wait(true);
-        slot.construct(std::forward<Args>(args)...);
-        slot.turn.test_and_set();
-        cv.notify_one();
-    }
-
-    constexpr size_t idx(size_t i) const noexcept {
-        return i & mask;
-    }
-
-    static constexpr size_t mask = capacity - 1;
-
-    // Align to avoid false sharing between head_ and tail_
-    alignas(hardware_interference_size) std::atomic<size_t> head_{0};
-    alignas(hardware_interference_size) std::atomic<size_t> tail_{0};
-
-    std::mutex cv_mutex;
-    std::condition_variable_any cv;
-
-    Slot<T>* slots;
-    [[no_unique_address]] std::allocator<Slot<T>> allocator;
-
-    static_assert(std::is_nothrow_copy_assignable_v<T> || std::is_nothrow_move_assignable_v<T>,
-                  "T must be nothrow copy or move assignable");
-
-    static_assert(std::is_nothrow_destructible_v<T>, "T must be nothrow destructible");
-};
-
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
-} // namespace Common
@@ -33,9 +33,9 @@ void DetachedTasks::AddTask(std::function<void()> task) {
    ++instance->count;
    std::thread([task{std::move(task)}]() {
        task();
-        std::unique_lock thread_lock{instance->mutex};
+        std::unique_lock lock{instance->mutex};
        --instance->count;
-        std::notify_all_at_thread_exit(instance->cv, std::move(thread_lock));
+        std::notify_all_at_thread_exit(instance->cv, std::move(lock));
    }).detach();
 }

@@ -20,8 +20,10 @@ struct Fiber::FiberImpl {
    VirtualBuffer<u8> rewind_stack;

    std::mutex guard;
-    std::function<void()> entry_point;
-    std::function<void()> rewind_point;
+    std::function<void(void*)> entry_point;
+    std::function<void(void*)> rewind_point;
+    void* rewind_parameter{};
+    void* start_parameter{};
    std::shared_ptr<Fiber> previous_fiber;
    bool is_thread_fiber{};
    bool released{};
@@ -32,8 +34,13 @@ struct Fiber::FiberImpl {
    boost::context::detail::fcontext_t rewind_context{};
 };

-void Fiber::SetRewindPoint(std::function<void()>&& rewind_func) {
+void Fiber::SetStartParameter(void* new_parameter) {
+    impl->start_parameter = new_parameter;
+}
+
+void Fiber::SetRewindPoint(std::function<void(void*)>&& rewind_func, void* rewind_param) {
    impl->rewind_point = std::move(rewind_func);
+    impl->rewind_parameter = rewind_param;
 }

 void Fiber::Start(boost::context::detail::transfer_t& transfer) {
@@ -41,7 +48,7 @@ void Fiber::Start(boost::context::detail::transfer_t& transfer) {
    impl->previous_fiber->impl->context = transfer.fctx;
    impl->previous_fiber->impl->guard.unlock();
    impl->previous_fiber.reset();
-    impl->entry_point();
+    impl->entry_point(impl->start_parameter);
    UNREACHABLE();
 }

@@ -52,7 +59,7 @@ void Fiber::OnRewind([[maybe_unused]] boost::context::detail::transfer_t& transf
    u8* tmp = impl->stack_limit;
    impl->stack_limit = impl->rewind_stack_limit;
    impl->rewind_stack_limit = tmp;
-    impl->rewind_point();
+    impl->rewind_point(impl->rewind_parameter);
    UNREACHABLE();
 }

@@ -66,8 +73,10 @@ void Fiber::RewindStartFunc(boost::context::detail::transfer_t transfer) {
    fiber->OnRewind(transfer);
 }

-Fiber::Fiber(std::function<void()>&& entry_point_func) : impl{std::make_unique<FiberImpl>()} {
+Fiber::Fiber(std::function<void(void*)>&& entry_point_func, void* start_parameter)
+    : impl{std::make_unique<FiberImpl>()} {
    impl->entry_point = std::move(entry_point_func);
+    impl->start_parameter = start_parameter;
    impl->stack_limit = impl->stack.data();
    impl->rewind_stack_limit = impl->rewind_stack.data();
    u8* stack_base = impl->stack_limit + default_stack_size;
@@ -29,7 +29,7 @@ namespace Common {
 */
 class Fiber {
 public:
-    Fiber(std::function<void()>&& entry_point_func);
+    Fiber(std::function<void(void*)>&& entry_point_func, void* start_parameter);
    ~Fiber();

    Fiber(const Fiber&) = delete;
@@ -43,13 +43,16 @@ public:
    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);
+    void SetRewindPoint(std::function<void(void*)>&& rewind_func, void* rewind_param);

    void Rewind();

    /// Only call from main thread's fiber
    void Exit();

+    /// Changes the start parameter of the fiber. Has no effect if the fiber already started
+    void SetStartParameter(void* new_parameter);
+
 private:
    Fiber();

@@ -15,9 +15,6 @@ enum class PageType : u8 {
    Unmapped,
    /// Page is mapped to regular memory. This is the only type you can get pointers to.
    Memory,
-    /// Page is mapped to regular memory, but inaccessible from CPU fastmem and must use
-    /// the callbacks.
-    DebugMemory,
    /// Page is mapped to regular memory, but also needs to check for rasterizer cache flushing and
    /// invalidation
    RasterizerCachedMemory,
@@ -76,7 +76,7 @@ std::string ParamPackage::Serialize() const {
 std::string ParamPackage::Get(const std::string& key, const std::string& default_value) const {
    auto pair = data.find(key);
    if (pair == data.end()) {
-        LOG_TRACE(Common, "key '{}' not found", key);
+        LOG_DEBUG(Common, "key '{}' not found", key);
        return default_value;
    }

@@ -86,7 +86,7 @@ std::string ParamPackage::Get(const std::string& key, const std::string& default
 int ParamPackage::Get(const std::string& key, int default_value) const {
    auto pair = data.find(key);
    if (pair == data.end()) {
-        LOG_TRACE(Common, "key '{}' not found", key);
+        LOG_DEBUG(Common, "key '{}' not found", key);
        return default_value;
    }

@@ -101,7 +101,7 @@ int ParamPackage::Get(const std::string& key, int default_value) const {
 float ParamPackage::Get(const std::string& key, float default_value) const {
    auto pair = data.find(key);
    if (pair == data.end()) {
-        LOG_TRACE(Common, "key {} not found", key);
+        LOG_DEBUG(Common, "key {} not found", key);
        return default_value;
    }

@@ -147,7 +147,7 @@ void UpdateRescalingInfo() {
        info.down_shift = 0;
        break;
    default:
-        ASSERT(false);
+        UNREACHABLE();
        info.up_scale = 1;
        info.down_shift = 0;
    }
@@ -101,15 +101,15 @@ struct ResolutionScalingInfo {
    }
 };

-/** The Setting class is a simple resource manager. It defines a label and default value alongside
- * the actual value of the setting for simpler and less-error prone use with frontend
- * configurations. Specifying a default value and label is required. A minimum and maximum range can
- * be specified for sanitization.
+/** The BasicSetting class is a simple resource manager. It defines a label and default value
+ * alongside the actual value of the setting for simpler and less-error prone use with frontend
+ * configurations. Setting a default value and label is required, though subclasses may deviate from
+ * this requirement.
 */
 template <typename Type>
-class Setting {
+class BasicSetting {
 protected:
-    Setting() = default;
+    BasicSetting() = default;

    /**
     * Only sets the setting to the given initializer, leaving the other members to their default
@@ -117,7 +117,7 @@ protected:
     *
     * @param global_val Initial value of the setting
     */
-    explicit Setting(const Type& val) : value{val} {}
+    explicit BasicSetting(const Type& global_val) : global{global_val} {}

 public:
    /**
@@ -126,22 +126,9 @@ public:
     * @param default_val Intial value of the setting, and default value of the setting
     * @param name Label for the setting
     */
-    explicit Setting(const Type& default_val, const std::string& name)
-        : value{default_val}, default_value{default_val}, ranged{false}, label{name} {}
-    virtual ~Setting() = default;
-
-    /**
-     * Sets a default value, minimum value, maximum value, and label.
-     *
-     * @param default_val Intial value of the setting, and default value of the setting
-     * @param min_val Sets the minimum allowed value of the setting
-     * @param max_val Sets the maximum allowed value of the setting
-     * @param name Label for the setting
-     */
-    explicit Setting(const Type& default_val, const Type& min_val, const Type& max_val,
-                     const std::string& name)
-        : value{default_val}, default_value{default_val}, maximum{max_val}, minimum{min_val},
-          ranged{true}, label{name} {}
+    explicit BasicSetting(const Type& default_val, const std::string& name)
+        : default_value{default_val}, global{default_val}, label{name} {}
+    virtual ~BasicSetting() = default;

    /**
     *  Returns a reference to the setting's value.
@@ -149,17 +136,17 @@ public:
     * @returns A reference to the setting
     */
    [[nodiscard]] virtual const Type& GetValue() const {
-        return value;
+        return global;
    }

    /**
     * Sets the setting to the given value.
     *
-     * @param val The desired value
+     * @param value The desired value
     */
-    virtual void SetValue(const Type& val) {
-        Type temp{(ranged) ? std::clamp(val, minimum, maximum) : val};
-        std::swap(value, temp);
+    virtual void SetValue(const Type& value) {
+        Type temp{value};
+        std::swap(global, temp);
    }

    /**
@@ -183,14 +170,14 @@ public:
    /**
     * Assigns a value to the setting.
     *
-     * @param val The desired setting value
+     * @param value The desired setting value
     *
     * @returns A reference to the setting
     */
-    virtual const Type& operator=(const Type& val) {
-        Type temp{(ranged) ? std::clamp(val, minimum, maximum) : val};
-        std::swap(value, temp);
-        return value;
+    virtual const Type& operator=(const Type& value) {
+        Type temp{value};
+        std::swap(global, temp);
+        return global;
    }

    /**
@@ -199,39 +186,23 @@ public:
     * @returns A reference to the setting
     */
    explicit virtual operator const Type&() const {
-        return value;
+        return global;
    }

 protected:
-    Type value{};               ///< The setting
    const Type default_value{}; ///< The default value
-    const Type maximum{};       ///< Maximum allowed value of the setting
-    const Type minimum{};       ///< Minimum allowed value of the setting
-    const bool ranged;          ///< The setting has sanitization ranges
+    Type global{};              ///< The setting
    const std::string label{};  ///< The setting's label
 };

 /**
- * The SwitchableSetting class is a slightly more complex version of the Setting class. This adds a
- * custom setting to switch to when a guest application specifically requires it. The effect is that
- * other components of the emulator can access the setting's intended value without any need for the
- * component to ask whether the custom or global setting is needed at the moment.
- *
- * By default, the global setting is used.
+ * BasicRangedSetting class is intended for use with quantifiable settings that need a more
+ * restrictive range than implicitly defined by its type. Implements a minimum and maximum that is
+ * simply used to sanitize SetValue and the assignment overload.
 */
 template <typename Type>
-class SwitchableSetting : virtual public Setting<Type> {
+class BasicRangedSetting : virtual public BasicSetting<Type> {
 public:
-    /**
-     * Sets a default value, label, and setting value.
-     *
-     * @param default_val Intial value of the setting, and default value of the setting
-     * @param name Label for the setting
-     */
-    explicit SwitchableSetting(const Type& default_val, const std::string& name)
-        : Setting<Type>{default_val, name} {}
-    virtual ~SwitchableSetting() = default;
-
    /**
     * Sets a default value, minimum value, maximum value, and label.
     *
@@ -240,9 +211,57 @@ public:
     * @param max_val Sets the maximum allowed value of the setting
     * @param name Label for the setting
     */
-    explicit SwitchableSetting(const Type& default_val, const Type& min_val, const Type& max_val,
-                               const std::string& name)
-        : Setting<Type>{default_val, min_val, max_val, name} {}
+    explicit BasicRangedSetting(const Type& default_val, const Type& min_val, const Type& max_val,
+                                const std::string& name)
+        : BasicSetting<Type>{default_val, name}, minimum{min_val}, maximum{max_val} {}
+    virtual ~BasicRangedSetting() = default;
+
+    /**
+     * Like BasicSetting's SetValue, except value is clamped to the range of the setting.
+     *
+     * @param value The desired value
+     */
+    void SetValue(const Type& value) override {
+        this->global = std::clamp(value, minimum, maximum);
+    }
+
+    /**
+     * Like BasicSetting's assignment overload, except value is clamped to the range of the setting.
+     *
+     * @param value The desired value
+     * @returns A reference to the setting's value
+     */
+    const Type& operator=(const Type& value) override {
+        this->global = std::clamp(value, minimum, maximum);
+        return this->global;
+    }
+
+    const Type minimum; ///< Minimum allowed value of the setting
+    const Type maximum; ///< Maximum allowed value of the setting
+};
+
+/**
+ * The Setting class is a slightly more complex version of the BasicSetting class. This adds a
+ * custom setting to switch to when a guest application specifically requires it. The effect is that
+ * other components of the emulator can access the setting's intended value without any need for the
+ * component to ask whether the custom or global setting is needed at the moment.
+ *
+ * By default, the global setting is used.
+ *
+ * Like the BasicSetting, this requires setting a default value and label to use.
+ */
+template <typename Type>
+class Setting : virtual public BasicSetting<Type> {
+public:
+    /**
+     * Sets a default value, label, and setting value.
+     *
+     * @param default_val Intial value of the setting, and default value of the setting
+     * @param name Label for the setting
+     */
+    explicit Setting(const Type& default_val, const std::string& name)
+        : BasicSetting<Type>(default_val, name) {}
+    virtual ~Setting() = default;

    /**
     * Tells this setting to represent either the global or custom setting when other member
@@ -273,13 +292,13 @@ public:
     */
    [[nodiscard]] virtual const Type& GetValue() const override {
        if (use_global) {
-            return this->value;
+            return this->global;
        }
        return custom;
    }
    [[nodiscard]] virtual const Type& GetValue(bool need_global) const {
        if (use_global || need_global) {
-            return this->value;
+            return this->global;
        }
        return custom;
    }
@@ -287,12 +306,12 @@ public:
    /**
     * Sets the current setting value depending on the global state.
     *
-     * @param val The new value
+     * @param value The new value
     */
-    void SetValue(const Type& val) override {
-        Type temp{(this->ranged) ? std::clamp(val, this->minimum, this->maximum) : val};
+    void SetValue(const Type& value) override {
+        Type temp{value};
        if (use_global) {
-            std::swap(this->value, temp);
+            std::swap(this->global, temp);
        } else {
            std::swap(custom, temp);
        }
@@ -301,15 +320,15 @@ public:
    /**
     * Assigns the current setting value depending on the global state.
     *
-     * @param val The new value
+     * @param value The new value
     *
     * @returns A reference to the current setting value
     */
-    const Type& operator=(const Type& val) override {
-        Type temp{(this->ranged) ? std::clamp(val, this->minimum, this->maximum) : val};
+    const Type& operator=(const Type& value) override {
+        Type temp{value};
        if (use_global) {
-            std::swap(this->value, temp);
-            return this->value;
+            std::swap(this->global, temp);
+            return this->global;
        }
        std::swap(custom, temp);
        return custom;
@@ -322,7 +341,7 @@ public:
     */
    virtual explicit operator const Type&() const override {
        if (use_global) {
-            return this->value;
+            return this->global;
        }
        return custom;
    }
@@ -332,6 +351,75 @@ protected:
    Type custom{};         ///< The custom value of the setting
 };

+/**
+ * RangedSetting is a Setting that implements a maximum and minimum value for its setting. Intended
+ * for use with quantifiable settings.
+ */
+template <typename Type>
+class RangedSetting final : public BasicRangedSetting<Type>, public Setting<Type> {
+public:
+    /**
+     * Sets a default value, minimum value, maximum value, and label.
+     *
+     * @param default_val Intial value of the setting, and default value of the setting
+     * @param min_val Sets the minimum allowed value of the setting
+     * @param max_val Sets the maximum allowed value of the setting
+     * @param name Label for the setting
+     */
+    explicit RangedSetting(const Type& default_val, const Type& min_val, const Type& max_val,
+                           const std::string& name)
+        : BasicSetting<Type>{default_val, name},
+          BasicRangedSetting<Type>{default_val, min_val, max_val, name}, Setting<Type>{default_val,
+                                                                                       name} {}
+    virtual ~RangedSetting() = default;
+
+    // The following are needed to avoid a MSVC bug
+    // (source: https://stackoverflow.com/questions/469508)
+    [[nodiscard]] const Type& GetValue() const override {
+        return Setting<Type>::GetValue();
+    }
+    [[nodiscard]] const Type& GetValue(bool need_global) const override {
+        return Setting<Type>::GetValue(need_global);
+    }
+    explicit operator const Type&() const override {
+        if (this->use_global) {
+            return this->global;
+        }
+        return this->custom;
+    }
+
+    /**
+     * Like BasicSetting's SetValue, except value is clamped to the range of the setting. Sets the
+     * appropriate value depending on the global state.
+     *
+     * @param value The desired value
+     */
+    void SetValue(const Type& value) override {
+        const Type temp = std::clamp(value, this->minimum, this->maximum);
+        if (this->use_global) {
+            this->global = temp;
+        }
+        this->custom = temp;
+    }
+
+    /**
+     * Like BasicSetting's assignment overload, except value is clamped to the range of the setting.
+     * Uses the appropriate value depending on the global state.
+     *
+     * @param value The desired value
+     * @returns A reference to the setting's value
+     */
+    const Type& operator=(const Type& value) override {
+        const Type temp = std::clamp(value, this->minimum, this->maximum);
+        if (this->use_global) {
+            this->global = temp;
+            return this->global;
+        }
+        this->custom = temp;
+        return this->custom;
+    }
+};
+
 /**
 * The InputSetting class allows for getting a reference to either the global or custom members.
 * This is required as we cannot easily modify the values of user-defined types within containers
@@ -343,7 +431,7 @@ template <typename Type>
 class InputSetting final {
 public:
    InputSetting() = default;
-    explicit InputSetting(Type val) : Setting<Type>(val) {}
+    explicit InputSetting(Type val) : BasicSetting<Type>(val) {}
    ~InputSetting() = default;
    void SetGlobal(bool to_global) {
        use_global = to_global;
@@ -371,175 +459,175 @@ struct TouchFromButtonMap {

 struct Values {
    // Audio
-    Setting<std::string> audio_device_id{"auto", "output_device"};
-    Setting<std::string> sink_id{"auto", "output_engine"};
-    Setting<bool> audio_muted{false, "audio_muted"};
-    SwitchableSetting<u8> volume{100, 0, 100, "volume"};
+    BasicSetting<std::string> audio_device_id{"auto", "output_device"};
+    BasicSetting<std::string> sink_id{"auto", "output_engine"};
+    BasicSetting<bool> audio_muted{false, "audio_muted"};
+    RangedSetting<u8> volume{100, 0, 100, "volume"};

    // Core
-    SwitchableSetting<bool> use_multi_core{true, "use_multi_core"};
-    SwitchableSetting<bool> use_extended_memory_layout{false, "use_extended_memory_layout"};
+    Setting<bool> use_multi_core{true, "use_multi_core"};
+    Setting<bool> use_extended_memory_layout{false, "use_extended_memory_layout"};

    // Cpu
-    SwitchableSetting<CPUAccuracy> cpu_accuracy{CPUAccuracy::Auto, CPUAccuracy::Auto,
-                                                CPUAccuracy::Paranoid, "cpu_accuracy"};
+    RangedSetting<CPUAccuracy> cpu_accuracy{CPUAccuracy::Auto, CPUAccuracy::Auto,
+                                            CPUAccuracy::Paranoid, "cpu_accuracy"};
    // TODO: remove cpu_accuracy_first_time, migration setting added 8 July 2021
-    Setting<bool> cpu_accuracy_first_time{true, "cpu_accuracy_first_time"};
-    Setting<bool> cpu_debug_mode{false, "cpu_debug_mode"};
+    BasicSetting<bool> cpu_accuracy_first_time{true, "cpu_accuracy_first_time"};
+    BasicSetting<bool> cpu_debug_mode{false, "cpu_debug_mode"};

-    Setting<bool> cpuopt_page_tables{true, "cpuopt_page_tables"};
-    Setting<bool> cpuopt_block_linking{true, "cpuopt_block_linking"};
-    Setting<bool> cpuopt_return_stack_buffer{true, "cpuopt_return_stack_buffer"};
-    Setting<bool> cpuopt_fast_dispatcher{true, "cpuopt_fast_dispatcher"};
-    Setting<bool> cpuopt_context_elimination{true, "cpuopt_context_elimination"};
-    Setting<bool> cpuopt_const_prop{true, "cpuopt_const_prop"};
-    Setting<bool> cpuopt_misc_ir{true, "cpuopt_misc_ir"};
-    Setting<bool> cpuopt_reduce_misalign_checks{true, "cpuopt_reduce_misalign_checks"};
-    Setting<bool> cpuopt_fastmem{true, "cpuopt_fastmem"};
-    Setting<bool> cpuopt_fastmem_exclusives{true, "cpuopt_fastmem_exclusives"};
-    Setting<bool> cpuopt_recompile_exclusives{true, "cpuopt_recompile_exclusives"};
+    BasicSetting<bool> cpuopt_page_tables{true, "cpuopt_page_tables"};
+    BasicSetting<bool> cpuopt_block_linking{true, "cpuopt_block_linking"};
+    BasicSetting<bool> cpuopt_return_stack_buffer{true, "cpuopt_return_stack_buffer"};
+    BasicSetting<bool> cpuopt_fast_dispatcher{true, "cpuopt_fast_dispatcher"};
+    BasicSetting<bool> cpuopt_context_elimination{true, "cpuopt_context_elimination"};
+    BasicSetting<bool> cpuopt_const_prop{true, "cpuopt_const_prop"};
+    BasicSetting<bool> cpuopt_misc_ir{true, "cpuopt_misc_ir"};
+    BasicSetting<bool> cpuopt_reduce_misalign_checks{true, "cpuopt_reduce_misalign_checks"};
+    BasicSetting<bool> cpuopt_fastmem{true, "cpuopt_fastmem"};
+    BasicSetting<bool> cpuopt_fastmem_exclusives{true, "cpuopt_fastmem_exclusives"};
+    BasicSetting<bool> cpuopt_recompile_exclusives{true, "cpuopt_recompile_exclusives"};

-    SwitchableSetting<bool> cpuopt_unsafe_unfuse_fma{true, "cpuopt_unsafe_unfuse_fma"};
-    SwitchableSetting<bool> cpuopt_unsafe_reduce_fp_error{true, "cpuopt_unsafe_reduce_fp_error"};
-    SwitchableSetting<bool> cpuopt_unsafe_ignore_standard_fpcr{
-        true, "cpuopt_unsafe_ignore_standard_fpcr"};
-    SwitchableSetting<bool> cpuopt_unsafe_inaccurate_nan{true, "cpuopt_unsafe_inaccurate_nan"};
-    SwitchableSetting<bool> cpuopt_unsafe_fastmem_check{true, "cpuopt_unsafe_fastmem_check"};
-    SwitchableSetting<bool> cpuopt_unsafe_ignore_global_monitor{
-        true, "cpuopt_unsafe_ignore_global_monitor"};
+    Setting<bool> cpuopt_unsafe_unfuse_fma{true, "cpuopt_unsafe_unfuse_fma"};
+    Setting<bool> cpuopt_unsafe_reduce_fp_error{true, "cpuopt_unsafe_reduce_fp_error"};
+    Setting<bool> cpuopt_unsafe_ignore_standard_fpcr{true, "cpuopt_unsafe_ignore_standard_fpcr"};
+    Setting<bool> cpuopt_unsafe_inaccurate_nan{true, "cpuopt_unsafe_inaccurate_nan"};
+    Setting<bool> cpuopt_unsafe_fastmem_check{true, "cpuopt_unsafe_fastmem_check"};
+    Setting<bool> cpuopt_unsafe_ignore_global_monitor{true, "cpuopt_unsafe_ignore_global_monitor"};

    // Renderer
-    SwitchableSetting<RendererBackend> renderer_backend{
-        RendererBackend::Vulkan, RendererBackend::OpenGL, RendererBackend::Vulkan, "backend"};
-    Setting<bool> renderer_debug{false, "debug"};
-    Setting<bool> renderer_shader_feedback{false, "shader_feedback"};
-    Setting<bool> enable_nsight_aftermath{false, "nsight_aftermath"};
-    Setting<bool> disable_shader_loop_safety_checks{false, "disable_shader_loop_safety_checks"};
-    SwitchableSetting<int> vulkan_device{0, "vulkan_device"};
+    RangedSetting<RendererBackend> renderer_backend{
+        RendererBackend::OpenGL, RendererBackend::OpenGL, RendererBackend::Vulkan, "backend"};
+    BasicSetting<bool> renderer_debug{false, "debug"};
+    BasicSetting<bool> renderer_shader_feedback{false, "shader_feedback"};
+    BasicSetting<bool> enable_nsight_aftermath{false, "nsight_aftermath"};
+    BasicSetting<bool> disable_shader_loop_safety_checks{false,
+                                                         "disable_shader_loop_safety_checks"};
+    Setting<int> vulkan_device{0, "vulkan_device"};

    ResolutionScalingInfo resolution_info{};
-    SwitchableSetting<ResolutionSetup> resolution_setup{ResolutionSetup::Res1X, "resolution_setup"};
-    SwitchableSetting<ScalingFilter> scaling_filter{ScalingFilter::Bilinear, "scaling_filter"};
-    SwitchableSetting<AntiAliasing> anti_aliasing{AntiAliasing::None, "anti_aliasing"};
+    Setting<ResolutionSetup> resolution_setup{ResolutionSetup::Res1X, "resolution_setup"};
+    Setting<ScalingFilter> scaling_filter{ScalingFilter::Bilinear, "scaling_filter"};
+    Setting<AntiAliasing> anti_aliasing{AntiAliasing::None, "anti_aliasing"};
    // *nix platforms may have issues with the borderless windowed fullscreen mode.
    // Default to exclusive fullscreen on these platforms for now.
-    SwitchableSetting<FullscreenMode> fullscreen_mode{
+    RangedSetting<FullscreenMode> fullscreen_mode{
 #ifdef _WIN32
        FullscreenMode::Borderless,
 #else
        FullscreenMode::Exclusive,
 #endif
        FullscreenMode::Borderless, FullscreenMode::Exclusive, "fullscreen_mode"};
-    SwitchableSetting<int> aspect_ratio{0, 0, 3, "aspect_ratio"};
-    SwitchableSetting<int> max_anisotropy{0, 0, 5, "max_anisotropy"};
-    SwitchableSetting<bool> use_speed_limit{true, "use_speed_limit"};
-    SwitchableSetting<u16> speed_limit{100, 0, 9999, "speed_limit"};
-    SwitchableSetting<bool> use_disk_shader_cache{true, "use_disk_shader_cache"};
-    SwitchableSetting<GPUAccuracy> gpu_accuracy{GPUAccuracy::High, GPUAccuracy::Normal,
-                                                GPUAccuracy::Extreme, "gpu_accuracy"};
-    SwitchableSetting<bool> use_asynchronous_gpu_emulation{true, "use_asynchronous_gpu_emulation"};
-    SwitchableSetting<NvdecEmulation> nvdec_emulation{NvdecEmulation::GPU, "nvdec_emulation"};
-    SwitchableSetting<bool> accelerate_astc{true, "accelerate_astc"};
-    SwitchableSetting<bool> use_vsync{true, "use_vsync"};
-    SwitchableSetting<u16> fps_cap{1000, 1, 1000, "fps_cap"};
-    Setting<bool> disable_fps_limit{false, "disable_fps_limit"};
-    SwitchableSetting<ShaderBackend> shader_backend{ShaderBackend::GLASM, ShaderBackend::GLSL,
-                                                    ShaderBackend::SPIRV, "shader_backend"};
-    SwitchableSetting<bool> use_asynchronous_shaders{false, "use_asynchronous_shaders"};
-    SwitchableSetting<bool> use_fast_gpu_time{true, "use_fast_gpu_time"};
+    RangedSetting<int> aspect_ratio{0, 0, 3, "aspect_ratio"};
+    RangedSetting<int> max_anisotropy{0, 0, 5, "max_anisotropy"};
+    Setting<bool> use_speed_limit{true, "use_speed_limit"};
+    RangedSetting<u16> speed_limit{100, 0, 9999, "speed_limit"};
+    Setting<bool> use_disk_shader_cache{true, "use_disk_shader_cache"};
+    RangedSetting<GPUAccuracy> gpu_accuracy{GPUAccuracy::High, GPUAccuracy::Normal,
+                                            GPUAccuracy::Extreme, "gpu_accuracy"};
+    Setting<bool> use_asynchronous_gpu_emulation{true, "use_asynchronous_gpu_emulation"};
+    Setting<NvdecEmulation> nvdec_emulation{NvdecEmulation::GPU, "nvdec_emulation"};
+    Setting<bool> accelerate_astc{true, "accelerate_astc"};
+    Setting<bool> use_vsync{true, "use_vsync"};
+    RangedSetting<u16> fps_cap{1000, 1, 1000, "fps_cap"};
+    BasicSetting<bool> disable_fps_limit{false, "disable_fps_limit"};
+    RangedSetting<ShaderBackend> shader_backend{ShaderBackend::GLASM, ShaderBackend::GLSL,
+                                                ShaderBackend::SPIRV, "shader_backend"};
+    Setting<bool> use_asynchronous_shaders{false, "use_asynchronous_shaders"};
+    Setting<bool> use_fast_gpu_time{true, "use_fast_gpu_time"};

-    SwitchableSetting<u8> bg_red{0, "bg_red"};
-    SwitchableSetting<u8> bg_green{0, "bg_green"};
-    SwitchableSetting<u8> bg_blue{0, "bg_blue"};
+    Setting<u8> bg_red{0, "bg_red"};
+    Setting<u8> bg_green{0, "bg_green"};
+    Setting<u8> bg_blue{0, "bg_blue"};

    // System
-    SwitchableSetting<std::optional<u32>> rng_seed{std::optional<u32>(), "rng_seed"};
+    Setting<std::optional<u32>> rng_seed{std::optional<u32>(), "rng_seed"};
    // Measured in seconds since epoch
    std::optional<s64> custom_rtc;
    // Set on game boot, reset on stop. Seconds difference between current time and `custom_rtc`
    s64 custom_rtc_differential;

-    Setting<s32> current_user{0, "current_user"};
-    SwitchableSetting<s32> language_index{1, 0, 17, "language_index"};
-    SwitchableSetting<s32> region_index{1, 0, 6, "region_index"};
-    SwitchableSetting<s32> time_zone_index{0, 0, 45, "time_zone_index"};
-    SwitchableSetting<s32> sound_index{1, 0, 2, "sound_index"};
+    BasicSetting<s32> current_user{0, "current_user"};
+    RangedSetting<s32> language_index{1, 0, 17, "language_index"};
+    RangedSetting<s32> region_index{1, 0, 6, "region_index"};
+    RangedSetting<s32> time_zone_index{0, 0, 45, "time_zone_index"};
+    RangedSetting<s32> sound_index{1, 0, 2, "sound_index"};

    // Controls
    InputSetting<std::array<PlayerInput, 10>> players;

-    SwitchableSetting<bool> use_docked_mode{true, "use_docked_mode"};
+    Setting<bool> use_docked_mode{true, "use_docked_mode"};

-    Setting<bool> enable_raw_input{false, "enable_raw_input"};
-    Setting<bool> controller_navigation{true, "controller_navigation"};
+    BasicSetting<bool> enable_raw_input{false, "enable_raw_input"};
+    BasicSetting<bool> controller_navigation{true, "controller_navigation"};

-    SwitchableSetting<bool> vibration_enabled{true, "vibration_enabled"};
-    SwitchableSetting<bool> enable_accurate_vibrations{false, "enable_accurate_vibrations"};
+    Setting<bool> vibration_enabled{true, "vibration_enabled"};
+    Setting<bool> enable_accurate_vibrations{false, "enable_accurate_vibrations"};

-    SwitchableSetting<bool> motion_enabled{true, "motion_enabled"};
-    Setting<std::string> udp_input_servers{"127.0.0.1:26760", "udp_input_servers"};
-    Setting<bool> enable_udp_controller{false, "enable_udp_controller"};
+    Setting<bool> motion_enabled{true, "motion_enabled"};
+    BasicSetting<std::string> udp_input_servers{"127.0.0.1:26760", "udp_input_servers"};
+    BasicSetting<bool> enable_udp_controller{false, "enable_udp_controller"};

-    Setting<bool> pause_tas_on_load{true, "pause_tas_on_load"};
-    Setting<bool> tas_enable{false, "tas_enable"};
-    Setting<bool> tas_loop{false, "tas_loop"};
+    BasicSetting<bool> pause_tas_on_load{true, "pause_tas_on_load"};
+    BasicSetting<bool> tas_enable{false, "tas_enable"};
+    BasicSetting<bool> tas_loop{false, "tas_loop"};

-    Setting<bool> mouse_panning{false, "mouse_panning"};
-    Setting<u8> mouse_panning_sensitivity{10, 1, 100, "mouse_panning_sensitivity"};
-    Setting<bool> mouse_enabled{false, "mouse_enabled"};
+    BasicSetting<bool> mouse_panning{false, "mouse_panning"};
+    BasicRangedSetting<u8> mouse_panning_sensitivity{10, 1, 100, "mouse_panning_sensitivity"};
+    BasicSetting<bool> mouse_enabled{false, "mouse_enabled"};

-    Setting<bool> emulate_analog_keyboard{false, "emulate_analog_keyboard"};
-    Setting<bool> keyboard_enabled{false, "keyboard_enabled"};
+    BasicSetting<bool> emulate_analog_keyboard{false, "emulate_analog_keyboard"};
+    BasicSetting<bool> keyboard_enabled{false, "keyboard_enabled"};

-    Setting<bool> debug_pad_enabled{false, "debug_pad_enabled"};
+    BasicSetting<bool> debug_pad_enabled{false, "debug_pad_enabled"};
    ButtonsRaw debug_pad_buttons;
    AnalogsRaw debug_pad_analogs;

    TouchscreenInput touchscreen;

-    Setting<std::string> touch_device{"min_x:100,min_y:50,max_x:1800,max_y:850", "touch_device"};
-    Setting<int> touch_from_button_map_index{0, "touch_from_button_map"};
+    BasicSetting<std::string> touch_device{"min_x:100,min_y:50,max_x:1800,max_y:850",
+                                           "touch_device"};
+    BasicSetting<int> touch_from_button_map_index{0, "touch_from_button_map"};
    std::vector<TouchFromButtonMap> touch_from_button_maps;

-    Setting<bool> enable_ring_controller{true, "enable_ring_controller"};
+    BasicSetting<bool> enable_ring_controller{true, "enable_ring_controller"};
    RingconRaw ringcon_analogs;

    // Data Storage
-    Setting<bool> use_virtual_sd{true, "use_virtual_sd"};
-    Setting<bool> gamecard_inserted{false, "gamecard_inserted"};
-    Setting<bool> gamecard_current_game{false, "gamecard_current_game"};
-    Setting<std::string> gamecard_path{std::string(), "gamecard_path"};
+    BasicSetting<bool> use_virtual_sd{true, "use_virtual_sd"};
+    BasicSetting<bool> gamecard_inserted{false, "gamecard_inserted"};
+    BasicSetting<bool> gamecard_current_game{false, "gamecard_current_game"};
+    BasicSetting<std::string> gamecard_path{std::string(), "gamecard_path"};

    // Debugging
    bool record_frame_times;
-    Setting<bool> use_gdbstub{false, "use_gdbstub"};
-    Setting<u16> gdbstub_port{6543, "gdbstub_port"};
-    Setting<std::string> program_args{std::string(), "program_args"};
-    Setting<bool> dump_exefs{false, "dump_exefs"};
-    Setting<bool> dump_nso{false, "dump_nso"};
-    Setting<bool> dump_shaders{false, "dump_shaders"};
-    Setting<bool> dump_macros{false, "dump_macros"};
-    Setting<bool> enable_fs_access_log{false, "enable_fs_access_log"};
-    Setting<bool> reporting_services{false, "reporting_services"};
-    Setting<bool> quest_flag{false, "quest_flag"};
-    Setting<bool> disable_macro_jit{false, "disable_macro_jit"};
-    Setting<bool> extended_logging{false, "extended_logging"};
-    Setting<bool> use_debug_asserts{false, "use_debug_asserts"};
-    Setting<bool> use_auto_stub{false, "use_auto_stub"};
-    Setting<bool> enable_all_controllers{false, "enable_all_controllers"};
+    BasicSetting<bool> use_gdbstub{false, "use_gdbstub"};
+    BasicSetting<u16> gdbstub_port{6543, "gdbstub_port"};
+    BasicSetting<std::string> program_args{std::string(), "program_args"};
+    BasicSetting<bool> dump_exefs{false, "dump_exefs"};
+    BasicSetting<bool> dump_nso{false, "dump_nso"};
+    BasicSetting<bool> dump_shaders{false, "dump_shaders"};
+    BasicSetting<bool> dump_macros{false, "dump_macros"};
+    BasicSetting<bool> enable_fs_access_log{false, "enable_fs_access_log"};
+    BasicSetting<bool> reporting_services{false, "reporting_services"};
+    BasicSetting<bool> quest_flag{false, "quest_flag"};
+    BasicSetting<bool> disable_macro_jit{false, "disable_macro_jit"};
+    BasicSetting<bool> extended_logging{false, "extended_logging"};
+    BasicSetting<bool> use_debug_asserts{false, "use_debug_asserts"};
+    BasicSetting<bool> use_auto_stub{false, "use_auto_stub"};
+    BasicSetting<bool> enable_all_controllers{false, "enable_all_controllers"};

    // Miscellaneous
-    Setting<std::string> log_filter{"*:Info", "log_filter"};
-    Setting<bool> use_dev_keys{false, "use_dev_keys"};
+    BasicSetting<std::string> log_filter{"*:Info", "log_filter"};
+    BasicSetting<bool> use_dev_keys{false, "use_dev_keys"};

    // Network
-    Setting<std::string> network_interface{std::string(), "network_interface"};
+    BasicSetting<std::string> network_interface{std::string(), "network_interface"};

    // WebService
-    Setting<bool> enable_telemetry{true, "enable_telemetry"};
-    Setting<std::string> web_api_url{"https://api.yuzu-emu.org", "web_api_url"};
-    Setting<std::string> yuzu_username{std::string(), "yuzu_username"};
-    Setting<std::string> yuzu_token{std::string(), "yuzu_token"};
+    BasicSetting<bool> enable_telemetry{true, "enable_telemetry"};
+    BasicSetting<std::string> web_api_url{"https://api.yuzu-emu.org", "web_api_url"};
+    BasicSetting<std::string> yuzu_username{std::string(), "yuzu_username"};
+    BasicSetting<std::string> yuzu_token{std::string(), "yuzu_token"};

    // Add-Ons
    std::map<u64, std::vector<std::string>> disabled_addons;
@@ -47,9 +47,6 @@ void SetCurrentThreadPriority(ThreadPriority new_priority) {
    case ThreadPriority::VeryHigh:
        windows_priority = THREAD_PRIORITY_HIGHEST;
        break;
-    case ThreadPriority::Critical:
-        windows_priority = THREAD_PRIORITY_TIME_CRITICAL;
-        break;
    default:
        windows_priority = THREAD_PRIORITY_NORMAL;
        break;
@@ -62,10 +59,9 @@ void SetCurrentThreadPriority(ThreadPriority new_priority) {
 void SetCurrentThreadPriority(ThreadPriority new_priority) {
    pthread_t this_thread = pthread_self();

-    const auto scheduling_type = SCHED_OTHER;
-    s32 max_prio = sched_get_priority_max(scheduling_type);
-    s32 min_prio = sched_get_priority_min(scheduling_type);
-    u32 level = std::max(static_cast<u32>(new_priority) + 1, 4U);
+    s32 max_prio = sched_get_priority_max(SCHED_OTHER);
+    s32 min_prio = sched_get_priority_min(SCHED_OTHER);
+    u32 level = static_cast<u32>(new_priority) + 1;

    struct sched_param params;
    if (max_prio > min_prio) {
@@ -74,7 +70,7 @@ void SetCurrentThreadPriority(ThreadPriority new_priority) {
        params.sched_priority = min_prio - ((min_prio - max_prio) * level) / 4;
    }

-    pthread_setschedparam(this_thread, scheduling_type, &params);
+    pthread_setschedparam(this_thread, SCHED_OTHER, &params);
 }

 #endif
@@ -92,7 +92,6 @@ enum class ThreadPriority : u32 {
    Normal = 1,
    High = 2,
    VeryHigh = 3,
-    Critical = 4,
 };

 void SetCurrentThreadPriority(ThreadPriority new_priority);
@@ -30,10 +30,6 @@ namespace Common {
 #else
    return _udiv128(r[1], r[0], d, &remainder);
 #endif
-#else
-#ifdef __SIZEOF_INT128__
-    const auto product = static_cast<unsigned __int128>(a) * static_cast<unsigned __int128>(b);
-    return static_cast<u64>(product / d);
 #else
    const u64 diva = a / d;
    const u64 moda = a % d;
@@ -41,7 +37,6 @@ namespace Common {
    const u64 modb = b % d;
    return diva * b + moda * divb + moda * modb / d;
 #endif
-#endif
 }

 // This function multiplies 2 u64 values and produces a u128 value;
@@ -75,8 +75,8 @@ NativeClock::NativeClock(u64 emulated_cpu_frequency_, u64 emulated_clock_frequen
 }

 u64 NativeClock::GetRTSC() {
-    TimePoint current_time_point{};
    TimePoint new_time_point{};
+    TimePoint current_time_point{};

    current_time_point.pack = Common::AtomicLoad128(time_point.pack.data());
    do {
@@ -89,7 +89,8 @@ u64 NativeClock::GetRTSC() {
        new_time_point.inner.accumulated_ticks = current_time_point.inner.accumulated_ticks + diff;
    } while (!Common::AtomicCompareAndSwap(time_point.pack.data(), new_time_point.pack,
                                           current_time_point.pack, current_time_point.pack));
-    return new_time_point.inner.accumulated_ticks;
+    /// The clock cannot be more precise than the guest timer, remove the lower bits
+    return new_time_point.inner.accumulated_ticks & inaccuracy_mask;
 }

 void NativeClock::Pause(bool is_paused) {
@@ -37,8 +37,12 @@ private:
        } inner;
    };

-    TimePoint time_point;
+    /// value used to reduce the native clocks accuracy as some apss rely on
+    /// undefined behavior where the level of accuracy in the clock shouldn't
+    /// be higher.
+    static constexpr u64 inaccuracy_mask = ~(UINT64_C(0x400) - 1);

+    TimePoint time_point;
    // factors
    u64 clock_rtsc_factor{};
    u64 cpu_rtsc_factor{};
@@ -222,7 +222,7 @@ add_library(core STATIC
    hle/kernel/k_page_buffer.h
    hle/kernel/k_page_heap.cpp
    hle/kernel/k_page_heap.h
-    hle/kernel/k_page_group.h
+    hle/kernel/k_page_linked_list.h
    hle/kernel/k_page_table.cpp
    hle/kernel/k_page_table.h
    hle/kernel/k_port.cpp
@@ -743,11 +743,16 @@ if (MSVC)
        /we4244 # 'conversion': conversion from 'type1' to 'type2', possible loss of data
        /we4245 # 'conversion': conversion from 'type1' to 'type2', signed/unsigned mismatch
        /we4254 # 'operator': conversion from 'type1:field_bits' to 'type2:field_bits', possible loss of data
+        /we4456 # Declaration of 'identifier' hides previous local declaration
+        /we4457 # Declaration of 'identifier' hides function parameter
+        /we4458 # Declaration of 'identifier' hides class member
+        /we4459 # Declaration of 'identifier' hides global declaration
    )
 else()
    target_compile_options(core PRIVATE
        -Werror=conversion
        -Werror=ignored-qualifiers
+        -Werror=shadow

        $<$<CXX_COMPILER_ID:GNU>:-Werror=class-memaccess>
        $<$<CXX_COMPILER_ID:GNU>:-Werror=unused-but-set-parameter>
@@ -1,10 +1,6 @@
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

-#ifndef _MSC_VER
-#include <cxxabi.h>
-#endif
-
 #include <map>
 #include <optional>
 #include "common/bit_field.h"
@@ -72,19 +68,8 @@ void ARM_Interface::SymbolicateBacktrace(Core::System& system, std::vector<Backt
        if (symbol_set != symbols.end()) {
            const auto symbol = Symbols::GetSymbolName(symbol_set->second, entry.offset);
            if (symbol.has_value()) {
-#ifdef _MSC_VER
                // TODO(DarkLordZach): Add demangling of symbol names.
                entry.name = *symbol;
-#else
-                int status{-1};
-                char* demangled{abi::__cxa_demangle(symbol->c_str(), nullptr, nullptr, &status)};
-                if (status == 0 && demangled != nullptr) {
-                    entry.name = demangled;
-                    std::free(demangled);
-                } else {
-                    entry.name = *symbol;
-                }
-#endif
            }
        }
    }
@@ -110,7 +95,7 @@ void ARM_Interface::Run() {
    using Kernel::SuspendType;

    while (true) {
-        Kernel::KThread* current_thread{Kernel::GetCurrentThreadPointer(system.Kernel())};
+        Kernel::KThread* current_thread{system.Kernel().CurrentScheduler()->GetCurrentThread()};
        Dynarmic::HaltReason hr{};

        // Notify the debugger and go to sleep if a step was performed
@@ -122,7 +107,6 @@ void ARM_Interface::Run() {
        }

        // Otherwise, run the thread.
-        system.EnterDynarmicProfile();
        if (current_thread->GetStepState() == StepState::StepPending) {
            hr = StepJit();

@@ -132,29 +116,14 @@ void ARM_Interface::Run() {
        } else {
            hr = RunJit();
        }
-        system.ExitDynarmicProfile();

-        // Notify the debugger and go to sleep if a breakpoint was hit,
-        // or if the thread is unable to continue for any reason.
-        if (Has(hr, breakpoint) || Has(hr, no_execute)) {
-            RewindBreakpointInstruction();
-            if (system.DebuggerEnabled()) {
-                system.GetDebugger().NotifyThreadStopped(current_thread);
-            }
+        // Notify the debugger and go to sleep if a breakpoint was hit.
+        if (Has(hr, breakpoint)) {
+            system.GetDebugger().NotifyThreadStopped(current_thread);
            current_thread->RequestSuspend(Kernel::SuspendType::Debug);
            break;
        }

-        // Notify the debugger and go to sleep if a watchpoint was hit.
-        if (Has(hr, watchpoint)) {
-            RewindBreakpointInstruction();
-            if (system.DebuggerEnabled()) {
-                system.GetDebugger().NotifyThreadWatchpoint(current_thread, *HaltedWatchpoint());
-            }
-            current_thread->RequestSuspend(SuspendType::Debug);
-            break;
-        }
-
        // Handle syscalls and scheduling (this may change the current thread)
        if (Has(hr, svc_call)) {
            Kernel::Svc::Call(system, GetSvcNumber());
@@ -165,36 +134,4 @@ void ARM_Interface::Run() {
    }
 }

-void ARM_Interface::LoadWatchpointArray(const WatchpointArray& wp) {
-    watchpoints = &wp;
-}
-
-const Kernel::DebugWatchpoint* ARM_Interface::MatchingWatchpoint(
-    VAddr addr, u64 size, Kernel::DebugWatchpointType access_type) const {
-    if (!watchpoints) {
-        return nullptr;
-    }
-
-    const VAddr start_address{addr};
-    const VAddr end_address{addr + size};
-
-    for (size_t i = 0; i < Core::Hardware::NUM_WATCHPOINTS; i++) {
-        const auto& watch{(*watchpoints)[i]};
-
-        if (end_address <= watch.start_address) {
-            continue;
-        }
-        if (start_address >= watch.end_address) {
-            continue;
-        }
-        if ((access_type & watch.type) == Kernel::DebugWatchpointType::None) {
-            continue;
-        }
-
-        return &watch;
-    }
-
-    return nullptr;
-}
-
 } // namespace Core
@@ -5,7 +5,6 @@
 #pragma once

 #include <array>
-#include <span>
 #include <vector>

 #include <dynarmic/interface/halt_reason.h>
@@ -20,16 +19,13 @@ struct PageTable;

 namespace Kernel {
 enum class VMAPermission : u8;
-enum class DebugWatchpointType : u8;
-struct DebugWatchpoint;
-} // namespace Kernel
+}

 namespace Core {
 class System;
 class CPUInterruptHandler;

 using CPUInterrupts = std::array<CPUInterruptHandler, Core::Hardware::NUM_CPU_CORES>;
-using WatchpointArray = std::array<Kernel::DebugWatchpoint, Core::Hardware::NUM_WATCHPOINTS>;

 /// Generic ARMv8 CPU interface
 class ARM_Interface {
@@ -174,7 +170,6 @@ public:
    virtual void SaveContext(ThreadContext64& ctx) = 0;
    virtual void LoadContext(const ThreadContext32& ctx) = 0;
    virtual void LoadContext(const ThreadContext64& ctx) = 0;
-    void LoadWatchpointArray(const WatchpointArray& wp);

    /// Clears the exclusive monitor's state.
    virtual void ClearExclusiveState() = 0;
@@ -203,25 +198,18 @@ public:
    static constexpr Dynarmic::HaltReason break_loop = Dynarmic::HaltReason::UserDefined2;
    static constexpr Dynarmic::HaltReason svc_call = Dynarmic::HaltReason::UserDefined3;
    static constexpr Dynarmic::HaltReason breakpoint = Dynarmic::HaltReason::UserDefined4;
-    static constexpr Dynarmic::HaltReason watchpoint = Dynarmic::HaltReason::UserDefined5;
-    static constexpr Dynarmic::HaltReason no_execute = Dynarmic::HaltReason::UserDefined6;

 protected:
    /// System context that this ARM interface is running under.
    System& system;
    CPUInterrupts& interrupt_handlers;
-    const WatchpointArray* watchpoints;
    bool uses_wall_clock;

    static void SymbolicateBacktrace(Core::System& system, std::vector<BacktraceEntry>& out);
-    const Kernel::DebugWatchpoint* MatchingWatchpoint(
-        VAddr addr, u64 size, Kernel::DebugWatchpointType access_type) const;

    virtual Dynarmic::HaltReason RunJit() = 0;
    virtual Dynarmic::HaltReason StepJit() = 0;
    virtual u32 GetSvcNumber() const = 0;
-    virtual const Kernel::DebugWatchpoint* HaltedWatchpoint() const = 0;
-    virtual void RewindBreakpointInstruction() = 0;
 };

 } // namespace Core
@@ -29,94 +29,64 @@ using namespace Common::Literals;
 class DynarmicCallbacks32 : public Dynarmic::A32::UserCallbacks {
 public:
    explicit DynarmicCallbacks32(ARM_Dynarmic_32& parent_)
-        : parent{parent_},
-          memory(parent.system.Memory()), debugger_enabled{parent.system.DebuggerEnabled()} {}
+        : parent{parent_}, memory(parent.system.Memory()) {}

    u8 MemoryRead8(u32 vaddr) override {
-        CheckMemoryAccess(vaddr, 1, Kernel::DebugWatchpointType::Read);
        return memory.Read8(vaddr);
    }
    u16 MemoryRead16(u32 vaddr) override {
-        CheckMemoryAccess(vaddr, 2, Kernel::DebugWatchpointType::Read);
        return memory.Read16(vaddr);
    }
    u32 MemoryRead32(u32 vaddr) override {
-        CheckMemoryAccess(vaddr, 4, Kernel::DebugWatchpointType::Read);
        return memory.Read32(vaddr);
    }
    u64 MemoryRead64(u32 vaddr) override {
-        CheckMemoryAccess(vaddr, 8, Kernel::DebugWatchpointType::Read);
        return memory.Read64(vaddr);
    }
-    std::optional<u32> MemoryReadCode(u32 vaddr) override {
-        if (!memory.IsValidVirtualAddressRange(vaddr, sizeof(u32))) {
-            return std::nullopt;
-        }
-        return MemoryRead32(vaddr);
-    }

    void MemoryWrite8(u32 vaddr, u8 value) override {
-        if (CheckMemoryAccess(vaddr, 1, Kernel::DebugWatchpointType::Write)) {
-            memory.Write8(vaddr, value);
-        }
+        memory.Write8(vaddr, value);
    }
    void MemoryWrite16(u32 vaddr, u16 value) override {
-        if (CheckMemoryAccess(vaddr, 2, Kernel::DebugWatchpointType::Write)) {
-            memory.Write16(vaddr, value);
-        }
+        memory.Write16(vaddr, value);
    }
    void MemoryWrite32(u32 vaddr, u32 value) override {
-        if (CheckMemoryAccess(vaddr, 4, Kernel::DebugWatchpointType::Write)) {
-            memory.Write32(vaddr, value);
-        }
+        memory.Write32(vaddr, value);
    }
    void MemoryWrite64(u32 vaddr, u64 value) override {
-        if (CheckMemoryAccess(vaddr, 8, Kernel::DebugWatchpointType::Write)) {
-            memory.Write64(vaddr, value);
-        }
+        memory.Write64(vaddr, value);
    }

    bool MemoryWriteExclusive8(u32 vaddr, u8 value, u8 expected) override {
-        return CheckMemoryAccess(vaddr, 1, Kernel::DebugWatchpointType::Write) &&
-               memory.WriteExclusive8(vaddr, value, expected);
+        return memory.WriteExclusive8(vaddr, value, expected);
    }
    bool MemoryWriteExclusive16(u32 vaddr, u16 value, u16 expected) override {
-        return CheckMemoryAccess(vaddr, 2, Kernel::DebugWatchpointType::Write) &&
-               memory.WriteExclusive16(vaddr, value, expected);
+        return memory.WriteExclusive16(vaddr, value, expected);
    }
    bool MemoryWriteExclusive32(u32 vaddr, u32 value, u32 expected) override {
-        return CheckMemoryAccess(vaddr, 4, Kernel::DebugWatchpointType::Write) &&
-               memory.WriteExclusive32(vaddr, value, expected);
+        return memory.WriteExclusive32(vaddr, value, expected);
    }
    bool MemoryWriteExclusive64(u32 vaddr, u64 value, u64 expected) override {
-        return CheckMemoryAccess(vaddr, 8, Kernel::DebugWatchpointType::Write) &&
-               memory.WriteExclusive64(vaddr, value, expected);
+        return memory.WriteExclusive64(vaddr, value, expected);
    }

    void InterpreterFallback(u32 pc, std::size_t num_instructions) override {
        parent.LogBacktrace();
-        LOG_ERROR(Core_ARM,
-                  "Unimplemented instruction @ 0x{:X} for {} instructions (instr = {:08X})", pc,
-                  num_instructions, MemoryRead32(pc));
+        UNIMPLEMENTED_MSG("This should never happen, pc = {:08X}, code = {:08X}", pc,
+                          MemoryReadCode(pc));
    }

    void ExceptionRaised(u32 pc, Dynarmic::A32::Exception exception) override {
-        switch (exception) {
-        case Dynarmic::A32::Exception::NoExecuteFault:
-            LOG_CRITICAL(Core_ARM, "Cannot execute instruction at unmapped address {:#08x}", pc);
-            ReturnException(pc, ARM_Interface::no_execute);
+        if (parent.system.DebuggerEnabled()) {
+            parent.jit.load()->Regs()[15] = pc;
+            parent.jit.load()->HaltExecution(ARM_Interface::breakpoint);
            return;
-        default:
-            if (debugger_enabled) {
-                ReturnException(pc, ARM_Interface::breakpoint);
-                return;
-            }
-
-            parent.LogBacktrace();
-            LOG_CRITICAL(Core_ARM,
-                         "ExceptionRaised(exception = {}, pc = {:08X}, code = {:08X}, thumb = {})",
-                         exception, pc, MemoryRead32(pc), parent.IsInThumbMode());
        }
+
+        parent.LogBacktrace();
+        LOG_CRITICAL(Core_ARM,
+                     "ExceptionRaised(exception = {}, pc = {:08X}, code = {:08X}, thumb = {})",
+                     exception, pc, MemoryReadCode(pc), parent.IsInThumbMode());
    }

    void CallSVC(u32 swi) override {
@@ -147,31 +117,9 @@ public:
        return std::max<s64>(parent.system.CoreTiming().GetDowncount(), 0);
    }

-    bool CheckMemoryAccess(VAddr addr, u64 size, Kernel::DebugWatchpointType type) {
-        if (!debugger_enabled) {
-            return true;
-        }
-
-        const auto match{parent.MatchingWatchpoint(addr, size, type)};
-        if (match) {
-            parent.halted_watchpoint = match;
-            ReturnException(parent.jit.load()->Regs()[15], ARM_Interface::watchpoint);
-            return false;
-        }
-
-        return true;
-    }
-
-    void ReturnException(u32 pc, Dynarmic::HaltReason hr) {
-        parent.SaveContext(parent.breakpoint_context);
-        parent.breakpoint_context.cpu_registers[15] = pc;
-        parent.jit.load()->HaltExecution(hr);
-    }
-
    ARM_Dynarmic_32& parent;
    Core::Memory::Memory& memory;
    std::size_t num_interpreted_instructions{};
-    bool debugger_enabled{};
    static constexpr u64 minimum_run_cycles = 1000U;
 };

@@ -206,11 +154,6 @@ std::shared_ptr<Dynarmic::A32::Jit> ARM_Dynarmic_32::MakeJit(Common::PageTable*
    config.code_cache_size = 512_MiB;
    config.far_code_offset = 400_MiB;

-    // Allow memory fault handling to work
-    if (system.DebuggerEnabled()) {
-        config.check_halt_on_memory_access = true;
-    }
-
    // null_jit
    if (!page_table) {
        // Don't waste too much memory on null_jit
@@ -305,14 +248,6 @@ u32 ARM_Dynarmic_32::GetSvcNumber() const {
    return svc_swi;
 }

-const Kernel::DebugWatchpoint* ARM_Dynarmic_32::HaltedWatchpoint() const {
-    return halted_watchpoint;
-}
-
-void ARM_Dynarmic_32::RewindBreakpointInstruction() {
-    LoadContext(breakpoint_context);
-}
-
 ARM_Dynarmic_32::ARM_Dynarmic_32(System& system_, CPUInterrupts& interrupt_handlers_,
                                 bool uses_wall_clock_, ExclusiveMonitor& exclusive_monitor_,
                                 std::size_t core_index_)
@@ -427,38 +362,18 @@ void ARM_Dynarmic_32::PageTableChanged(Common::PageTable& page_table,
 }

 std::vector<ARM_Interface::BacktraceEntry> ARM_Dynarmic_32::GetBacktrace(Core::System& system,
-                                                                         u64 fp, u64 lr, u64 pc) {
-    std::vector<BacktraceEntry> out;
-    auto& memory = system.Memory();
-
-    out.push_back({"", 0, pc, 0, ""});
-
-    // fp (= r11) points to the last frame record.
-    // Frame records are two words long:
-    // fp+0 : pointer to previous frame record
-    // fp+4 : value of lr for frame
-    while (true) {
-        out.push_back({"", 0, lr, 0, ""});
-        if (!fp || (fp % 4 != 0) || !memory.IsValidVirtualAddressRange(fp, 8)) {
-            break;
-        }
-        lr = memory.Read32(fp + 4);
-        fp = memory.Read32(fp);
-    }
-
-    SymbolicateBacktrace(system, out);
-
-    return out;
+                                                                         u64 sp, u64 lr) {
+    // No way to get accurate stack traces in A32 yet
+    return {};
 }

 std::vector<ARM_Interface::BacktraceEntry> ARM_Dynarmic_32::GetBacktraceFromContext(
    System& system, const ThreadContext32& ctx) {
-    const auto& reg = ctx.cpu_registers;
-    return GetBacktrace(system, reg[11], reg[14], reg[15]);
+    return GetBacktrace(system, ctx.cpu_registers[13], ctx.cpu_registers[14]);
 }

 std::vector<ARM_Interface::BacktraceEntry> ARM_Dynarmic_32::GetBacktrace() const {
-    return GetBacktrace(system, GetReg(11), GetReg(14), GetReg(15));
+    return GetBacktrace(system, GetReg(13), GetReg(14));
 }

 } // namespace Core
@@ -72,13 +72,11 @@ protected:
    Dynarmic::HaltReason RunJit() override;
    Dynarmic::HaltReason StepJit() override;
    u32 GetSvcNumber() const override;
-    const Kernel::DebugWatchpoint* HaltedWatchpoint() const override;
-    void RewindBreakpointInstruction() override;

 private:
    std::shared_ptr<Dynarmic::A32::Jit> MakeJit(Common::PageTable* page_table) const;

-    static std::vector<BacktraceEntry> GetBacktrace(Core::System& system, u64 fp, u64 lr, u64 pc);
+    static std::vector<BacktraceEntry> GetBacktrace(Core::System& system, u64 sp, u64 lr);

    using JitCacheKey = std::pair<Common::PageTable*, std::size_t>;
    using JitCacheType =
@@ -100,10 +98,6 @@ private:

    // SVC callback
    u32 svc_swi{};
-
-    // Watchpoint info
-    const Kernel::DebugWatchpoint* halted_watchpoint;
-    ThreadContext32 breakpoint_context;
 };

 } // namespace Core
@@ -29,89 +29,62 @@ using namespace Common::Literals;
 class DynarmicCallbacks64 : public Dynarmic::A64::UserCallbacks {
 public:
    explicit DynarmicCallbacks64(ARM_Dynarmic_64& parent_)
-        : parent{parent_},
-          memory(parent.system.Memory()), debugger_enabled{parent.system.DebuggerEnabled()} {}
+        : parent{parent_}, memory(parent.system.Memory()) {}

    u8 MemoryRead8(u64 vaddr) override {
-        CheckMemoryAccess(vaddr, 1, Kernel::DebugWatchpointType::Read);
        return memory.Read8(vaddr);
    }
    u16 MemoryRead16(u64 vaddr) override {
-        CheckMemoryAccess(vaddr, 2, Kernel::DebugWatchpointType::Read);
        return memory.Read16(vaddr);
    }
    u32 MemoryRead32(u64 vaddr) override {
-        CheckMemoryAccess(vaddr, 4, Kernel::DebugWatchpointType::Read);
        return memory.Read32(vaddr);
    }
    u64 MemoryRead64(u64 vaddr) override {
-        CheckMemoryAccess(vaddr, 8, Kernel::DebugWatchpointType::Read);
        return memory.Read64(vaddr);
    }
    Vector MemoryRead128(u64 vaddr) override {
-        CheckMemoryAccess(vaddr, 16, Kernel::DebugWatchpointType::Read);
        return {memory.Read64(vaddr), memory.Read64(vaddr + 8)};
    }
-    std::optional<u32> MemoryReadCode(u64 vaddr) override {
-        if (!memory.IsValidVirtualAddressRange(vaddr, sizeof(u32))) {
-            return std::nullopt;
-        }
-        return MemoryRead32(vaddr);
-    }

    void MemoryWrite8(u64 vaddr, u8 value) override {
-        if (CheckMemoryAccess(vaddr, 1, Kernel::DebugWatchpointType::Write)) {
-            memory.Write8(vaddr, value);
-        }
+        memory.Write8(vaddr, value);
    }
    void MemoryWrite16(u64 vaddr, u16 value) override {
-        if (CheckMemoryAccess(vaddr, 2, Kernel::DebugWatchpointType::Write)) {
-            memory.Write16(vaddr, value);
-        }
+        memory.Write16(vaddr, value);
    }
    void MemoryWrite32(u64 vaddr, u32 value) override {
-        if (CheckMemoryAccess(vaddr, 4, Kernel::DebugWatchpointType::Write)) {
-            memory.Write32(vaddr, value);
-        }
+        memory.Write32(vaddr, value);
    }
    void MemoryWrite64(u64 vaddr, u64 value) override {
-        if (CheckMemoryAccess(vaddr, 8, Kernel::DebugWatchpointType::Write)) {
-            memory.Write64(vaddr, value);
-        }
+        memory.Write64(vaddr, value);
    }
    void MemoryWrite128(u64 vaddr, Vector value) override {
-        if (CheckMemoryAccess(vaddr, 16, Kernel::DebugWatchpointType::Write)) {
-            memory.Write64(vaddr, value[0]);
-            memory.Write64(vaddr + 8, value[1]);
-        }
+        memory.Write64(vaddr, value[0]);
+        memory.Write64(vaddr + 8, value[1]);
    }

    bool MemoryWriteExclusive8(u64 vaddr, std::uint8_t value, std::uint8_t expected) override {
-        return CheckMemoryAccess(vaddr, 1, Kernel::DebugWatchpointType::Write) &&
-               memory.WriteExclusive8(vaddr, value, expected);
+        return memory.WriteExclusive8(vaddr, value, expected);
    }
    bool MemoryWriteExclusive16(u64 vaddr, std::uint16_t value, std::uint16_t expected) override {
-        return CheckMemoryAccess(vaddr, 2, Kernel::DebugWatchpointType::Write) &&
-               memory.WriteExclusive16(vaddr, value, expected);
+        return memory.WriteExclusive16(vaddr, value, expected);
    }
    bool MemoryWriteExclusive32(u64 vaddr, std::uint32_t value, std::uint32_t expected) override {
-        return CheckMemoryAccess(vaddr, 4, Kernel::DebugWatchpointType::Write) &&
-               memory.WriteExclusive32(vaddr, value, expected);
+        return memory.WriteExclusive32(vaddr, value, expected);
    }
    bool MemoryWriteExclusive64(u64 vaddr, std::uint64_t value, std::uint64_t expected) override {
-        return CheckMemoryAccess(vaddr, 8, Kernel::DebugWatchpointType::Write) &&
-               memory.WriteExclusive64(vaddr, value, expected);
+        return memory.WriteExclusive64(vaddr, value, expected);
    }
    bool MemoryWriteExclusive128(u64 vaddr, Vector value, Vector expected) override {
-        return CheckMemoryAccess(vaddr, 16, Kernel::DebugWatchpointType::Write) &&
-               memory.WriteExclusive128(vaddr, value, expected);
+        return memory.WriteExclusive128(vaddr, value, expected);
    }

    void InterpreterFallback(u64 pc, std::size_t num_instructions) override {
        parent.LogBacktrace();
        LOG_ERROR(Core_ARM,
                  "Unimplemented instruction @ 0x{:X} for {} instructions (instr = {:08X})", pc,
-                  num_instructions, MemoryRead32(pc));
+                  num_instructions, MemoryReadCode(pc));
    }

    void InstructionCacheOperationRaised(Dynarmic::A64::InstructionCacheOperation op,
@@ -144,19 +117,16 @@ public:
        case Dynarmic::A64::Exception::SendEventLocal:
        case Dynarmic::A64::Exception::Yield:
            return;
-        case Dynarmic::A64::Exception::NoExecuteFault:
-            LOG_CRITICAL(Core_ARM, "Cannot execute instruction at unmapped address {:#016x}", pc);
-            ReturnException(pc, ARM_Interface::no_execute);
-            return;
        default:
-            if (debugger_enabled) {
-                ReturnException(pc, ARM_Interface::breakpoint);
+            if (parent.system.DebuggerEnabled()) {
+                parent.jit.load()->SetPC(pc);
+                parent.jit.load()->HaltExecution(ARM_Interface::breakpoint);
                return;
            }

            parent.LogBacktrace();
-            LOG_CRITICAL(Core_ARM, "ExceptionRaised(exception = {}, pc = {:08X}, code = {:08X})",
-                         static_cast<std::size_t>(exception), pc, MemoryRead32(pc));
+            ASSERT_MSG(false, "ExceptionRaised(exception = {}, pc = {:08X}, code = {:08X})",
+                       static_cast<std::size_t>(exception), pc, MemoryReadCode(pc));
        }
    }

@@ -190,32 +160,10 @@ public:
        return parent.system.CoreTiming().GetClockTicks();
    }

-    bool CheckMemoryAccess(VAddr addr, u64 size, Kernel::DebugWatchpointType type) {
-        if (!debugger_enabled) {
-            return true;
-        }
-
-        const auto match{parent.MatchingWatchpoint(addr, size, type)};
-        if (match) {
-            parent.halted_watchpoint = match;
-            ReturnException(parent.jit.load()->GetPC(), ARM_Interface::watchpoint);
-            return false;
-        }
-
-        return true;
-    }
-
-    void ReturnException(u64 pc, Dynarmic::HaltReason hr) {
-        parent.SaveContext(parent.breakpoint_context);
-        parent.breakpoint_context.pc = pc;
-        parent.jit.load()->HaltExecution(hr);
-    }
-
    ARM_Dynarmic_64& parent;
    Core::Memory::Memory& memory;
    u64 tpidrro_el0 = 0;
    u64 tpidr_el0 = 0;
-    bool debugger_enabled{};
    static constexpr u64 minimum_run_cycles = 1000U;
 };

@@ -266,11 +214,6 @@ std::shared_ptr<Dynarmic::A64::Jit> ARM_Dynarmic_64::MakeJit(Common::PageTable*
    config.code_cache_size = 512_MiB;
    config.far_code_offset = 400_MiB;

-    // Allow memory fault handling to work
-    if (system.DebuggerEnabled()) {
-        config.check_halt_on_memory_access = true;
-    }
-
    // null_jit
    if (!page_table) {
        // Don't waste too much memory on null_jit
@@ -365,14 +308,6 @@ u32 ARM_Dynarmic_64::GetSvcNumber() const {
    return svc_swi;
 }

-const Kernel::DebugWatchpoint* ARM_Dynarmic_64::HaltedWatchpoint() const {
-    return halted_watchpoint;
-}
-
-void ARM_Dynarmic_64::RewindBreakpointInstruction() {
-    LoadContext(breakpoint_context);
-}
-
 ARM_Dynarmic_64::ARM_Dynarmic_64(System& system_, CPUInterrupts& interrupt_handlers_,
                                 bool uses_wall_clock_, ExclusiveMonitor& exclusive_monitor_,
                                 std::size_t core_index_)
@@ -494,22 +429,22 @@ void ARM_Dynarmic_64::PageTableChanged(Common::PageTable& page_table,
 }

 std::vector<ARM_Interface::BacktraceEntry> ARM_Dynarmic_64::GetBacktrace(Core::System& system,
-                                                                         u64 fp, u64 lr, u64 pc) {
+                                                                         u64 fp, u64 lr) {
    std::vector<BacktraceEntry> out;
    auto& memory = system.Memory();

-    out.push_back({"", 0, pc, 0, ""});
-
-    // fp (= x29) points to the previous frame record.
+    // fp (= r29) points to the last frame record.
+    // Note that this is the frame record for the *previous* frame, not the current one.
+    // Note we need to subtract 4 from our last read to get the proper address
    // Frame records are two words long:
    // fp+0 : pointer to previous frame record
    // fp+8 : value of lr for frame
    while (true) {
        out.push_back({"", 0, lr, 0, ""});
-        if (!fp || (fp % 4 != 0) || !memory.IsValidVirtualAddressRange(fp, 16)) {
+        if (!fp) {
            break;
        }
-        lr = memory.Read64(fp + 8);
+        lr = memory.Read64(fp + 8) - 4;
        fp = memory.Read64(fp);
    }

@@ -520,12 +455,11 @@ std::vector<ARM_Interface::BacktraceEntry> ARM_Dynarmic_64::GetBacktrace(Core::S

 std::vector<ARM_Interface::BacktraceEntry> ARM_Dynarmic_64::GetBacktraceFromContext(
    System& system, const ThreadContext64& ctx) {
-    const auto& reg = ctx.cpu_registers;
-    return GetBacktrace(system, reg[29], reg[30], ctx.pc);
+    return GetBacktrace(system, ctx.cpu_registers[29], ctx.cpu_registers[30]);
 }

 std::vector<ARM_Interface::BacktraceEntry> ARM_Dynarmic_64::GetBacktrace() const {
-    return GetBacktrace(system, GetReg(29), GetReg(30), GetPC());
+    return GetBacktrace(system, GetReg(29), GetReg(30));
 }

 } // namespace Core
@@ -66,14 +66,12 @@ protected:
    Dynarmic::HaltReason RunJit() override;
    Dynarmic::HaltReason StepJit() override;
    u32 GetSvcNumber() const override;
-    const Kernel::DebugWatchpoint* HaltedWatchpoint() const override;
-    void RewindBreakpointInstruction() override;

 private:
    std::shared_ptr<Dynarmic::A64::Jit> MakeJit(Common::PageTable* page_table,
                                                std::size_t address_space_bits) const;

-    static std::vector<BacktraceEntry> GetBacktrace(Core::System& system, u64 fp, u64 lr, u64 pc);
+    static std::vector<BacktraceEntry> GetBacktrace(Core::System& system, u64 fp, u64 lr);

    using JitCacheKey = std::pair<Common::PageTable*, std::size_t>;
    using JitCacheType =
@@ -93,10 +91,6 @@ private:

    // SVC callback
    u32 svc_swi{};
-
-    // Breakpoint info
-    const Kernel::DebugWatchpoint* halted_watchpoint;
-    ThreadContext64 breakpoint_context;
 };

 } // namespace Core
@@ -138,6 +138,7 @@ struct System::Impl {

        kernel.Suspend(false);
        core_timing.SyncPause(false);
+        cpu_manager.Pause(false);
        is_paused = false;

        return status;
@@ -149,22 +150,25 @@ struct System::Impl {

        core_timing.SyncPause(true);
        kernel.Suspend(true);
+        cpu_manager.Pause(true);
        is_paused = true;

        return status;
    }

-    std::unique_lock<std::mutex> StallProcesses() {
+    std::unique_lock<std::mutex> StallCPU() {
        std::unique_lock<std::mutex> lk(suspend_guard);
        kernel.Suspend(true);
        core_timing.SyncPause(true);
+        cpu_manager.Pause(true);
        return lk;
    }

-    void UnstallProcesses() {
+    void UnstallCPU() {
        if (!is_paused) {
            core_timing.SyncPause(false);
            kernel.Suspend(false);
+            cpu_manager.Pause(false);
        }
    }

@@ -330,8 +334,6 @@ struct System::Impl {
            gpu_core->NotifyShutdown();
        }

-        kernel.ShutdownCores();
-        cpu_manager.Shutdown();
        debugger.reset();
        services.reset();
        service_manager.reset();
@@ -491,18 +493,12 @@ void System::Shutdown() {
    impl->Shutdown();
 }

-void System::DetachDebugger() {
-    if (impl->debugger) {
-        impl->debugger->NotifyShutdown();
-    }
+std::unique_lock<std::mutex> System::StallCPU() {
+    return impl->StallCPU();
 }

-std::unique_lock<std::mutex> System::StallProcesses() {
-    return impl->StallProcesses();
-}
-
-void System::UnstallProcesses() {
-    impl->UnstallProcesses();
+void System::UnstallCPU() {
+    impl->UnstallCPU();
 }

 void System::InitializeDebugger() {
@@ -160,11 +160,8 @@ public:
    /// Shutdown the emulated system.
    void Shutdown();

-    /// Forcibly detach the debugger if it is running.
-    void DetachDebugger();
-
-    std::unique_lock<std::mutex> StallProcesses();
-    void UnstallProcesses();
+    std::unique_lock<std::mutex> StallCPU();
+    void UnstallCPU();

    /**
     * Initialize the debugger.
@@ -6,9 +6,7 @@
 #include <string>
 #include <tuple>

-#include "common/logging/log.h"
 #include "common/microprofile.h"
-#include "common/thread.h"
 #include "core/core_timing.h"
 #include "core/core_timing_util.h"
 #include "core/hardware_properties.h"
@@ -22,11 +20,10 @@ std::shared_ptr<EventType> CreateEvent(std::string name, TimedCallback&& callbac
 }

 struct CoreTiming::Event {
-    s64 time;
+    u64 time;
    u64 fifo_order;
    std::uintptr_t user_data;
    std::weak_ptr<EventType> type;
-    s64 reschedule_time;

    // Sort by time, unless the times are the same, in which case sort by
    // the order added to the queue
@@ -44,11 +41,11 @@ CoreTiming::CoreTiming()

 CoreTiming::~CoreTiming() = default;

-void CoreTiming::ThreadEntry(CoreTiming& instance, size_t id) {
-    const std::string name = "yuzu:HostTiming_" + std::to_string(id);
-    MicroProfileOnThreadCreate(name.c_str());
-    Common::SetCurrentThreadName(name.c_str());
-    Common::SetCurrentThreadPriority(Common::ThreadPriority::Critical);
+void CoreTiming::ThreadEntry(CoreTiming& instance) {
+    constexpr char name[] = "yuzu:HostTiming";
+    MicroProfileOnThreadCreate(name);
+    Common::SetCurrentThreadName(name);
+    Common::SetCurrentThreadPriority(Common::ThreadPriority::VeryHigh);
    instance.on_thread_init();
    instance.ThreadLoop();
    MicroProfileOnThreadExit();
@@ -59,131 +56,71 @@ void CoreTiming::Initialize(std::function<void()>&& on_thread_init_) {
    event_fifo_id = 0;
    shutting_down = false;
    ticks = 0;
-    const auto empty_timed_callback = [](std::uintptr_t, u64, std::chrono::nanoseconds)
-        -> std::optional<std::chrono::nanoseconds> { return std::nullopt; };
+    const auto empty_timed_callback = [](std::uintptr_t, std::chrono::nanoseconds) {};
    ev_lost = CreateEvent("_lost_event", empty_timed_callback);
    if (is_multicore) {
-        worker_threads.emplace_back(ThreadEntry, std::ref(*this), 0);
+        timer_thread = std::make_unique<std::thread>(ThreadEntry, std::ref(*this));
    }
 }

 void CoreTiming::Shutdown() {
-    is_paused = true;
+    paused = true;
    shutting_down = true;
-    std::atomic_thread_fence(std::memory_order_release);
-
-    event_cv.notify_all();
-    wait_pause_cv.notify_all();
-    for (auto& thread : worker_threads) {
-        thread.join();
+    pause_event.Set();
+    event.Set();
+    if (timer_thread) {
+        timer_thread->join();
    }
-    worker_threads.clear();
-    pause_callbacks.clear();
    ClearPendingEvents();
+    timer_thread.reset();
    has_started = false;
 }

-void CoreTiming::Pause(bool is_paused_) {
-    std::unique_lock main_lock(event_mutex);
-    if (is_paused_ == paused_state.load(std::memory_order_relaxed)) {
-        return;
-    }
-    if (is_multicore) {
-        is_paused = is_paused_;
-        event_cv.notify_all();
-        if (!is_paused_) {
-            wait_pause_cv.notify_all();
-        }
-    }
-    paused_state.store(is_paused_, std::memory_order_relaxed);
-
-    if (!is_paused_) {
-        pause_end_time = GetGlobalTimeNs().count();
-    }
-
-    for (auto& cb : pause_callbacks) {
-        cb(is_paused_);
-    }
+void CoreTiming::Pause(bool is_paused) {
+    paused = is_paused;
+    pause_event.Set();
 }

-void CoreTiming::SyncPause(bool is_paused_) {
-    std::unique_lock main_lock(event_mutex);
-    if (is_paused_ == paused_state.load(std::memory_order_relaxed)) {
+void CoreTiming::SyncPause(bool is_paused) {
+    if (is_paused == paused && paused_set == paused) {
        return;
    }
-
-    if (is_multicore) {
-        is_paused = is_paused_;
-        event_cv.notify_all();
-        if (!is_paused_) {
-            wait_pause_cv.notify_all();
+    Pause(is_paused);
+    if (timer_thread) {
+        if (!is_paused) {
+            pause_event.Set();
        }
-    }
-    paused_state.store(is_paused_, std::memory_order_relaxed);
-    if (is_multicore) {
-        if (is_paused_) {
-            wait_signal_cv.wait(main_lock, [this] { return pause_count == worker_threads.size(); });
-        } else {
-            wait_signal_cv.wait(main_lock, [this] { return pause_count == 0; });
-        }
-    }
-
-    if (!is_paused_) {
-        pause_end_time = GetGlobalTimeNs().count();
-    }
-
-    for (auto& cb : pause_callbacks) {
-        cb(is_paused_);
+        event.Set();
+        while (paused_set != is_paused)
+            ;
    }
 }

 bool CoreTiming::IsRunning() const {
-    return !paused_state.load(std::memory_order_acquire);
+    return !paused_set;
 }

 bool CoreTiming::HasPendingEvents() const {
-    std::unique_lock main_lock(event_mutex);
-    return !event_queue.empty() || pending_events.load(std::memory_order_relaxed) != 0;
+    return !(wait_set && event_queue.empty());
 }

 void CoreTiming::ScheduleEvent(std::chrono::nanoseconds ns_into_future,
                               const std::shared_ptr<EventType>& event_type,
-                               std::uintptr_t user_data, bool absolute_time) {
+                               std::uintptr_t user_data) {
+    {
+        std::scoped_lock scope{basic_lock};
+        const u64 timeout = static_cast<u64>((GetGlobalTimeNs() + ns_into_future).count());

-    std::unique_lock main_lock(event_mutex);
-    const auto next_time{absolute_time ? ns_into_future : GetGlobalTimeNs() + ns_into_future};
+        event_queue.emplace_back(Event{timeout, event_fifo_id++, user_data, event_type});

-    event_queue.emplace_back(Event{next_time.count(), event_fifo_id++, user_data, event_type, 0});
-    pending_events.fetch_add(1, std::memory_order_relaxed);
-
-    std::push_heap(event_queue.begin(), event_queue.end(), std::greater<>());
-
-    if (is_multicore) {
-        event_cv.notify_one();
-    }
-}
-
-void CoreTiming::ScheduleLoopingEvent(std::chrono::nanoseconds start_time,
-                                      std::chrono::nanoseconds resched_time,
-                                      const std::shared_ptr<EventType>& event_type,
-                                      std::uintptr_t user_data, bool absolute_time) {
-    std::unique_lock main_lock(event_mutex);
-    const auto next_time{absolute_time ? start_time : GetGlobalTimeNs() + start_time};
-
-    event_queue.emplace_back(
-        Event{next_time.count(), event_fifo_id++, user_data, event_type, resched_time.count()});
-    pending_events.fetch_add(1, std::memory_order_relaxed);
-
-    std::push_heap(event_queue.begin(), event_queue.end(), std::greater<>());
-
-    if (is_multicore) {
-        event_cv.notify_one();
+        std::push_heap(event_queue.begin(), event_queue.end(), std::greater<>());
    }
+    event.Set();
 }

 void CoreTiming::UnscheduleEvent(const std::shared_ptr<EventType>& event_type,
                                 std::uintptr_t user_data) {
-    std::unique_lock main_lock(event_mutex);
+    std::scoped_lock scope{basic_lock};
    const auto itr = std::remove_if(event_queue.begin(), event_queue.end(), [&](const Event& e) {
        return e.type.lock().get() == event_type.get() && e.user_data == user_data;
    });
@@ -192,7 +129,6 @@ void CoreTiming::UnscheduleEvent(const std::shared_ptr<EventType>& event_type,
    if (itr != event_queue.end()) {
        event_queue.erase(itr, event_queue.end());
        std::make_heap(event_queue.begin(), event_queue.end(), std::greater<>());
-        pending_events.fetch_sub(1, std::memory_order_relaxed);
    }
 }

@@ -232,12 +168,11 @@ u64 CoreTiming::GetClockTicks() const {
 }

 void CoreTiming::ClearPendingEvents() {
-    std::unique_lock main_lock(event_mutex);
    event_queue.clear();
 }

 void CoreTiming::RemoveEvent(const std::shared_ptr<EventType>& event_type) {
-    std::unique_lock main_lock(event_mutex);
+    std::scoped_lock lock{basic_lock};

    const auto itr = std::remove_if(event_queue.begin(), event_queue.end(), [&](const Event& e) {
        return e.type.lock().get() == event_type.get();
@@ -250,48 +185,22 @@ void CoreTiming::RemoveEvent(const std::shared_ptr<EventType>& event_type) {
    }
 }

-void CoreTiming::RegisterPauseCallback(PauseCallback&& callback) {
-    std::unique_lock main_lock(event_mutex);
-    pause_callbacks.emplace_back(std::move(callback));
-}
-
 std::optional<s64> CoreTiming::Advance() {
+    std::scoped_lock lock{advance_lock, basic_lock};
    global_timer = GetGlobalTimeNs().count();

-    std::unique_lock main_lock(event_mutex);
    while (!event_queue.empty() && event_queue.front().time <= global_timer) {
        Event evt = std::move(event_queue.front());
        std::pop_heap(event_queue.begin(), event_queue.end(), std::greater<>());
        event_queue.pop_back();
+        basic_lock.unlock();

        if (const auto event_type{evt.type.lock()}) {
-            event_mutex.unlock();
-
-            const auto new_schedule_time{event_type->callback(
-                evt.user_data, evt.time,
-                std::chrono::nanoseconds{GetGlobalTimeNs().count() - evt.time})};
-
-            event_mutex.lock();
-            pending_events.fetch_sub(1, std::memory_order_relaxed);
-
-            if (evt.reschedule_time != 0) {
-                // If this event was scheduled into a pause, its time now is going to be way behind.
-                // Re-set this event to continue from the end of the pause.
-                auto next_time{evt.time + evt.reschedule_time};
-                if (evt.time < pause_end_time) {
-                    next_time = pause_end_time + evt.reschedule_time;
-                }
-
-                const auto next_schedule_time{new_schedule_time.has_value()
-                                                  ? new_schedule_time.value().count()
-                                                  : evt.reschedule_time};
-                event_queue.emplace_back(
-                    Event{next_time, event_fifo_id++, evt.user_data, evt.type, next_schedule_time});
-                pending_events.fetch_add(1, std::memory_order_relaxed);
-                std::push_heap(event_queue.begin(), event_queue.end(), std::greater<>());
-            }
+            event_type->callback(
+                evt.user_data, std::chrono::nanoseconds{static_cast<s64>(global_timer - evt.time)});
        }

+        basic_lock.lock();
        global_timer = GetGlobalTimeNs().count();
    }

@@ -304,34 +213,26 @@ std::optional<s64> CoreTiming::Advance() {
 }

 void CoreTiming::ThreadLoop() {
-    const auto predicate = [this] { return !event_queue.empty() || is_paused; };
    has_started = true;
    while (!shutting_down) {
-        while (!is_paused && !shutting_down) {
+        while (!paused) {
+            paused_set = false;
            const auto next_time = Advance();
            if (next_time) {
                if (*next_time > 0) {
                    std::chrono::nanoseconds next_time_ns = std::chrono::nanoseconds(*next_time);
-                    std::unique_lock main_lock(event_mutex);
-                    event_cv.wait_for(main_lock, next_time_ns, predicate);
+                    event.WaitFor(next_time_ns);
                }
            } else {
-                std::unique_lock main_lock(event_mutex);
-                event_cv.wait(main_lock, predicate);
+                wait_set = true;
+                event.Wait();
            }
+            wait_set = false;
        }
-        std::unique_lock main_lock(event_mutex);
-        pause_count++;
-        if (pause_count == worker_threads.size()) {
-            clock->Pause(true);
-            wait_signal_cv.notify_all();
-        }
-        wait_pause_cv.wait(main_lock, [this] { return !is_paused || shutting_down; });
-        pause_count--;
-        if (pause_count == 0) {
-            clock->Pause(false);
-            wait_signal_cv.notify_all();
-        }
+        paused_set = true;
+        clock->Pause(true);
+        pause_event.Wait();
+        clock->Pause(false);
    }
 }

@@ -5,7 +5,6 @@

 #include <atomic>
 #include <chrono>
-#include <condition_variable>
 #include <functional>
 #include <memory>
 #include <mutex>
@@ -15,14 +14,14 @@
 #include <vector>

 #include "common/common_types.h"
+#include "common/thread.h"
 #include "common/wall_clock.h"

 namespace Core::Timing {

 /// A callback that may be scheduled for a particular core timing event.
-using TimedCallback = std::function<std::optional<std::chrono::nanoseconds>(
-    std::uintptr_t user_data, s64 time, std::chrono::nanoseconds ns_late)>;
-using PauseCallback = std::function<void(bool paused)>;
+using TimedCallback =
+    std::function<void(std::uintptr_t user_data, std::chrono::nanoseconds ns_late)>;

 /// Contains the characteristics of a particular event.
 struct EventType {
@@ -94,15 +93,7 @@ public:

    /// Schedules an event in core timing
    void ScheduleEvent(std::chrono::nanoseconds ns_into_future,
-                       const std::shared_ptr<EventType>& event_type, std::uintptr_t user_data = 0,
-                       bool absolute_time = false);
-
-    /// Schedules an event which will automatically re-schedule itself with the given time, until
-    /// unscheduled
-    void ScheduleLoopingEvent(std::chrono::nanoseconds start_time,
-                              std::chrono::nanoseconds resched_time,
-                              const std::shared_ptr<EventType>& event_type,
-                              std::uintptr_t user_data = 0, bool absolute_time = false);
+                       const std::shared_ptr<EventType>& event_type, std::uintptr_t user_data = 0);

    void UnscheduleEvent(const std::shared_ptr<EventType>& event_type, std::uintptr_t user_data);

@@ -134,21 +125,18 @@ public:
    /// Checks for events manually and returns time in nanoseconds for next event, threadsafe.
    std::optional<s64> Advance();

-    /// Register a callback function to be called when coretiming pauses.
-    void RegisterPauseCallback(PauseCallback&& callback);
-
 private:
    struct Event;

    /// Clear all pending events. This should ONLY be done on exit.
    void ClearPendingEvents();

-    static void ThreadEntry(CoreTiming& instance, size_t id);
+    static void ThreadEntry(CoreTiming& instance);
    void ThreadLoop();

    std::unique_ptr<Common::WallClock> clock;

-    s64 global_timer = 0;
+    u64 global_timer = 0;

    // The queue is a min-heap using std::make_heap/push_heap/pop_heap.
    // We don't use std::priority_queue because we need to be able to serialize, unserialize and
@@ -156,31 +144,25 @@ private:
    // accomodated by the standard adaptor class.
    std::vector<Event> event_queue;
    u64 event_fifo_id = 0;
-    std::atomic<size_t> pending_events{};

    std::shared_ptr<EventType> ev_lost;
+    Common::Event event{};
+    Common::Event pause_event{};
+    std::mutex basic_lock;
+    std::mutex advance_lock;
+    std::unique_ptr<std::thread> timer_thread;
+    std::atomic<bool> paused{};
+    std::atomic<bool> paused_set{};
+    std::atomic<bool> wait_set{};
+    std::atomic<bool> shutting_down{};
    std::atomic<bool> has_started{};
    std::function<void()> on_thread_init{};

-    std::vector<std::thread> worker_threads;
-
-    std::condition_variable event_cv;
-    std::condition_variable wait_pause_cv;
-    std::condition_variable wait_signal_cv;
-    mutable std::mutex event_mutex;
-
-    std::atomic<bool> paused_state{};
-    bool is_paused{};
-    bool shutting_down{};
    bool is_multicore{};
-    size_t pause_count{};
-    s64 pause_end_time{};

    /// Cycle timing
    u64 ticks{};
    s64 downcount{};
-
-    std::vector<PauseCallback> pause_callbacks{};
 };

 /// Creates a core timing event with the given name and callback.
@@ -21,52 +21,75 @@ CpuManager::~CpuManager() = default;

 void CpuManager::ThreadStart(std::stop_token stop_token, CpuManager& cpu_manager,
                             std::size_t core) {
-    cpu_manager.RunThread(core);
+    cpu_manager.RunThread(stop_token, core);
 }

 void CpuManager::Initialize() {
-    num_cores = is_multicore ? Core::Hardware::NUM_CPU_CORES : 1;
-    gpu_barrier = std::make_unique<Common::Barrier>(num_cores + 1);
-
-    for (std::size_t core = 0; core < num_cores; core++) {
-        core_data[core].host_thread = std::jthread(ThreadStart, std::ref(*this), core);
+    running_mode = true;
+    if (is_multicore) {
+        for (std::size_t core = 0; core < Core::Hardware::NUM_CPU_CORES; core++) {
+            core_data[core].host_thread = std::jthread(ThreadStart, std::ref(*this), core);
+        }
+    } else {
+        core_data[0].host_thread = std::jthread(ThreadStart, std::ref(*this), 0);
    }
 }

 void CpuManager::Shutdown() {
-    for (std::size_t core = 0; core < num_cores; core++) {
-        if (core_data[core].host_thread.joinable()) {
-            core_data[core].host_thread.join();
-        }
-    }
+    running_mode = false;
+    Pause(false);
 }

-void CpuManager::GuestThreadFunction() {
-    if (is_multicore) {
-        MultiCoreRunGuestThread();
+std::function<void(void*)> CpuManager::GetGuestThreadStartFunc() {
+    return GuestThreadFunction;
+}
+
+std::function<void(void*)> CpuManager::GetIdleThreadStartFunc() {
+    return IdleThreadFunction;
+}
+
+std::function<void(void*)> CpuManager::GetSuspendThreadStartFunc() {
+    return SuspendThreadFunction;
+}
+
+void CpuManager::GuestThreadFunction(void* cpu_manager_) {
+    CpuManager* cpu_manager = static_cast<CpuManager*>(cpu_manager_);
+    if (cpu_manager->is_multicore) {
+        cpu_manager->MultiCoreRunGuestThread();
    } else {
-        SingleCoreRunGuestThread();
+        cpu_manager->SingleCoreRunGuestThread();
    }
 }

-void CpuManager::GuestRewindFunction() {
-    if (is_multicore) {
-        MultiCoreRunGuestLoop();
+void CpuManager::GuestRewindFunction(void* cpu_manager_) {
+    CpuManager* cpu_manager = static_cast<CpuManager*>(cpu_manager_);
+    if (cpu_manager->is_multicore) {
+        cpu_manager->MultiCoreRunGuestLoop();
    } else {
-        SingleCoreRunGuestLoop();
+        cpu_manager->SingleCoreRunGuestLoop();
    }
 }

-void CpuManager::IdleThreadFunction() {
-    if (is_multicore) {
-        MultiCoreRunIdleThread();
+void CpuManager::IdleThreadFunction(void* cpu_manager_) {
+    CpuManager* cpu_manager = static_cast<CpuManager*>(cpu_manager_);
+    if (cpu_manager->is_multicore) {
+        cpu_manager->MultiCoreRunIdleThread();
    } else {
-        SingleCoreRunIdleThread();
+        cpu_manager->SingleCoreRunIdleThread();
    }
 }

-void CpuManager::ShutdownThreadFunction() {
-    ShutdownThread();
+void CpuManager::SuspendThreadFunction(void* cpu_manager_) {
+    CpuManager* cpu_manager = static_cast<CpuManager*>(cpu_manager_);
+    if (cpu_manager->is_multicore) {
+        cpu_manager->MultiCoreRunSuspendThread();
+    } else {
+        cpu_manager->SingleCoreRunSuspendThread();
+    }
+}
+
+void* CpuManager::GetStartFuncParamater() {
+    return static_cast<void*>(this);
 }

 ///////////////////////////////////////////////////////////////////////////////
@@ -76,9 +99,9 @@ void CpuManager::ShutdownThreadFunction() {
 void CpuManager::MultiCoreRunGuestThread() {
    auto& kernel = system.Kernel();
    kernel.CurrentScheduler()->OnThreadStart();
-    auto* thread = kernel.CurrentScheduler()->GetSchedulerCurrentThread();
+    auto* thread = kernel.CurrentScheduler()->GetCurrentThread();
    auto& host_context = thread->GetHostContext();
-    host_context->SetRewindPoint([this] { GuestRewindFunction(); });
+    host_context->SetRewindPoint(GuestRewindFunction, this);
    MultiCoreRunGuestLoop();
 }

@@ -87,10 +110,12 @@ void CpuManager::MultiCoreRunGuestLoop() {

    while (true) {
        auto* physical_core = &kernel.CurrentPhysicalCore();
+        system.EnterDynarmicProfile();
        while (!physical_core->IsInterrupted()) {
            physical_core->Run();
            physical_core = &kernel.CurrentPhysicalCore();
        }
+        system.ExitDynarmicProfile();
        {
            Kernel::KScopedDisableDispatch dd(kernel);
            physical_core->ArmInterface().ClearExclusiveState();
@@ -106,6 +131,58 @@ void CpuManager::MultiCoreRunIdleThread() {
    }
 }

+void CpuManager::MultiCoreRunSuspendThread() {
+    auto& kernel = system.Kernel();
+    kernel.CurrentScheduler()->OnThreadStart();
+    while (true) {
+        auto core = kernel.CurrentPhysicalCoreIndex();
+        auto& scheduler = *kernel.CurrentScheduler();
+        Kernel::KThread* current_thread = scheduler.GetCurrentThread();
+        Common::Fiber::YieldTo(current_thread->GetHostContext(), *core_data[core].host_context);
+        ASSERT(scheduler.ContextSwitchPending());
+        ASSERT(core == kernel.CurrentPhysicalCoreIndex());
+        scheduler.RescheduleCurrentCore();
+    }
+}
+
+void CpuManager::MultiCorePause(bool paused) {
+    if (!paused) {
+        bool all_not_barrier = false;
+        while (!all_not_barrier) {
+            all_not_barrier = true;
+            for (const auto& data : core_data) {
+                all_not_barrier &= !data.is_running.load() && data.initialized.load();
+            }
+        }
+        for (auto& data : core_data) {
+            data.enter_barrier->Set();
+        }
+        if (paused_state.load()) {
+            bool all_barrier = false;
+            while (!all_barrier) {
+                all_barrier = true;
+                for (const auto& data : core_data) {
+                    all_barrier &= data.is_paused.load() && data.initialized.load();
+                }
+            }
+            for (auto& data : core_data) {
+                data.exit_barrier->Set();
+            }
+        }
+    } else {
+        /// Wait until all cores are paused.
+        bool all_barrier = false;
+        while (!all_barrier) {
+            all_barrier = true;
+            for (const auto& data : core_data) {
+                all_barrier &= data.is_paused.load() && data.initialized.load();
+            }
+        }
+        /// Don't release the barrier
+    }
+    paused_state = paused;
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 ///                             SingleCore                                   ///
 ///////////////////////////////////////////////////////////////////////////////
@@ -113,9 +190,9 @@ void CpuManager::MultiCoreRunIdleThread() {
 void CpuManager::SingleCoreRunGuestThread() {
    auto& kernel = system.Kernel();
    kernel.CurrentScheduler()->OnThreadStart();
-    auto* thread = kernel.CurrentScheduler()->GetSchedulerCurrentThread();
+    auto* thread = kernel.CurrentScheduler()->GetCurrentThread();
    auto& host_context = thread->GetHostContext();
-    host_context->SetRewindPoint([this] { GuestRewindFunction(); });
+    host_context->SetRewindPoint(GuestRewindFunction, this);
    SingleCoreRunGuestLoop();
 }

@@ -123,10 +200,12 @@ void CpuManager::SingleCoreRunGuestLoop() {
    auto& kernel = system.Kernel();
    while (true) {
        auto* physical_core = &kernel.CurrentPhysicalCore();
+        system.EnterDynarmicProfile();
        if (!physical_core->IsInterrupted()) {
            physical_core->Run();
            physical_core = &kernel.CurrentPhysicalCore();
        }
+        system.ExitDynarmicProfile();
        kernel.SetIsPhantomModeForSingleCore(true);
        system.CoreTiming().Advance();
        kernel.SetIsPhantomModeForSingleCore(false);
@@ -149,11 +228,25 @@ void CpuManager::SingleCoreRunIdleThread() {
    }
 }

+void CpuManager::SingleCoreRunSuspendThread() {
+    auto& kernel = system.Kernel();
+    kernel.CurrentScheduler()->OnThreadStart();
+    while (true) {
+        auto core = kernel.GetCurrentHostThreadID();
+        auto& scheduler = *kernel.CurrentScheduler();
+        Kernel::KThread* current_thread = scheduler.GetCurrentThread();
+        Common::Fiber::YieldTo(current_thread->GetHostContext(), *core_data[0].host_context);
+        ASSERT(scheduler.ContextSwitchPending());
+        ASSERT(core == kernel.GetCurrentHostThreadID());
+        scheduler.RescheduleCurrentCore();
+    }
+}
+
 void CpuManager::PreemptSingleCore(bool from_running_enviroment) {
    {
        auto& kernel = system.Kernel();
        auto& scheduler = kernel.Scheduler(current_core);
-        Kernel::KThread* current_thread = scheduler.GetSchedulerCurrentThread();
+        Kernel::KThread* current_thread = scheduler.GetCurrentThread();
        if (idle_count >= 4 || from_running_enviroment) {
            if (!from_running_enviroment) {
                system.CoreTiming().Idle();
@@ -165,7 +258,7 @@ void CpuManager::PreemptSingleCore(bool from_running_enviroment) {
        }
        current_core.store((current_core + 1) % Core::Hardware::NUM_CPU_CORES);
        system.CoreTiming().ResetTicks();
-        scheduler.Unload(scheduler.GetSchedulerCurrentThread());
+        scheduler.Unload(scheduler.GetCurrentThread());

        auto& next_scheduler = kernel.Scheduler(current_core);
        Common::Fiber::YieldTo(current_thread->GetHostContext(), *next_scheduler.ControlContext());
@@ -174,23 +267,47 @@ void CpuManager::PreemptSingleCore(bool from_running_enviroment) {
    // May have changed scheduler
    {
        auto& scheduler = system.Kernel().Scheduler(current_core);
-        scheduler.Reload(scheduler.GetSchedulerCurrentThread());
+        scheduler.Reload(scheduler.GetCurrentThread());
        if (!scheduler.IsIdle()) {
            idle_count = 0;
        }
    }
 }

-void CpuManager::ShutdownThread() {
-    auto& kernel = system.Kernel();
-    auto core = is_multicore ? kernel.CurrentPhysicalCoreIndex() : 0;
-    auto* current_thread = kernel.GetCurrentEmuThread();
-
-    Common::Fiber::YieldTo(current_thread->GetHostContext(), *core_data[core].host_context);
-    UNREACHABLE();
+void CpuManager::SingleCorePause(bool paused) {
+    if (!paused) {
+        bool all_not_barrier = false;
+        while (!all_not_barrier) {
+            all_not_barrier = !core_data[0].is_running.load() && core_data[0].initialized.load();
+        }
+        core_data[0].enter_barrier->Set();
+        if (paused_state.load()) {
+            bool all_barrier = false;
+            while (!all_barrier) {
+                all_barrier = core_data[0].is_paused.load() && core_data[0].initialized.load();
+            }
+            core_data[0].exit_barrier->Set();
+        }
+    } else {
+        /// Wait until all cores are paused.
+        bool all_barrier = false;
+        while (!all_barrier) {
+            all_barrier = core_data[0].is_paused.load() && core_data[0].initialized.load();
+        }
+        /// Don't release the barrier
+    }
+    paused_state = paused;
 }

-void CpuManager::RunThread(std::size_t core) {
+void CpuManager::Pause(bool paused) {
+    if (is_multicore) {
+        MultiCorePause(paused);
+    } else {
+        SingleCorePause(paused);
+    }
+}
+
+void CpuManager::RunThread(std::stop_token stop_token, std::size_t core) {
    /// Initialization
    system.RegisterCoreThread(core);
    std::string name;
@@ -203,24 +320,45 @@ void CpuManager::RunThread(std::size_t core) {
    Common::SetCurrentThreadName(name.c_str());
    Common::SetCurrentThreadPriority(Common::ThreadPriority::High);
    auto& data = core_data[core];
+    data.enter_barrier = std::make_unique<Common::Event>();
+    data.exit_barrier = std::make_unique<Common::Event>();
    data.host_context = Common::Fiber::ThreadToFiber();
+    data.is_running = false;
+    data.initialized = true;
+    const bool sc_sync = !is_async_gpu && !is_multicore;
+    bool sc_sync_first_use = sc_sync;

    // Cleanup
    SCOPE_EXIT({
        data.host_context->Exit();
+        data.enter_barrier.reset();
+        data.exit_barrier.reset();
+        data.initialized = false;
        MicroProfileOnThreadExit();
    });

-    // Running
-    gpu_barrier->Sync();
+    /// Running
+    while (running_mode) {
+        data.is_running = false;
+        data.enter_barrier->Wait();
+        if (sc_sync_first_use) {
+            system.GPU().ObtainContext();
+            sc_sync_first_use = false;
+        }

-    if (!is_async_gpu && !is_multicore) {
-        system.GPU().ObtainContext();
+        // Emulation was stopped
+        if (stop_token.stop_requested()) {
+            return;
+        }
+
+        auto current_thread = system.Kernel().CurrentScheduler()->GetCurrentThread();
+        data.is_running = true;
+        Common::Fiber::YieldTo(data.host_context, *current_thread->GetHostContext());
+        data.is_running = false;
+        data.is_paused = true;
+        data.exit_barrier->Wait();
+        data.is_paused = false;
    }
-
-    auto* current_thread = system.Kernel().CurrentScheduler()->GetIdleThread();
-    Kernel::SetCurrentThread(system.Kernel(), current_thread);
-    Common::Fiber::YieldTo(data.host_context, *current_thread->GetHostContext());
 }

 } // namespace Core
@@ -43,22 +43,15 @@ public:
        is_async_gpu = is_async;
    }

-    void OnGpuReady() {
-        gpu_barrier->Sync();
-    }
-
    void Initialize();
    void Shutdown();

-    std::function<void()> GetGuestThreadStartFunc() {
-        return [this] { GuestThreadFunction(); };
-    }
-    std::function<void()> GetIdleThreadStartFunc() {
-        return [this] { IdleThreadFunction(); };
-    }
-    std::function<void()> GetShutdownThreadStartFunc() {
-        return [this] { ShutdownThreadFunction(); };
-    }
+    void Pause(bool paused);
+
+    static std::function<void(void*)> GetGuestThreadStartFunc();
+    static std::function<void(void*)> GetIdleThreadStartFunc();
+    static std::function<void(void*)> GetSuspendThreadStartFunc();
+    void* GetStartFuncParamater();

    void PreemptSingleCore(bool from_running_enviroment = true);

@@ -67,37 +60,46 @@ public:
    }

 private:
-    void GuestThreadFunction();
-    void GuestRewindFunction();
-    void IdleThreadFunction();
-    void ShutdownThreadFunction();
+    static void GuestThreadFunction(void* cpu_manager);
+    static void GuestRewindFunction(void* cpu_manager);
+    static void IdleThreadFunction(void* cpu_manager);
+    static void SuspendThreadFunction(void* cpu_manager);

    void MultiCoreRunGuestThread();
    void MultiCoreRunGuestLoop();
    void MultiCoreRunIdleThread();
+    void MultiCoreRunSuspendThread();
+    void MultiCorePause(bool paused);

    void SingleCoreRunGuestThread();
    void SingleCoreRunGuestLoop();
    void SingleCoreRunIdleThread();
+    void SingleCoreRunSuspendThread();
+    void SingleCorePause(bool paused);

    static void ThreadStart(std::stop_token stop_token, CpuManager& cpu_manager, std::size_t core);

-    void ShutdownThread();
-    void RunThread(std::size_t core);
+    void RunThread(std::stop_token stop_token, std::size_t core);

    struct CoreData {
        std::shared_ptr<Common::Fiber> host_context;
+        std::unique_ptr<Common::Event> enter_barrier;
+        std::unique_ptr<Common::Event> exit_barrier;
+        std::atomic<bool> is_running;
+        std::atomic<bool> is_paused;
+        std::atomic<bool> initialized;
        std::jthread host_thread;
    };

-    std::unique_ptr<Common::Barrier> gpu_barrier{};
+    std::atomic<bool> running_mode{};
+    std::atomic<bool> paused_state{};
+
    std::array<CoreData, Core::Hardware::NUM_CPU_CORES> core_data{};

    bool is_async_gpu{};
    bool is_multicore{};
    std::atomic<std::size_t> current_core{};
    std::size_t idle_count{};
-    std::size_t num_cores{};
    static constexpr std::size_t max_cycle_runs = 5;

    System& system;
@@ -140,6 +140,7 @@ u64 GetSignatureTypeDataSize(SignatureType type) {
        return 0x3C;
    }
    UNREACHABLE();
+    return 0;
 }

 u64 GetSignatureTypePaddingSize(SignatureType type) {
@@ -154,6 +155,7 @@ u64 GetSignatureTypePaddingSize(SignatureType type) {
        return 0x40;
    }
    UNREACHABLE();
+    return 0;
 }

 SignatureType Ticket::GetSignatureType() const {
@@ -42,18 +42,6 @@ static std::span<const u8> ReceiveInto(Readable& r, Buffer& buffer) {
    return received_data;
 }

-enum class SignalType {
-    Stopped,
-    Watchpoint,
-    ShuttingDown,
-};
-
-struct SignalInfo {
-    SignalType type;
-    Kernel::KThread* thread;
-    const Kernel::DebugWatchpoint* watchpoint;
-};
-
 namespace Core {

 class DebuggerImpl : public DebuggerBackend {
@@ -68,23 +56,17 @@ public:
        ShutdownServer();
    }

-    bool SignalDebugger(SignalInfo signal_info) {
-        {
-            std::scoped_lock lk{connection_lock};
+    bool NotifyThreadStopped(Kernel::KThread* thread) {
+        std::scoped_lock lk{connection_lock};

-            if (stopped) {
-                // Do not notify the debugger about another event.
-                // It should be ignored.
-                return false;
-            }
-
-            // Set up the state.
-            stopped = true;
-            info = signal_info;
+        if (stopped) {
+            // Do not notify the debugger about another event.
+            // It should be ignored.
+            return false;
        }
+        stopped = true;

-        // Write a single byte into the pipe to wake up the debug interface.
-        boost::asio::write(signal_pipe, boost::asio::buffer(&stopped, sizeof(stopped)));
+        boost::asio::write(signal_pipe, boost::asio::buffer(&thread, sizeof(thread)));
        return true;
    }

@@ -114,7 +96,7 @@ private:
        connection_thread = std::jthread([&, port](std::stop_token stop_token) {
            try {
                // Initialize the listening socket and accept a new client.
-                tcp::endpoint endpoint{boost::asio::ip::address_v4::any(), port};
+                tcp::endpoint endpoint{boost::asio::ip::address_v4::loopback(), port};
                tcp::acceptor acceptor{io_context, endpoint};

                acceptor.async_accept(client_socket, [](const auto&) {});
@@ -142,9 +124,12 @@ private:
        Common::SetCurrentThreadName("yuzu:Debugger");

        // Set up the client signals for new data.
-        AsyncReceiveInto(signal_pipe, pipe_data, [&](auto d) { PipeData(d); });
+        AsyncReceiveInto(signal_pipe, active_thread, [&](auto d) { PipeData(d); });
        AsyncReceiveInto(client_socket, client_data, [&](auto d) { ClientData(d); });

+        // Stop the emulated CPU.
+        AllCoreStop();
+
        // Set the active thread.
        UpdateActiveThread();

@@ -157,33 +142,9 @@ private:
    }

    void PipeData(std::span<const u8> data) {
-        switch (info.type) {
-        case SignalType::Stopped:
-        case SignalType::Watchpoint:
-            // Stop emulation.
-            PauseEmulation();
-
-            // Notify the client.
-            active_thread = info.thread;
-            UpdateActiveThread();
-
-            if (info.type == SignalType::Watchpoint) {
-                frontend->Watchpoint(active_thread, *info.watchpoint);
-            } else {
-                frontend->Stopped(active_thread);
-            }
-
-            break;
-        case SignalType::ShuttingDown:
-            frontend->ShuttingDown();
-
-            // Wait for emulation to shut down gracefully now.
-            signal_pipe.close();
-            client_socket.shutdown(boost::asio::socket_base::shutdown_both);
-            LOG_INFO(Debug_GDBStub, "Shut down server");
-
-            break;
-        }
+        AllCoreStop();
+        UpdateActiveThread();
+        frontend->Stopped(active_thread);
    }

    void ClientData(std::span<const u8> data) {
@@ -195,29 +156,32 @@ private:
                    std::scoped_lock lk{connection_lock};
                    stopped = true;
                }
-                PauseEmulation();
+                AllCoreStop();
                UpdateActiveThread();
                frontend->Stopped(active_thread);
                break;
            }
            case DebuggerAction::Continue:
-                MarkResumed([&] { ResumeEmulation(); });
+                active_thread->SetStepState(Kernel::StepState::NotStepping);
+                ResumeInactiveThreads();
+                AllCoreResume();
                break;
            case DebuggerAction::StepThreadUnlocked:
-                MarkResumed([&] {
-                    active_thread->SetStepState(Kernel::StepState::StepPending);
-                    active_thread->Resume(Kernel::SuspendType::Debug);
-                    ResumeEmulation(active_thread);
-                });
+                active_thread->SetStepState(Kernel::StepState::StepPending);
+                ResumeInactiveThreads();
+                AllCoreResume();
                break;
-            case DebuggerAction::StepThreadLocked: {
-                MarkResumed([&] {
-                    active_thread->SetStepState(Kernel::StepState::StepPending);
-                    active_thread->Resume(Kernel::SuspendType::Debug);
-                });
+            case DebuggerAction::StepThreadLocked:
+                active_thread->SetStepState(Kernel::StepState::StepPending);
+                SuspendInactiveThreads();
+                AllCoreResume();
                break;
-            }
            case DebuggerAction::ShutdownEmulation: {
+                // Suspend all threads and release any locks held
+                active_thread->RequestSuspend(Kernel::SuspendType::Debug);
+                SuspendInactiveThreads();
+                AllCoreResume();
+
                // Spawn another thread that will exit after shutdown,
                // to avoid a deadlock
                Core::System* system_ref{&system};
@@ -229,33 +193,33 @@ private:
        }
    }

-    void PauseEmulation() {
-        // Put all threads to sleep on next scheduler round.
-        for (auto* thread : ThreadList()) {
-            thread->RequestSuspend(Kernel::SuspendType::Debug);
-        }
-
-        // Signal an interrupt so that scheduler will fire.
-        system.Kernel().InterruptAllPhysicalCores();
-    }
-
-    void ResumeEmulation(Kernel::KThread* except = nullptr) {
-        // Wake up all threads.
-        for (auto* thread : ThreadList()) {
-            if (thread == except) {
-                continue;
-            }
-
-            thread->SetStepState(Kernel::StepState::NotStepping);
-            thread->Resume(Kernel::SuspendType::Debug);
+    void AllCoreStop() {
+        if (!suspend) {
+            suspend = system.StallCPU();
        }
    }

-    template <typename Callback>
-    void MarkResumed(Callback&& cb) {
-        std::scoped_lock lk{connection_lock};
+    void AllCoreResume() {
        stopped = false;
-        cb();
+        system.UnstallCPU();
+        suspend.reset();
+    }
+
+    void SuspendInactiveThreads() {
+        for (auto* thread : ThreadList()) {
+            if (thread != active_thread) {
+                thread->RequestSuspend(Kernel::SuspendType::Debug);
+            }
+        }
+    }
+
+    void ResumeInactiveThreads() {
+        for (auto* thread : ThreadList()) {
+            if (thread != active_thread) {
+                thread->Resume(Kernel::SuspendType::Debug);
+                thread->SetStepState(Kernel::StepState::NotStepping);
+            }
+        }
    }

    void UpdateActiveThread() {
@@ -263,6 +227,8 @@ private:
        if (std::find(threads.begin(), threads.end(), active_thread) == threads.end()) {
            active_thread = threads[0];
        }
+        active_thread->Resume(Kernel::SuspendType::Debug);
+        active_thread->SetStepState(Kernel::StepState::NotStepping);
    }

    const std::vector<Kernel::KThread*>& ThreadList() {
@@ -278,10 +244,9 @@ private:
    boost::asio::io_context io_context;
    boost::process::async_pipe signal_pipe;
    boost::asio::ip::tcp::socket client_socket;
+    std::optional<std::unique_lock<std::mutex>> suspend;

-    SignalInfo info;
    Kernel::KThread* active_thread;
-    bool pipe_data;
    bool stopped;

    std::array<u8, 4096> client_data;
@@ -298,18 +263,7 @@ Debugger::Debugger(Core::System& system, u16 port) {
 Debugger::~Debugger() = default;

 bool Debugger::NotifyThreadStopped(Kernel::KThread* thread) {
-    return impl && impl->SignalDebugger(SignalInfo{SignalType::Stopped, thread, nullptr});
-}
-
-bool Debugger::NotifyThreadWatchpoint(Kernel::KThread* thread,
-                                      const Kernel::DebugWatchpoint& watch) {
-    return impl && impl->SignalDebugger(SignalInfo{SignalType::Watchpoint, thread, &watch});
-}
-
-void Debugger::NotifyShutdown() {
-    if (impl) {
-        impl->SignalDebugger(SignalInfo{SignalType::ShuttingDown, nullptr, nullptr});
-    }
+    return impl && impl->NotifyThreadStopped(thread);
 }

 } // namespace Core
@@ -9,8 +9,7 @@

 namespace Kernel {
 class KThread;
-struct DebugWatchpoint;
-} // namespace Kernel
+}

 namespace Core {
 class System;
@@ -36,16 +35,6 @@ public:
     */
    bool NotifyThreadStopped(Kernel::KThread* thread);

-    /**
-     * Notify the debugger that a shutdown is being performed now and disconnect.
-     */
-    void NotifyShutdown();
-
-    /*
-     * Notify the debugger that the given thread has stopped due to hitting a watchpoint.
-     */
-    bool NotifyThreadWatchpoint(Kernel::KThread* thread, const Kernel::DebugWatchpoint& watch);
-
 private:
    std::unique_ptr<DebuggerImpl> impl;
 };
@@ -11,8 +11,7 @@

 namespace Kernel {
 class KThread;
-struct DebugWatchpoint;
-} // namespace Kernel
+}

 namespace Core {

@@ -67,16 +66,6 @@ public:
     */
    virtual void Stopped(Kernel::KThread* thread) = 0;

-    /**
-     * Called when emulation is shutting down.
-     */
-    virtual void ShuttingDown() = 0;
-
-    /*
-     * Called when emulation has stopped on a watchpoint.
-     */
-    virtual void Watchpoint(Kernel::KThread* thread, const Kernel::DebugWatchpoint& watch) = 0;
-
    /**
     * Called when new data is asynchronously received on the client socket.
     * A list of actions to perform is returned.
@@ -106,29 +106,10 @@ GDBStub::~GDBStub() = default;

 void GDBStub::Connected() {}

-void GDBStub::ShuttingDown() {}
-
 void GDBStub::Stopped(Kernel::KThread* thread) {
    SendReply(arch->ThreadStatus(thread, GDB_STUB_SIGTRAP));
 }

-void GDBStub::Watchpoint(Kernel::KThread* thread, const Kernel::DebugWatchpoint& watch) {
-    const auto status{arch->ThreadStatus(thread, GDB_STUB_SIGTRAP)};
-
-    switch (watch.type) {
-    case Kernel::DebugWatchpointType::Read:
-        SendReply(fmt::format("{}rwatch:{:x};", status, watch.start_address));
-        break;
-    case Kernel::DebugWatchpointType::Write:
-        SendReply(fmt::format("{}watch:{:x};", status, watch.start_address));
-        break;
-    case Kernel::DebugWatchpointType::ReadOrWrite:
-    default:
-        SendReply(fmt::format("{}awatch:{:x};", status, watch.start_address));
-        break;
-    }
-}
-
 std::vector<DebuggerAction> GDBStub::ClientData(std::span<const u8> data) {
    std::vector<DebuggerAction> actions;
    current_command.insert(current_command.end(), data.begin(), data.end());
@@ -252,7 +233,6 @@ void GDBStub::ExecuteCommand(std::string_view packet, std::vector<DebuggerAction
        const auto sep{std::find(command.begin(), command.end(), '=') - command.begin() + 1};
        const size_t reg{static_cast<size_t>(strtoll(command.data(), nullptr, 16))};
        arch->RegWrite(backend.GetActiveThread(), reg, std::string_view(command).substr(sep));
-        SendReply(GDB_STUB_REPLY_OK);
        break;
    }
    case 'm': {
@@ -296,121 +276,41 @@ void GDBStub::ExecuteCommand(std::string_view packet, std::vector<DebuggerAction
    case 'c':
        actions.push_back(DebuggerAction::Continue);
        break;
-    case 'Z':
-        HandleBreakpointInsert(command);
-        break;
-    case 'z':
-        HandleBreakpointRemove(command);
-        break;
-    default:
-        SendReply(GDB_STUB_REPLY_EMPTY);
-        break;
-    }
-}
+    case 'Z': {
+        const auto addr_sep{std::find(command.begin(), command.end(), ',') - command.begin() + 1};
+        const size_t addr{static_cast<size_t>(strtoll(command.data() + addr_sep, nullptr, 16))};

-enum class BreakpointType {
-    Software = 0,
-    Hardware = 1,
-    WriteWatch = 2,
-    ReadWatch = 3,
-    AccessWatch = 4,
-};
-
-void GDBStub::HandleBreakpointInsert(std::string_view command) {
-    const auto type{static_cast<BreakpointType>(strtoll(command.data(), nullptr, 16))};
-    const auto addr_sep{std::find(command.begin(), command.end(), ',') - command.begin() + 1};
-    const auto size_sep{std::find(command.begin() + addr_sep, command.end(), ',') -
-                        command.begin() + 1};
-    const size_t addr{static_cast<size_t>(strtoll(command.data() + addr_sep, nullptr, 16))};
-    const size_t size{static_cast<size_t>(strtoll(command.data() + size_sep, nullptr, 16))};
-
-    if (!system.Memory().IsValidVirtualAddressRange(addr, size)) {
-        SendReply(GDB_STUB_REPLY_ERR);
-        return;
-    }
-
-    bool success{};
-
-    switch (type) {
-    case BreakpointType::Software:
-        replaced_instructions[addr] = system.Memory().Read32(addr);
-        system.Memory().Write32(addr, arch->BreakpointInstruction());
-        system.InvalidateCpuInstructionCacheRange(addr, sizeof(u32));
-        success = true;
-        break;
-    case BreakpointType::WriteWatch:
-        success = system.CurrentProcess()->InsertWatchpoint(system, addr, size,
-                                                            Kernel::DebugWatchpointType::Write);
-        break;
-    case BreakpointType::ReadWatch:
-        success = system.CurrentProcess()->InsertWatchpoint(system, addr, size,
-                                                            Kernel::DebugWatchpointType::Read);
-        break;
-    case BreakpointType::AccessWatch:
-        success = system.CurrentProcess()->InsertWatchpoint(
-            system, addr, size, Kernel::DebugWatchpointType::ReadOrWrite);
-        break;
-    case BreakpointType::Hardware:
-    default:
-        SendReply(GDB_STUB_REPLY_EMPTY);
-        return;
-    }
-
-    if (success) {
-        SendReply(GDB_STUB_REPLY_OK);
-    } else {
-        SendReply(GDB_STUB_REPLY_ERR);
-    }
-}
-
-void GDBStub::HandleBreakpointRemove(std::string_view command) {
-    const auto type{static_cast<BreakpointType>(strtoll(command.data(), nullptr, 16))};
-    const auto addr_sep{std::find(command.begin(), command.end(), ',') - command.begin() + 1};
-    const auto size_sep{std::find(command.begin() + addr_sep, command.end(), ',') -
-                        command.begin() + 1};
-    const size_t addr{static_cast<size_t>(strtoll(command.data() + addr_sep, nullptr, 16))};
-    const size_t size{static_cast<size_t>(strtoll(command.data() + size_sep, nullptr, 16))};
-
-    if (!system.Memory().IsValidVirtualAddressRange(addr, size)) {
-        SendReply(GDB_STUB_REPLY_ERR);
-        return;
-    }
-
-    bool success{};
-
-    switch (type) {
-    case BreakpointType::Software: {
-        const auto orig_insn{replaced_instructions.find(addr)};
-        if (orig_insn != replaced_instructions.end()) {
-            system.Memory().Write32(addr, orig_insn->second);
+        if (system.Memory().IsValidVirtualAddress(addr)) {
+            replaced_instructions[addr] = system.Memory().Read32(addr);
+            system.Memory().Write32(addr, arch->BreakpointInstruction());
            system.InvalidateCpuInstructionCacheRange(addr, sizeof(u32));
-            replaced_instructions.erase(addr);
-            success = true;
+
+            SendReply(GDB_STUB_REPLY_OK);
+        } else {
+            SendReply(GDB_STUB_REPLY_ERR);
        }
        break;
    }
-    case BreakpointType::WriteWatch:
-        success = system.CurrentProcess()->RemoveWatchpoint(system, addr, size,
-                                                            Kernel::DebugWatchpointType::Write);
+    case 'z': {
+        const auto addr_sep{std::find(command.begin(), command.end(), ',') - command.begin() + 1};
+        const size_t addr{static_cast<size_t>(strtoll(command.data() + addr_sep, nullptr, 16))};
+
+        const auto orig_insn{replaced_instructions.find(addr)};
+        if (system.Memory().IsValidVirtualAddress(addr) &&
+            orig_insn != replaced_instructions.end()) {
+            system.Memory().Write32(addr, orig_insn->second);
+            system.InvalidateCpuInstructionCacheRange(addr, sizeof(u32));
+            replaced_instructions.erase(addr);
+
+            SendReply(GDB_STUB_REPLY_OK);
+        } else {
+            SendReply(GDB_STUB_REPLY_ERR);
+        }
        break;
-    case BreakpointType::ReadWatch:
-        success = system.CurrentProcess()->RemoveWatchpoint(system, addr, size,
-                                                            Kernel::DebugWatchpointType::Read);
-        break;
-    case BreakpointType::AccessWatch:
-        success = system.CurrentProcess()->RemoveWatchpoint(
-            system, addr, size, Kernel::DebugWatchpointType::ReadOrWrite);
-        break;
-    case BreakpointType::Hardware:
+    }
    default:
        SendReply(GDB_STUB_REPLY_EMPTY);
-        return;
-    }
-
-    if (success) {
-        SendReply(GDB_STUB_REPLY_OK);
-    } else {
-        SendReply(GDB_STUB_REPLY_ERR);
+        break;
    }
 }

@@ -23,8 +23,6 @@ public:

    void Connected() override;
    void Stopped(Kernel::KThread* thread) override;
-    void ShuttingDown() override;
-    void Watchpoint(Kernel::KThread* thread, const Kernel::DebugWatchpoint& watch) override;
    std::vector<DebuggerAction> ClientData(std::span<const u8> data) override;

 private:
@@ -32,8 +30,6 @@ private:
    void ExecuteCommand(std::string_view packet, std::vector<DebuggerAction>& actions);
    void HandleVCont(std::string_view command, std::vector<DebuggerAction>& actions);
    void HandleQuery(std::string_view command);
-    void HandleBreakpointInsert(std::string_view command);
-    void HandleBreakpointRemove(std::string_view command);
    std::vector<char>::const_iterator CommandEnd() const;
    std::optional<std::string> DetachCommand();
    Kernel::KThread* GetThreadByID(u64 thread_id);
@@ -191,10 +191,8 @@ std::string GDBStubA64::RegRead(const Kernel::KThread* thread, size_t id) const
    const auto& gprs{context.cpu_registers};
    const auto& fprs{context.vector_registers};

-    if (id < SP_REGISTER) {
+    if (id <= SP_REGISTER) {
        return ValueToHex(gprs[id]);
-    } else if (id == SP_REGISTER) {
-        return ValueToHex(context.sp);
    } else if (id == PC_REGISTER) {
        return ValueToHex(context.pc);
    } else if (id == PSTATE_REGISTER) {
@@ -217,10 +215,8 @@ void GDBStubA64::RegWrite(Kernel::KThread* thread, size_t id, std::string_view v

    auto& context{thread->GetContext64()};

-    if (id < SP_REGISTER) {
+    if (id <= SP_REGISTER) {
        context.cpu_registers[id] = HexToValue<u64>(value);
-    } else if (id == SP_REGISTER) {
-        context.sp = HexToValue<u64>(value);
    } else if (id == PC_REGISTER) {
        context.pc = HexToValue<u64>(value);
    } else if (id == PSTATE_REGISTER) {
@@ -15,7 +15,6 @@ namespace Core {

 class GDBStubArch {
 public:
-    virtual ~GDBStubArch() = default;
    virtual std::string GetTargetXML() const = 0;
    virtual std::string RegRead(const Kernel::KThread* thread, size_t id) const = 0;
    virtual void RegWrite(Kernel::KThread* thread, size_t id, std::string_view value) const = 0;
@@ -419,7 +419,7 @@ std::optional<Core::Crypto::Key128> NCA::GetKeyAreaKey(NCASectionCryptoType type
        Core::Crypto::Mode::ECB);
    cipher.Transcode(key_area.data(), key_area.size(), key_area.data(), Core::Crypto::Op::Decrypt);

-    Core::Crypto::Key128 out{};
+    Core::Crypto::Key128 out;
    if (type == NCASectionCryptoType::XTS) {
        std::copy(key_area.begin(), key_area.begin() + 0x10, out.begin());
    } else if (type == NCASectionCryptoType::CTR || type == NCASectionCryptoType::BKTR) {
@@ -8,14 +8,14 @@

 namespace FileSys {

-constexpr Result ERROR_PATH_NOT_FOUND{ErrorModule::FS, 1};
-constexpr Result ERROR_PATH_ALREADY_EXISTS{ErrorModule::FS, 2};
-constexpr Result ERROR_ENTITY_NOT_FOUND{ErrorModule::FS, 1002};
-constexpr Result ERROR_SD_CARD_NOT_FOUND{ErrorModule::FS, 2001};
-constexpr Result ERROR_OUT_OF_BOUNDS{ErrorModule::FS, 3005};
-constexpr Result ERROR_FAILED_MOUNT_ARCHIVE{ErrorModule::FS, 3223};
-constexpr Result ERROR_INVALID_ARGUMENT{ErrorModule::FS, 6001};
-constexpr Result ERROR_INVALID_OFFSET{ErrorModule::FS, 6061};
-constexpr Result ERROR_INVALID_SIZE{ErrorModule::FS, 6062};
+constexpr ResultCode ERROR_PATH_NOT_FOUND{ErrorModule::FS, 1};
+constexpr ResultCode ERROR_PATH_ALREADY_EXISTS{ErrorModule::FS, 2};
+constexpr ResultCode ERROR_ENTITY_NOT_FOUND{ErrorModule::FS, 1002};
+constexpr ResultCode ERROR_SD_CARD_NOT_FOUND{ErrorModule::FS, 2001};
+constexpr ResultCode ERROR_OUT_OF_BOUNDS{ErrorModule::FS, 3005};
+constexpr ResultCode ERROR_FAILED_MOUNT_ARCHIVE{ErrorModule::FS, 3223};
+constexpr ResultCode ERROR_INVALID_ARGUMENT{ErrorModule::FS, 6001};
+constexpr ResultCode ERROR_INVALID_OFFSET{ErrorModule::FS, 6061};
+constexpr ResultCode ERROR_INVALID_SIZE{ErrorModule::FS, 6062};

 } // namespace FileSys
@@ -50,7 +50,7 @@ std::pair<std::size_t, std::size_t> SearchBucketEntry(u64 offset, const BlockTyp
            low = mid + 1;
        }
    }
-    ASSERT_MSG(false, "Offset could not be found in BKTR block.");
+    UNREACHABLE_MSG("Offset could not be found in BKTR block.");
    return {0, 0};
 }
 } // Anonymous namespace
@@ -108,7 +108,7 @@ ContentRecordType GetCRTypeFromNCAType(NCAContentType type) {
        // TODO(DarkLordZach): Peek at NCA contents to differentiate Manual and Legal.
        return ContentRecordType::HtmlDocument;
    default:
-        ASSERT_MSG(false, "Invalid NCAContentType={:02X}", type);
+        UNREACHABLE_MSG("Invalid NCAContentType={:02X}", type);
        return ContentRecordType{};
    }
 }
@@ -144,7 +144,7 @@ VirtualFile RealVfsFilesystem::MoveFile(std::string_view old_path_, std::string_
            LOG_ERROR(Service_FS, "Failed to open path {} in order to re-cache it", new_path);
        }
    } else {
-        ASSERT(false);
+        UNREACHABLE();
        return nullptr;
    }

--- a/Show More
+++ b/Show More