common/setting: Make ranged a property of the type

- Avoids new GCC 12 warnings when Type is of form std::optional<T>
- Makes more sense this way, because ranged is not a property which would change over time

.ci/scripts/clang/docker.sh

@@ -3,14 +3,12 @@
 # Exit on error, rather than continuing with the rest of the script.
 set -e
 
-cd /yuzu
-
 ccache -s
 
 mkdir build || true && cd build
-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"
+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"
 
-make -j$(nproc)
+ninja
 
 ccache -s
 

.ci/scripts/clang/exec.sh

@@ -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 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" -w /yuzu yuzuemu/build-environments:linux-fresh /bin/bash /yuzu/.ci/scripts/clang/docker.sh "$1"
 sudo chown -R $UID ./

.ci/scripts/common/post-upload.sh

@@ -4,8 +4,10 @@
 cp license.txt "$DIR_NAME"
 cp README.md "$DIR_NAME"
 
-tar -cJvf "${REV_NAME}-source.tar.xz" src externals CMakeLists.txt README.md license.txt
-cp "${REV_NAME}-source.tar.xz" "$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 $COMPRESSION_FLAGS "$ARCHIVE_NAME" "$DIR_NAME"
 

.ci/scripts/format/exec.sh

@@ -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 yuzuemu/build-environments:linux-clang-format /bin/bash -ex /yuzu/.ci/scripts/format/docker.sh
+docker run -v "$(pwd):/yuzu" -w /yuzu yuzuemu/build-environments:linux-clang-format /bin/bash -ex /yuzu/.ci/scripts/format/docker.sh
 sudo chown -R $UID ./

.ci/scripts/linux/docker.sh

@@ -3,8 +3,6 @@
 # Exit on error, rather than continuing with the rest of the script.
 set -e
 
-cd /yuzu
-
 ccache -s
 
 mkdir build || true && cd build
@@ -19,15 +17,16 @@ cmake .. \
       -DENABLE_QT_TRANSLATION=ON \
       -DUSE_DISCORD_PRESENCE=ON \
       -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${ENABLE_COMPATIBILITY_REPORTING:-"OFF"} \
-      -DYUZU_USE_BUNDLED_FFMPEG=ON
+      -DYUZU_USE_BUNDLED_FFMPEG=ON \
+      -GNinja
 
-make -j$(nproc)
+ninja
 
 ccache -s
 
 ctest -VV -C Release
 
-make install DESTDIR=AppDir
+DESTDIR="$PWD/AppDir" ninja install
 rm -vf AppDir/usr/bin/yuzu-cmd AppDir/usr/bin/yuzu-tester
 
 # Download tools needed to build an AppImage

.ci/scripts/linux/exec.sh

@@ -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 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" -w /yuzu yuzuemu/build-environments:linux-fresh /bin/bash /yuzu/.ci/scripts/linux/docker.sh "$1"
 sudo chown -R $UID ./

.ci/scripts/linux/upload.sh

@@ -24,6 +24,11 @@ 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}"

.ci/scripts/windows/docker.sh

@@ -1,14 +1,33 @@
 #!/bin/bash -ex
 
-cd /yuzu
+set -e
 
-ccache -s
+#cd /yuzu
 
-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
+ccache -sv
 
-ccache -s
+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
 
 echo "Tests skipped"
 #ctest -VV -C Release
@@ -46,7 +65,7 @@ python3 .ci/scripts/windows/scan_dll.py package/*.exe package/imageformats/*.dll
 # copy FFmpeg libraries
 EXTERNALS_PATH="$(pwd)/build/externals"
 FFMPEG_DLL_PATH="$(find "${EXTERNALS_PATH}" -maxdepth 1 -type d | grep 'ffmpeg-')/bin"
-find ${FFMPEG_DLL_PATH} -type f -regex ".*\.dll" -exec cp -v {} package/ ';'
+find ${FFMPEG_DLL_PATH} -type f -regex ".*\.dll" -exec cp -nv {} package/ ';'
 
 # copy libraries from yuzu.exe path
 find "$(pwd)/build/bin/" -type f -regex ".*\.dll" -exec cp -v {} package/ ';'

.ci/scripts/windows/exec.sh

@@ -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 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" -w /yuzu yuzuemu/build-environments:linux-mingw /bin/bash -ex /yuzu/.ci/scripts/windows/docker.sh "$1"
 sudo chown -R $UID ./

.github/workflows/ci.yml

@@ -13,7 +13,7 @@ jobs:
     container: yuzuemu/build-environments:linux-transifex
     if: ${{ github.repository == 'yuzu-emu/yuzu' && !github.head_ref }}
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
         with:
           submodules: recursive
           fetch-depth: 0   

.github/workflows/verify.yml

@@ -0,0 +1,115 @@
+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@v3
+        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@v3
+        with:
+          submodules: recursive
+          fetch-depth: 0
+      - name: Set up cache
+        uses: actions/cache@v3
+        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@v3
+        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@v3
+        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/

CMakeLists.txt

@@ -627,6 +627,14 @@ 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)

CMakeModules/CopyYuzuFFmpegDeps.cmake

@@ -2,5 +2,6 @@ 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)

CMakeModules/MSVCCache.cmake

@@ -0,0 +1,12 @@
+# 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)

CMakeModules/MinGWClangCross.cmake

@@ -0,0 +1,55 @@
+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()

externals/microprofile/microprofile.h

@@ -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();

externals/microprofile/microprofileui.h

@@ -213,8 +213,8 @@ struct MicroProfileCustom
 
 struct SOptionDesc
 {
-    SOptionDesc(){}
-    SOptionDesc(uint8_t nSubType, uint8_t nIndex, const char* fmt, ...):nSubType(nSubType), nIndex(nIndex)
+    SOptionDesc()=default;
+    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 i = 0; i < MICROPROFILE_META_MAX; ++i)
+                        for(int k = 0; k < MICROPROFILE_META_MAX; ++k)
                         {
-                            nMetaSumInclusive[i] += nMetaSum[i];
-                            nMetaSum[i] = 0;
+                            nMetaSumInclusive[k] += nMetaSum[k];
+                            nMetaSum[k] = 0;
                         }
                     }
                     break;
@@ -708,10 +708,10 @@ inline void MicroProfileDrawFloatTooltip(uint32_t nX, uint32_t nY, uint32_t nTok
 
     if(UI.nMouseLeftMod)
     {
-        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;
+        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;
 
     }
 }
@@ -917,9 +917,8 @@ 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(((fStart-fMsBase) * fMsToScreen), nBaseY, (fNext-fMsBase) * fMsToScreen+1, nBaseY + nHeight, UI.nOpacityBackground | g_nMicroProfileBackColors[nColorIndex++ & 1]);
+            MicroProfileDrawBox(((f-fMsBase) * fMsToScreen), nBaseY, (fNext-fMsBase) * fMsToScreen+1, nBaseY + nHeight, UI.nOpacityBackground | g_nMicroProfileBackColors[nColorIndex++ & 1]);
             f = fNext;
         }
     }
@@ -1116,9 +1115,9 @@ inline void MicroProfileDrawDetailedBars(uint32_t nWidth, uint32_t nHeight, int
 
                         nMaxStackDepth = MicroProfileMax(nMaxStackDepth, nStackPos);
                         float fMsStart = fToMs * MicroProfileLogTickDifference(nBaseTicks, nTickStart);
-                        float fMsEnd = fToMs * MicroProfileLogTickDifference(nBaseTicks, nTickEnd);
+                        float fMsEnd2 = fToMs * MicroProfileLogTickDifference(nBaseTicks, nTickEnd);
                         float fXStart = fMsStart * fMsToScreen;
-                        float fXEnd = fMsEnd * fMsToScreen;
+                        float fXEnd = fMsEnd2 * fMsToScreen;
                         float fYStart = (float)(nY + nStackPos * nYDelta);
                         float fYEnd = fYStart + (MICROPROFILE_DETAILED_BAR_HEIGHT);
                         float fXDist = MicroProfileMax(fXStart - fMouseX, fMouseX - fXEnd);
@@ -1269,22 +1268,22 @@ inline void MicroProfileDrawDetailedBars(uint32_t nWidth, uint32_t nHeight, int
         if(UI.nRangeBegin != UI.nRangeEnd)
         {
             float fMsStart = fToMsCpu * MicroProfileLogTickDifference(nBaseTicksCpu, UI.nRangeBegin);
-            float fMsEnd = fToMsCpu * MicroProfileLogTickDifference(nBaseTicksCpu, UI.nRangeEnd);
+            float fMsEnd3 = fToMsCpu * MicroProfileLogTickDifference(nBaseTicksCpu, UI.nRangeEnd);
             float fXStart = fMsStart * fMsToScreen;
-            float fXEnd = fMsEnd * fMsToScreen;
+            float fXEnd = fMsEnd3 * 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;
-            fMsEnd += fDetailedOffset;
+            fMsEnd3 += 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", fMsEnd);
+            uint32_t nLenEnd = snprintf(sBuffer, sizeof(sBuffer)-1, "%.2fms", fMsEnd3);
             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);
 
@@ -1297,9 +1296,9 @@ inline void MicroProfileDrawDetailedBars(uint32_t nWidth, uint32_t nHeight, int
         if(UI.nRangeBeginGpu != UI.nRangeEndGpu)
         {
             float fMsStart = fToMsGpu * MicroProfileLogTickDifference(nBaseTicksGpu, UI.nRangeBeginGpu);
-            float fMsEnd = fToMsGpu * MicroProfileLogTickDifference(nBaseTicksGpu, UI.nRangeEndGpu);
+            float fMsEnd4 = fToMsGpu * MicroProfileLogTickDifference(nBaseTicksGpu, UI.nRangeEndGpu);
             float fXStart = fMsStart * fMsToScreen;
-            float fXEnd = fMsEnd * fMsToScreen;
+            float fXEnd = fMsEnd4 * 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);
@@ -1307,14 +1306,14 @@ inline void MicroProfileDrawDetailedBars(uint32_t nWidth, uint32_t nHeight, int
             nBaseY += MICROPROFILE_TEXT_HEIGHT+1;
 
             fMsStart += fDetailedOffset;
-            fMsEnd += fDetailedOffset;
+            fMsEnd4 += 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", fMsEnd);
+            uint32_t nLenEnd = snprintf(sBuffer, sizeof(sBuffer)-1, "%.2fms", fMsEnd4);
             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);
         }
@@ -1716,8 +1715,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 nX = UI.nMouseX;
-        uint32_t nY = UI.nMouseY + 20;
+        uint32_t nMouseX = UI.nMouseX;
+        uint32_t nMouseY = UI.nMouseY + 20;
 
         for(uint32_t i = 0; i < MICROPROFILE_MAX_GRAPHS; ++i)
         {
@@ -1736,7 +1735,7 @@ bool MicroProfileDrawGraph(uint32_t nScreenWidth, uint32_t nScreenHeight)
         }
         if(nTextCount)
         {
-            MicroProfileDrawFloatWindow(nX, nY, Strings.ppStrings, Strings.nNumStrings, 0, pColors);
+            MicroProfileDrawFloatWindow(nMouseX, nMouseY, Strings.ppStrings, Strings.nNumStrings, 0, pColors);
         }
 
         if(UI.nMouseRight)
@@ -2321,8 +2320,8 @@ inline void MicroProfileDrawMenu(uint32_t nWidth, uint32_t nHeight)
     uint32_t    nMenuX[MICROPROFILE_MENU_MAX] = {0};
     uint32_t nNumMenuItems = 0;
 
-    int nLen = snprintf(buffer, 127, "MicroProfile");
-    MicroProfileDrawText(nX, nY, UINT32_MAX, buffer, nLen);
+    int nMPTextLen = snprintf(buffer, 127, "MicroProfile");
+    MicroProfileDrawText(nX, nY, UINT32_MAX, buffer, nMPTextLen);
     nX += (sizeof("MicroProfile")+2) * (MICROPROFILE_TEXT_WIDTH+1);
     pMenuText[nNumMenuItems++] = "Mode";
     pMenuText[nNumMenuItems++] = "Groups";
@@ -2438,16 +2437,16 @@ inline void MicroProfileDrawMenu(uint32_t nWidth, uint32_t nHeight)
         int nNumLines = 0;
         bool bSelected = false;
         const char* pString = CB(nNumLines, &bSelected);
-        uint32_t nWidth = 0, nHeight = 0;
+        uint32_t nTextWidth = 0, nTextHeight = 0;
         while(pString)
         {
-            nWidth = MicroProfileMax<int>(nWidth, (int)strlen(pString));
+            nTextWidth = MicroProfileMax<int>(nTextWidth, (int)strlen(pString));
             nNumLines++;
             pString = CB(nNumLines, &bSelected);
         }
-        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)
+        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)
         {
             UI.nActiveMenu = nMenu;
         }
@@ -2455,21 +2454,21 @@ inline void MicroProfileDrawMenu(uint32_t nWidth, uint32_t nHeight)
         {
             UI.nActiveMenu = UINT32_MAX;
         }
-        MicroProfileDrawBox(nX, nY, nX + nWidth, nY + nHeight, 0xff000000|g_nMicroProfileBackColors[1]);
+        MicroProfileDrawBox(nX, nY, nX + nTextWidth, nY + nTextHeight, 0xff000000|g_nMicroProfileBackColors[1]);
         for(int i = 0; i < nNumLines; ++i)
         {
-            bool bSelected = false;
-            const char* pString = CB(i, &bSelected);
+            bool bSelected2 = false;
+            const char* pString2 = CB(i, &bSelected2);
             if(UI.nMouseY >= nY && UI.nMouseY < nY + MICROPROFILE_TEXT_HEIGHT + 1)
             {
                 if(UI.nMouseLeft || UI.nMouseRight)
                 {
                     CBClick[nMenu](i);
                 }
-                MicroProfileDrawBox(nX, nY, nX + nWidth, nY + MICROPROFILE_TEXT_HEIGHT + 1, 0xff888888);
+                MicroProfileDrawBox(nX, nY, nX + nTextWidth, nY + MICROPROFILE_TEXT_HEIGHT + 1, 0xff888888);
             }
-            int nLen = snprintf(buffer, SBUF_SIZE-1, "%c %s", bSelected ? '*' : ' ' ,pString);
-            MicroProfileDrawText(nX, nY, UINT32_MAX, buffer, nLen);
+            int nTextLen = snprintf(buffer, SBUF_SIZE-1, "%c %s", bSelected2 ? '*' : ' ' ,pString2);
+            MicroProfileDrawText(nX, nY, UINT32_MAX, buffer, nTextLen);
             nY += MICROPROFILE_TEXT_HEIGHT+1;
         }
     }
@@ -2605,7 +2604,7 @@ inline void MicroProfileDrawCustom(uint32_t nWidth, uint32_t nHeight)
             for(uint32_t i = 0; i < nCount; ++i)
             {
                 nOffsetY += (1+MICROPROFILE_TEXT_HEIGHT);
-                uint32_t nWidth = MicroProfileMin(nMaxWidth, (uint32_t)(nMaxWidth * pMs[i] * fRcpReference));
+                nWidth = MicroProfileMin(nMaxWidth, (uint32_t)(nMaxWidth * pMs[i] * fRcpReference));
                 MicroProfileDrawBox(nMaxOffsetX, nOffsetY, nMaxOffsetX+nWidth, nOffsetY+MICROPROFILE_TEXT_HEIGHT, pColors[i]|0xff000000);
             }
         }

src/CMakeLists.txt

@@ -36,7 +36,6 @@ if (MSVC)
     # /GT                 - Supports fiber safety for data allocated using static thread-local storage
     add_compile_options(
         /MP
-        /Zi
         /Zm200
         /Zo
         /permissive-
@@ -65,6 +64,10 @@ 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'?
@@ -75,6 +78,13 @@ 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()
@@ -92,6 +102,7 @@ else()
         -Werror=missing-declarations
         -Werror=missing-field-initializers
         -Werror=reorder
+        -Werror=shadow
         -Werror=sign-compare
         -Werror=switch
         -Werror=uninitialized

src/audio_core/CMakeLists.txt

@@ -49,9 +49,6 @@ 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>

src/audio_core/audio_renderer.cpp

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include <limits>
+#include <optional>
 #include <vector>
 
 #include "audio_core/audio_out.h"
@@ -88,9 +89,12 @@ 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, std::chrono::nanoseconds) { ReleaseAndQueueBuffers(); });
+    process_event =
+        Core::Timing::CreateEvent(fmt::format("AudioRenderer-Instance{}-Process", instance_number),
+                                  [this](std::uintptr_t, s64, std::chrono::nanoseconds) {
+                                      ReleaseAndQueueBuffers();
+                                      return std::nullopt;
+                                  });
     for (s32 i = 0; i < NUM_BUFFERS; ++i) {
         QueueMixedBuffer(i);
     }
@@ -98,13 +102,13 @@ AudioRenderer::AudioRenderer(Core::Timing::CoreTiming& core_timing_, Core::Memor
 
 AudioRenderer::~AudioRenderer() = default;
 
-ResultCode AudioRenderer::Start() {
+Result AudioRenderer::Start() {
     audio_out->StartStream(stream);
     ReleaseAndQueueBuffers();
     return ResultSuccess;
 }
 
-ResultCode AudioRenderer::Stop() {
+Result AudioRenderer::Stop() {
     audio_out->StopStream(stream);
     return ResultSuccess;
 }
@@ -125,8 +129,8 @@ Stream::State AudioRenderer::GetStreamState() const {
     return stream->GetState();
 }
 
-ResultCode AudioRenderer::UpdateAudioRenderer(const std::vector<u8>& input_params,
-                                              std::vector<u8>& output_params) {
+Result 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};
 

src/audio_core/audio_renderer.h

@@ -43,10 +43,10 @@ public:
                   Stream::ReleaseCallback&& release_callback, std::size_t instance_number);
     ~AudioRenderer();
 
-    [[nodiscard]] ResultCode UpdateAudioRenderer(const std::vector<u8>& input_params,
-                                                 std::vector<u8>& output_params);
-    [[nodiscard]] ResultCode Start();
-    [[nodiscard]] ResultCode Stop();
+    [[nodiscard]] Result UpdateAudioRenderer(const std::vector<u8>& input_params,
+                                             std::vector<u8>& output_params);
+    [[nodiscard]] Result Start();
+    [[nodiscard]] Result Stop();
     void QueueMixedBuffer(Buffer::Tag tag);
     void ReleaseAndQueueBuffers();
     [[nodiscard]] u32 GetSampleRate() const;

src/audio_core/common.h

@@ -10,8 +10,8 @@
 
 namespace AudioCommon {
 namespace Audren {
-constexpr ResultCode ERR_INVALID_PARAMETERS{ErrorModule::Audio, 41};
-constexpr ResultCode ERR_SPLITTER_SORT_FAILED{ErrorModule::Audio, 43};
+constexpr Result ERR_INVALID_PARAMETERS{ErrorModule::Audio, 41};
+constexpr Result ERR_SPLITTER_SORT_FAILED{ErrorModule::Audio, 43};
 } // namespace Audren
 
 constexpr u8 BASE_REVISION = '0';

src/audio_core/info_updater.cpp

@@ -285,9 +285,8 @@ bool InfoUpdater::UpdateSplitterInfo(SplitterContext& splitter_context) {
     return true;
 }
 
-ResultCode InfoUpdater::UpdateMixes(MixContext& mix_context, std::size_t mix_buffer_count,
-                                    SplitterContext& splitter_context,
-                                    EffectContext& effect_context) {
+Result 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()) {

src/audio_core/info_updater.h

@@ -32,8 +32,8 @@ public:
                       VAddr audio_codec_dsp_addr);
     bool UpdateEffects(EffectContext& effect_context, bool is_active);
     bool UpdateSplitterInfo(SplitterContext& splitter_context);
-    ResultCode UpdateMixes(MixContext& mix_context, std::size_t mix_buffer_count,
-                           SplitterContext& splitter_context, EffectContext& effect_context);
+    Result 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);

src/audio_core/stream.cpp

@@ -34,9 +34,10 @@ 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, std::chrono::nanoseconds ns_late) {
+    release_event = Core::Timing::CreateEvent(
+        name, [this](std::uintptr_t, s64 time, std::chrono::nanoseconds ns_late) {
             ReleaseActiveBuffer(ns_late);
+            return std::nullopt;
         });
 }
 

src/common/bounded_threadsafe_queue.h

@@ -1,10 +1,7 @@
 // SPDX-FileCopyrightText: Copyright (c) 2020 Erik Rigtorp <erik@rigtorp.se>
 // SPDX-License-Identifier: MIT
+
 #pragma once
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable : 4324)
-#endif
 
 #include <atomic>
 #include <bit>
@@ -12,105 +9,63 @@
 #include <memory>
 #include <mutex>
 #include <new>
-#include <stdexcept>
 #include <stop_token>
 #include <type_traits>
 #include <utility>
 
 namespace Common {
-namespace mpsc {
+
 #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
 
-template <typename T>
-using AlignedAllocator = std::allocator<T>;
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4324)
+#endif
 
-template <typename T>
-struct Slot {
-    ~Slot() noexcept {
-        if (turn.test()) {
-            destroy();
-        }
-    }
-
-    template <typename... Args>
-    void construct(Args&&... args) noexcept {
-        static_assert(std::is_nothrow_constructible_v<T, Args&&...>,
-                      "T must be nothrow constructible with Args&&...");
-        std::construct_at(reinterpret_cast<T*>(&storage), std::forward<Args>(args)...);
-    }
-
-    void destroy() noexcept {
-        static_assert(std::is_nothrow_destructible_v<T>, "T must be nothrow destructible");
-        std::destroy_at(reinterpret_cast<T*>(&storage));
-    }
-
-    T&& move() noexcept {
-        return reinterpret_cast<T&&>(storage);
-    }
-
-    // Align to avoid false sharing between adjacent slots
-    alignas(hardware_interference_size) std::atomic_flag turn{};
-    struct aligned_store {
-        struct type {
-            alignas(T) unsigned char data[sizeof(T)];
-        };
-    };
-    typename aligned_store::type storage;
-};
-
-template <typename T, typename Allocator = AlignedAllocator<Slot<T>>>
-class Queue {
+template <typename T, size_t capacity = 0x400>
+class MPSCQueue {
 public:
-    explicit Queue(const size_t capacity, const Allocator& allocator = Allocator())
-        : allocator_(allocator) {
-        if (capacity < 1) {
-            throw std::invalid_argument("capacity < 1");
-        }
-        // Ensure that the queue length is an integer power of 2
-        // This is so that idx(i) can be a simple i & mask_ insted of i % capacity
-        // https://github.com/rigtorp/MPMCQueue/pull/36
-        if (!std::has_single_bit(capacity)) {
-            throw std::invalid_argument("capacity must be an integer power of 2");
-        }
-
-        mask_ = capacity - 1;
-
+    explicit MPSCQueue() : allocator{std::allocator<Slot<T>>()} {
         // Allocate one extra slot to prevent false sharing on the last slot
-        slots_ = allocator_.allocate(mask_ + 2);
+        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_, mask_ + 2);
+        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 < mask_ + 1; ++i) {
-            std::construct_at(&slots_[i]);
+        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(Queue) % hardware_interference_size == 0,
+        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");
     }
 
-    ~Queue() noexcept {
-        for (size_t i = 0; i < mask_ + 1; ++i) {
-            slots_[i].~Slot();
+    ~MPSCQueue() noexcept {
+        for (size_t i = 0; i < capacity; ++i) {
+            std::destroy_at(&slots[i]);
         }
-        allocator_.deallocate(slots_, mask_ + 2);
+        allocator.deallocate(slots, capacity + 1);
     }
 
-    // non-copyable and non-movable
-    Queue(const Queue&) = delete;
-    Queue& operator=(const Queue&) = delete;
+    // 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>,
@@ -125,8 +80,8 @@ public:
 
     void Pop(T& v, std::stop_token stop) noexcept {
         auto const tail = tail_.fetch_add(1);
-        auto& slot = slots_[idx(tail)];
-        if (false == slot.turn.test()) {
+        auto& slot = slots[idx(tail)];
+        if (!slot.turn.test()) {
             std::unique_lock lock{cv_mutex};
             cv.wait(lock, stop, [&slot] { return slot.turn.test(); });
         }
@@ -137,12 +92,46 @@ public:
     }
 
 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)];
+        auto& slot = slots[idx(head)];
         slot.turn.wait(true);
         slot.construct(std::forward<Args>(args)...);
         slot.turn.test_and_set();
@@ -150,31 +139,29 @@ private:
     }
 
     constexpr size_t idx(size_t i) const noexcept {
-        return i & mask_;
+        return i & mask;
     }
 
-    std::conditional_t<true, std::condition_variable_any, std::condition_variable> cv;
-    std::mutex cv_mutex;
-    size_t mask_;
-    Slot<T>* slots_;
-    [[no_unique_address]] Allocator allocator_;
+    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");
 };
-} // namespace mpsc
-
-template <typename T, typename Allocator = mpsc::AlignedAllocator<mpsc::Slot<T>>>
-using MPSCQueue = mpsc::Queue<T, Allocator>;
-
-} // namespace Common
 
 #ifdef _MSC_VER
 #pragma warning(pop)
 #endif
+
+} // namespace Common

src/common/common_funcs.h

@@ -18,14 +18,16 @@
 /// Helper macros to insert unused bytes or words to properly align structs. These values will be
 /// zero-initialized.
 #define INSERT_PADDING_BYTES(num_bytes)                                                            \
-    std::array<u8, num_bytes> CONCAT2(pad, __LINE__) {}
+    [[maybe_unused]] std::array<u8, num_bytes> CONCAT2(pad, __LINE__) {}
 #define INSERT_PADDING_WORDS(num_words)                                                            \
-    std::array<u32, num_words> CONCAT2(pad, __LINE__) {}
+    [[maybe_unused]] std::array<u32, num_words> CONCAT2(pad, __LINE__) {}
 
 /// These are similar to the INSERT_PADDING_* macros but do not zero-initialize the contents.
 /// This keeps the structure trivial to construct.
-#define INSERT_PADDING_BYTES_NOINIT(num_bytes) std::array<u8, num_bytes> CONCAT2(pad, __LINE__)
-#define INSERT_PADDING_WORDS_NOINIT(num_words) std::array<u32, num_words> CONCAT2(pad, __LINE__)
+#define INSERT_PADDING_BYTES_NOINIT(num_bytes)                                                     \
+    [[maybe_unused]] std::array<u8, num_bytes> CONCAT2(pad, __LINE__)
+#define INSERT_PADDING_WORDS_NOINIT(num_words)                                                     \
+    [[maybe_unused]] std::array<u32, num_words> CONCAT2(pad, __LINE__)
 
 #ifndef _MSC_VER
 

src/common/detached_tasks.cpp

@@ -33,9 +33,9 @@ void DetachedTasks::AddTask(std::function<void()> task) {
     ++instance->count;
     std::thread([task{std::move(task)}]() {
         task();
-        std::unique_lock lock{instance->mutex};
+        std::unique_lock thread_lock{instance->mutex};
         --instance->count;
-        std::notify_all_at_thread_exit(instance->cv, std::move(lock));
+        std::notify_all_at_thread_exit(instance->cv, std::move(thread_lock));
     }).detach();
 }
 

src/common/fiber.cpp

@@ -20,10 +20,8 @@ struct Fiber::FiberImpl {
     VirtualBuffer<u8> rewind_stack;
 
     std::mutex guard;
-    std::function<void(void*)> entry_point;
-    std::function<void(void*)> rewind_point;
-    void* rewind_parameter{};
-    void* start_parameter{};
+    std::function<void()> entry_point;
+    std::function<void()> rewind_point;
     std::shared_ptr<Fiber> previous_fiber;
     bool is_thread_fiber{};
     bool released{};
@@ -34,13 +32,8 @@ struct Fiber::FiberImpl {
     boost::context::detail::fcontext_t rewind_context{};
 };
 
-void Fiber::SetStartParameter(void* new_parameter) {
-    impl->start_parameter = new_parameter;
-}
-
-void Fiber::SetRewindPoint(std::function<void(void*)>&& rewind_func, void* rewind_param) {
+void Fiber::SetRewindPoint(std::function<void()>&& rewind_func) {
     impl->rewind_point = std::move(rewind_func);
-    impl->rewind_parameter = rewind_param;
 }
 
 void Fiber::Start(boost::context::detail::transfer_t& transfer) {
@@ -48,7 +41,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->start_parameter);
+    impl->entry_point();
     UNREACHABLE();
 }
 
@@ -59,7 +52,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_parameter);
+    impl->rewind_point();
     UNREACHABLE();
 }
 
@@ -73,10 +66,8 @@ void Fiber::RewindStartFunc(boost::context::detail::transfer_t transfer) {
     fiber->OnRewind(transfer);
 }
 
-Fiber::Fiber(std::function<void(void*)>&& entry_point_func, void* start_parameter)
-    : impl{std::make_unique<FiberImpl>()} {
+Fiber::Fiber(std::function<void()>&& entry_point_func) : 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;

src/common/fiber.h

@@ -29,7 +29,7 @@ namespace Common {
  */
 class Fiber {
 public:
-    Fiber(std::function<void(void*)>&& entry_point_func, void* start_parameter);
+    Fiber(std::function<void()>&& entry_point_func);
     ~Fiber();
 
     Fiber(const Fiber&) = delete;
@@ -43,16 +43,13 @@ public:
     static void YieldTo(std::weak_ptr<Fiber> weak_from, Fiber& to);
     [[nodiscard]] static std::shared_ptr<Fiber> ThreadToFiber();
 
-    void SetRewindPoint(std::function<void(void*)>&& rewind_func, void* rewind_param);
+    void SetRewindPoint(std::function<void()>&& rewind_func);
 
     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();
 

src/common/page_table.h

@@ -15,6 +15,9 @@ 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,

src/common/param_package.cpp

@@ -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_DEBUG(Common, "key '{}' not found", key);
+        LOG_TRACE(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_DEBUG(Common, "key '{}' not found", key);
+        LOG_TRACE(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_DEBUG(Common, "key {} not found", key);
+        LOG_TRACE(Common, "key {} not found", key);
         return default_value;
     }
 

src/common/settings.h

@@ -101,15 +101,15 @@ struct ResolutionScalingInfo {
     }
 };
 
-/** 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.
+/** 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.
  */
-template <typename Type>
-class BasicSetting {
+template <typename Type, bool ranged = false>
+class Setting {
 protected:
-    BasicSetting() = default;
+    Setting() = 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 BasicSetting(const Type& global_val) : global{global_val} {}
+    explicit Setting(const Type& val) : value{val} {}
 
 public:
     /**
@@ -126,9 +126,22 @@ public:
      * @param default_val Intial value of the setting, and default value of the setting
      * @param name Label for the setting
      */
-    explicit BasicSetting(const Type& default_val, const std::string& name)
-        : default_value{default_val}, global{default_val}, label{name} {}
-    virtual ~BasicSetting() = default;
+    explicit Setting(const Type& default_val, const std::string& name) requires(!ranged)
+        : value{default_val}, default_value{default_val}, 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) requires(ranged)
+        : value{default_val},
+          default_value{default_val}, maximum{max_val}, minimum{min_val}, label{name} {}
 
     /**
      *  Returns a reference to the setting's value.
@@ -136,17 +149,17 @@ public:
      * @returns A reference to the setting
      */
     [[nodiscard]] virtual const Type& GetValue() const {
-        return global;
+        return value;
     }
 
     /**
      * Sets the setting to the given value.
      *
-     * @param value The desired value
+     * @param val The desired value
      */
-    virtual void SetValue(const Type& value) {
-        Type temp{value};
-        std::swap(global, temp);
+    virtual void SetValue(const Type& val) {
+        Type temp{ranged ? std::clamp(val, minimum, maximum) : val};
+        std::swap(value, temp);
     }
 
     /**
@@ -170,14 +183,14 @@ public:
     /**
      * Assigns a value to the setting.
      *
-     * @param value The desired setting value
+     * @param val The desired setting value
      *
      * @returns A reference to the setting
      */
-    virtual const Type& operator=(const Type& value) {
-        Type temp{value};
-        std::swap(global, temp);
-        return global;
+    virtual const Type& operator=(const Type& val) {
+        Type temp{ranged ? std::clamp(val, minimum, maximum) : val};
+        std::swap(value, temp);
+        return value;
     }
 
     /**
@@ -186,23 +199,38 @@ public:
      * @returns A reference to the setting
      */
     explicit virtual operator const Type&() const {
-        return global;
+        return value;
     }
 
 protected:
+    Type value{};               ///< The setting
     const Type default_value{}; ///< The default value
-    Type global{};              ///< The setting
+    const Type maximum{};       ///< Maximum allowed value of the setting
+    const Type minimum{};       ///< Minimum allowed value of the setting
     const std::string label{};  ///< The setting's label
 };
 
 /**
- * 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.
+ * 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.
  */
-template <typename Type>
-class BasicRangedSetting : virtual public BasicSetting<Type> {
+template <typename Type, bool ranged = false>
+class SwitchableSetting : virtual public Setting<Type, ranged> {
 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) requires(!ranged)
+        : Setting<Type>{default_val, name} {}
+    virtual ~SwitchableSetting() = default;
+
     /**
      * Sets a default value, minimum value, maximum value, and label.
      *
@@ -211,57 +239,9 @@ public:
      * @param max_val Sets the maximum allowed value of the setting
      * @param name Label for the setting
      */
-    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;
+    explicit SwitchableSetting(const Type& default_val, const Type& min_val, const Type& max_val,
+                               const std::string& name) requires(ranged)
+        : Setting<Type, true>{default_val, min_val, max_val, name} {}
 
     /**
      * Tells this setting to represent either the global or custom setting when other member
@@ -292,13 +272,13 @@ public:
      */
     [[nodiscard]] virtual const Type& GetValue() const override {
         if (use_global) {
-            return this->global;
+            return this->value;
         }
         return custom;
     }
     [[nodiscard]] virtual const Type& GetValue(bool need_global) const {
         if (use_global || need_global) {
-            return this->global;
+            return this->value;
         }
         return custom;
     }
@@ -306,12 +286,12 @@ public:
     /**
      * Sets the current setting value depending on the global state.
      *
-     * @param value The new value
+     * @param val The new value
      */
-    void SetValue(const Type& value) override {
-        Type temp{value};
+    void SetValue(const Type& val) override {
+        Type temp{ranged ? std::clamp(val, this->minimum, this->maximum) : val};
         if (use_global) {
-            std::swap(this->global, temp);
+            std::swap(this->value, temp);
         } else {
             std::swap(custom, temp);
         }
@@ -320,15 +300,15 @@ public:
     /**
      * Assigns the current setting value depending on the global state.
      *
-     * @param value The new value
+     * @param val The new value
      *
      * @returns A reference to the current setting value
      */
-    const Type& operator=(const Type& value) override {
-        Type temp{value};
+    const Type& operator=(const Type& val) override {
+        Type temp{ranged ? std::clamp(val, this->minimum, this->maximum) : val};
         if (use_global) {
-            std::swap(this->global, temp);
-            return this->global;
+            std::swap(this->value, temp);
+            return this->value;
         }
         std::swap(custom, temp);
         return custom;
@@ -341,7 +321,7 @@ public:
      */
     virtual explicit operator const Type&() const override {
         if (use_global) {
-            return this->global;
+            return this->value;
         }
         return custom;
     }
@@ -351,75 +331,6 @@ 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
@@ -431,7 +342,7 @@ template <typename Type>
 class InputSetting final {
 public:
     InputSetting() = default;
-    explicit InputSetting(Type val) : BasicSetting<Type>(val) {}
+    explicit InputSetting(Type val) : Setting<Type>(val) {}
     ~InputSetting() = default;
     void SetGlobal(bool to_global) {
         use_global = to_global;
@@ -459,175 +370,175 @@ struct TouchFromButtonMap {
 
 struct Values {
     // Audio
-    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"};
+    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, true> volume{100, 0, 100, "volume"};
 
     // Core
-    Setting<bool> use_multi_core{true, "use_multi_core"};
-    Setting<bool> use_extended_memory_layout{false, "use_extended_memory_layout"};
+    SwitchableSetting<bool> use_multi_core{true, "use_multi_core"};
+    SwitchableSetting<bool> use_extended_memory_layout{false, "use_extended_memory_layout"};
 
     // Cpu
-    RangedSetting<CPUAccuracy> cpu_accuracy{CPUAccuracy::Auto, CPUAccuracy::Auto,
-                                            CPUAccuracy::Paranoid, "cpu_accuracy"};
+    SwitchableSetting<CPUAccuracy, true> cpu_accuracy{CPUAccuracy::Auto, CPUAccuracy::Auto,
+                                                      CPUAccuracy::Paranoid, "cpu_accuracy"};
     // TODO: remove cpu_accuracy_first_time, migration setting added 8 July 2021
-    BasicSetting<bool> cpu_accuracy_first_time{true, "cpu_accuracy_first_time"};
-    BasicSetting<bool> cpu_debug_mode{false, "cpu_debug_mode"};
+    Setting<bool> cpu_accuracy_first_time{true, "cpu_accuracy_first_time"};
+    Setting<bool> cpu_debug_mode{false, "cpu_debug_mode"};
 
-    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"};
+    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"};
 
-    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"};
+    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"};
 
     // Renderer
-    RangedSetting<RendererBackend> renderer_backend{
+    SwitchableSetting<RendererBackend, true> renderer_backend{
         RendererBackend::Vulkan, 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"};
+    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"};
 
     ResolutionScalingInfo resolution_info{};
-    Setting<ResolutionSetup> resolution_setup{ResolutionSetup::Res1X, "resolution_setup"};
-    Setting<ScalingFilter> scaling_filter{ScalingFilter::Bilinear, "scaling_filter"};
-    Setting<AntiAliasing> anti_aliasing{AntiAliasing::None, "anti_aliasing"};
+    SwitchableSetting<ResolutionSetup> resolution_setup{ResolutionSetup::Res1X, "resolution_setup"};
+    SwitchableSetting<ScalingFilter> scaling_filter{ScalingFilter::Bilinear, "scaling_filter"};
+    SwitchableSetting<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.
-    RangedSetting<FullscreenMode> fullscreen_mode{
+    SwitchableSetting<FullscreenMode, true> fullscreen_mode{
 #ifdef _WIN32
         FullscreenMode::Borderless,
 #else
         FullscreenMode::Exclusive,
 #endif
         FullscreenMode::Borderless, FullscreenMode::Exclusive, "fullscreen_mode"};
-    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<int, true> aspect_ratio{0, 0, 3, "aspect_ratio"};
+    SwitchableSetting<int, true> max_anisotropy{0, 0, 5, "max_anisotropy"};
+    SwitchableSetting<bool> use_speed_limit{true, "use_speed_limit"};
+    SwitchableSetting<u16, true> speed_limit{100, 0, 9999, "speed_limit"};
+    SwitchableSetting<bool> use_disk_shader_cache{true, "use_disk_shader_cache"};
+    SwitchableSetting<GPUAccuracy, true> 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, true> fps_cap{1000, 1, 1000, "fps_cap"};
+    Setting<bool> disable_fps_limit{false, "disable_fps_limit"};
+    SwitchableSetting<ShaderBackend, true> 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"};
 
-    Setting<u8> bg_red{0, "bg_red"};
-    Setting<u8> bg_green{0, "bg_green"};
-    Setting<u8> bg_blue{0, "bg_blue"};
+    SwitchableSetting<u8> bg_red{0, "bg_red"};
+    SwitchableSetting<u8> bg_green{0, "bg_green"};
+    SwitchableSetting<u8> bg_blue{0, "bg_blue"};
 
     // System
-    Setting<std::optional<u32>> rng_seed{std::optional<u32>(), "rng_seed"};
+    SwitchableSetting<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;
 
-    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"};
+    Setting<s32> current_user{0, "current_user"};
+    SwitchableSetting<s32, true> language_index{1, 0, 17, "language_index"};
+    SwitchableSetting<s32, true> region_index{1, 0, 6, "region_index"};
+    SwitchableSetting<s32, true> time_zone_index{0, 0, 45, "time_zone_index"};
+    SwitchableSetting<s32, true> sound_index{1, 0, 2, "sound_index"};
 
     // Controls
     InputSetting<std::array<PlayerInput, 10>> players;
 
-    Setting<bool> use_docked_mode{true, "use_docked_mode"};
+    SwitchableSetting<bool> use_docked_mode{true, "use_docked_mode"};
 
-    BasicSetting<bool> enable_raw_input{false, "enable_raw_input"};
-    BasicSetting<bool> controller_navigation{true, "controller_navigation"};
+    Setting<bool> enable_raw_input{false, "enable_raw_input"};
+    Setting<bool> controller_navigation{true, "controller_navigation"};
 
-    Setting<bool> vibration_enabled{true, "vibration_enabled"};
-    Setting<bool> enable_accurate_vibrations{false, "enable_accurate_vibrations"};
+    SwitchableSetting<bool> vibration_enabled{true, "vibration_enabled"};
+    SwitchableSetting<bool> enable_accurate_vibrations{false, "enable_accurate_vibrations"};
 
-    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"};
+    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"};
 
-    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> 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> 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> mouse_panning{false, "mouse_panning"};
+    Setting<u8, true> mouse_panning_sensitivity{10, 1, 100, "mouse_panning_sensitivity"};
+    Setting<bool> mouse_enabled{false, "mouse_enabled"};
 
-    BasicSetting<bool> emulate_analog_keyboard{false, "emulate_analog_keyboard"};
-    BasicSetting<bool> keyboard_enabled{false, "keyboard_enabled"};
+    Setting<bool> emulate_analog_keyboard{false, "emulate_analog_keyboard"};
+    Setting<bool> keyboard_enabled{false, "keyboard_enabled"};
 
-    BasicSetting<bool> debug_pad_enabled{false, "debug_pad_enabled"};
+    Setting<bool> debug_pad_enabled{false, "debug_pad_enabled"};
     ButtonsRaw debug_pad_buttons;
     AnalogsRaw debug_pad_analogs;
 
     TouchscreenInput touchscreen;
 
-    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"};
+    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"};
     std::vector<TouchFromButtonMap> touch_from_button_maps;
 
-    BasicSetting<bool> enable_ring_controller{true, "enable_ring_controller"};
+    Setting<bool> enable_ring_controller{true, "enable_ring_controller"};
     RingconRaw ringcon_analogs;
 
     // Data Storage
-    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"};
+    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"};
 
     // Debugging
     bool record_frame_times;
-    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"};
+    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"};
 
     // Miscellaneous
-    BasicSetting<std::string> log_filter{"*:Info", "log_filter"};
-    BasicSetting<bool> use_dev_keys{false, "use_dev_keys"};
+    Setting<std::string> log_filter{"*:Info", "log_filter"};
+    Setting<bool> use_dev_keys{false, "use_dev_keys"};
 
     // Network
-    BasicSetting<std::string> network_interface{std::string(), "network_interface"};
+    Setting<std::string> network_interface{std::string(), "network_interface"};
 
     // WebService
-    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"};
+    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"};
 
     // Add-Ons
     std::map<u64, std::vector<std::string>> disabled_addons;

src/common/thread.cpp

@@ -47,6 +47,9 @@ 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;
@@ -59,9 +62,10 @@ void SetCurrentThreadPriority(ThreadPriority new_priority) {
 void SetCurrentThreadPriority(ThreadPriority new_priority) {
     pthread_t this_thread = pthread_self();
 
-    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;
+    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);
 
     struct sched_param params;
     if (max_prio > min_prio) {
@@ -70,7 +74,7 @@ void SetCurrentThreadPriority(ThreadPriority new_priority) {
         params.sched_priority = min_prio - ((min_prio - max_prio) * level) / 4;
     }
 
-    pthread_setschedparam(this_thread, SCHED_OTHER, &params);
+    pthread_setschedparam(this_thread, scheduling_type, &params);
 }
 
 #endif

src/common/thread.h

@@ -92,6 +92,7 @@ enum class ThreadPriority : u32 {
     Normal = 1,
     High = 2,
     VeryHigh = 3,
+    Critical = 4,
 };
 
 void SetCurrentThreadPriority(ThreadPriority new_priority);

src/common/uint128.h

@@ -30,6 +30,10 @@ 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;
@@ -37,6 +41,7 @@ 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;

src/common/x64/native_clock.cpp

@@ -75,8 +75,8 @@ NativeClock::NativeClock(u64 emulated_cpu_frequency_, u64 emulated_clock_frequen
 }
 
 u64 NativeClock::GetRTSC() {
-    TimePoint new_time_point{};
     TimePoint current_time_point{};
+    TimePoint new_time_point{};
 
     current_time_point.pack = Common::AtomicLoad128(time_point.pack.data());
     do {
@@ -89,8 +89,7 @@ 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));
-    /// The clock cannot be more precise than the guest timer, remove the lower bits
-    return new_time_point.inner.accumulated_ticks & inaccuracy_mask;
+    return new_time_point.inner.accumulated_ticks;
 }
 
 void NativeClock::Pause(bool is_paused) {

src/common/x64/native_clock.h

@@ -37,12 +37,8 @@ private:
         } inner;
     };
 
-    /// 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{};

src/core/CMakeLists.txt

@@ -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_linked_list.h
+    hle/kernel/k_page_group.h
     hle/kernel/k_page_table.cpp
     hle/kernel/k_page_table.h
     hle/kernel/k_port.cpp
@@ -743,16 +743,11 @@ 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>

src/core/arm/arm_interface.cpp

@@ -1,6 +1,10 @@
 // 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"
@@ -68,8 +72,19 @@ 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
             }
         }
     }
@@ -95,7 +110,7 @@ void ARM_Interface::Run() {
     using Kernel::SuspendType;
 
     while (true) {
-        Kernel::KThread* current_thread{system.Kernel().CurrentScheduler()->GetCurrentThread()};
+        Kernel::KThread* current_thread{Kernel::GetCurrentThreadPointer(system.Kernel())};
         Dynarmic::HaltReason hr{};
 
         // Notify the debugger and go to sleep if a step was performed
@@ -107,6 +122,7 @@ void ARM_Interface::Run() {
         }
 
         // Otherwise, run the thread.
+        system.EnterDynarmicProfile();
         if (current_thread->GetStepState() == StepState::StepPending) {
             hr = StepJit();
 
@@ -116,14 +132,29 @@ void ARM_Interface::Run() {
         } else {
             hr = RunJit();
         }
+        system.ExitDynarmicProfile();
 
-        // Notify the debugger and go to sleep if a breakpoint was hit.
-        if (Has(hr, breakpoint)) {
-            system.GetDebugger().NotifyThreadStopped(current_thread);
+        // 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);
+            }
             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());
@@ -134,4 +165,36 @@ 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

src/core/arm/arm_interface.h

@@ -5,6 +5,7 @@
 #pragma once
 
 #include <array>
+#include <span>
 #include <vector>
 
 #include <dynarmic/interface/halt_reason.h>
@@ -19,13 +20,16 @@ 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 {
@@ -170,6 +174,7 @@ 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;
@@ -198,18 +203,25 @@ 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

src/core/arm/dynarmic/arm_dynarmic_32.cpp

@@ -29,64 +29,94 @@ using namespace Common::Literals;
 class DynarmicCallbacks32 : public Dynarmic::A32::UserCallbacks {
 public:
     explicit DynarmicCallbacks32(ARM_Dynarmic_32& parent_)
-        : parent{parent_}, memory(parent.system.Memory()) {}
+        : parent{parent_},
+          memory(parent.system.Memory()), debugger_enabled{parent.system.DebuggerEnabled()} {}
 
     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 {
-        memory.Write8(vaddr, value);
+        if (CheckMemoryAccess(vaddr, 1, Kernel::DebugWatchpointType::Write)) {
+            memory.Write8(vaddr, value);
+        }
     }
     void MemoryWrite16(u32 vaddr, u16 value) override {
-        memory.Write16(vaddr, value);
+        if (CheckMemoryAccess(vaddr, 2, Kernel::DebugWatchpointType::Write)) {
+            memory.Write16(vaddr, value);
+        }
     }
     void MemoryWrite32(u32 vaddr, u32 value) override {
-        memory.Write32(vaddr, value);
+        if (CheckMemoryAccess(vaddr, 4, Kernel::DebugWatchpointType::Write)) {
+            memory.Write32(vaddr, value);
+        }
     }
     void MemoryWrite64(u32 vaddr, u64 value) override {
-        memory.Write64(vaddr, value);
+        if (CheckMemoryAccess(vaddr, 8, Kernel::DebugWatchpointType::Write)) {
+            memory.Write64(vaddr, value);
+        }
     }
 
     bool MemoryWriteExclusive8(u32 vaddr, u8 value, u8 expected) override {
-        return memory.WriteExclusive8(vaddr, value, expected);
+        return CheckMemoryAccess(vaddr, 1, Kernel::DebugWatchpointType::Write) &&
+               memory.WriteExclusive8(vaddr, value, expected);
     }
     bool MemoryWriteExclusive16(u32 vaddr, u16 value, u16 expected) override {
-        return memory.WriteExclusive16(vaddr, value, expected);
+        return CheckMemoryAccess(vaddr, 2, Kernel::DebugWatchpointType::Write) &&
+               memory.WriteExclusive16(vaddr, value, expected);
     }
     bool MemoryWriteExclusive32(u32 vaddr, u32 value, u32 expected) override {
-        return memory.WriteExclusive32(vaddr, value, expected);
+        return CheckMemoryAccess(vaddr, 4, Kernel::DebugWatchpointType::Write) &&
+               memory.WriteExclusive32(vaddr, value, expected);
     }
     bool MemoryWriteExclusive64(u32 vaddr, u64 value, u64 expected) override {
-        return memory.WriteExclusive64(vaddr, value, expected);
+        return CheckMemoryAccess(vaddr, 8, Kernel::DebugWatchpointType::Write) &&
+               memory.WriteExclusive64(vaddr, value, expected);
     }
 
     void InterpreterFallback(u32 pc, std::size_t num_instructions) override {
         parent.LogBacktrace();
-        UNIMPLEMENTED_MSG("This should never happen, pc = {:08X}, code = {:08X}", pc,
-                          MemoryReadCode(pc));
+        LOG_ERROR(Core_ARM,
+                  "Unimplemented instruction @ 0x{:X} for {} instructions (instr = {:08X})", pc,
+                  num_instructions, MemoryRead32(pc));
     }
 
     void ExceptionRaised(u32 pc, Dynarmic::A32::Exception exception) override {
-        if (parent.system.DebuggerEnabled()) {
-            parent.jit.load()->Regs()[15] = pc;
-            parent.jit.load()->HaltExecution(ARM_Interface::breakpoint);
+        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);
             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, MemoryReadCode(pc), parent.IsInThumbMode());
+            parent.LogBacktrace();
+            LOG_CRITICAL(Core_ARM,
+                         "ExceptionRaised(exception = {}, pc = {:08X}, code = {:08X}, thumb = {})",
+                         exception, pc, MemoryRead32(pc), parent.IsInThumbMode());
+        }
     }
 
     void CallSVC(u32 swi) override {
@@ -117,9 +147,31 @@ 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;
 };
 
@@ -154,6 +206,11 @@ 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
@@ -248,6 +305,14 @@ 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_)
@@ -362,18 +427,38 @@ void ARM_Dynarmic_32::PageTableChanged(Common::PageTable& page_table,
 }
 
 std::vector<ARM_Interface::BacktraceEntry> ARM_Dynarmic_32::GetBacktrace(Core::System& system,
-                                                                         u64 sp, u64 lr) {
-    // No way to get accurate stack traces in A32 yet
-    return {};
+                                                                         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;
 }
 
 std::vector<ARM_Interface::BacktraceEntry> ARM_Dynarmic_32::GetBacktraceFromContext(
     System& system, const ThreadContext32& ctx) {
-    return GetBacktrace(system, ctx.cpu_registers[13], ctx.cpu_registers[14]);
+    const auto& reg = ctx.cpu_registers;
+    return GetBacktrace(system, reg[11], reg[14], reg[15]);
 }
 
 std::vector<ARM_Interface::BacktraceEntry> ARM_Dynarmic_32::GetBacktrace() const {
-    return GetBacktrace(system, GetReg(13), GetReg(14));
+    return GetBacktrace(system, GetReg(11), GetReg(14), GetReg(15));
 }
 
 } // namespace Core

src/core/arm/dynarmic/arm_dynarmic_32.h

@@ -72,11 +72,13 @@ 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 sp, u64 lr);
+    static std::vector<BacktraceEntry> GetBacktrace(Core::System& system, u64 fp, u64 lr, u64 pc);
 
     using JitCacheKey = std::pair<Common::PageTable*, std::size_t>;
     using JitCacheType =
@@ -98,6 +100,10 @@ private:
 
     // SVC callback
     u32 svc_swi{};
+
+    // Watchpoint info
+    const Kernel::DebugWatchpoint* halted_watchpoint;
+    ThreadContext32 breakpoint_context;
 };
 
 } // namespace Core

src/core/arm/dynarmic/arm_dynarmic_64.cpp

@@ -29,62 +29,89 @@ using namespace Common::Literals;
 class DynarmicCallbacks64 : public Dynarmic::A64::UserCallbacks {
 public:
     explicit DynarmicCallbacks64(ARM_Dynarmic_64& parent_)
-        : parent{parent_}, memory(parent.system.Memory()) {}
+        : parent{parent_},
+          memory(parent.system.Memory()), debugger_enabled{parent.system.DebuggerEnabled()} {}
 
     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 {
-        memory.Write8(vaddr, value);
+        if (CheckMemoryAccess(vaddr, 1, Kernel::DebugWatchpointType::Write)) {
+            memory.Write8(vaddr, value);
+        }
     }
     void MemoryWrite16(u64 vaddr, u16 value) override {
-        memory.Write16(vaddr, value);
+        if (CheckMemoryAccess(vaddr, 2, Kernel::DebugWatchpointType::Write)) {
+            memory.Write16(vaddr, value);
+        }
     }
     void MemoryWrite32(u64 vaddr, u32 value) override {
-        memory.Write32(vaddr, value);
+        if (CheckMemoryAccess(vaddr, 4, Kernel::DebugWatchpointType::Write)) {
+            memory.Write32(vaddr, value);
+        }
     }
     void MemoryWrite64(u64 vaddr, u64 value) override {
-        memory.Write64(vaddr, value);
+        if (CheckMemoryAccess(vaddr, 8, Kernel::DebugWatchpointType::Write)) {
+            memory.Write64(vaddr, value);
+        }
     }
     void MemoryWrite128(u64 vaddr, Vector value) override {
-        memory.Write64(vaddr, value[0]);
-        memory.Write64(vaddr + 8, value[1]);
+        if (CheckMemoryAccess(vaddr, 16, Kernel::DebugWatchpointType::Write)) {
+            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 memory.WriteExclusive8(vaddr, value, expected);
+        return CheckMemoryAccess(vaddr, 1, Kernel::DebugWatchpointType::Write) &&
+               memory.WriteExclusive8(vaddr, value, expected);
     }
     bool MemoryWriteExclusive16(u64 vaddr, std::uint16_t value, std::uint16_t expected) override {
-        return memory.WriteExclusive16(vaddr, value, expected);
+        return CheckMemoryAccess(vaddr, 2, Kernel::DebugWatchpointType::Write) &&
+               memory.WriteExclusive16(vaddr, value, expected);
     }
     bool MemoryWriteExclusive32(u64 vaddr, std::uint32_t value, std::uint32_t expected) override {
-        return memory.WriteExclusive32(vaddr, value, expected);
+        return CheckMemoryAccess(vaddr, 4, Kernel::DebugWatchpointType::Write) &&
+               memory.WriteExclusive32(vaddr, value, expected);
     }
     bool MemoryWriteExclusive64(u64 vaddr, std::uint64_t value, std::uint64_t expected) override {
-        return memory.WriteExclusive64(vaddr, value, expected);
+        return CheckMemoryAccess(vaddr, 8, Kernel::DebugWatchpointType::Write) &&
+               memory.WriteExclusive64(vaddr, value, expected);
     }
     bool MemoryWriteExclusive128(u64 vaddr, Vector value, Vector expected) override {
-        return memory.WriteExclusive128(vaddr, value, expected);
+        return CheckMemoryAccess(vaddr, 16, Kernel::DebugWatchpointType::Write) &&
+               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, MemoryReadCode(pc));
+                  num_instructions, MemoryRead32(pc));
     }
 
     void InstructionCacheOperationRaised(Dynarmic::A64::InstructionCacheOperation op,
@@ -117,16 +144,19 @@ 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 (parent.system.DebuggerEnabled()) {
-                parent.jit.load()->SetPC(pc);
-                parent.jit.load()->HaltExecution(ARM_Interface::breakpoint);
+            if (debugger_enabled) {
+                ReturnException(pc, ARM_Interface::breakpoint);
                 return;
             }
 
             parent.LogBacktrace();
-            ASSERT_MSG(false, "ExceptionRaised(exception = {}, pc = {:08X}, code = {:08X})",
-                       static_cast<std::size_t>(exception), pc, MemoryReadCode(pc));
+            LOG_CRITICAL(Core_ARM, "ExceptionRaised(exception = {}, pc = {:08X}, code = {:08X})",
+                         static_cast<std::size_t>(exception), pc, MemoryRead32(pc));
         }
     }
 
@@ -160,10 +190,32 @@ 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;
 };
 
@@ -214,6 +266,11 @@ 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
@@ -308,6 +365,14 @@ 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_)
@@ -429,22 +494,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 fp, u64 lr, u64 pc) {
     std::vector<BacktraceEntry> out;
     auto& memory = system.Memory();
 
-    // 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
+    out.push_back({"", 0, pc, 0, ""});
+
+    // fp (= x29) points to the previous frame record.
     // 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) {
+        if (!fp || (fp % 4 != 0) || !memory.IsValidVirtualAddressRange(fp, 16)) {
             break;
         }
-        lr = memory.Read64(fp + 8) - 4;
+        lr = memory.Read64(fp + 8);
         fp = memory.Read64(fp);
     }
 
@@ -455,11 +520,12 @@ 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) {
-    return GetBacktrace(system, ctx.cpu_registers[29], ctx.cpu_registers[30]);
+    const auto& reg = ctx.cpu_registers;
+    return GetBacktrace(system, reg[29], reg[30], ctx.pc);
 }
 
 std::vector<ARM_Interface::BacktraceEntry> ARM_Dynarmic_64::GetBacktrace() const {
-    return GetBacktrace(system, GetReg(29), GetReg(30));
+    return GetBacktrace(system, GetReg(29), GetReg(30), GetPC());
 }
 
 } // namespace Core

src/core/arm/dynarmic/arm_dynarmic_64.h

@@ -66,12 +66,14 @@ 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);
+    static std::vector<BacktraceEntry> GetBacktrace(Core::System& system, u64 fp, u64 lr, u64 pc);
 
     using JitCacheKey = std::pair<Common::PageTable*, std::size_t>;
     using JitCacheType =
@@ -91,6 +93,10 @@ private:
 
     // SVC callback
     u32 svc_swi{};
+
+    // Breakpoint info
+    const Kernel::DebugWatchpoint* halted_watchpoint;
+    ThreadContext64 breakpoint_context;
 };
 
 } // namespace Core

src/core/core.cpp

@@ -138,7 +138,6 @@ struct System::Impl {
 
         kernel.Suspend(false);
         core_timing.SyncPause(false);
-        cpu_manager.Pause(false);
         is_paused = false;
 
         return status;
@@ -150,25 +149,22 @@ struct System::Impl {
 
         core_timing.SyncPause(true);
         kernel.Suspend(true);
-        cpu_manager.Pause(true);
         is_paused = true;
 
         return status;
     }
 
-    std::unique_lock<std::mutex> StallCPU() {
+    std::unique_lock<std::mutex> StallProcesses() {
         std::unique_lock<std::mutex> lk(suspend_guard);
         kernel.Suspend(true);
         core_timing.SyncPause(true);
-        cpu_manager.Pause(true);
         return lk;
     }
 
-    void UnstallCPU() {
+    void UnstallProcesses() {
         if (!is_paused) {
             core_timing.SyncPause(false);
             kernel.Suspend(false);
-            cpu_manager.Pause(false);
         }
     }
 
@@ -334,6 +330,8 @@ struct System::Impl {
             gpu_core->NotifyShutdown();
         }
 
+        kernel.ShutdownCores();
+        cpu_manager.Shutdown();
         debugger.reset();
         services.reset();
         service_manager.reset();
@@ -499,12 +497,12 @@ void System::DetachDebugger() {
     }
 }
 
-std::unique_lock<std::mutex> System::StallCPU() {
-    return impl->StallCPU();
+std::unique_lock<std::mutex> System::StallProcesses() {
+    return impl->StallProcesses();
 }
 
-void System::UnstallCPU() {
-    impl->UnstallCPU();
+void System::UnstallProcesses() {
+    impl->UnstallProcesses();
 }
 
 void System::InitializeDebugger() {

src/core/core.h

@@ -163,8 +163,8 @@ public:
     /// Forcibly detach the debugger if it is running.
     void DetachDebugger();
 
-    std::unique_lock<std::mutex> StallCPU();
-    void UnstallCPU();
+    std::unique_lock<std::mutex> StallProcesses();
+    void UnstallProcesses();
 
     /**
      * Initialize the debugger.

src/core/core_timing.cpp

@@ -6,7 +6,9 @@
 #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"
@@ -20,10 +22,11 @@ std::shared_ptr<EventType> CreateEvent(std::string name, TimedCallback&& callbac
 }
 
 struct CoreTiming::Event {
-    u64 time;
+    s64 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
@@ -41,11 +44,11 @@ CoreTiming::CoreTiming()
 
 CoreTiming::~CoreTiming() = default;
 
-void CoreTiming::ThreadEntry(CoreTiming& instance) {
-    constexpr char name[] = "yuzu:HostTiming";
-    MicroProfileOnThreadCreate(name);
-    Common::SetCurrentThreadName(name);
-    Common::SetCurrentThreadPriority(Common::ThreadPriority::VeryHigh);
+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);
     instance.on_thread_init();
     instance.ThreadLoop();
     MicroProfileOnThreadExit();
@@ -56,71 +59,131 @@ 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, std::chrono::nanoseconds) {};
+    const auto empty_timed_callback = [](std::uintptr_t, u64, std::chrono::nanoseconds)
+        -> std::optional<std::chrono::nanoseconds> { return std::nullopt; };
     ev_lost = CreateEvent("_lost_event", empty_timed_callback);
     if (is_multicore) {
-        timer_thread = std::make_unique<std::thread>(ThreadEntry, std::ref(*this));
+        worker_threads.emplace_back(ThreadEntry, std::ref(*this), 0);
     }
 }
 
 void CoreTiming::Shutdown() {
-    paused = true;
+    is_paused = true;
     shutting_down = true;
-    pause_event.Set();
-    event.Set();
-    if (timer_thread) {
-        timer_thread->join();
+    std::atomic_thread_fence(std::memory_order_release);
+
+    event_cv.notify_all();
+    wait_pause_cv.notify_all();
+    for (auto& thread : worker_threads) {
+        thread.join();
     }
+    worker_threads.clear();
+    pause_callbacks.clear();
     ClearPendingEvents();
-    timer_thread.reset();
     has_started = false;
 }
 
-void CoreTiming::Pause(bool is_paused) {
-    paused = is_paused;
-    pause_event.Set();
-}
-
-void CoreTiming::SyncPause(bool is_paused) {
-    if (is_paused == paused && paused_set == paused) {
+void CoreTiming::Pause(bool is_paused_) {
+    std::unique_lock main_lock(event_mutex);
+    if (is_paused_ == paused_state.load(std::memory_order_relaxed)) {
         return;
     }
-    Pause(is_paused);
-    if (timer_thread) {
-        if (!is_paused) {
-            pause_event.Set();
+    if (is_multicore) {
+        is_paused = is_paused_;
+        event_cv.notify_all();
+        if (!is_paused_) {
+            wait_pause_cv.notify_all();
         }
-        event.Set();
-        while (paused_set != is_paused)
-            ;
+    }
+    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::SyncPause(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_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_);
     }
 }
 
 bool CoreTiming::IsRunning() const {
-    return !paused_set;
+    return !paused_state.load(std::memory_order_acquire);
 }
 
 bool CoreTiming::HasPendingEvents() const {
-    return !(wait_set && event_queue.empty());
+    std::unique_lock main_lock(event_mutex);
+    return !event_queue.empty() || pending_events.load(std::memory_order_relaxed) != 0;
 }
 
 void CoreTiming::ScheduleEvent(std::chrono::nanoseconds ns_into_future,
                                const std::shared_ptr<EventType>& event_type,
-                               std::uintptr_t user_data) {
-    {
-        std::scoped_lock scope{basic_lock};
-        const u64 timeout = static_cast<u64>((GetGlobalTimeNs() + ns_into_future).count());
+                               std::uintptr_t user_data, bool absolute_time) {
 
-        event_queue.emplace_back(Event{timeout, event_fifo_id++, user_data, event_type});
+    std::unique_lock main_lock(event_mutex);
+    const auto next_time{absolute_time ? ns_into_future : GetGlobalTimeNs() + ns_into_future};
 
-        std::push_heap(event_queue.begin(), event_queue.end(), std::greater<>());
+    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();
     }
-    event.Set();
 }
 
 void CoreTiming::UnscheduleEvent(const std::shared_ptr<EventType>& event_type,
                                  std::uintptr_t user_data) {
-    std::scoped_lock scope{basic_lock};
+    std::unique_lock main_lock(event_mutex);
     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;
     });
@@ -129,6 +192,7 @@ 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);
     }
 }
 
@@ -168,11 +232,12 @@ 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::scoped_lock lock{basic_lock};
+    std::unique_lock main_lock(event_mutex);
 
     const auto itr = std::remove_if(event_queue.begin(), event_queue.end(), [&](const Event& e) {
         return e.type.lock().get() == event_type.get();
@@ -185,22 +250,48 @@ 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_type->callback(
-                evt.user_data, std::chrono::nanoseconds{static_cast<s64>(global_timer - evt.time)});
+            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<>());
+            }
         }
 
-        basic_lock.lock();
         global_timer = GetGlobalTimeNs().count();
     }
 
@@ -213,26 +304,34 @@ 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 (!paused) {
-            paused_set = false;
+        while (!is_paused && !shutting_down) {
             const auto next_time = Advance();
             if (next_time) {
                 if (*next_time > 0) {
                     std::chrono::nanoseconds next_time_ns = std::chrono::nanoseconds(*next_time);
-                    event.WaitFor(next_time_ns);
+                    std::unique_lock main_lock(event_mutex);
+                    event_cv.wait_for(main_lock, next_time_ns, predicate);
                 }
             } else {
-                wait_set = true;
-                event.Wait();
+                std::unique_lock main_lock(event_mutex);
+                event_cv.wait(main_lock, predicate);
             }
-            wait_set = false;
         }
-        paused_set = true;
-        clock->Pause(true);
-        pause_event.Wait();
-        clock->Pause(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();
+        }
     }
 }
 

src/core/core_timing.h

@@ -5,6 +5,7 @@
 
 #include <atomic>
 #include <chrono>
+#include <condition_variable>
 #include <functional>
 #include <memory>
 #include <mutex>
@@ -14,14 +15,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<void(std::uintptr_t user_data, std::chrono::nanoseconds ns_late)>;
+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)>;
 
 /// Contains the characteristics of a particular event.
 struct EventType {
@@ -93,7 +94,15 @@ 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);
+                       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);
 
     void UnscheduleEvent(const std::shared_ptr<EventType>& event_type, std::uintptr_t user_data);
 
@@ -125,18 +134,21 @@ 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);
+    static void ThreadEntry(CoreTiming& instance, size_t id);
     void ThreadLoop();
 
     std::unique_ptr<Common::WallClock> clock;
 
-    u64 global_timer = 0;
+    s64 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
@@ -144,25 +156,31 @@ 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.

src/core/cpu_manager.cpp

@@ -16,83 +16,57 @@
 
 namespace Core {
 
-CpuManager::CpuManager(System& system_)
-    : pause_barrier{std::make_unique<Common::Barrier>(1)}, system{system_} {}
+CpuManager::CpuManager(System& system_) : system{system_} {}
 CpuManager::~CpuManager() = default;
 
 void CpuManager::ThreadStart(std::stop_token stop_token, CpuManager& cpu_manager,
                              std::size_t core) {
-    cpu_manager.RunThread(stop_token, core);
+    cpu_manager.RunThread(core);
 }
 
 void CpuManager::Initialize() {
-    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);
-        }
-        pause_barrier = std::make_unique<Common::Barrier>(Core::Hardware::NUM_CPU_CORES + 1);
-    } else {
-        core_data[0].host_thread = std::jthread(ThreadStart, std::ref(*this), 0);
-        pause_barrier = std::make_unique<Common::Barrier>(2);
+    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);
     }
 }
 
 void CpuManager::Shutdown() {
-    running_mode = false;
-    Pause(false);
-}
-
-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 {
-        cpu_manager->SingleCoreRunGuestThread();
+    for (std::size_t core = 0; core < num_cores; core++) {
+        if (core_data[core].host_thread.joinable()) {
+            core_data[core].host_thread.join();
+        }
     }
 }
 
-void CpuManager::GuestRewindFunction(void* cpu_manager_) {
-    CpuManager* cpu_manager = static_cast<CpuManager*>(cpu_manager_);
-    if (cpu_manager->is_multicore) {
-        cpu_manager->MultiCoreRunGuestLoop();
+void CpuManager::GuestThreadFunction() {
+    if (is_multicore) {
+        MultiCoreRunGuestThread();
     } else {
-        cpu_manager->SingleCoreRunGuestLoop();
+        SingleCoreRunGuestThread();
     }
 }
 
-void CpuManager::IdleThreadFunction(void* cpu_manager_) {
-    CpuManager* cpu_manager = static_cast<CpuManager*>(cpu_manager_);
-    if (cpu_manager->is_multicore) {
-        cpu_manager->MultiCoreRunIdleThread();
+void CpuManager::GuestRewindFunction() {
+    if (is_multicore) {
+        MultiCoreRunGuestLoop();
     } else {
-        cpu_manager->SingleCoreRunIdleThread();
+        SingleCoreRunGuestLoop();
     }
 }
 
-void CpuManager::SuspendThreadFunction(void* cpu_manager_) {
-    CpuManager* cpu_manager = static_cast<CpuManager*>(cpu_manager_);
-    if (cpu_manager->is_multicore) {
-        cpu_manager->MultiCoreRunSuspendThread();
+void CpuManager::IdleThreadFunction() {
+    if (is_multicore) {
+        MultiCoreRunIdleThread();
     } else {
-        cpu_manager->SingleCoreRunSuspendThread();
+        SingleCoreRunIdleThread();
     }
 }
 
-void* CpuManager::GetStartFuncParamater() {
-    return static_cast<void*>(this);
+void CpuManager::ShutdownThreadFunction() {
+    ShutdownThread();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -102,9 +76,9 @@ void* CpuManager::GetStartFuncParamater() {
 void CpuManager::MultiCoreRunGuestThread() {
     auto& kernel = system.Kernel();
     kernel.CurrentScheduler()->OnThreadStart();
-    auto* thread = kernel.CurrentScheduler()->GetCurrentThread();
+    auto* thread = kernel.CurrentScheduler()->GetSchedulerCurrentThread();
     auto& host_context = thread->GetHostContext();
-    host_context->SetRewindPoint(GuestRewindFunction, this);
+    host_context->SetRewindPoint([this] { GuestRewindFunction(); });
     MultiCoreRunGuestLoop();
 }
 
@@ -113,12 +87,10 @@ 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();
@@ -134,21 +106,6 @@ 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();
-        current_thread->DisableDispatch();
-
-        Common::Fiber::YieldTo(current_thread->GetHostContext(), *core_data[core].host_context);
-        ASSERT(core == kernel.CurrentPhysicalCoreIndex());
-        scheduler.RescheduleCurrentCore();
-    }
-}
-
 ///////////////////////////////////////////////////////////////////////////////
 ///                             SingleCore                                   ///
 ///////////////////////////////////////////////////////////////////////////////
@@ -156,9 +113,9 @@ void CpuManager::MultiCoreRunSuspendThread() {
 void CpuManager::SingleCoreRunGuestThread() {
     auto& kernel = system.Kernel();
     kernel.CurrentScheduler()->OnThreadStart();
-    auto* thread = kernel.CurrentScheduler()->GetCurrentThread();
+    auto* thread = kernel.CurrentScheduler()->GetSchedulerCurrentThread();
     auto& host_context = thread->GetHostContext();
-    host_context->SetRewindPoint(GuestRewindFunction, this);
+    host_context->SetRewindPoint([this] { GuestRewindFunction(); });
     SingleCoreRunGuestLoop();
 }
 
@@ -166,12 +123,10 @@ 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);
@@ -194,26 +149,11 @@ 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();
-        current_thread->DisableDispatch();
-
-        Common::Fiber::YieldTo(current_thread->GetHostContext(), *core_data[0].host_context);
-        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.GetCurrentThread();
+        Kernel::KThread* current_thread = scheduler.GetSchedulerCurrentThread();
         if (idle_count >= 4 || from_running_enviroment) {
             if (!from_running_enviroment) {
                 system.CoreTiming().Idle();
@@ -225,7 +165,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.GetCurrentThread());
+        scheduler.Unload(scheduler.GetSchedulerCurrentThread());
 
         auto& next_scheduler = kernel.Scheduler(current_core);
         Common::Fiber::YieldTo(current_thread->GetHostContext(), *next_scheduler.ControlContext());
@@ -234,31 +174,23 @@ void CpuManager::PreemptSingleCore(bool from_running_enviroment) {
     // May have changed scheduler
     {
         auto& scheduler = system.Kernel().Scheduler(current_core);
-        scheduler.Reload(scheduler.GetCurrentThread());
+        scheduler.Reload(scheduler.GetSchedulerCurrentThread());
         if (!scheduler.IsIdle()) {
             idle_count = 0;
         }
     }
 }
 
-void CpuManager::Pause(bool paused) {
-    std::scoped_lock lk{pause_lock};
+void CpuManager::ShutdownThread() {
+    auto& kernel = system.Kernel();
+    auto core = is_multicore ? kernel.CurrentPhysicalCoreIndex() : 0;
+    auto* current_thread = kernel.GetCurrentEmuThread();
 
-    if (pause_state == paused) {
-        return;
-    }
-
-    // Set the new state
-    pause_state.store(paused);
-
-    // Wake up any waiting threads
-    pause_state.notify_all();
-
-    // Wait for all threads to successfully change state before returning
-    pause_barrier->Sync();
+    Common::Fiber::YieldTo(current_thread->GetHostContext(), *core_data[core].host_context);
+    UNREACHABLE();
 }
 
-void CpuManager::RunThread(std::stop_token stop_token, std::size_t core) {
+void CpuManager::RunThread(std::size_t core) {
     /// Initialization
     system.RegisterCoreThread(core);
     std::string name;
@@ -272,8 +204,6 @@ void CpuManager::RunThread(std::stop_token stop_token, std::size_t core) {
     Common::SetCurrentThreadPriority(Common::ThreadPriority::High);
     auto& data = core_data[core];
     data.host_context = Common::Fiber::ThreadToFiber();
-    const bool sc_sync = !is_async_gpu && !is_multicore;
-    bool sc_sync_first_use = sc_sync;
 
     // Cleanup
     SCOPE_EXIT({
@@ -281,32 +211,16 @@ void CpuManager::RunThread(std::stop_token stop_token, std::size_t core) {
         MicroProfileOnThreadExit();
     });
 
-    /// Running
-    while (running_mode) {
-        if (pause_state.load(std::memory_order_relaxed)) {
-            // Wait for caller to acknowledge pausing
-            pause_barrier->Sync();
+    // Running
+    gpu_barrier->Sync();
 
-            // Wait until unpaused
-            pause_state.wait(true, std::memory_order_relaxed);
-
-            // Wait for caller to acknowledge unpausing
-            pause_barrier->Sync();
-        }
-
-        if (sc_sync_first_use) {
-            system.GPU().ObtainContext();
-            sc_sync_first_use = false;
-        }
-
-        // Emulation was stopped
-        if (stop_token.stop_requested()) {
-            return;
-        }
-
-        auto current_thread = system.Kernel().CurrentScheduler()->GetCurrentThread();
-        Common::Fiber::YieldTo(data.host_context, *current_thread->GetHostContext());
+    if (!is_async_gpu && !is_multicore) {
+        system.GPU().ObtainContext();
     }
+
+    auto* current_thread = system.Kernel().CurrentScheduler()->GetIdleThread();
+    Kernel::SetCurrentThread(system.Kernel(), current_thread);
+    Common::Fiber::YieldTo(data.host_context, *current_thread->GetHostContext());
 }
 
 } // namespace Core

src/core/cpu_manager.h

@@ -43,15 +43,22 @@ public:
         is_async_gpu = is_async;
     }
 
+    void OnGpuReady() {
+        gpu_barrier->Sync();
+    }
+
     void Initialize();
     void Shutdown();
 
-    void Pause(bool paused);
-
-    static std::function<void(void*)> GetGuestThreadStartFunc();
-    static std::function<void(void*)> GetIdleThreadStartFunc();
-    static std::function<void(void*)> GetSuspendThreadStartFunc();
-    void* GetStartFuncParamater();
+    std::function<void()> GetGuestThreadStartFunc() {
+        return [this] { GuestThreadFunction(); };
+    }
+    std::function<void()> GetIdleThreadStartFunc() {
+        return [this] { IdleThreadFunction(); };
+    }
+    std::function<void()> GetShutdownThreadStartFunc() {
+        return [this] { ShutdownThreadFunction(); };
+    }
 
     void PreemptSingleCore(bool from_running_enviroment = true);
 
@@ -60,41 +67,37 @@ public:
     }
 
 private:
-    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 GuestThreadFunction();
+    void GuestRewindFunction();
+    void IdleThreadFunction();
+    void ShutdownThreadFunction();
 
     void MultiCoreRunGuestThread();
     void MultiCoreRunGuestLoop();
     void MultiCoreRunIdleThread();
-    void MultiCoreRunSuspendThread();
 
     void SingleCoreRunGuestThread();
     void SingleCoreRunGuestLoop();
     void SingleCoreRunIdleThread();
-    void SingleCoreRunSuspendThread();
 
     static void ThreadStart(std::stop_token stop_token, CpuManager& cpu_manager, std::size_t core);
 
-    void RunThread(std::stop_token stop_token, std::size_t core);
+    void ShutdownThread();
+    void RunThread(std::size_t core);
 
     struct CoreData {
         std::shared_ptr<Common::Fiber> host_context;
         std::jthread host_thread;
     };
 
-    std::atomic<bool> running_mode{};
-    std::atomic<bool> pause_state{};
-    std::unique_ptr<Common::Barrier> pause_barrier{};
-    std::mutex pause_lock{};
-
+    std::unique_ptr<Common::Barrier> gpu_barrier{};
     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;

src/core/debugger/debugger.cpp

@@ -44,12 +44,14 @@ static std::span<const u8> ReceiveInto(Readable& r, Buffer& buffer) {
 
 enum class SignalType {
     Stopped,
+    Watchpoint,
     ShuttingDown,
 };
 
 struct SignalInfo {
     SignalType type;
     Kernel::KThread* thread;
+    const Kernel::DebugWatchpoint* watchpoint;
 };
 
 namespace Core {
@@ -67,18 +69,20 @@ public:
     }
 
     bool SignalDebugger(SignalInfo signal_info) {
-        std::scoped_lock lk{connection_lock};
+        {
+            std::scoped_lock lk{connection_lock};
 
-        if (stopped) {
-            // Do not notify the debugger about another event.
-            // It should be ignored.
-            return false;
+            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;
         }
 
-        // Set up the state.
-        stopped = true;
-        info = signal_info;
-
         // Write a single byte into the pipe to wake up the debug interface.
         boost::asio::write(signal_pipe, boost::asio::buffer(&stopped, sizeof(stopped)));
         return true;
@@ -141,9 +145,6 @@ private:
         AsyncReceiveInto(signal_pipe, pipe_data, [&](auto d) { PipeData(d); });
         AsyncReceiveInto(client_socket, client_data, [&](auto d) { ClientData(d); });
 
-        // Stop the emulated CPU.
-        AllCoreStop();
-
         // Set the active thread.
         UpdateActiveThread();
 
@@ -158,20 +159,25 @@ private:
     void PipeData(std::span<const u8> data) {
         switch (info.type) {
         case SignalType::Stopped:
+        case SignalType::Watchpoint:
             // Stop emulation.
-            AllCoreStop();
+            PauseEmulation();
 
             // Notify the client.
             active_thread = info.thread;
             UpdateActiveThread();
-            frontend->Stopped(active_thread);
+
+            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.
-            suspend.reset();
             signal_pipe.close();
             client_socket.shutdown(boost::asio::socket_base::shutdown_both);
             LOG_INFO(Debug_GDBStub, "Shut down server");
@@ -189,32 +195,29 @@ private:
                     std::scoped_lock lk{connection_lock};
                     stopped = true;
                 }
-                AllCoreStop();
+                PauseEmulation();
                 UpdateActiveThread();
                 frontend->Stopped(active_thread);
                 break;
             }
             case DebuggerAction::Continue:
-                active_thread->SetStepState(Kernel::StepState::NotStepping);
-                ResumeInactiveThreads();
-                AllCoreResume();
+                MarkResumed([&] { ResumeEmulation(); });
                 break;
             case DebuggerAction::StepThreadUnlocked:
-                active_thread->SetStepState(Kernel::StepState::StepPending);
-                ResumeInactiveThreads();
-                AllCoreResume();
+                MarkResumed([&] {
+                    active_thread->SetStepState(Kernel::StepState::StepPending);
+                    active_thread->Resume(Kernel::SuspendType::Debug);
+                    ResumeEmulation(active_thread);
+                });
                 break;
-            case DebuggerAction::StepThreadLocked:
-                active_thread->SetStepState(Kernel::StepState::StepPending);
-                SuspendInactiveThreads();
-                AllCoreResume();
+            case DebuggerAction::StepThreadLocked: {
+                MarkResumed([&] {
+                    active_thread->SetStepState(Kernel::StepState::StepPending);
+                    active_thread->Resume(Kernel::SuspendType::Debug);
+                });
                 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};
@@ -226,33 +229,33 @@ private:
         }
     }
 
-    void AllCoreStop() {
-        if (!suspend) {
-            suspend = system.StallCPU();
+    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 AllCoreResume() {
+    template <typename Callback>
+    void MarkResumed(Callback&& cb) {
+        std::scoped_lock lk{connection_lock};
         stopped = false;
-        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);
-            }
-        }
+        cb();
     }
 
     void UpdateActiveThread() {
@@ -260,8 +263,6 @@ 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() {
@@ -277,7 +278,6 @@ 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;
@@ -298,12 +298,17 @@ Debugger::Debugger(Core::System& system, u16 port) {
 Debugger::~Debugger() = default;
 
 bool Debugger::NotifyThreadStopped(Kernel::KThread* thread) {
-    return impl && impl->SignalDebugger(SignalInfo{SignalType::Stopped, 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});
+        impl->SignalDebugger(SignalInfo{SignalType::ShuttingDown, nullptr, nullptr});
     }
 }
 

src/core/debugger/debugger.h

@@ -9,7 +9,8 @@
 
 namespace Kernel {
 class KThread;
-}
+struct DebugWatchpoint;
+} // namespace Kernel
 
 namespace Core {
 class System;
@@ -40,6 +41,11 @@ public:
      */
     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;
 };

src/core/debugger/debugger_interface.h

@@ -11,7 +11,8 @@
 
 namespace Kernel {
 class KThread;
-}
+struct DebugWatchpoint;
+} // namespace Kernel
 
 namespace Core {
 
@@ -71,6 +72,11 @@ public:
      */
     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.

src/core/debugger/gdbstub.cpp

@@ -112,6 +112,23 @@ 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());
@@ -235,6 +252,7 @@ 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': {
@@ -278,44 +296,124 @@ void GDBStub::ExecuteCommand(std::string_view packet, std::vector<DebuggerAction
     case 'c':
         actions.push_back(DebuggerAction::Continue);
         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))};
-
-        if (system.Memory().IsValidVirtualAddress(addr)) {
-            replaced_instructions[addr] = system.Memory().Read32(addr);
-            system.Memory().Write32(addr, arch->BreakpointInstruction());
-            system.InvalidateCpuInstructionCacheRange(addr, sizeof(u32));
-
-            SendReply(GDB_STUB_REPLY_OK);
-        } else {
-            SendReply(GDB_STUB_REPLY_ERR);
-        }
+    case 'Z':
+        HandleBreakpointInsert(command);
         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))};
-
-        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);
-        }
+    case 'z':
+        HandleBreakpointRemove(command);
         break;
-    }
     default:
         SendReply(GDB_STUB_REPLY_EMPTY);
         break;
     }
 }
 
+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);
+            system.InvalidateCpuInstructionCacheRange(addr, sizeof(u32));
+            replaced_instructions.erase(addr);
+            success = true;
+        }
+        break;
+    }
+    case BreakpointType::WriteWatch:
+        success = system.CurrentProcess()->RemoveWatchpoint(system, addr, size,
+                                                            Kernel::DebugWatchpointType::Write);
+        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);
+    }
+}
+
 // Structure offsets are from Atmosphere
 // See osdbg_thread_local_region.os.horizon.hpp and osdbg_thread_type.os.horizon.hpp
 

src/core/debugger/gdbstub.h

@@ -24,6 +24,7 @@ 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:
@@ -31,6 +32,8 @@ 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);

src/core/debugger/gdbstub_arch.cpp

@@ -191,8 +191,10 @@ 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) {
@@ -215,8 +217,10 @@ 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) {

src/core/file_sys/errors.h

@@ -8,14 +8,14 @@
 
 namespace FileSys {
 
-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};
+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};
 
 } // namespace FileSys

src/core/frontend/applets/error.cpp

@@ -8,12 +8,12 @@ namespace Core::Frontend {
 
 ErrorApplet::~ErrorApplet() = default;
 
-void DefaultErrorApplet::ShowError(ResultCode error, std::function<void()> finished) const {
+void DefaultErrorApplet::ShowError(Result error, std::function<void()> finished) const {
     LOG_CRITICAL(Service_Fatal, "Application requested error display: {:04}-{:04} (raw={:08X})",
                  error.module.Value(), error.description.Value(), error.raw);
 }
 
-void DefaultErrorApplet::ShowErrorWithTimestamp(ResultCode error, std::chrono::seconds time,
+void DefaultErrorApplet::ShowErrorWithTimestamp(Result error, std::chrono::seconds time,
                                                 std::function<void()> finished) const {
     LOG_CRITICAL(
         Service_Fatal,
@@ -21,7 +21,7 @@ void DefaultErrorApplet::ShowErrorWithTimestamp(ResultCode error, std::chrono::s
         error.module.Value(), error.description.Value(), error.raw, time.count());
 }
 
-void DefaultErrorApplet::ShowCustomErrorText(ResultCode error, std::string main_text,
+void DefaultErrorApplet::ShowCustomErrorText(Result error, std::string main_text,
                                              std::string detail_text,
                                              std::function<void()> finished) const {
     LOG_CRITICAL(Service_Fatal,

src/core/frontend/applets/error.h

@@ -14,22 +14,22 @@ class ErrorApplet {
 public:
     virtual ~ErrorApplet();
 
-    virtual void ShowError(ResultCode error, std::function<void()> finished) const = 0;
+    virtual void ShowError(Result error, std::function<void()> finished) const = 0;
 
-    virtual void ShowErrorWithTimestamp(ResultCode error, std::chrono::seconds time,
+    virtual void ShowErrorWithTimestamp(Result error, std::chrono::seconds time,
                                         std::function<void()> finished) const = 0;
 
-    virtual void ShowCustomErrorText(ResultCode error, std::string dialog_text,
+    virtual void ShowCustomErrorText(Result error, std::string dialog_text,
                                      std::string fullscreen_text,
                                      std::function<void()> finished) const = 0;
 };
 
 class DefaultErrorApplet final : public ErrorApplet {
 public:
-    void ShowError(ResultCode error, std::function<void()> finished) const override;
-    void ShowErrorWithTimestamp(ResultCode error, std::chrono::seconds time,
+    void ShowError(Result error, std::function<void()> finished) const override;
+    void ShowErrorWithTimestamp(Result error, std::chrono::seconds time,
                                 std::function<void()> finished) const override;
-    void ShowCustomErrorText(ResultCode error, std::string main_text, std::string detail_text,
+    void ShowCustomErrorText(Result error, std::string main_text, std::string detail_text,
                              std::function<void()> finished) const override;
 };
 

src/core/hardware_interrupt_manager.cpp

@@ -11,11 +11,14 @@ namespace Core::Hardware {
 
 InterruptManager::InterruptManager(Core::System& system_in) : system(system_in) {
     gpu_interrupt_event = Core::Timing::CreateEvent(
-        "GPUInterrupt", [this](std::uintptr_t message, std::chrono::nanoseconds) {
+        "GPUInterrupt",
+        [this](std::uintptr_t message, u64 time,
+               std::chrono::nanoseconds) -> std::optional<std::chrono::nanoseconds> {
             auto nvdrv = system.ServiceManager().GetService<Service::Nvidia::NVDRV>("nvdrv");
             const u32 syncpt = static_cast<u32>(message >> 32);
             const u32 value = static_cast<u32>(message);
             nvdrv->SignalGPUInterruptSyncpt(syncpt, value);
+            return std::nullopt;
         });
 }
 

src/core/hardware_properties.h

@@ -25,6 +25,9 @@ constexpr std::array<s32, Common::BitSize<u64>()> VirtualToPhysicalCoreMap{
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3,
 };
 
+// Cortex-A57 supports 4 memory watchpoints
+constexpr u64 NUM_WATCHPOINTS = 4;
+
 } // namespace Hardware
 
 } // namespace Core

src/core/hid/hid_types.h

@@ -272,6 +272,7 @@ enum class VibrationDeviceType : u32 {
     Unknown = 0,
     LinearResonantActuator = 1,
     GcErm = 2,
+    N64 = 3,
 };
 
 // This is nn::hid::VibrationGcErmCommand

src/core/hle/ipc_helpers.h

@@ -19,7 +19,7 @@
 
 namespace IPC {
 
-constexpr ResultCode ERR_REMOTE_PROCESS_DEAD{ErrorModule::HIPC, 301};
+constexpr Result ERR_REMOTE_PROCESS_DEAD{ErrorModule::HIPC, 301};
 
 class RequestHelperBase {
 protected:
@@ -176,7 +176,7 @@ public:
     void PushImpl(float value);
     void PushImpl(double value);
     void PushImpl(bool value);
-    void PushImpl(ResultCode value);
+    void PushImpl(Result value);
 
     template <typename T>
     void Push(T value) {
@@ -251,7 +251,7 @@ void ResponseBuilder::PushRaw(const T& value) {
     index += (sizeof(T) + 3) / 4; // round up to word length
 }
 
-inline void ResponseBuilder::PushImpl(ResultCode value) {
+inline void ResponseBuilder::PushImpl(Result value) {
     // Result codes are actually 64-bit in the IPC buffer, but only the high part is discarded.
     Push(value.raw);
     Push<u32>(0);
@@ -481,8 +481,8 @@ inline bool RequestParser::Pop() {
 }
 
 template <>
-inline ResultCode RequestParser::Pop() {
-    return ResultCode{Pop<u32>()};
+inline Result RequestParser::Pop() {
+    return Result{Pop<u32>()};
 }
 
 template <typename T>

src/core/hle/kernel/hle_ipc.cpp

@@ -188,8 +188,8 @@ void HLERequestContext::ParseCommandBuffer(const KHandleTable& handle_table, u32
     rp.Skip(1, false); // The command is actually an u64, but we don't use the high part.
 }
 
-ResultCode HLERequestContext::PopulateFromIncomingCommandBuffer(const KHandleTable& handle_table,
-                                                                u32_le* src_cmdbuf) {
+Result HLERequestContext::PopulateFromIncomingCommandBuffer(const KHandleTable& handle_table,
+                                                            u32_le* src_cmdbuf) {
     ParseCommandBuffer(handle_table, src_cmdbuf, true);
 
     if (command_header->IsCloseCommand()) {
@@ -202,7 +202,7 @@ ResultCode HLERequestContext::PopulateFromIncomingCommandBuffer(const KHandleTab
     return ResultSuccess;
 }
 
-ResultCode HLERequestContext::WriteToOutgoingCommandBuffer(KThread& requesting_thread) {
+Result HLERequestContext::WriteToOutgoingCommandBuffer(KThread& requesting_thread) {
     auto current_offset = handles_offset;
     auto& owner_process = *requesting_thread.GetOwnerProcess();
     auto& handle_table = owner_process.GetHandleTable();

src/core/hle/kernel/hle_ipc.h

@@ -18,7 +18,7 @@
 #include "core/hle/ipc.h"
 #include "core/hle/kernel/svc_common.h"
 
-union ResultCode;
+union Result;
 
 namespace Core::Memory {
 class Memory;
@@ -71,10 +71,10 @@ public:
      * it should be used to differentiate which client (As in ClientSession) we're answering to.
      * TODO(Subv): Use a wrapper structure to hold all the information relevant to
      * this request (ServerSession, Originator thread, Translated command buffer, etc).
-     * @returns ResultCode the result code of the translate operation.
+     * @returns Result the result code of the translate operation.
      */
-    virtual ResultCode HandleSyncRequest(Kernel::KServerSession& session,
-                                         Kernel::HLERequestContext& context) = 0;
+    virtual Result HandleSyncRequest(Kernel::KServerSession& session,
+                                     Kernel::HLERequestContext& context) = 0;
 
     /**
      * Signals that a client has just connected to this HLE handler and keeps the
@@ -212,11 +212,10 @@ public:
     }
 
     /// Populates this context with data from the requesting process/thread.
-    ResultCode PopulateFromIncomingCommandBuffer(const KHandleTable& handle_table,
-                                                 u32_le* src_cmdbuf);
+    Result PopulateFromIncomingCommandBuffer(const KHandleTable& handle_table, u32_le* src_cmdbuf);
 
     /// Writes data from this context back to the requesting process/thread.
-    ResultCode WriteToOutgoingCommandBuffer(KThread& requesting_thread);
+    Result WriteToOutgoingCommandBuffer(KThread& requesting_thread);
 
     u32_le GetHipcCommand() const {
         return command;

src/core/hle/kernel/k_address_arbiter.cpp

@@ -90,8 +90,7 @@ public:
     explicit ThreadQueueImplForKAddressArbiter(KernelCore& kernel_, KAddressArbiter::ThreadTree* t)
         : KThreadQueue(kernel_), m_tree(t) {}
 
-    void CancelWait(KThread* waiting_thread, ResultCode wait_result,
-                    bool cancel_timer_task) override {
+    void CancelWait(KThread* waiting_thread, Result wait_result, bool cancel_timer_task) override {
         // If the thread is waiting on an address arbiter, remove it from the tree.
         if (waiting_thread->IsWaitingForAddressArbiter()) {
             m_tree->erase(m_tree->iterator_to(*waiting_thread));
@@ -108,7 +107,7 @@ private:
 
 } // namespace
 
-ResultCode KAddressArbiter::Signal(VAddr addr, s32 count) {
+Result KAddressArbiter::Signal(VAddr addr, s32 count) {
     // Perform signaling.
     s32 num_waiters{};
     {
@@ -131,7 +130,7 @@ ResultCode KAddressArbiter::Signal(VAddr addr, s32 count) {
     return ResultSuccess;
 }
 
-ResultCode KAddressArbiter::SignalAndIncrementIfEqual(VAddr addr, s32 value, s32 count) {
+Result KAddressArbiter::SignalAndIncrementIfEqual(VAddr addr, s32 value, s32 count) {
     // Perform signaling.
     s32 num_waiters{};
     {
@@ -164,7 +163,7 @@ ResultCode KAddressArbiter::SignalAndIncrementIfEqual(VAddr addr, s32 value, s32
     return ResultSuccess;
 }
 
-ResultCode KAddressArbiter::SignalAndModifyByWaitingCountIfEqual(VAddr addr, s32 value, s32 count) {
+Result KAddressArbiter::SignalAndModifyByWaitingCountIfEqual(VAddr addr, s32 value, s32 count) {
     // Perform signaling.
     s32 num_waiters{};
     {
@@ -232,9 +231,9 @@ ResultCode KAddressArbiter::SignalAndModifyByWaitingCountIfEqual(VAddr addr, s32
     return ResultSuccess;
 }
 
-ResultCode KAddressArbiter::WaitIfLessThan(VAddr addr, s32 value, bool decrement, s64 timeout) {
+Result KAddressArbiter::WaitIfLessThan(VAddr addr, s32 value, bool decrement, s64 timeout) {
     // Prepare to wait.
-    KThread* cur_thread = kernel.CurrentScheduler()->GetCurrentThread();
+    KThread* cur_thread = GetCurrentThreadPointer(kernel);
     ThreadQueueImplForKAddressArbiter wait_queue(kernel, std::addressof(thread_tree));
 
     {
@@ -285,9 +284,9 @@ ResultCode KAddressArbiter::WaitIfLessThan(VAddr addr, s32 value, bool decrement
     return cur_thread->GetWaitResult();
 }
 
-ResultCode KAddressArbiter::WaitIfEqual(VAddr addr, s32 value, s64 timeout) {
+Result KAddressArbiter::WaitIfEqual(VAddr addr, s32 value, s64 timeout) {
     // Prepare to wait.
-    KThread* cur_thread = kernel.CurrentScheduler()->GetCurrentThread();
+    KThread* cur_thread = GetCurrentThreadPointer(kernel);
     ThreadQueueImplForKAddressArbiter wait_queue(kernel, std::addressof(thread_tree));
 
     {

src/core/hle/kernel/k_address_arbiter.h

@@ -8,7 +8,7 @@
 #include "core/hle/kernel/k_condition_variable.h"
 #include "core/hle/kernel/svc_types.h"
 
-union ResultCode;
+union Result;
 
 namespace Core {
 class System;
@@ -25,8 +25,7 @@ public:
     explicit KAddressArbiter(Core::System& system_);
     ~KAddressArbiter();
 
-    [[nodiscard]] ResultCode SignalToAddress(VAddr addr, Svc::SignalType type, s32 value,
-                                             s32 count) {
+    [[nodiscard]] Result SignalToAddress(VAddr addr, Svc::SignalType type, s32 value, s32 count) {
         switch (type) {
         case Svc::SignalType::Signal:
             return Signal(addr, count);
@@ -39,8 +38,8 @@ public:
         return ResultUnknown;
     }
 
-    [[nodiscard]] ResultCode WaitForAddress(VAddr addr, Svc::ArbitrationType type, s32 value,
-                                            s64 timeout) {
+    [[nodiscard]] Result WaitForAddress(VAddr addr, Svc::ArbitrationType type, s32 value,
+                                        s64 timeout) {
         switch (type) {
         case Svc::ArbitrationType::WaitIfLessThan:
             return WaitIfLessThan(addr, value, false, timeout);
@@ -54,11 +53,11 @@ public:
     }
 
 private:
-    [[nodiscard]] ResultCode Signal(VAddr addr, s32 count);
-    [[nodiscard]] ResultCode SignalAndIncrementIfEqual(VAddr addr, s32 value, s32 count);
-    [[nodiscard]] ResultCode SignalAndModifyByWaitingCountIfEqual(VAddr addr, s32 value, s32 count);
-    [[nodiscard]] ResultCode WaitIfLessThan(VAddr addr, s32 value, bool decrement, s64 timeout);
-    [[nodiscard]] ResultCode WaitIfEqual(VAddr addr, s32 value, s64 timeout);
+    [[nodiscard]] Result Signal(VAddr addr, s32 count);
+    [[nodiscard]] Result SignalAndIncrementIfEqual(VAddr addr, s32 value, s32 count);
+    [[nodiscard]] Result SignalAndModifyByWaitingCountIfEqual(VAddr addr, s32 value, s32 count);
+    [[nodiscard]] Result WaitIfLessThan(VAddr addr, s32 value, bool decrement, s64 timeout);
+    [[nodiscard]] Result WaitIfEqual(VAddr addr, s32 value, s64 timeout);
 
     ThreadTree thread_tree;
 

src/core/hle/kernel/k_client_port.cpp

@@ -59,8 +59,8 @@ bool KClientPort::IsSignaled() const {
     return num_sessions < max_sessions;
 }
 
-ResultCode KClientPort::CreateSession(KClientSession** out,
-                                      std::shared_ptr<SessionRequestManager> session_manager) {
+Result KClientPort::CreateSession(KClientSession** out,
+                                  std::shared_ptr<SessionRequestManager> session_manager) {
     // Reserve a new session from the resource limit.
     KScopedResourceReservation session_reservation(kernel.CurrentProcess()->GetResourceLimit(),
                                                    LimitableResource::Sessions);

src/core/hle/kernel/k_client_port.h

@@ -53,8 +53,8 @@ public:
     void Destroy() override;
     bool IsSignaled() const override;
 
-    ResultCode CreateSession(KClientSession** out,
-                             std::shared_ptr<SessionRequestManager> session_manager = nullptr);
+    Result CreateSession(KClientSession** out,
+                         std::shared_ptr<SessionRequestManager> session_manager = nullptr);
 
 private:
     std::atomic<s32> num_sessions{};

src/core/hle/kernel/k_client_session.cpp

@@ -21,8 +21,8 @@ void KClientSession::Destroy() {
 
 void KClientSession::OnServerClosed() {}
 
-ResultCode KClientSession::SendSyncRequest(KThread* thread, Core::Memory::Memory& memory,
-                                           Core::Timing::CoreTiming& core_timing) {
+Result KClientSession::SendSyncRequest(KThread* thread, Core::Memory::Memory& memory,
+                                       Core::Timing::CoreTiming& core_timing) {
     // Signal the server session that new data is available
     return parent->GetServerSession().HandleSyncRequest(thread, memory, core_timing);
 }

src/core/hle/kernel/k_client_session.h

@@ -9,7 +9,7 @@
 #include "core/hle/kernel/slab_helpers.h"
 #include "core/hle/result.h"
 
-union ResultCode;
+union Result;
 
 namespace Core::Memory {
 class Memory;
@@ -46,8 +46,8 @@ public:
         return parent;
     }
 
-    ResultCode SendSyncRequest(KThread* thread, Core::Memory::Memory& memory,
-                               Core::Timing::CoreTiming& core_timing);
+    Result SendSyncRequest(KThread* thread, Core::Memory::Memory& memory,
+                           Core::Timing::CoreTiming& core_timing);
 
     void OnServerClosed();
 

src/core/hle/kernel/k_code_memory.cpp

@@ -7,7 +7,7 @@
 #include "core/hle/kernel/k_code_memory.h"
 #include "core/hle/kernel/k_light_lock.h"
 #include "core/hle/kernel/k_memory_block.h"
-#include "core/hle/kernel/k_page_linked_list.h"
+#include "core/hle/kernel/k_page_group.h"
 #include "core/hle/kernel/k_page_table.h"
 #include "core/hle/kernel/k_process.h"
 #include "core/hle/kernel/slab_helpers.h"
@@ -19,7 +19,7 @@ namespace Kernel {
 KCodeMemory::KCodeMemory(KernelCore& kernel_)
     : KAutoObjectWithSlabHeapAndContainer{kernel_}, m_lock(kernel_) {}
 
-ResultCode KCodeMemory::Initialize(Core::DeviceMemory& device_memory, VAddr addr, size_t size) {
+Result KCodeMemory::Initialize(Core::DeviceMemory& device_memory, VAddr addr, size_t size) {
     // Set members.
     m_owner = kernel.CurrentProcess();
 
@@ -62,7 +62,7 @@ void KCodeMemory::Finalize() {
     m_owner->Close();
 }
 
-ResultCode KCodeMemory::Map(VAddr address, size_t size) {
+Result KCodeMemory::Map(VAddr address, size_t size) {
     // Validate the size.
     R_UNLESS(m_page_group.GetNumPages() == Common::DivideUp(size, PageSize), ResultInvalidSize);
 
@@ -82,7 +82,7 @@ ResultCode KCodeMemory::Map(VAddr address, size_t size) {
     return ResultSuccess;
 }
 
-ResultCode KCodeMemory::Unmap(VAddr address, size_t size) {
+Result KCodeMemory::Unmap(VAddr address, size_t size) {
     // Validate the size.
     R_UNLESS(m_page_group.GetNumPages() == Common::DivideUp(size, PageSize), ResultInvalidSize);
 
@@ -99,7 +99,7 @@ ResultCode KCodeMemory::Unmap(VAddr address, size_t size) {
     return ResultSuccess;
 }
 
-ResultCode KCodeMemory::MapToOwner(VAddr address, size_t size, Svc::MemoryPermission perm) {
+Result KCodeMemory::MapToOwner(VAddr address, size_t size, Svc::MemoryPermission perm) {
     // Validate the size.
     R_UNLESS(m_page_group.GetNumPages() == Common::DivideUp(size, PageSize), ResultInvalidSize);
 
@@ -133,7 +133,7 @@ ResultCode KCodeMemory::MapToOwner(VAddr address, size_t size, Svc::MemoryPermis
     return ResultSuccess;
 }
 
-ResultCode KCodeMemory::UnmapFromOwner(VAddr address, size_t size) {
+Result KCodeMemory::UnmapFromOwner(VAddr address, size_t size) {
     // Validate the size.
     R_UNLESS(m_page_group.GetNumPages() == Common::DivideUp(size, PageSize), ResultInvalidSize);