Draft: trying to tweak ZL/ZR triggering

This is related to Issue 9096

.github/ISSUE_TEMPLATE/blank_issue_template.yml

@@ -1,10 +0,0 @@
-name: New Issue (Developers Only)
-description: A blank issue template for developers only. If you are not a developer, do not use this issue template. Your issue WILL BE CLOSED if you do not use the appropriate issue template.
-body:
-  - type: markdown
-    attributes:
-      value: |
-        **If you are not a developer, do not use this issue template. Your issue WILL BE CLOSED if you do not use the appropriate issue template.**
-  - type: textarea
-    attributes:
-      label: "Issue"

.github/ISSUE_TEMPLATE/bug-report-feature-request.md

@@ -0,0 +1,39 @@
+---
+name: Bug Report / Feature Request
+about: Tech support does not belong here. You should only file an issue here if you think you have experienced an actual bug with yuzu or you are requesting a feature you believe would make yuzu better.
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+<!---
+Please keep in mind yuzu is EXPERIMENTAL SOFTWARE.
+
+Please read the FAQ:
+https://yuzu-emu.org/wiki/faq/
+
+THIS IS NOT A SUPPORT FORUM, FOR SUPPORT GO TO:
+https://community.citra-emu.org/
+
+If the FAQ does not answer your question, please go to:
+https://community.citra-emu.org/
+
+When submitting an issue, please check the following:
+
+- You have read the above.
+- You have provided the version (commit hash) of yuzu you are using.
+- You have provided sufficient detail for the issue to be reproduced.
+- You have provided system specs (if relevant).
+- Please also provide:
+  - For any issues, a log file
+  - For crashes, a backtrace.
+  - For graphical issues, comparison screenshots with real hardware.
+  - For emulation inaccuracies, a test-case (if able).
+
+-->
+
+
+
+
+

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -1,64 +0,0 @@
-name: Bug Report
-description: File a bug report
-body:
-  - type: markdown
-    attributes:
-      value: Tech support does not belong here. You should only file an issue here if you think you have experienced an actual bug with yuzu.
-  - type: checkboxes
-    attributes:
-      label: Is there an existing issue for this?
-      description: Please search to see if an issue already exists for the bug you encountered.
-      options:
-      - label: I have searched the existing issues
-        required: true
-  - type: input
-    attributes:
-      label: Affected Build(s)
-      description: List the affected build(s) that this issue applies to.
-      placeholder: Mainline 1234 / Early Access 1234
-    validations:
-      required: true
-  - type: textarea
-    id: issue-desc
-    attributes:
-      label: Description of Issue
-      description: A brief description of the issue encountered along with any images and/or videos.
-    validations:
-      required: true
-  - type: textarea
-    id: expected-behavior
-    attributes:
-      label: Expected Behavior
-      description: A brief description of how it is expected to work along with any images and/or videos.
-    validations:
-      required: true
-  - type: textarea
-    id: reproduction-steps
-    attributes:
-      label: Reproduction Steps
-      description: A brief explanation of how to reproduce this issue. If possible, provide a save file to aid in reproducing the issue.
-    validations:
-      required: true
-  - type: textarea
-    id: log
-    attributes:
-      label: Log File
-      description: A log file will help our developers to better diagnose and fix the issue.
-    validations:
-      required: true
-  - type: textarea
-    id: system-config
-    attributes:
-      label: System Configuration
-      placeholder: |
-        CPU: Intel i5-10400 / AMD Ryzen 5 3600
-        GPU/Driver: NVIDIA GeForce GTX 1060 (Driver 512.95)
-        RAM: 16GB DDR4-3200
-        OS: Windows 11 22H2 (Build 22621.819)
-      value: |
-        CPU:
-        GPU/Driver:
-        RAM:
-        OS:
-    validations:
-      required: true

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -1,28 +0,0 @@
-name: Feature Request
-description: File a feature request
-labels: "request"
-body:
-  - type: markdown
-    attributes:
-      value: Tech support does not belong here. You should only file an issue here if you are requesting a feature you believe would make yuzu better.
-  - type: checkboxes
-    attributes:
-      label: Is there an existing issue for this?
-      description: Please search to see if an issue already exists for the feature you are requesting.
-      options:
-      - label: I have searched the existing issues
-        required: true
-  - type: textarea
-    id: what-feature
-    attributes:
-      label: What feature are you suggesting?
-      description: A brief description of the requested feature.
-    validations:
-      required: true
-  - type: textarea
-    id: why-feature
-    attributes:
-      label: Why would this feature be useful?
-      description: A brief description of why this feature would make yuzu better.
-    validations:
-      required: true

.reuse/dep5

@@ -132,6 +132,10 @@ Files: vcpkg.json
 Copyright: 2022 yuzu Emulator Project
 License: GPL-3.0-or-later
 
-Files: .github/ISSUE_TEMPLATE/*
-Copyright: 2022 yuzu Emulator Project
+Files: .github/ISSUE_TEMPLATE/config.yml
+Copyright: 2020 tgsm <doodrabbit@hotmail.com>
+License: GPL-2.0-or-later
+
+Files: .github/ISSUE_TEMPLATE/bug-report-feature-request.md
+Copyright: 2016 MerryMage
 License: GPL-2.0-or-later

CMakeLists.txt

@@ -19,9 +19,6 @@ CMAKE_DEPENDENT_OPTION(YUZU_USE_BUNDLED_SDL2 "Download bundled SDL2 binaries" ON
 CMAKE_DEPENDENT_OPTION(YUZU_USE_EXTERNAL_SDL2 "Compile external SDL2" ON "ENABLE_SDL2;NOT MSVC" OFF)
 
 option(ENABLE_QT "Enable the Qt frontend" ON)
-option(ENABLE_QT6 "Allow usage of Qt6 to be attempted" OFF)
-set(QT6_LOCATION "" CACHE PATH "Additional Location to search for Qt6 libraries like C:/Qt/6.3.1/msvc2019_64/")
-
 option(ENABLE_QT_TRANSLATION "Enable translations for the Qt frontend" OFF)
 CMAKE_DEPENDENT_OPTION(YUZU_USE_BUNDLED_QT "Download bundled Qt binaries" "${MSVC}" "ENABLE_QT" OFF)
 
@@ -31,8 +28,6 @@ option(YUZU_USE_BUNDLED_LIBUSB "Compile bundled libusb" OFF)
 
 option(YUZU_USE_BUNDLED_FFMPEG "Download/Build bundled FFmpeg" "${WIN32}")
 
-option(YUZU_USE_QT_MULTIMEDIA "Use QtMultimedia for Camera" OFF)
-
 option(YUZU_USE_QT_WEB_ENGINE "Use QtWebEngine for web applet implementation" OFF)
 
 option(ENABLE_CUBEB "Enables the cubeb audio backend" ON)
@@ -138,13 +133,13 @@ if (NOT ENABLE_GENERIC)
     if (MSVC)
         detect_architecture("_M_AMD64" x86_64)
         detect_architecture("_M_IX86" x86)
-        detect_architecture("_M_ARM" arm)
-        detect_architecture("_M_ARM64" arm64)
+        detect_architecture("_M_ARM" ARM)
+        detect_architecture("_M_ARM64" ARM64)
     else()
         detect_architecture("__x86_64__" x86_64)
         detect_architecture("__i386__" x86)
-        detect_architecture("__arm__" arm)
-        detect_architecture("__aarch64__" arm64)
+        detect_architecture("__arm__" ARM)
+        detect_architecture("__aarch64__" ARM64)
     endif()
 endif()
 
@@ -218,166 +213,128 @@ if (MINGW)
     find_library(MSWSOCK_LIBRARY mswsock REQUIRED)
 endif()
 
-# Please consider this as a stub
-if(ENABLE_QT6 AND Qt6_LOCATION)
-    list(APPEND CMAKE_PREFIX_PATH "${Qt6_LOCATION}")
-endif()
-
-function(set_yuzu_qt_components)
-    # Best practice is to ask for all components at once, so they are from the same version
-    set(YUZU_QT_COMPONENTS2 Core Widgets Concurrent)
-    if (${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
-        list(APPEND YUZU_QT_COMPONENTS2 DBus)
-    endif()
-    if (YUZU_USE_QT_MULTIMEDIA)
-        list(APPEND YUZU_QT_COMPONENTS2 Multimedia)
-    endif()
-    if (YUZU_USE_QT_WEB_ENGINE)
-        list(APPEND YUZU_QT_COMPONENTS2 WebEngineCore WebEngineWidgets)
-    endif()
-    if (ENABLE_QT_TRANSLATION)
-        list(APPEND YUZU_QT_COMPONENTS2 LinguistTools)
-    endif()
-    set(YUZU_QT_COMPONENTS ${YUZU_QT_COMPONENTS2} PARENT_SCOPE)
-endfunction(set_yuzu_qt_components)
-
 # Qt5 requires that we find components, so it doesn't fit our pretty little find package function
 if(ENABLE_QT)
     set(QT_VERSION 5.15)
-    # These are used to specify minimum versions
-    set(QT5_VERSION 5.15)
-    set(QT6_VERSION 6.3.1)
 
-    set_yuzu_qt_components()
-    if (ENABLE_QT6)
-        find_package(Qt6 ${QT6_VERSION} COMPONENTS ${YUZU_QT_COMPONENTS})
+    # Check for system Qt on Linux, fallback to bundled Qt
+    if (${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
+        if (NOT YUZU_USE_BUNDLED_QT)
+            find_package(Qt5 ${QT_VERSION} COMPONENTS Widgets DBus Multimedia)
+        endif()
+        if (NOT Qt5_FOUND OR YUZU_USE_BUNDLED_QT)
+            # Check for dependencies, then enable bundled Qt download
+
+            # Check that the system GLIBCXX version is compatible
+            find_program(OBJDUMP objdump)
+            if ("${OBJDUMP}" STREQUAL "OBJDUMP-NOTFOUND")
+                message(FATAL_ERROR "Required program `objdump` not found.")
+            endif()
+            find_library(LIBSTDCXX libstdc++.so.6)
+            execute_process(
+                COMMAND
+                    ${OBJDUMP} -T ${LIBSTDCXX}
+                COMMAND
+                    grep GLIBCXX_3.4.28
+                COMMAND
+                    sed "s/[0-9a-f]*.*  //"
+                COMMAND
+                    sed "s/ .*//"
+                COMMAND
+                    sort -u
+                OUTPUT_VARIABLE
+                    GLIBCXX_MET
+            )
+            if (NOT GLIBCXX_MET)
+                message(FATAL_ERROR "Qt too old or not found, and bundled Qt package is not \
+                    compatible with this system. Either install Qt ${QT_VERSION}, or provide the path \
+                    to Qt by setting the variable Qt5_ROOT.")
+            endif()
+
+            # Check for headers
+            find_package(PkgConfig REQUIRED)
+            pkg_check_modules(QT_DEP_GLU QUIET glu>=9.0.0)
+            if (NOT QT_DEP_GLU_FOUND)
+                message(FATAL_ERROR "Qt bundled pacakge dependency `glu` not found. \
+                    Perhaps `libglu1-mesa-dev` needs to be installed?")
+            endif()
+            pkg_check_modules(QT_DEP_MESA QUIET dri>=20.0.8)
+            if (NOT QT_DEP_MESA_FOUND)
+                message(FATAL_ERROR "Qt bundled pacakge dependency `dri` not found. \
+                    Perhaps `mesa-common-dev` needs to be installed?")
+            endif()
+
+            # Check for X libraries
+            set(BUNDLED_QT_REQUIREMENTS
+                libxcb-icccm.so.4
+                libxcb-image.so.0
+                libxcb-keysyms.so.1
+                libxcb-randr.so.0
+                libxcb-render-util.so.0
+                libxcb-render.so.0
+                libxcb-shape.so.0
+                libxcb-shm.so.0
+                libxcb-sync.so.1
+                libxcb-xfixes.so.0
+                libxcb-xinerama.so.0
+                libxcb-xkb.so.1
+                libxcb.so.1
+                libxkbcommon-x11.so.0
+                libxkbcommon.so.0
+            )
+            set(UNRESOLVED_QT_DEPS "")
+            foreach (REQUIREMENT ${BUNDLED_QT_REQUIREMENTS})
+                find_library(BUNDLED_QT_${REQUIREMENT} ${REQUIREMENT})
+                if ("${BUNDLED_QT_${REQUIREMENT}}" STREQUAL "BUNDLED_QT_${REQUIREMENT}-NOTFOUND")
+                    set(UNRESOLVED_QT_DEPS ${UNRESOLVED_QT_DEPS} ${REQUIREMENT})
+                endif()
+                unset(BUNDLED_QT_${REQUIREMENT})
+            endforeach()
+            unset(BUNDLED_QT_REQUIREMENTS)
+
+            if (NOT "${UNRESOLVED_QT_DEPS}" STREQUAL "")
+                message(FATAL_ERROR "Bundled Qt package missing required dependencies: ${UNRESOLVED_QT_DEPS}")
+            endif()
+
+            set(YUZU_USE_BUNDLED_QT ON CACHE BOOL "Download bundled Qt" FORCE)
+        endif()
+        if (YUZU_USE_BUNDLED_QT)
+            # Binary package currently does not support Qt webengine, so make sure it's disabled
+            set(YUZU_USE_QT_WEB_ENGINE OFF CACHE BOOL "Use Qt Webengine" FORCE)
+        endif()
     endif()
-    if (Qt6_FOUND)
-        message(STATUS "yuzu/CMakeLists.txt: Qt6Widgets_VERSION ${Qt6Widgets_VERSION}, setting QT_VERSION")
-        set(QT_VERSION ${Qt6Widgets_VERSION})
-        set(QT_MAJOR_VERSION 6)
-        # Qt6 sets cxx_std_17 and we need to undo that
-        set_target_properties(Qt6::Platform PROPERTIES INTERFACE_COMPILE_FEATURES "")
+
+    set(YUZU_QT_NO_CMAKE_SYSTEM_PATH)
+
+    if(YUZU_USE_BUNDLED_QT)
+        if ((MSVC_VERSION GREATER_EQUAL 1920 AND MSVC_VERSION LESS 1940) AND ARCHITECTURE_x86_64)
+            set(QT_BUILD qt-5.15.2-msvc2019_64)
+        elseif ((${CMAKE_SYSTEM_NAME} STREQUAL "Linux") AND NOT MINGW AND ARCHITECTURE_x86_64)
+            set(QT_BUILD qt5_5_15_2)
+        else()
+            message(FATAL_ERROR "No bundled Qt binaries for your toolchain. Disable YUZU_USE_BUNDLED_QT and provide your own.")
+        endif()
+
+        if (DEFINED QT_BUILD)
+            download_bundled_external("qt/" ${QT_BUILD} QT_PREFIX)
+        endif()
+
+        set(QT_PREFIX_HINT HINTS "${QT_PREFIX}")
+
+        set(YUZU_QT_NO_CMAKE_SYSTEM_PATH "NO_CMAKE_SYSTEM_PATH")
+    endif()
+    if ((${CMAKE_SYSTEM_NAME} STREQUAL "Linux") AND YUZU_USE_BUNDLED_QT)
+        find_package(Qt5 ${QT_VERSION} REQUIRED COMPONENTS Widgets Concurrent Multimedia DBus ${QT_PREFIX_HINT} ${YUZU_QT_NO_CMAKE_SYSTEM_PATH})
     else()
-        message(STATUS "yuzu/CMakeLists.txt: Qt6 not found/not selected, trying for Qt5")
-        # When Qt6 partially found, need this set to use Qt5 when not specifying version
-        set(QT_DEFAULT_MAJOR_VERSION 5)
-        set(QT_MAJOR_VERSION 5)
-
-        set(YUZU_USE_QT_MULTIMEDIA ON)
-        # Check for system Qt on Linux, fallback to bundled Qt
-        if (UNIX AND NOT APPLE)
-            if (NOT YUZU_USE_BUNDLED_QT)
-                find_package(Qt5 ${QT5_VERSION} COMPONENTS Widgets DBus Multimedia)
-            endif()
-            if (${CMAKE_SYSTEM_NAME} STREQUAL "Linux" AND (NOT Qt5_FOUND OR YUZU_USE_BUNDLED_QT))
-                # Check for dependencies, then enable bundled Qt download
-
-                # Check that the system GLIBCXX version is compatible
-                find_program(OBJDUMP objdump)
-                if (NOT OBJDUMP)
-                    message(FATAL_ERROR "Required program `objdump` not found.")
-                endif()
-                find_library(LIBSTDCXX libstdc++.so.6)
-                execute_process(
-                    COMMAND
-                        ${OBJDUMP} -T ${LIBSTDCXX}
-                    COMMAND
-                        grep GLIBCXX_3.4.28
-                    COMMAND
-                        sed "s/[0-9a-f]*.*  //"
-                    COMMAND
-                        sed "s/ .*//"
-                    COMMAND
-                        sort -u
-                    OUTPUT_VARIABLE
-                        GLIBCXX_MET
-                )
-                if (NOT GLIBCXX_MET)
-                    message(FATAL_ERROR "Qt too old or not found, and bundled Qt package is not \
-                        compatible with this system. Either install Qt ${QT_VERSION}, or provide the path \
-                        to Qt by setting the variable Qt5_ROOT.")
-                endif()
-
-                # Check for headers
-                find_package(PkgConfig REQUIRED)
-                pkg_check_modules(QT_DEP_GLU QUIET glu>=9.0.0)
-                if (NOT QT_DEP_GLU_FOUND)
-                    message(FATAL_ERROR "Qt bundled pacakge dependency `glu` not found. \
-                        Perhaps `libglu1-mesa-dev` needs to be installed?")
-                endif()
-                pkg_check_modules(QT_DEP_MESA QUIET dri>=20.0.8)
-                if (NOT QT_DEP_MESA_FOUND)
-                    message(FATAL_ERROR "Qt bundled pacakge dependency `dri` not found. \
-                        Perhaps `mesa-common-dev` needs to be installed?")
-                endif()
-
-                # Check for X libraries
-                set(BUNDLED_QT_REQUIREMENTS
-                    libxcb-icccm.so.4
-                    libxcb-image.so.0
-                    libxcb-keysyms.so.1
-                    libxcb-randr.so.0
-                    libxcb-render-util.so.0
-                    libxcb-render.so.0
-                    libxcb-shape.so.0
-                    libxcb-shm.so.0
-                    libxcb-sync.so.1
-                    libxcb-xfixes.so.0
-                    libxcb-xinerama.so.0
-                    libxcb-xkb.so.1
-                    libxcb.so.1
-                    libxkbcommon-x11.so.0
-                    libxkbcommon.so.0
-                )
-                set(UNRESOLVED_QT_DEPS "")
-                foreach (REQUIREMENT ${BUNDLED_QT_REQUIREMENTS})
-                    find_library(BUNDLED_QT_${REQUIREMENT} ${REQUIREMENT})
-                    if (NOT BUNDLED_QT_${REQUIREMENT})
-                        set(UNRESOLVED_QT_DEPS ${UNRESOLVED_QT_DEPS} ${REQUIREMENT})
-                    endif()
-                    unset(BUNDLED_QT_${REQUIREMENT})
-                endforeach()
-                unset(BUNDLED_QT_REQUIREMENTS)
-
-                if (NOT "${UNRESOLVED_QT_DEPS}" STREQUAL "")
-                    message(FATAL_ERROR "Bundled Qt package missing required dependencies: ${UNRESOLVED_QT_DEPS}")
-                endif()
-
-                set(YUZU_USE_BUNDLED_QT ON CACHE BOOL "Download bundled Qt" FORCE)
-            endif()
-            if (YUZU_USE_BUNDLED_QT)
-                # Binary package currently does not support Qt webengine, so make sure it's disabled
-                set(YUZU_USE_QT_WEB_ENGINE OFF CACHE BOOL "Use Qt Webengine" FORCE)
-            endif()
-        endif()
-
-        set(YUZU_QT_NO_CMAKE_SYSTEM_PATH)
-
-        if(YUZU_USE_BUNDLED_QT)
-            if ((MSVC_VERSION GREATER_EQUAL 1920 AND MSVC_VERSION LESS 1940) AND ARCHITECTURE_x86_64)
-                set(QT_BUILD qt-5.15.2-msvc2019_64)
-            elseif ((${CMAKE_SYSTEM_NAME} STREQUAL "Linux") AND NOT MINGW AND ARCHITECTURE_x86_64)
-                set(QT_BUILD qt5_5_15_2)
-            else()
-                message(FATAL_ERROR "No bundled Qt binaries for your toolchain. Disable YUZU_USE_BUNDLED_QT and provide your own.")
-            endif()
-
-            if (DEFINED QT_BUILD)
-                download_bundled_external("qt/" ${QT_BUILD} QT_PREFIX)
-            endif()
-
-            set(QT_PREFIX_HINT HINTS "${QT_PREFIX}")
-
-            set(YUZU_QT_NO_CMAKE_SYSTEM_PATH "NO_CMAKE_SYSTEM_PATH")
-            # Binary package for Qt5 has Qt Multimedia
-            set(YUZU_USE_QT_MULTIMEDIA ON CACHE BOOL "Use Qt Multimedia" FORCE)
-        endif()
-
-        set_yuzu_qt_components()
-        find_package(Qt5 ${QT5_VERSION} COMPONENTS ${YUZU_QT_COMPONENTS} ${QT_PREFIX_HINT} ${YUZU_QT_NO_CMAKE_SYSTEM_PATH})
+        find_package(Qt5 ${QT_VERSION} REQUIRED COMPONENTS Widgets Concurrent Multimedia ${QT_PREFIX_HINT} ${YUZU_QT_NO_CMAKE_SYSTEM_PATH})
+    endif()
+    if (YUZU_USE_QT_WEB_ENGINE)
+        find_package(Qt5 REQUIRED COMPONENTS WebEngineCore WebEngineWidgets)
     endif()
 
+    if (ENABLE_QT_TRANSLATION)
+        find_package(Qt5 REQUIRED COMPONENTS LinguistTools ${QT_PREFIX_HINT})
+    endif()
 endif()
 
 # find SDL2 exports a bunch of variables that are needed, so its easier to do this outside of the yuzu_find_package
@@ -584,9 +541,9 @@ add_definitions(-DBOOST_ERROR_CODE_HEADER_ONLY
 # Adjustments for MSVC + Ninja
 if (MSVC AND CMAKE_GENERATOR STREQUAL "Ninja")
     add_compile_options(
-        /wd4464 # relative include path contains '..'
         /wd4711 # function 'function' selected for automatic inline expansion
-        /wd4820 # 'bytes' bytes padding added after construct 'member_name'
+        /wd4464 # relative include path contains '..'
+        /wd4820 # 'identifier1': '4' bytes padding added after data member 'identifier2'
     )
 endif()
 

CMakeModules/CopyYuzuQt5Deps.cmake

@@ -27,13 +27,10 @@ function(copy_yuzu_Qt5_deps target_dir)
             Qt5Core$<$<CONFIG:Debug>:d>.*
             Qt5Gui$<$<CONFIG:Debug>:d>.*
             Qt5Widgets$<$<CONFIG:Debug>:d>.*
+            Qt5Multimedia$<$<CONFIG:Debug>:d>.*
             Qt5Network$<$<CONFIG:Debug>:d>.*
         )
-        if (YUZU_USE_QT_MULTIMEDIA)
-            windows_copy_files(${target_dir} ${Qt5_DLL_DIR} ${DLL_DEST}
-                Qt5Multimedia$<$<CONFIG:Debug>:d>.*
-            )
-        endif()
+
         if (YUZU_USE_QT_WEB_ENGINE)
             windows_copy_files(${target_dir} ${Qt5_DLL_DIR} ${DLL_DEST}
                 Qt5Network$<$<CONFIG:Debug>:d>.*

externals/CMakeLists.txt

@@ -7,14 +7,15 @@ include(DownloadExternals)
 
 # xbyak
 if (ARCHITECTURE_x86 OR ARCHITECTURE_x86_64)
-    add_subdirectory(xbyak)
+    add_library(xbyak INTERFACE)
+    file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/xbyak/include)
+    file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/xbyak/xbyak DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/xbyak/include)
+    target_include_directories(xbyak SYSTEM INTERFACE ${CMAKE_CURRENT_BINARY_DIR}/xbyak/include)
+    target_compile_definitions(xbyak INTERFACE XBYAK_NO_OP_NAMES)
 endif()
 
 # Dynarmic
-if (ARCHITECTURE_x86_64 OR ARCHITECTURE_arm64)
-    if (ARCHITECTURE_arm64)
-       set(DYNARMIC_FRONTENDS "A32")
-    endif()
+if (ARCHITECTURE_x86_64)
     set(DYNARMIC_NO_BUNDLED_FMT ON)
     set(DYNARMIC_IGNORE_ASSERTS ON CACHE BOOL "" FORCE)
     add_subdirectory(dynarmic)
@@ -92,14 +93,10 @@ endif()
 add_subdirectory(sirit)
 
 if (ENABLE_WEB_SERVICE)
-    if (NOT WIN32)
-        find_package(OpenSSL 1.1)
-        if (OPENSSL_FOUND)
-            set(OPENSSL_LIBRARIES OpenSSL::SSL OpenSSL::Crypto)
-        endif()
-    endif()
-
-    if (WIN32 OR NOT OPENSSL_FOUND)
+    find_package(OpenSSL 1.1)
+    if (OPENSSL_FOUND)
+        set(OPENSSL_LIBRARIES OpenSSL::SSL OpenSSL::Crypto)
+    else()
         # LibreSSL
         set(LIBRESSL_SKIP_INSTALL ON CACHE BOOL "")
         set(OPENSSLDIR "/etc/ssl/")

externals/microprofile/microprofileui.h

@@ -845,6 +845,8 @@ inline void MicroProfileDrawDetailedBars(uint32_t nWidth, uint32_t nHeight, int
     MicroProfile& S = *MicroProfileGet();
     MP_DEBUG_DUMP_RANGE();
     int nY = nBaseY - UI.nOffsetY;
+    int64_t nNumBoxes = 0;
+    int64_t nNumLines = 0;
 
     uint32_t nFrameNext = (S.nFrameCurrent+1) % MICROPROFILE_MAX_FRAME_HISTORY;
     MicroProfileFrameState* pFrameCurrent = &S.Frames[S.nFrameCurrent];
@@ -1147,6 +1149,7 @@ inline void MicroProfileDrawDetailedBars(uint32_t nWidth, uint32_t nHeight, int
                                 }
                             }
 #endif
+                            ++nNumBoxes;
                         }
                         else
                         {
@@ -1162,6 +1165,7 @@ inline void MicroProfileDrawDetailedBars(uint32_t nWidth, uint32_t nHeight, int
                                 }
                                 nLinesDrawn[nStackPos] = nLineX;
                                 MicroProfileDrawLineVertical(nLineX, fYStart + 0.5f, fYEnd + 0.5f, nColor|UI.nOpacityForeground);
+                                ++nNumLines;
                             }
                         }
                         nStackPos--;

src/CMakeLists.txt

@@ -58,11 +58,13 @@ if (MSVC)
 
         # Warnings
         /W3
-        /WX
-
+        /we4018 # 'expression': signed/unsigned mismatch
         /we4062 # Enumerator 'identifier' in a switch of enum 'enumeration' is not handled
+        /we4101 # 'identifier': unreferenced local variable
         /we4189 # 'identifier': local variable is initialized but not referenced
         /we4265 # 'class': class has virtual functions, but destructor is not virtual
+        /we4267 # 'var': conversion from 'size_t' to 'type', possible loss of data
+        /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
@@ -73,13 +75,10 @@ if (MSVC)
         /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'?
         /we4555 # Expression has no effect; expected expression with side-effect
-        /we4826 # Conversion from 'type1' to 'type2' is sign-extended. This may cause unexpected runtime behavior.
+        /we4715 # 'function': not all control paths return a value
+        /we4834 # Discarding return value of function with 'nodiscard' attribute
         /we5038 # data member 'member1' will be initialized after data member 'member2'
-        /we5233 # explicit lambda capture 'identifier' is not used
         /we5245 # 'function': unreferenced function with internal linkage has been removed
-
-        /wd4100 # 'identifier': unreferenced formal parameter
-        /wd4324 # 'struct_name': structure was padded due to __declspec(align())
     )
 
     if (USE_CCACHE)
@@ -100,18 +99,24 @@ if (MSVC)
     set(CMAKE_EXE_LINKER_FLAGS_RELEASE "/DEBUG /MANIFEST:NO /INCREMENTAL:NO /OPT:REF,ICF" CACHE STRING "" FORCE)
 else()
     add_compile_options(
-        -Werror=all
-        -Werror=extra
+        -Wall
+        -Werror=array-bounds
+        -Werror=implicit-fallthrough
         -Werror=missing-declarations
+        -Werror=missing-field-initializers
+        -Werror=reorder
         -Werror=shadow
-        -Werror=unused
-
+        -Werror=sign-compare
+        -Werror=switch
+        -Werror=uninitialized
+        -Werror=unused-function
+        -Werror=unused-result
+        -Werror=unused-variable
+        -Wextra
+        -Wmissing-declarations
         -Wno-attributes
         -Wno-invalid-offsetof
         -Wno-unused-parameter
-
-        $<$<CXX_COMPILER_ID:Clang>:-Wno-braced-scalar-init>
-        $<$<CXX_COMPILER_ID:Clang>:-Wno-unused-private-field>
     )
 
     if (ARCHITECTURE_x86_64)

src/audio_core/CMakeLists.txt

@@ -206,18 +206,27 @@ 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
-        /we4800 # Implicit conversion from 'type' to bool. Possible information loss
+        /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(audio_core PRIVATE
         -Werror=conversion
+        -Werror=ignored-qualifiers
+        -Werror=shadow
+        -Werror=unused-variable
+
+        $<$<CXX_COMPILER_ID:GNU>:-Werror=unused-but-set-parameter>
+        $<$<CXX_COMPILER_ID:GNU>:-Werror=unused-but-set-variable>
 
         -Wno-sign-conversion
     )
 endif()
 
 target_link_libraries(audio_core PUBLIC common core)
-if (ARCHITECTURE_x86_64 OR ARCHITECTURE_arm64)
+if (ARCHITECTURE_x86_64)
     target_link_libraries(audio_core PRIVATE dynarmic)
 endif()
 

src/audio_core/in/audio_in_system.cpp

@@ -56,7 +56,7 @@ Result System::IsConfigValid(const std::string_view device_name,
     return ResultSuccess;
 }
 
-Result System::Initialize(std::string device_name, const AudioInParameter& in_params,
+Result System::Initialize(std::string& device_name, const AudioInParameter& in_params,
                           const u32 handle_, const u64 applet_resource_user_id_) {
     auto result{IsConfigValid(device_name, in_params)};
     if (result.IsError()) {

src/audio_core/in/audio_in_system.h

@@ -97,7 +97,7 @@ public:
      * @param applet_resource_user_id - Unused.
      * @return Result code.
      */
-    Result Initialize(std::string device_name, const AudioInParameter& in_params, u32 handle,
+    Result Initialize(std::string& device_name, const AudioInParameter& in_params, u32 handle,
                       u64 applet_resource_user_id);
 
     /**

src/audio_core/out/audio_out_system.cpp

@@ -49,8 +49,8 @@ Result System::IsConfigValid(std::string_view device_name,
     return Service::Audio::ERR_INVALID_CHANNEL_COUNT;
 }
 
-Result System::Initialize(std::string device_name, const AudioOutParameter& in_params, u32 handle_,
-                          u64 applet_resource_user_id_) {
+Result System::Initialize(std::string& device_name, const AudioOutParameter& in_params, u32 handle_,
+                          u64& applet_resource_user_id_) {
     auto result = IsConfigValid(device_name, in_params);
     if (result.IsError()) {
         return result;

src/audio_core/out/audio_out_system.h

@@ -88,8 +88,8 @@ public:
      * @param applet_resource_user_id - Unused.
      * @return Result code.
      */
-    Result Initialize(std::string device_name, const AudioOutParameter& in_params, u32 handle,
-                      u64 applet_resource_user_id);
+    Result Initialize(std::string& device_name, const AudioOutParameter& in_params, u32 handle,
+                      u64& applet_resource_user_id);
 
     /**
      * Start this system.

src/audio_core/renderer/behavior/info_updater.cpp

@@ -91,7 +91,7 @@ Result InfoUpdater::UpdateVoices(VoiceContext& voice_context,
             voice_info.Initialize();
 
             for (u32 channel = 0; channel < in_param.channel_count; channel++) {
-                *voice_states[channel] = {};
+                std::memset(voice_states[channel], 0, sizeof(VoiceState));
             }
         }
 

src/audio_core/renderer/command/command_buffer.cpp

@@ -460,23 +460,21 @@ void CommandBuffer::GenerateDeviceSinkCommand(const s32 node_id, const s16 buffe
 
     cmd.session_id = session_id;
 
-    cmd.input_count = parameter.input_count;
-    s16 max_input{0};
-    for (u32 i = 0; i < parameter.input_count; i++) {
-        cmd.inputs[i] = buffer_offset + parameter.inputs[i];
-        max_input = std::max(max_input, cmd.inputs[i]);
-    }
-
     if (state.upsampler_info != nullptr) {
         const auto size_{state.upsampler_info->sample_count * parameter.input_count};
         const auto size_bytes{size_ * sizeof(s32)};
         const auto addr{memory_pool->Translate(state.upsampler_info->samples_pos, size_bytes)};
         cmd.sample_buffer = {reinterpret_cast<s32*>(addr),
-                             (max_input + 1) * state.upsampler_info->sample_count};
+                             parameter.input_count * state.upsampler_info->sample_count};
     } else {
         cmd.sample_buffer = samples_buffer;
     }
 
+    cmd.input_count = parameter.input_count;
+    for (u32 i = 0; i < parameter.input_count; i++) {
+        cmd.inputs[i] = buffer_offset + parameter.inputs[i];
+    }
+
     GenerateEnd<DeviceSinkCommand>(cmd);
 }
 

src/audio_core/renderer/command/effect/biquad_filter.cpp

@@ -94,7 +94,7 @@ void BiquadFilterCommand::Dump([[maybe_unused]] const ADSP::CommandListProcessor
 void BiquadFilterCommand::Process(const ADSP::CommandListProcessor& processor) {
     auto state_{reinterpret_cast<VoiceState::BiquadFilterState*>(state)};
     if (needs_init) {
-        *state_ = {};
+        std::memset(state_, 0, sizeof(VoiceState::BiquadFilterState));
     }
 
     auto input_buffer{

src/audio_core/renderer/command/effect/multi_tap_biquad_filter.cpp

@@ -30,7 +30,7 @@ void MultiTapBiquadFilterCommand::Process(const ADSP::CommandListProcessor& proc
     for (u32 i = 0; i < filter_tap_count; i++) {
         auto state{reinterpret_cast<VoiceState::BiquadFilterState*>(states[i])};
         if (needs_init[i]) {
-            *state = {};
+            std::memset(state, 0, sizeof(VoiceState::BiquadFilterState));
         }
 
         ApplyBiquadFilterFloat(output_buffer, input_buffer, biquads[i].b, biquads[i].a, *state,

src/audio_core/renderer/performance/performance_manager.cpp

@@ -26,7 +26,6 @@ void PerformanceManager::CreateImpl(const size_t version) {
         impl = std::make_unique<
             PerformanceManagerImpl<PerformanceVersion::Version1, PerformanceFrameHeaderVersion1,
                                    PerformanceEntryVersion1, PerformanceDetailVersion1>>();
-        break;
     }
 }
 

src/audio_core/renderer/system.cpp

@@ -98,8 +98,9 @@ System::System(Core::System& core_, Kernel::KEvent* adsp_rendered_event_)
     : core{core_}, adsp{core.AudioCore().GetADSP()}, adsp_rendered_event{adsp_rendered_event_} {}
 
 Result System::Initialize(const AudioRendererParameterInternal& params,
-                          Kernel::KTransferMemory* transfer_memory, u64 transfer_memory_size,
-                          u32 process_handle_, u64 applet_resource_user_id_, s32 session_id_) {
+                          Kernel::KTransferMemory* transfer_memory, const u64 transfer_memory_size,
+                          const u32 process_handle_, const u64 applet_resource_user_id_,
+                          const s32 session_id_) {
     if (!CheckValidRevision(params.revision)) {
         return Service::Audio::ERR_INVALID_REVISION;
     }
@@ -353,8 +354,6 @@ Result System::Initialize(const AudioRendererParameterInternal& params,
 
     render_time_limit_percent = 100;
     drop_voice = params.voice_drop_enabled && params.execution_mode == ExecutionMode::Auto;
-    drop_voice_param = 1.0f;
-    num_voices_dropped = 0;
 
     allocator.Align(0x40);
     command_workbuffer_size = allocator.GetRemainingSize();
@@ -548,7 +547,7 @@ u32 System::GetRenderingTimeLimit() const {
     return render_time_limit_percent;
 }
 
-void System::SetRenderingTimeLimit(u32 limit) {
+void System::SetRenderingTimeLimit(const u32 limit) {
     render_time_limit_percent = limit;
 }
 
@@ -636,7 +635,7 @@ void System::SendCommandToDsp() {
 }
 
 u64 System::GenerateCommand(std::span<u8> in_command_buffer,
-                            [[maybe_unused]] u64 command_buffer_size_) {
+                            [[maybe_unused]] const u64 command_buffer_size_) {
     PoolMapper::ClearUseState(memory_pool_workbuffer, memory_pool_count);
     const auto start_time{core.CoreTiming().GetClockTicks()};
 
@@ -694,8 +693,7 @@ u64 System::GenerateCommand(std::span<u8> in_command_buffer,
 
     voice_context.SortInfo();
 
-    const auto start_estimated_time{drop_voice_param *
-                                    static_cast<f32>(command_buffer.estimated_process_time)};
+    const auto start_estimated_time{command_buffer.estimated_process_time};
 
     command_generator.GenerateVoiceCommands();
     command_generator.GenerateSubMixCommands();
@@ -714,16 +712,11 @@ u64 System::GenerateCommand(std::span<u8> in_command_buffer,
             render_context.behavior->IsAudioRendererProcessingTimeLimit70PercentSupported();
             time_limit_percent = 70.0f;
         }
-
-        const auto end_estimated_time{drop_voice_param *
-                                      static_cast<f32>(command_buffer.estimated_process_time)};
-        const auto estimated_time{start_estimated_time - end_estimated_time};
-
         const auto time_limit{static_cast<u32>(
-            estimated_time + (((time_limit_percent / 100.0f) * 2'880'000.0) *
-                              (static_cast<f32>(render_time_limit_percent) / 100.0f)))};
-        num_voices_dropped =
-            DropVoices(command_buffer, static_cast<u32>(start_estimated_time), time_limit);
+            static_cast<f32>(start_estimated_time - command_buffer.estimated_process_time) +
+            (((time_limit_percent / 100.0f) * 2'880'000.0) *
+             (static_cast<f32>(render_time_limit_percent) / 100.0f)))};
+        num_voices_dropped = DropVoices(command_buffer, start_estimated_time, time_limit);
     }
 
     command_list_header->buffer_size = command_buffer.size;
@@ -744,33 +737,24 @@ u64 System::GenerateCommand(std::span<u8> in_command_buffer,
     return command_buffer.size;
 }
 
-f32 System::GetVoiceDropParameter() const {
-    return drop_voice_param;
-}
-
-void System::SetVoiceDropParameter(f32 voice_drop_) {
-    drop_voice_param = voice_drop_;
-}
-
-u32 System::DropVoices(CommandBuffer& command_buffer, u32 estimated_process_time, u32 time_limit) {
+u32 System::DropVoices(CommandBuffer& command_buffer, const u32 estimated_process_time,
+                       const u32 time_limit) {
     u32 i{0};
     auto command_list{command_buffer.command_list.data() + sizeof(CommandListHeader)};
-    ICommand* cmd{nullptr};
+    ICommand* cmd{};
 
-    // Find a first valid voice to drop
-    while (i < command_buffer.count) {
+    for (; i < command_buffer.count; i++) {
         cmd = reinterpret_cast<ICommand*>(command_list);
-        if (cmd->type == CommandId::Performance ||
-            cmd->type == CommandId::DataSourcePcmInt16Version1 ||
-            cmd->type == CommandId::DataSourcePcmInt16Version2 ||
-            cmd->type == CommandId::DataSourcePcmFloatVersion1 ||
-            cmd->type == CommandId::DataSourcePcmFloatVersion2 ||
-            cmd->type == CommandId::DataSourceAdpcmVersion1 ||
-            cmd->type == CommandId::DataSourceAdpcmVersion2) {
+        if (cmd->type != CommandId::Performance &&
+            cmd->type != CommandId::DataSourcePcmInt16Version1 &&
+            cmd->type != CommandId::DataSourcePcmInt16Version2 &&
+            cmd->type != CommandId::DataSourcePcmFloatVersion1 &&
+            cmd->type != CommandId::DataSourcePcmFloatVersion2 &&
+            cmd->type != CommandId::DataSourceAdpcmVersion1 &&
+            cmd->type != CommandId::DataSourceAdpcmVersion2) {
             break;
         }
         command_list += cmd->size;
-        i++;
     }
 
     if (cmd == nullptr || command_buffer.count == 0 || i >= command_buffer.count) {
@@ -783,7 +767,6 @@ u32 System::DropVoices(CommandBuffer& command_buffer, u32 estimated_process_time
         const auto node_id_type{cmd->node_id >> 28};
         const auto node_id_base{cmd->node_id & 0xFFF};
 
-        // If the new estimated process time falls below the limit, we're done dropping.
         if (estimated_process_time <= time_limit) {
             break;
         }
@@ -792,7 +775,6 @@ u32 System::DropVoices(CommandBuffer& command_buffer, u32 estimated_process_time
             break;
         }
 
-        // Don't drop voices marked with the highest priority.
         auto& voice_info{voice_context.GetInfo(node_id_base)};
         if (voice_info.priority == HighestVoicePriority) {
             break;
@@ -801,23 +783,18 @@ u32 System::DropVoices(CommandBuffer& command_buffer, u32 estimated_process_time
         voices_dropped++;
         voice_info.voice_dropped = true;
 
-        // First iteration should drop the voice, and then iterate through all of the commands tied
-        // to the voice. We don't need reverb on a voice which we've just removed, for example.
-        // Depops can't be removed otherwise we'll introduce audio popping, and we don't
-        // remove perf commands. Lower the estimated time for each command dropped.
-        while (i < command_buffer.count && cmd->node_id == node_id) {
-            if (cmd->type == CommandId::DepopPrepare) {
-                cmd->enabled = true;
-            } else if (cmd->enabled && cmd->type != CommandId::Performance) {
-                cmd->enabled = false;
-                estimated_process_time -= static_cast<u32>(
-                    drop_voice_param * static_cast<f32>(cmd->estimated_process_time));
+        if (i < command_buffer.count) {
+            while (cmd->node_id == node_id) {
+                if (cmd->type == CommandId::DepopPrepare) {
+                    cmd->enabled = true;
+                } else if (cmd->type == CommandId::Performance || !cmd->enabled) {
+                    cmd->enabled = false;
+                }
+                i++;
+                command_list += cmd->size;
+                cmd = reinterpret_cast<ICommand*>(command_list);
             }
-            command_list += cmd->size;
-            cmd = reinterpret_cast<ICommand*>(command_list);
-            i++;
         }
-        i++;
     }
     return voices_dropped;
 }

src/audio_core/renderer/system.h

@@ -196,20 +196,6 @@ public:
      */
     u32 DropVoices(CommandBuffer& command_buffer, u32 estimated_process_time, u32 time_limit);
 
-    /**
-     * Get the current voice drop parameter.
-     *
-     * @return The current voice drop.
-     */
-    f32 GetVoiceDropParameter() const;
-
-    /**
-     * Set the voice drop parameter.
-     *
-     * @param The new voice drop.
-     */
-    void SetVoiceDropParameter(f32 voice_drop);
-
 private:
     /// Core system
     Core::System& core;
@@ -315,8 +301,6 @@ private:
     u32 num_voices_dropped{};
     /// Tick that rendering started
     u64 render_start_tick{};
-    /// Parameter to control the threshold for dropping voices if the audio graph gets too large
-    f32 drop_voice_param{1.0f};
 };
 
 } // namespace AudioRenderer

src/audio_core/renderer/voice/voice_context.cpp

@@ -74,8 +74,8 @@ void VoiceContext::SortInfo() {
     }
 
     std::ranges::sort(sorted_voice_info, [](const VoiceInfo* a, const VoiceInfo* b) {
-        return a->priority != b->priority ? a->priority > b->priority
-                                          : a->sort_order > b->sort_order;
+        return a->priority != b->priority ? a->priority < b->priority
+                                          : a->sort_order < b->sort_order;
     });
 }
 

src/common/CMakeLists.txt

@@ -34,8 +34,6 @@ add_library(common STATIC
     bit_util.h
     cityhash.cpp
     cityhash.h
-    cache_management.cpp
-    cache_management.h
     common_funcs.h
     common_types.h
     concepts.h
@@ -158,13 +156,12 @@ if (MSVC)
   )
   target_compile_options(common PRIVATE
     /W4
-
-    /we4242 # 'identifier': conversion from 'type1' to 'type2', possible loss of data
-    /we4254 # 'operator': conversion from 'type1:field_bits' to 'type2:field_bits', possible loss of data
-    /we4800 # Implicit conversion from 'type' to bool. Possible information loss
+    /WX
   )
 else()
   target_compile_options(common PRIVATE
+    -Werror
+
     $<$<CXX_COMPILER_ID:Clang>:-fsized-deallocation>
   )
 endif()
@@ -172,11 +169,7 @@ endif()
 create_target_directory_groups(common)
 
 target_link_libraries(common PUBLIC ${Boost_LIBRARIES} fmt::fmt microprofile Threads::Threads)
-if (TARGET lz4::lz4)
-  target_link_libraries(common PRIVATE lz4::lz4)
-else()
-  target_link_libraries(common PRIVATE LZ4::lz4_shared)
-endif()
+target_link_libraries(common PRIVATE lz4::lz4)
 if (TARGET zstd::zstd)
   target_link_libraries(common PRIVATE zstd::zstd)
 else()

src/common/atomic_helpers.h

@@ -156,7 +156,6 @@ AE_FORCEINLINE void compiler_fence(memory_order order) AE_NO_TSAN {
         break;
     default:
         assert(false);
-        break;
     }
 }
 

src/common/bit_field.h

@@ -141,6 +141,10 @@ public:
     constexpr BitField(BitField&&) noexcept = default;
     constexpr BitField& operator=(BitField&&) noexcept = default;
 
+    [[nodiscard]] constexpr operator T() const {
+        return Value();
+    }
+
     constexpr void Assign(const T& value) {
 #ifdef _MSC_VER
         storage = static_cast<StorageType>((storage & ~mask) | FormatValue(value));
@@ -158,17 +162,6 @@ public:
         return ExtractValue(storage);
     }
 
-    template <typename ConvertedToType>
-    [[nodiscard]] constexpr ConvertedToType As() const {
-        static_assert(!std::is_same_v<T, ConvertedToType>,
-                      "Unnecessary cast. Use Value() instead.");
-        return static_cast<ConvertedToType>(Value());
-    }
-
-    [[nodiscard]] constexpr operator T() const {
-        return Value();
-    }
-
     [[nodiscard]] constexpr explicit operator bool() const {
         return Value() != 0;
     }

src/common/bounded_threadsafe_queue.h

@@ -21,6 +21,11 @@ constexpr size_t hardware_interference_size = std::hardware_destructive_interfer
 constexpr size_t hardware_interference_size = 64;
 #endif
 
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4324)
+#endif
+
 template <typename T, size_t capacity = 0x400>
 class MPSCQueue {
 public:
@@ -155,4 +160,8 @@ private:
     static_assert(std::is_nothrow_destructible_v<T>, "T must be nothrow destructible");
 };
 
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
 } // namespace Common

src/common/cache_management.cpp

@@ -1,60 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include <cstring>
-
-#include "alignment.h"
-#include "cache_management.h"
-#include "common_types.h"
-
-namespace Common {
-
-#if defined(ARCHITECTURE_x86_64)
-
-// Most cache operations are no-ops on x86
-
-void DataCacheLineCleanByVAToPoU(void* start, size_t size) {}
-void DataCacheLineCleanAndInvalidateByVAToPoC(void* start, size_t size) {}
-void DataCacheLineCleanByVAToPoC(void* start, size_t size) {}
-void DataCacheZeroByVA(void* start, size_t size) {
-    std::memset(start, 0, size);
-}
-
-#elif defined(ARCHITECTURE_arm64)
-
-// BS/DminLine is log2(cache size in words), we want size in bytes
-#define EXTRACT_DMINLINE(ctr_el0) (1 << ((((ctr_el0) >> 16) & 0xf) + 2))
-#define EXTRACT_BS(dczid_el0) (1 << (((dczid_el0)&0xf) + 2))
-
-#define DEFINE_DC_OP(op_name, function_name)                                                       \
-    void function_name(void* start, size_t size) {                                                 \
-        size_t ctr_el0;                                                                            \
-        asm volatile("mrs %[ctr_el0], ctr_el0\n\t" : [ctr_el0] "=r"(ctr_el0));                     \
-        size_t cacheline_size = EXTRACT_DMINLINE(ctr_el0);                                         \
-        uintptr_t va_start = reinterpret_cast<uintptr_t>(start);                                   \
-        uintptr_t va_end = va_start + size;                                                        \
-        for (uintptr_t va = va_start; va < va_end; va += cacheline_size) {                         \
-            asm volatile("dc " #op_name ", %[va]\n\t" : : [va] "r"(va) : "memory");                \
-        }                                                                                          \
-    }
-
-#define DEFINE_DC_OP_DCZID(op_name, function_name)                                                 \
-    void function_name(void* start, size_t size) {                                                 \
-        size_t dczid_el0;                                                                          \
-        asm volatile("mrs %[dczid_el0], dczid_el0\n\t" : [dczid_el0] "=r"(dczid_el0));             \
-        size_t cacheline_size = EXTRACT_BS(dczid_el0);                                             \
-        uintptr_t va_start = reinterpret_cast<uintptr_t>(start);                                   \
-        uintptr_t va_end = va_start + size;                                                        \
-        for (uintptr_t va = va_start; va < va_end; va += cacheline_size) {                         \
-            asm volatile("dc " #op_name ", %[va]\n\t" : : [va] "r"(va) : "memory");                \
-        }                                                                                          \
-    }
-
-DEFINE_DC_OP(cvau, DataCacheLineCleanByVAToPoU);
-DEFINE_DC_OP(civac, DataCacheLineCleanAndInvalidateByVAToPoC);
-DEFINE_DC_OP(cvac, DataCacheLineCleanByVAToPoC);
-DEFINE_DC_OP_DCZID(zva, DataCacheZeroByVA);
-
-#endif
-
-} // namespace Common

src/common/cache_management.h

@@ -1,27 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include "stdlib.h"
-
-namespace Common {
-
-// Data cache instructions enabled at EL0 by SCTLR_EL1.UCI.
-// VA = virtual address
-// PoC = point of coherency
-// PoU = point of unification
-
-// dc cvau
-void DataCacheLineCleanByVAToPoU(void* start, size_t size);
-
-// dc civac
-void DataCacheLineCleanAndInvalidateByVAToPoC(void* start, size_t size);
-
-// dc cvac
-void DataCacheLineCleanByVAToPoC(void* start, size_t size);
-
-// dc zva
-void DataCacheZeroByVA(void* start, size_t size);
-
-} // namespace Common

src/common/common_funcs.h

@@ -31,10 +31,8 @@
 
 #ifndef _MSC_VER
 
-#if defined(ARCHITECTURE_x86_64)
+#ifdef ARCHITECTURE_x86_64
 #define Crash() __asm__ __volatile__("int $3")
-#elif defined(ARCHITECTURE_arm64)
-#define Crash() __asm__ __volatile__("brk #0")
 #else
 #define Crash() exit(1)
 #endif

src/common/concepts.h

@@ -3,14 +3,24 @@
 
 #pragma once
 
-#include <iterator>
 #include <type_traits>
 
 namespace Common {
 
-// Check if type satisfies the ContiguousContainer named requirement.
+// Check if type is like an STL container
 template <typename T>
-concept IsContiguousContainer = std::contiguous_iterator<typename T::iterator>;
+concept IsSTLContainer = requires(T t) {
+    typename T::value_type;
+    typename T::iterator;
+    typename T::const_iterator;
+    // TODO(ogniK): Replace below is std::same_as<void> when MSVC supports it.
+    t.begin();
+    t.end();
+    t.cbegin();
+    t.cend();
+    t.data();
+    t.size();
+};
 
 // TODO: Replace with std::derived_from when the <concepts> header
 //       is available on all supported platforms.
@@ -24,12 +34,4 @@ concept DerivedFrom = requires {
 template <typename From, typename To>
 concept ConvertibleTo = std::is_convertible_v<From, To>;
 
-// No equivalents in the stdlib
-
-template <typename T>
-concept IsArithmetic = std::is_arithmetic_v<T>;
-
-template <typename T>
-concept IsIntegral = std::is_integral_v<T>;
-
 } // namespace Common

src/common/fixed_point.h

@@ -4,7 +4,14 @@
 // From: https://github.com/eteran/cpp-utilities/blob/master/fixed/include/cpp-utilities/fixed.h
 // See also: http://stackoverflow.com/questions/79677/whats-the-best-way-to-do-fixed-point-math
 
-#pragma once
+#ifndef FIXED_H_
+#define FIXED_H_
+
+#if __cplusplus >= 201402L
+#define CONSTEXPR14 constexpr
+#else
+#define CONSTEXPR14
+#endif
 
 #include <cstddef> // for size_t
 #include <cstdint>
@@ -12,8 +19,6 @@
 #include <ostream>
 #include <type_traits>
 
-#include <common/concepts.h>
-
 namespace Common {
 
 template <size_t I, size_t F>
@@ -52,8 +57,8 @@ struct type_from_size<64> {
     static constexpr size_t size = 64;
 
     using value_type = int64_t;
-    using unsigned_type = std::make_unsigned_t<value_type>;
-    using signed_type = std::make_signed_t<value_type>;
+    using unsigned_type = std::make_unsigned<value_type>::type;
+    using signed_type = std::make_signed<value_type>::type;
     using next_size = type_from_size<128>;
 };
 
@@ -63,8 +68,8 @@ struct type_from_size<32> {
     static constexpr size_t size = 32;
 
     using value_type = int32_t;
-    using unsigned_type = std::make_unsigned_t<value_type>;
-    using signed_type = std::make_signed_t<value_type>;
+    using unsigned_type = std::make_unsigned<value_type>::type;
+    using signed_type = std::make_signed<value_type>::type;
     using next_size = type_from_size<64>;
 };
 
@@ -74,8 +79,8 @@ struct type_from_size<16> {
     static constexpr size_t size = 16;
 
     using value_type = int16_t;
-    using unsigned_type = std::make_unsigned_t<value_type>;
-    using signed_type = std::make_signed_t<value_type>;
+    using unsigned_type = std::make_unsigned<value_type>::type;
+    using signed_type = std::make_signed<value_type>::type;
     using next_size = type_from_size<32>;
 };
 
@@ -85,8 +90,8 @@ struct type_from_size<8> {
     static constexpr size_t size = 8;
 
     using value_type = int8_t;
-    using unsigned_type = std::make_unsigned_t<value_type>;
-    using signed_type = std::make_signed_t<value_type>;
+    using unsigned_type = std::make_unsigned<value_type>::type;
+    using signed_type = std::make_signed<value_type>::type;
     using next_size = type_from_size<16>;
 };
 
@@ -101,9 +106,9 @@ constexpr B next_to_base(N rhs) {
 struct divide_by_zero : std::exception {};
 
 template <size_t I, size_t F>
-constexpr FixedPoint<I, F> divide(
+CONSTEXPR14 FixedPoint<I, F> divide(
     FixedPoint<I, F> numerator, FixedPoint<I, F> denominator, FixedPoint<I, F>& remainder,
-    std::enable_if_t<type_from_size<I + F>::next_size::is_specialized>* = nullptr) {
+    typename std::enable_if<type_from_size<I + F>::next_size::is_specialized>::type* = nullptr) {
 
     using next_type = typename FixedPoint<I, F>::next_type;
     using base_type = typename FixedPoint<I, F>::base_type;
@@ -121,9 +126,9 @@ constexpr FixedPoint<I, F> divide(
 }
 
 template <size_t I, size_t F>
-constexpr FixedPoint<I, F> divide(
+CONSTEXPR14 FixedPoint<I, F> divide(
     FixedPoint<I, F> numerator, FixedPoint<I, F> denominator, FixedPoint<I, F>& remainder,
-    std::enable_if_t<!type_from_size<I + F>::next_size::is_specialized>* = nullptr) {
+    typename std::enable_if<!type_from_size<I + F>::next_size::is_specialized>::type* = nullptr) {
 
     using unsigned_type = typename FixedPoint<I, F>::unsigned_type;
 
@@ -191,9 +196,9 @@ constexpr FixedPoint<I, F> divide(
 
 // this is the usual implementation of multiplication
 template <size_t I, size_t F>
-constexpr FixedPoint<I, F> multiply(
+CONSTEXPR14 FixedPoint<I, F> multiply(
     FixedPoint<I, F> lhs, FixedPoint<I, F> rhs,
-    std::enable_if_t<type_from_size<I + F>::next_size::is_specialized>* = nullptr) {
+    typename std::enable_if<type_from_size<I + F>::next_size::is_specialized>::type* = nullptr) {
 
     using next_type = typename FixedPoint<I, F>::next_type;
     using base_type = typename FixedPoint<I, F>::base_type;
@@ -210,9 +215,9 @@ constexpr FixedPoint<I, F> multiply(
 // it is slightly slower, but is more robust since it doesn't
 // require and upgraded type
 template <size_t I, size_t F>
-constexpr FixedPoint<I, F> multiply(
+CONSTEXPR14 FixedPoint<I, F> multiply(
     FixedPoint<I, F> lhs, FixedPoint<I, F> rhs,
-    std::enable_if_t<!type_from_size<I + F>::next_size::is_specialized>* = nullptr) {
+    typename std::enable_if<!type_from_size<I + F>::next_size::is_specialized>::type* = nullptr) {
 
     using base_type = typename FixedPoint<I, F>::base_type;
 
@@ -267,20 +272,19 @@ public:
     static constexpr base_type one = base_type(1) << fractional_bits;
 
 public: // constructors
-    constexpr FixedPoint() = default;
+    FixedPoint() = default;
+    FixedPoint(const FixedPoint&) = default;
+    FixedPoint(FixedPoint&&) = default;
+    FixedPoint& operator=(const FixedPoint&) = default;
 
-    constexpr FixedPoint(const FixedPoint&) = default;
-    constexpr FixedPoint& operator=(const FixedPoint&) = default;
-
-    constexpr FixedPoint(FixedPoint&&) noexcept = default;
-    constexpr FixedPoint& operator=(FixedPoint&&) noexcept = default;
-
-    template <IsArithmetic Number>
-    constexpr FixedPoint(Number n) : data_(static_cast<base_type>(n * one)) {}
+    template <class Number>
+    constexpr FixedPoint(
+        Number n, typename std::enable_if<std::is_arithmetic<Number>::value>::type* = nullptr)
+        : data_(static_cast<base_type>(n * one)) {}
 
 public: // conversion
     template <size_t I2, size_t F2>
-    constexpr explicit FixedPoint(FixedPoint<I2, F2> other) {
+    CONSTEXPR14 explicit FixedPoint(FixedPoint<I2, F2> other) {
         static_assert(I2 <= I && F2 <= F, "Scaling conversion can only upgrade types");
         using T = FixedPoint<I2, F2>;
 
@@ -304,14 +308,36 @@ public:
     }
 
 public: // comparison operators
-    friend constexpr auto operator<=>(FixedPoint lhs, FixedPoint rhs) = default;
+    constexpr bool operator==(FixedPoint rhs) const {
+        return data_ == rhs.data_;
+    }
+
+    constexpr bool operator!=(FixedPoint rhs) const {
+        return data_ != rhs.data_;
+    }
+
+    constexpr bool operator<(FixedPoint rhs) const {
+        return data_ < rhs.data_;
+    }
+
+    constexpr bool operator>(FixedPoint rhs) const {
+        return data_ > rhs.data_;
+    }
+
+    constexpr bool operator<=(FixedPoint rhs) const {
+        return data_ <= rhs.data_;
+    }
+
+    constexpr bool operator>=(FixedPoint rhs) const {
+        return data_ >= rhs.data_;
+    }
 
 public: // unary operators
-    [[nodiscard]] constexpr bool operator!() const {
+    constexpr bool operator!() const {
         return !data_;
     }
 
-    [[nodiscard]] constexpr FixedPoint operator~() const {
+    constexpr FixedPoint operator~() const {
         // NOTE(eteran): this will often appear to "just negate" the value
         // that is not an error, it is because -x == (~x+1)
         // and that "+1" is adding an infinitesimally small fraction to the
@@ -319,87 +345,89 @@ public: // unary operators
         return FixedPoint::from_base(~data_);
     }
 
-    [[nodiscard]] constexpr FixedPoint operator-() const {
+    constexpr FixedPoint operator-() const {
         return FixedPoint::from_base(-data_);
     }
 
-    [[nodiscard]] constexpr FixedPoint operator+() const {
+    constexpr FixedPoint operator+() const {
         return FixedPoint::from_base(+data_);
     }
 
-    constexpr FixedPoint& operator++() {
+    CONSTEXPR14 FixedPoint& operator++() {
         data_ += one;
         return *this;
     }
 
-    constexpr FixedPoint& operator--() {
+    CONSTEXPR14 FixedPoint& operator--() {
         data_ -= one;
         return *this;
     }
 
-    constexpr FixedPoint operator++(int) {
+    CONSTEXPR14 FixedPoint operator++(int) {
         FixedPoint tmp(*this);
         data_ += one;
         return tmp;
     }
 
-    constexpr FixedPoint operator--(int) {
+    CONSTEXPR14 FixedPoint operator--(int) {
         FixedPoint tmp(*this);
         data_ -= one;
         return tmp;
     }
 
 public: // basic math operators
-    constexpr FixedPoint& operator+=(FixedPoint n) {
+    CONSTEXPR14 FixedPoint& operator+=(FixedPoint n) {
         data_ += n.data_;
         return *this;
     }
 
-    constexpr FixedPoint& operator-=(FixedPoint n) {
+    CONSTEXPR14 FixedPoint& operator-=(FixedPoint n) {
         data_ -= n.data_;
         return *this;
     }
 
-    constexpr FixedPoint& operator*=(FixedPoint n) {
+    CONSTEXPR14 FixedPoint& operator*=(FixedPoint n) {
         return assign(detail::multiply(*this, n));
     }
 
-    constexpr FixedPoint& operator/=(FixedPoint n) {
+    CONSTEXPR14 FixedPoint& operator/=(FixedPoint n) {
         FixedPoint temp;
         return assign(detail::divide(*this, n, temp));
     }
 
 private:
-    constexpr FixedPoint& assign(FixedPoint rhs) {
+    CONSTEXPR14 FixedPoint& assign(FixedPoint rhs) {
         data_ = rhs.data_;
         return *this;
     }
 
 public: // binary math operators, effects underlying bit pattern since these
         // don't really typically make sense for non-integer values
-    constexpr FixedPoint& operator&=(FixedPoint n) {
+    CONSTEXPR14 FixedPoint& operator&=(FixedPoint n) {
         data_ &= n.data_;
         return *this;
     }
 
-    constexpr FixedPoint& operator|=(FixedPoint n) {
+    CONSTEXPR14 FixedPoint& operator|=(FixedPoint n) {
         data_ |= n.data_;
         return *this;
     }
 
-    constexpr FixedPoint& operator^=(FixedPoint n) {
+    CONSTEXPR14 FixedPoint& operator^=(FixedPoint n) {
         data_ ^= n.data_;
         return *this;
     }
 
-    template <IsIntegral Integer>
-    constexpr FixedPoint& operator>>=(Integer n) {
+    template <class Integer,
+              class = typename std::enable_if<std::is_integral<Integer>::value>::type>
+    CONSTEXPR14 FixedPoint& operator>>=(Integer n) {
         data_ >>= n;
         return *this;
     }
 
-    template <IsIntegral Integer>
-    constexpr FixedPoint& operator<<=(Integer n) {
+    template <class Integer,
+              class = typename std::enable_if<std::is_integral<Integer>::value>::type>
+    CONSTEXPR14 FixedPoint& operator<<=(Integer n) {
         data_ <<= n;
         return *this;
     }
@@ -409,42 +437,42 @@ public: // conversion to basic types
         data_ += (data_ & fractional_mask) >> 1;
     }
 
-    [[nodiscard]] constexpr int to_int() {
+    constexpr int to_int() {
         round_up();
         return static_cast<int>((data_ & integer_mask) >> fractional_bits);
     }
 
-    [[nodiscard]] constexpr unsigned int to_uint() {
+    constexpr unsigned int to_uint() const {
         round_up();
         return static_cast<unsigned int>((data_ & integer_mask) >> fractional_bits);
     }
 
-    [[nodiscard]] constexpr int64_t to_long() {
+    constexpr int64_t to_long() {
         round_up();
         return static_cast<int64_t>((data_ & integer_mask) >> fractional_bits);
     }
 
-    [[nodiscard]] constexpr int to_int_floor() const {
+    constexpr int to_int_floor() const {
         return static_cast<int>((data_ & integer_mask) >> fractional_bits);
     }
 
-    [[nodiscard]] constexpr int64_t to_long_floor() const {
+    constexpr int64_t to_long_floor() {
         return static_cast<int64_t>((data_ & integer_mask) >> fractional_bits);
     }
 
-    [[nodiscard]] constexpr unsigned int to_uint_floor() const {
+    constexpr unsigned int to_uint_floor() const {
         return static_cast<unsigned int>((data_ & integer_mask) >> fractional_bits);
     }
 
-    [[nodiscard]] constexpr float to_float() const {
+    constexpr float to_float() const {
         return static_cast<float>(data_) / FixedPoint::one;
     }
 
-    [[nodiscard]] constexpr double to_double() const {
+    constexpr double to_double() const {
         return static_cast<double>(data_) / FixedPoint::one;
     }
 
-    [[nodiscard]] constexpr base_type to_raw() const {
+    constexpr base_type to_raw() const {
         return data_;
     }
 
@@ -452,27 +480,27 @@ public: // conversion to basic types
         data_ &= fractional_mask;
     }
 
-    [[nodiscard]] constexpr base_type get_frac() const {
+    constexpr base_type get_frac() const {
         return data_ & fractional_mask;
     }
 
 public:
-    constexpr void swap(FixedPoint& rhs) noexcept {
+    CONSTEXPR14 void swap(FixedPoint& rhs) {
         using std::swap;
         swap(data_, rhs.data_);
     }
 
 public:
-    base_type data_{};
+    base_type data_;
 };
 
 // if we have the same fractional portion, but differing integer portions, we trivially upgrade the
 // smaller type
 template <size_t I1, size_t I2, size_t F>
-constexpr std::conditional_t<I1 >= I2, FixedPoint<I1, F>, FixedPoint<I2, F>> operator+(
-    FixedPoint<I1, F> lhs, FixedPoint<I2, F> rhs) {
+CONSTEXPR14 typename std::conditional<I1 >= I2, FixedPoint<I1, F>, FixedPoint<I2, F>>::type
+operator+(FixedPoint<I1, F> lhs, FixedPoint<I2, F> rhs) {
 
-    using T = std::conditional_t<I1 >= I2, FixedPoint<I1, F>, FixedPoint<I2, F>>;
+    using T = typename std::conditional<I1 >= I2, FixedPoint<I1, F>, FixedPoint<I2, F>>::type;
 
     const T l = T::from_base(lhs.to_raw());
     const T r = T::from_base(rhs.to_raw());
@@ -480,10 +508,10 @@ constexpr std::conditional_t<I1 >= I2, FixedPoint<I1, F>, FixedPoint<I2, F>> ope
 }
 
 template <size_t I1, size_t I2, size_t F>
-constexpr std::conditional_t<I1 >= I2, FixedPoint<I1, F>, FixedPoint<I2, F>> operator-(
-    FixedPoint<I1, F> lhs, FixedPoint<I2, F> rhs) {
+CONSTEXPR14 typename std::conditional<I1 >= I2, FixedPoint<I1, F>, FixedPoint<I2, F>>::type
+operator-(FixedPoint<I1, F> lhs, FixedPoint<I2, F> rhs) {
 
-    using T = std::conditional_t<I1 >= I2, FixedPoint<I1, F>, FixedPoint<I2, F>>;
+    using T = typename std::conditional<I1 >= I2, FixedPoint<I1, F>, FixedPoint<I2, F>>::type;
 
     const T l = T::from_base(lhs.to_raw());
     const T r = T::from_base(rhs.to_raw());
@@ -491,10 +519,10 @@ constexpr std::conditional_t<I1 >= I2, FixedPoint<I1, F>, FixedPoint<I2, F>> ope
 }
 
 template <size_t I1, size_t I2, size_t F>
-constexpr std::conditional_t<I1 >= I2, FixedPoint<I1, F>, FixedPoint<I2, F>> operator*(
-    FixedPoint<I1, F> lhs, FixedPoint<I2, F> rhs) {
+CONSTEXPR14 typename std::conditional<I1 >= I2, FixedPoint<I1, F>, FixedPoint<I2, F>>::type
+operator*(FixedPoint<I1, F> lhs, FixedPoint<I2, F> rhs) {
 
-    using T = std::conditional_t<I1 >= I2, FixedPoint<I1, F>, FixedPoint<I2, F>>;
+    using T = typename std::conditional<I1 >= I2, FixedPoint<I1, F>, FixedPoint<I2, F>>::type;
 
     const T l = T::from_base(lhs.to_raw());
     const T r = T::from_base(rhs.to_raw());
@@ -502,10 +530,10 @@ constexpr std::conditional_t<I1 >= I2, FixedPoint<I1, F>, FixedPoint<I2, F>> ope
 }
 
 template <size_t I1, size_t I2, size_t F>
-constexpr std::conditional_t<I1 >= I2, FixedPoint<I1, F>, FixedPoint<I2, F>> operator/(
-    FixedPoint<I1, F> lhs, FixedPoint<I2, F> rhs) {
+CONSTEXPR14 typename std::conditional<I1 >= I2, FixedPoint<I1, F>, FixedPoint<I2, F>>::type
+operator/(FixedPoint<I1, F> lhs, FixedPoint<I2, F> rhs) {
 
-    using T = std::conditional_t<I1 >= I2, FixedPoint<I1, F>, FixedPoint<I2, F>>;
+    using T = typename std::conditional<I1 >= I2, FixedPoint<I1, F>, FixedPoint<I2, F>>::type;
 
     const T l = T::from_base(lhs.to_raw());
     const T r = T::from_base(rhs.to_raw());
@@ -520,133 +548,159 @@ std::ostream& operator<<(std::ostream& os, FixedPoint<I, F> f) {
 
 // basic math operators
 template <size_t I, size_t F>
-constexpr FixedPoint<I, F> operator+(FixedPoint<I, F> lhs, FixedPoint<I, F> rhs) {
+CONSTEXPR14 FixedPoint<I, F> operator+(FixedPoint<I, F> lhs, FixedPoint<I, F> rhs) {
     lhs += rhs;
     return lhs;
 }
 template <size_t I, size_t F>
-constexpr FixedPoint<I, F> operator-(FixedPoint<I, F> lhs, FixedPoint<I, F> rhs) {
+CONSTEXPR14 FixedPoint<I, F> operator-(FixedPoint<I, F> lhs, FixedPoint<I, F> rhs) {
     lhs -= rhs;
     return lhs;
 }
 template <size_t I, size_t F>
-constexpr FixedPoint<I, F> operator*(FixedPoint<I, F> lhs, FixedPoint<I, F> rhs) {
+CONSTEXPR14 FixedPoint<I, F> operator*(FixedPoint<I, F> lhs, FixedPoint<I, F> rhs) {
     lhs *= rhs;
     return lhs;
 }
 template <size_t I, size_t F>
-constexpr FixedPoint<I, F> operator/(FixedPoint<I, F> lhs, FixedPoint<I, F> rhs) {
+CONSTEXPR14 FixedPoint<I, F> operator/(FixedPoint<I, F> lhs, FixedPoint<I, F> rhs) {
     lhs /= rhs;
     return lhs;
 }
 
-template <size_t I, size_t F, IsArithmetic Number>
-constexpr FixedPoint<I, F> operator+(FixedPoint<I, F> lhs, Number rhs) {
+template <size_t I, size_t F, class Number,
+          class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
+CONSTEXPR14 FixedPoint<I, F> operator+(FixedPoint<I, F> lhs, Number rhs) {
     lhs += FixedPoint<I, F>(rhs);
     return lhs;
 }
-template <size_t I, size_t F, IsArithmetic Number>
-constexpr FixedPoint<I, F> operator-(FixedPoint<I, F> lhs, Number rhs) {
+template <size_t I, size_t F, class Number,
+          class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
+CONSTEXPR14 FixedPoint<I, F> operator-(FixedPoint<I, F> lhs, Number rhs) {
     lhs -= FixedPoint<I, F>(rhs);
     return lhs;
 }
-template <size_t I, size_t F, IsArithmetic Number>
-constexpr FixedPoint<I, F> operator*(FixedPoint<I, F> lhs, Number rhs) {
+template <size_t I, size_t F, class Number,
+          class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
+CONSTEXPR14 FixedPoint<I, F> operator*(FixedPoint<I, F> lhs, Number rhs) {
     lhs *= FixedPoint<I, F>(rhs);
     return lhs;
 }
-template <size_t I, size_t F, IsArithmetic Number>
-constexpr FixedPoint<I, F> operator/(FixedPoint<I, F> lhs, Number rhs) {
+template <size_t I, size_t F, class Number,
+          class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
+CONSTEXPR14 FixedPoint<I, F> operator/(FixedPoint<I, F> lhs, Number rhs) {
     lhs /= FixedPoint<I, F>(rhs);
     return lhs;
 }
 
-template <size_t I, size_t F, IsArithmetic Number>
-constexpr FixedPoint<I, F> operator+(Number lhs, FixedPoint<I, F> rhs) {
+template <size_t I, size_t F, class Number,
+          class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
+CONSTEXPR14 FixedPoint<I, F> operator+(Number lhs, FixedPoint<I, F> rhs) {
     FixedPoint<I, F> tmp(lhs);
     tmp += rhs;
     return tmp;
 }
-template <size_t I, size_t F, IsArithmetic Number>
-constexpr FixedPoint<I, F> operator-(Number lhs, FixedPoint<I, F> rhs) {
+template <size_t I, size_t F, class Number,
+          class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
+CONSTEXPR14 FixedPoint<I, F> operator-(Number lhs, FixedPoint<I, F> rhs) {
     FixedPoint<I, F> tmp(lhs);
     tmp -= rhs;
     return tmp;
 }
-template <size_t I, size_t F, IsArithmetic Number>
-constexpr FixedPoint<I, F> operator*(Number lhs, FixedPoint<I, F> rhs) {
+template <size_t I, size_t F, class Number,
+          class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
+CONSTEXPR14 FixedPoint<I, F> operator*(Number lhs, FixedPoint<I, F> rhs) {
     FixedPoint<I, F> tmp(lhs);
     tmp *= rhs;
     return tmp;
 }
-template <size_t I, size_t F, IsArithmetic Number>
-constexpr FixedPoint<I, F> operator/(Number lhs, FixedPoint<I, F> rhs) {
+template <size_t I, size_t F, class Number,
+          class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
+CONSTEXPR14 FixedPoint<I, F> operator/(Number lhs, FixedPoint<I, F> rhs) {
     FixedPoint<I, F> tmp(lhs);
     tmp /= rhs;
     return tmp;
 }
 
 // shift operators
-template <size_t I, size_t F, IsIntegral Integer>
-constexpr FixedPoint<I, F> operator<<(FixedPoint<I, F> lhs, Integer rhs) {
+template <size_t I, size_t F, class Integer,
+          class = typename std::enable_if<std::is_integral<Integer>::value>::type>
+CONSTEXPR14 FixedPoint<I, F> operator<<(FixedPoint<I, F> lhs, Integer rhs) {
     lhs <<= rhs;
     return lhs;
 }
-template <size_t I, size_t F, IsIntegral Integer>
-constexpr FixedPoint<I, F> operator>>(FixedPoint<I, F> lhs, Integer rhs) {
+template <size_t I, size_t F, class Integer,
+          class = typename std::enable_if<std::is_integral<Integer>::value>::type>
+CONSTEXPR14 FixedPoint<I, F> operator>>(FixedPoint<I, F> lhs, Integer rhs) {
     lhs >>= rhs;
     return lhs;
 }
 
 // comparison operators
-template <size_t I, size_t F, IsArithmetic Number>
+template <size_t I, size_t F, class Number,
+          class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
 constexpr bool operator>(FixedPoint<I, F> lhs, Number rhs) {
     return lhs > FixedPoint<I, F>(rhs);
 }
-template <size_t I, size_t F, IsArithmetic Number>
+template <size_t I, size_t F, class Number,
+          class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
 constexpr bool operator<(FixedPoint<I, F> lhs, Number rhs) {
     return lhs < FixedPoint<I, F>(rhs);
 }
-template <size_t I, size_t F, IsArithmetic Number>
+template <size_t I, size_t F, class Number,
+          class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
 constexpr bool operator>=(FixedPoint<I, F> lhs, Number rhs) {
     return lhs >= FixedPoint<I, F>(rhs);
 }
-template <size_t I, size_t F, IsArithmetic Number>
+template <size_t I, size_t F, class Number,
+          class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
 constexpr bool operator<=(FixedPoint<I, F> lhs, Number rhs) {
     return lhs <= FixedPoint<I, F>(rhs);
 }
-template <size_t I, size_t F, IsArithmetic Number>
+template <size_t I, size_t F, class Number,
+          class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
 constexpr bool operator==(FixedPoint<I, F> lhs, Number rhs) {
     return lhs == FixedPoint<I, F>(rhs);
 }
-template <size_t I, size_t F, IsArithmetic Number>
+template <size_t I, size_t F, class Number,
+          class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
 constexpr bool operator!=(FixedPoint<I, F> lhs, Number rhs) {
     return lhs != FixedPoint<I, F>(rhs);
 }
 
-template <size_t I, size_t F, IsArithmetic Number>
+template <size_t I, size_t F, class Number,
+          class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
 constexpr bool operator>(Number lhs, FixedPoint<I, F> rhs) {
     return FixedPoint<I, F>(lhs) > rhs;
 }
-template <size_t I, size_t F, IsArithmetic Number>
+template <size_t I, size_t F, class Number,
+          class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
 constexpr bool operator<(Number lhs, FixedPoint<I, F> rhs) {
     return FixedPoint<I, F>(lhs) < rhs;
 }
-template <size_t I, size_t F, IsArithmetic Number>
+template <size_t I, size_t F, class Number,
+          class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
 constexpr bool operator>=(Number lhs, FixedPoint<I, F> rhs) {
     return FixedPoint<I, F>(lhs) >= rhs;
 }
-template <size_t I, size_t F, IsArithmetic Number>
+template <size_t I, size_t F, class Number,
+          class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
 constexpr bool operator<=(Number lhs, FixedPoint<I, F> rhs) {
     return FixedPoint<I, F>(lhs) <= rhs;
 }
-template <size_t I, size_t F, IsArithmetic Number>
+template <size_t I, size_t F, class Number,
+          class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
 constexpr bool operator==(Number lhs, FixedPoint<I, F> rhs) {
     return FixedPoint<I, F>(lhs) == rhs;
 }
-template <size_t I, size_t F, IsArithmetic Number>
+template <size_t I, size_t F, class Number,
+          class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
 constexpr bool operator!=(Number lhs, FixedPoint<I, F> rhs) {
     return FixedPoint<I, F>(lhs) != rhs;
 }
 
 } // namespace Common
+
+#undef CONSTEXPR14
+
+#endif

src/common/fs/file.h

@@ -209,8 +209,8 @@ public:
 
     /**
      * Helper function which deduces the value type of a contiguous STL container used in ReadSpan.
-     * If T is not a contiguous container as defined by the concept IsContiguousContainer, this
-     * calls ReadObject and T must be a trivially copyable object.
+     * If T is not a contiguous STL container as defined by the concept IsSTLContainer, this calls
+     * ReadObject and T must be a trivially copyable object.
      *
      * See ReadSpan for more details if T is a contiguous container.
      * See ReadObject for more details if T is a trivially copyable object.
@@ -223,7 +223,7 @@ public:
      */
     template <typename T>
     [[nodiscard]] size_t Read(T& data) const {
-        if constexpr (IsContiguousContainer<T>) {
+        if constexpr (IsSTLContainer<T>) {
             using ContiguousType = typename T::value_type;
             static_assert(std::is_trivially_copyable_v<ContiguousType>,
                           "Data type must be trivially copyable.");
@@ -235,8 +235,8 @@ public:
 
     /**
      * Helper function which deduces the value type of a contiguous STL container used in WriteSpan.
-     * If T is not a contiguous STL container as defined by the concept IsContiguousContainer, this
-     * calls WriteObject and T must be a trivially copyable object.
+     * If T is not a contiguous STL container as defined by the concept IsSTLContainer, this calls
+     * WriteObject and T must be a trivially copyable object.
      *
      * See WriteSpan for more details if T is a contiguous container.
      * See WriteObject for more details if T is a trivially copyable object.
@@ -249,7 +249,7 @@ public:
      */
     template <typename T>
     [[nodiscard]] size_t Write(const T& data) const {
-        if constexpr (IsContiguousContainer<T>) {
+        if constexpr (IsSTLContainer<T>) {
             using ContiguousType = typename T::value_type;
             static_assert(std::is_trivially_copyable_v<ContiguousType>,
                           "Data type must be trivially copyable.");

src/common/host_memory.cpp

@@ -359,12 +359,6 @@ public:
             }
         });
 
-        long page_size = sysconf(_SC_PAGESIZE);
-        if (page_size != 0x1000) {
-            LOG_CRITICAL(HW_Memory, "page size {:#x} is incompatible with 4K paging", page_size);
-            throw std::bad_alloc{};
-        }
-
         // Backing memory initialization
 #if defined(__FreeBSD__) && __FreeBSD__ < 13
         // XXX Drop after FreeBSD 12.* reaches EOL on 2024-06-30

src/common/input.h

@@ -100,6 +100,7 @@ enum class CameraError {
 enum class VibrationAmplificationType {
     Linear,
     Exponential,
+    Test,
 };
 
 // Analog properties for calibration
@@ -324,10 +325,6 @@ public:
         return VibrationError::NotSupported;
     }
 
-    virtual bool IsVibrationEnabled() {
-        return false;
-    }
-
     virtual PollingError SetPollingMode([[maybe_unused]] PollingMode polling_mode) {
         return PollingError::NotSupported;
     }

src/common/settings.cpp

@@ -48,7 +48,6 @@ void LogSettings() {
     log_setting("CPU_Accuracy", values.cpu_accuracy.GetValue());
     log_setting("Renderer_UseResolutionScaling", values.resolution_setup.GetValue());
     log_setting("Renderer_ScalingFilter", values.scaling_filter.GetValue());
-    log_setting("Renderer_FSRSlider", values.fsr_sharpening_slider.GetValue());
     log_setting("Renderer_AntiAliasing", values.anti_aliasing.GetValue());
     log_setting("Renderer_UseSpeedLimit", values.use_speed_limit.GetValue());
     log_setting("Renderer_SpeedLimit", values.speed_limit.GetValue());
@@ -152,7 +151,6 @@ void UpdateRescalingInfo() {
         ASSERT(false);
         info.up_scale = 1;
         info.down_shift = 0;
-        break;
     }
     info.up_factor = static_cast<f32>(info.up_scale) / (1U << info.down_shift);
     info.down_factor = static_cast<f32>(1U << info.down_shift) / info.up_scale;
@@ -182,7 +180,6 @@ void RestoreGlobalState(bool is_powered_on) {
     values.cpuopt_unsafe_ignore_global_monitor.SetGlobal(true);
 
     // Renderer
-    values.fsr_sharpening_slider.SetGlobal(true);
     values.renderer_backend.SetGlobal(true);
     values.vulkan_device.SetGlobal(true);
     values.aspect_ratio.SetGlobal(true);

src/common/settings.h

@@ -421,7 +421,6 @@ struct Values {
     ResolutionScalingInfo resolution_info{};
     SwitchableSetting<ResolutionSetup> resolution_setup{ResolutionSetup::Res1X, "resolution_setup"};
     SwitchableSetting<ScalingFilter> scaling_filter{ScalingFilter::Bilinear, "scaling_filter"};
-    SwitchableSetting<int, true> fsr_sharpening_slider{25, 0, 200, "fsr_sharpening_slider"};
     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.
@@ -443,7 +442,7 @@ struct Values {
     SwitchableSetting<NvdecEmulation> nvdec_emulation{NvdecEmulation::GPU, "nvdec_emulation"};
     SwitchableSetting<bool> accelerate_astc{true, "accelerate_astc"};
     SwitchableSetting<bool> use_vsync{true, "use_vsync"};
-    SwitchableSetting<ShaderBackend, true> shader_backend{ShaderBackend::GLSL, ShaderBackend::GLSL,
+    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"};

src/common/x64/cpu_detect.cpp

@@ -4,27 +4,14 @@
 
 #include <array>
 #include <cstring>
-#include <fstream>
 #include <iterator>
-#include <optional>
 #include <string_view>
-#include <thread>
-#include <vector>
 #include "common/bit_util.h"
 #include "common/common_types.h"
-#include "common/logging/log.h"
 #include "common/x64/cpu_detect.h"
 
-#ifdef _WIN32
-#include <windows.h>
-#endif
-
 #ifdef _MSC_VER
 #include <intrin.h>
-
-static inline u64 xgetbv(u32 index) {
-    return _xgetbv(index);
-}
 #else
 
 #if defined(__DragonFly__) || defined(__FreeBSD__)
@@ -52,11 +39,12 @@ static inline void __cpuid(int info[4], u32 function_id) {
 }
 
 #define _XCR_XFEATURE_ENABLED_MASK 0
-static inline u64 xgetbv(u32 index) {
+static inline u64 _xgetbv(u32 index) {
     u32 eax, edx;
     __asm__ __volatile__("xgetbv" : "=a"(eax), "=d"(edx) : "c"(index));
     return ((u64)edx << 32) | eax;
 }
+
 #endif // _MSC_VER
 
 namespace Common {
@@ -119,7 +107,7 @@ static CPUCaps Detect() {
         //  - Is the XSAVE bit set in CPUID?
         //  - XGETBV result has the XCR bit set.
         if (Common::Bit<28>(cpu_id[2]) && Common::Bit<27>(cpu_id[2])) {
-            if ((xgetbv(_XCR_XFEATURE_ENABLED_MASK) & 0x6) == 0x6) {
+            if ((_xgetbv(_XCR_XFEATURE_ENABLED_MASK) & 0x6) == 0x6) {
                 caps.avx = true;
                 if (Common::Bit<12>(cpu_id[2]))
                     caps.fma = true;
@@ -204,45 +192,4 @@ const CPUCaps& GetCPUCaps() {
     return caps;
 }
 
-std::optional<int> GetProcessorCount() {
-#if defined(_WIN32)
-    // Get the buffer length.
-    DWORD length = 0;
-    GetLogicalProcessorInformation(nullptr, &length);
-    if (GetLastError() != ERROR_INSUFFICIENT_BUFFER) {
-        LOG_ERROR(Frontend, "Failed to query core count.");
-        return std::nullopt;
-    }
-    std::vector<SYSTEM_LOGICAL_PROCESSOR_INFORMATION> buffer(
-        length / sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION));
-    // Now query the core count.
-    if (!GetLogicalProcessorInformation(buffer.data(), &length)) {
-        LOG_ERROR(Frontend, "Failed to query core count.");
-        return std::nullopt;
-    }
-    return static_cast<int>(
-        std::count_if(buffer.cbegin(), buffer.cend(), [](const auto& proc_info) {
-            return proc_info.Relationship == RelationProcessorCore;
-        }));
-#elif defined(__unix__)
-    const int thread_count = std::thread::hardware_concurrency();
-    std::ifstream smt("/sys/devices/system/cpu/smt/active");
-    char state = '0';
-    if (smt) {
-        smt.read(&state, sizeof(state));
-    }
-    switch (state) {
-    case '0':
-        return thread_count;
-    case '1':
-        return thread_count / 2;
-    default:
-        return std::nullopt;
-    }
-#else
-    // Shame on you
-    return std::nullopt;
-#endif
-}
-
 } // namespace Common

src/common/x64/cpu_detect.h

@@ -4,7 +4,6 @@
 
 #pragma once
 
-#include <optional>
 #include <string_view>
 #include "common/common_types.h"
 
@@ -75,7 +74,4 @@ struct CPUCaps {
  */
 const CPUCaps& GetCPUCaps();
 
-/// Detects CPU core count
-std::optional<int> GetProcessorCount();
-
 } // namespace Common

src/core/CMakeLists.txt

@@ -120,8 +120,6 @@ add_library(core STATIC
     file_sys/vfs_vector.h
     file_sys/xts_archive.cpp
     file_sys/xts_archive.h
-    frontend/applets/cabinet.cpp
-    frontend/applets/cabinet.h
     frontend/applets/controller.cpp
     frontend/applets/controller.h
     frontend/applets/error.cpp
@@ -192,13 +190,8 @@ add_library(core STATIC
     hle/kernel/k_code_memory.h
     hle/kernel/k_condition_variable.cpp
     hle/kernel/k_condition_variable.h
-    hle/kernel/k_debug.h
-    hle/kernel/k_dynamic_page_manager.h
-    hle/kernel/k_dynamic_resource_manager.h
-    hle/kernel/k_dynamic_slab_heap.h
     hle/kernel/k_event.cpp
     hle/kernel/k_event.h
-    hle/kernel/k_event_info.h
     hle/kernel/k_handle_table.cpp
     hle/kernel/k_handle_table.h
     hle/kernel/k_interrupt_manager.cpp
@@ -226,8 +219,6 @@ add_library(core STATIC
     hle/kernel/k_page_group.h
     hle/kernel/k_page_table.cpp
     hle/kernel/k_page_table.h
-    hle/kernel/k_page_table_manager.h
-    hle/kernel/k_page_table_slab_heap.h
     hle/kernel/k_port.cpp
     hle/kernel/k_port.h
     hle/kernel/k_priority_queue.h
@@ -249,8 +240,6 @@ add_library(core STATIC
     hle/kernel/k_server_session.h
     hle/kernel/k_session.cpp
     hle/kernel/k_session.h
-    hle/kernel/k_session_request.cpp
-    hle/kernel/k_session_request.h
     hle/kernel/k_shared_memory.cpp
     hle/kernel/k_shared_memory.h
     hle/kernel/k_shared_memory_info.h
@@ -260,8 +249,6 @@ add_library(core STATIC
     hle/kernel/k_synchronization_object.cpp
     hle/kernel/k_synchronization_object.h
     hle/kernel/k_system_control.h
-    hle/kernel/k_system_resource.cpp
-    hle/kernel/k_system_resource.h
     hle/kernel/k_thread.cpp
     hle/kernel/k_thread.h
     hle/kernel/k_thread_local_page.cpp
@@ -314,8 +301,6 @@ add_library(core STATIC
     hle/service/am/applet_ae.h
     hle/service/am/applet_oe.cpp
     hle/service/am/applet_oe.h
-    hle/service/am/applets/applet_cabinet.cpp
-    hle/service/am/applets/applet_cabinet.h
     hle/service/am/applets/applet_controller.cpp
     hle/service/am/applets/applet_controller.h
     hle/service/am/applets/applet_error.cpp
@@ -501,6 +486,10 @@ add_library(core STATIC
     hle/service/hid/irsensor/processor_base.h
     hle/service/hid/irsensor/tera_plugin_processor.cpp
     hle/service/hid/irsensor/tera_plugin_processor.h
+    hle/service/jit/jit_context.cpp
+    hle/service/jit/jit_context.h
+    hle/service/jit/jit.cpp
+    hle/service/jit/jit.h
     hle/service/lbl/lbl.cpp
     hle/service/lbl/lbl.h
     hle/service/ldn/lan_discovery.cpp
@@ -530,11 +519,6 @@ add_library(core STATIC
     hle/service/ncm/ncm.h
     hle/service/nfc/nfc.cpp
     hle/service/nfc/nfc.h
-    hle/service/nfc/nfc_device.cpp
-    hle/service/nfc/nfc_device.h
-    hle/service/nfc/nfc_result.h
-    hle/service/nfc/nfc_user.cpp
-    hle/service/nfc/nfc_user.h
     hle/service/nfp/amiibo_crypto.cpp
     hle/service/nfp/amiibo_crypto.h
     hle/service/nfp/nfp.cpp
@@ -785,15 +769,19 @@ 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
-        /we4800 # Implicit conversion from 'type' to bool. Possible information loss
     )
 else()
     target_compile_options(core PRIVATE
         -Werror=conversion
+        -Werror=ignored-qualifiers
 
-        -Wno-sign-conversion
+        $<$<CXX_COMPILER_ID:GNU>:-Werror=class-memaccess>
+        $<$<CXX_COMPILER_ID:GNU>:-Werror=unused-but-set-parameter>
+        $<$<CXX_COMPILER_ID:GNU>:-Werror=unused-but-set-variable>
 
         $<$<CXX_COMPILER_ID:Clang>:-fsized-deallocation>
+
+        -Wno-sign-conversion
     )
 endif()
 
@@ -810,18 +798,14 @@ if (ENABLE_WEB_SERVICE)
     target_link_libraries(core PRIVATE web_service)
 endif()
 
-if (ARCHITECTURE_x86_64 OR ARCHITECTURE_arm64)
+if (ARCHITECTURE_x86_64)
     target_sources(core PRIVATE
-        arm/dynarmic/arm_dynarmic_64.cpp
-        arm/dynarmic/arm_dynarmic_64.h
         arm/dynarmic/arm_dynarmic_32.cpp
         arm/dynarmic/arm_dynarmic_32.h
+        arm/dynarmic/arm_dynarmic_64.cpp
+        arm/dynarmic/arm_dynarmic_64.h
         arm/dynarmic/arm_dynarmic_cp15.cpp
         arm/dynarmic/arm_dynarmic_cp15.h
-        hle/service/jit/jit_context.cpp
-        hle/service/jit/jit_context.h
-        hle/service/jit/jit.cpp
-        hle/service/jit/jit.h
     )
     target_link_libraries(core PRIVATE dynarmic)
 endif()

src/core/arm/arm_interface.cpp

@@ -134,14 +134,6 @@ void ARM_Interface::Run() {
         }
         system.ExitDynarmicProfile();
 
-        // If the thread is scheduled for termination, exit the thread.
-        if (current_thread->HasDpc()) {
-            if (current_thread->IsTerminationRequested()) {
-                current_thread->Exit();
-                UNREACHABLE();
-            }
-        }
-
         // 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)) {

src/core/arm/dynarmic/arm_dynarmic_32.cpp

@@ -301,11 +301,6 @@ std::shared_ptr<Dynarmic::A32::Jit> ARM_Dynarmic_32::MakeJit(Common::PageTable*
         }
     }
 
-#ifdef ARCHITECTURE_arm64
-    // TODO: remove when fixed in dynarmic
-    config.optimizations &= ~Dynarmic::OptimizationFlag::BlockLinking;
-#endif
-
     return std::make_unique<Dynarmic::A32::Jit>(config);
 }
 
@@ -455,7 +450,7 @@ std::vector<ARM_Interface::BacktraceEntry> ARM_Dynarmic_32::GetBacktrace(Core::S
     // Frame records are two words long:
     // fp+0 : pointer to previous frame record
     // fp+4 : value of lr for frame
-    for (size_t i = 0; i < 256; i++) {
+    while (true) {
         out.push_back({"", 0, lr, 0, ""});
         if (!fp || (fp % 4 != 0) || !memory.IsValidVirtualAddressRange(fp, 8)) {
             break;

src/core/arm/dynarmic/arm_dynarmic_64.cpp

@@ -348,6 +348,7 @@ std::shared_ptr<Dynarmic::A64::Jit> ARM_Dynarmic_64::MakeJit(Common::PageTable*
         if (Settings::values.cpu_accuracy.GetValue() == Settings::CPUAccuracy::Auto) {
             config.unsafe_optimizations = true;
             config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_UnfuseFMA;
+            config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_InaccurateNaN;
             config.fastmem_address_space_bits = 64;
             config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_IgnoreGlobalMonitor;
         }
@@ -516,7 +517,7 @@ std::vector<ARM_Interface::BacktraceEntry> ARM_Dynarmic_64::GetBacktrace(Core::S
     // Frame records are two words long:
     // fp+0 : pointer to previous frame record
     // fp+8 : value of lr for frame
-    for (size_t i = 0; i < 256; i++) {
+    while (true) {
         out.push_back({"", 0, lr, 0, ""});
         if (!fp || (fp % 4 != 0) || !memory.IsValidVirtualAddressRange(fp, 16)) {
             break;

src/core/arm/dynarmic/arm_dynarmic_cp15.cpp

@@ -52,16 +52,12 @@ CallbackOrAccessOneWord DynarmicCP15::CompileSendOneWord(bool two, unsigned opc1
         case 4:
             // CP15_DATA_SYNC_BARRIER
             return Callback{
-                [](void*, std::uint32_t, std::uint32_t) -> std::uint64_t {
-#if defined(_MSC_VER) && defined(ARCHITECTURE_x86_64)
+                [](Dynarmic::A32::Jit*, void*, std::uint32_t, std::uint32_t) -> std::uint64_t {
+#ifdef _MSC_VER
                     _mm_mfence();
                     _mm_lfence();
-#elif defined(ARCHITECTURE_x86_64)
-                    asm volatile("mfence\n\tlfence\n\t" : : : "memory");
-#elif defined(ARCHITECTURE_arm64)
-                    asm volatile("dsb sy\n\t" : : : "memory");
 #else
-#error Unsupported architecture
+                    asm volatile("mfence\n\tlfence\n\t" : : : "memory");
 #endif
                     return 0;
                 },
@@ -70,15 +66,11 @@ CallbackOrAccessOneWord DynarmicCP15::CompileSendOneWord(bool two, unsigned opc1
         case 5:
             // CP15_DATA_MEMORY_BARRIER
             return Callback{
-                [](void*, std::uint32_t, std::uint32_t) -> std::uint64_t {
-#if defined(_MSC_VER) && defined(ARCHITECTURE_x86_64)
+                [](Dynarmic::A32::Jit*, void*, std::uint32_t, std::uint32_t) -> std::uint64_t {
+#ifdef _MSC_VER
                     _mm_mfence();
-#elif defined(ARCHITECTURE_x86_64)
-                    asm volatile("mfence\n\t" : : : "memory");
-#elif defined(ARCHITECTURE_arm64)
-                    asm volatile("dmb sy\n\t" : : : "memory");
 #else
-#error Unsupported architecture
+                    asm volatile("mfence\n\t" : : : "memory");
 #endif
                     return 0;
                 },
@@ -123,7 +115,7 @@ CallbackOrAccessOneWord DynarmicCP15::CompileGetOneWord(bool two, unsigned opc1,
 CallbackOrAccessTwoWords DynarmicCP15::CompileGetTwoWords(bool two, unsigned opc, CoprocReg CRm) {
     if (!two && opc == 0 && CRm == CoprocReg::C14) {
         // CNTPCT
-        const auto callback = [](void* arg, u32, u32) -> u64 {
+        const auto callback = [](Dynarmic::A32::Jit*, void* arg, u32, u32) -> u64 {
             const auto& parent_arg = *static_cast<ARM_Dynarmic_32*>(arg);
             return parent_arg.system.CoreTiming().GetClockTicks();
         };

src/core/arm/exclusive_monitor.cpp

@@ -1,7 +1,7 @@
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-#if defined(ARCHITECTURE_x86_64) || defined(ARCHITECTURE_arm64)
+#ifdef ARCHITECTURE_x86_64
 #include "core/arm/dynarmic/arm_exclusive_monitor.h"
 #endif
 #include "core/arm/exclusive_monitor.h"
@@ -13,7 +13,7 @@ ExclusiveMonitor::~ExclusiveMonitor() = default;
 
 std::unique_ptr<Core::ExclusiveMonitor> MakeExclusiveMonitor(Memory::Memory& memory,
                                                              std::size_t num_cores) {
-#if defined(ARCHITECTURE_x86_64) || defined(ARCHITECTURE_arm64)
+#ifdef ARCHITECTURE_x86_64
     return std::make_unique<Core::DynarmicExclusiveMonitor>(memory, num_cores);
 #else
     // TODO(merry): Passthrough exclusive monitor

src/core/core.cpp

@@ -133,56 +133,6 @@ struct System::Impl {
         : kernel{system}, fs_controller{system}, memory{system}, hid_core{}, room_network{},
           cpu_manager{system}, reporter{system}, applet_manager{system}, time_manager{system} {}
 
-    void Initialize(System& system) {
-        device_memory = std::make_unique<Core::DeviceMemory>();
-
-        is_multicore = Settings::values.use_multi_core.GetValue();
-        extended_memory_layout = Settings::values.use_extended_memory_layout.GetValue();
-
-        core_timing.SetMulticore(is_multicore);
-        core_timing.Initialize([&system]() { system.RegisterHostThread(); });
-
-        const auto posix_time = std::chrono::system_clock::now().time_since_epoch();
-        const auto current_time =
-            std::chrono::duration_cast<std::chrono::seconds>(posix_time).count();
-        Settings::values.custom_rtc_differential =
-            Settings::values.custom_rtc.value_or(current_time) - current_time;
-
-        // Create a default fs if one doesn't already exist.
-        if (virtual_filesystem == nullptr) {
-            virtual_filesystem = std::make_shared<FileSys::RealVfsFilesystem>();
-        }
-        if (content_provider == nullptr) {
-            content_provider = std::make_unique<FileSys::ContentProviderUnion>();
-        }
-
-        // Create default implementations of applets if one is not provided.
-        applet_manager.SetDefaultAppletsIfMissing();
-
-        is_async_gpu = Settings::values.use_asynchronous_gpu_emulation.GetValue();
-
-        kernel.SetMulticore(is_multicore);
-        cpu_manager.SetMulticore(is_multicore);
-        cpu_manager.SetAsyncGpu(is_async_gpu);
-    }
-
-    void ReinitializeIfNecessary(System& system) {
-        const bool must_reinitialize =
-            is_multicore != Settings::values.use_multi_core.GetValue() ||
-            extended_memory_layout != Settings::values.use_extended_memory_layout.GetValue();
-
-        if (!must_reinitialize) {
-            return;
-        }
-
-        LOG_DEBUG(Kernel, "Re-initializing");
-
-        is_multicore = Settings::values.use_multi_core.GetValue();
-        extended_memory_layout = Settings::values.use_extended_memory_layout.GetValue();
-
-        Initialize(system);
-    }
-
     SystemResultStatus Run() {
         std::unique_lock<std::mutex> lk(suspend_guard);
         status = SystemResultStatus::Success;
@@ -228,14 +178,37 @@ struct System::Impl {
         debugger = std::make_unique<Debugger>(system, port);
     }
 
-    SystemResultStatus SetupForMainProcess(System& system, Frontend::EmuWindow& emu_window) {
+    SystemResultStatus Init(System& system, Frontend::EmuWindow& emu_window) {
         LOG_DEBUG(Core, "initialized OK");
 
-        // Setting changes may require a full system reinitialization (e.g., disabling multicore).
-        ReinitializeIfNecessary(system);
+        device_memory = std::make_unique<Core::DeviceMemory>();
+
+        is_multicore = Settings::values.use_multi_core.GetValue();
+        is_async_gpu = Settings::values.use_asynchronous_gpu_emulation.GetValue();
+
+        kernel.SetMulticore(is_multicore);
+        cpu_manager.SetMulticore(is_multicore);
+        cpu_manager.SetAsyncGpu(is_async_gpu);
+        core_timing.SetMulticore(is_multicore);
 
         kernel.Initialize();
         cpu_manager.Initialize();
+        core_timing.Initialize([&system]() { system.RegisterHostThread(); });
+
+        const auto posix_time = std::chrono::system_clock::now().time_since_epoch();
+        const auto current_time =
+            std::chrono::duration_cast<std::chrono::seconds>(posix_time).count();
+        Settings::values.custom_rtc_differential =
+            Settings::values.custom_rtc.value_or(current_time) - current_time;
+
+        // Create a default fs if one doesn't already exist.
+        if (virtual_filesystem == nullptr)
+            virtual_filesystem = std::make_shared<FileSys::RealVfsFilesystem>();
+        if (content_provider == nullptr)
+            content_provider = std::make_unique<FileSys::ContentProviderUnion>();
+
+        /// Create default implementations of applets if one is not provided.
+        applet_manager.SetDefaultAppletsIfMissing();
 
         /// Reset all glue registrations
         arp_manager.ResetAll();
@@ -280,11 +253,11 @@ struct System::Impl {
             return SystemResultStatus::ErrorGetLoader;
         }
 
-        SystemResultStatus init_result{SetupForMainProcess(system, emu_window)};
+        SystemResultStatus init_result{Init(system, emu_window)};
         if (init_result != SystemResultStatus::Success) {
             LOG_CRITICAL(Core, "Failed to initialize system (Error {})!",
                          static_cast<int>(init_result));
-            ShutdownMainProcess();
+            Shutdown();
             return init_result;
         }
 
@@ -303,7 +276,7 @@ struct System::Impl {
         const auto [load_result, load_parameters] = app_loader->Load(*main_process, system);
         if (load_result != Loader::ResultStatus::Success) {
             LOG_CRITICAL(Core, "Failed to load ROM (Error {})!", load_result);
-            ShutdownMainProcess();
+            Shutdown();
 
             return static_cast<SystemResultStatus>(
                 static_cast<u32>(SystemResultStatus::ErrorLoader) + static_cast<u32>(load_result));
@@ -362,7 +335,7 @@ struct System::Impl {
         return status;
     }
 
-    void ShutdownMainProcess() {
+    void Shutdown() {
         SetShuttingDown(true);
 
         // Log last frame performance stats if game was loded
@@ -390,14 +363,13 @@ struct System::Impl {
         kernel.ShutdownCores();
         cpu_manager.Shutdown();
         debugger.reset();
-        services->KillNVNFlinger();
         kernel.CloseServices();
         services.reset();
         service_manager.reset();
         cheat_engine.reset();
         telemetry_session.reset();
         time_manager.Shutdown();
-        core_timing.ClearPendingEvents();
+        core_timing.Shutdown();
         app_loader.reset();
         audio_core.reset();
         gpu_core.reset();
@@ -405,6 +377,7 @@ struct System::Impl {
         perf_stats.reset();
         kernel.Shutdown();
         memory.Reset();
+        applet_manager.ClearAll();
 
         if (auto room_member = room_network.GetRoomMember().lock()) {
             Network::GameInfo game_info{};
@@ -527,7 +500,6 @@ struct System::Impl {
 
     bool is_multicore{};
     bool is_async_gpu{};
-    bool extended_memory_layout{};
 
     ExecuteProgramCallback execute_program_callback;
     ExitCallback exit_callback;
@@ -548,10 +520,6 @@ const CpuManager& System::GetCpuManager() const {
     return impl->cpu_manager;
 }
 
-void System::Initialize() {
-    impl->Initialize(*this);
-}
-
 SystemResultStatus System::Run() {
     return impl->Run();
 }
@@ -572,8 +540,8 @@ void System::InvalidateCpuInstructionCacheRange(VAddr addr, std::size_t size) {
     impl->kernel.InvalidateCpuInstructionCacheRange(addr, size);
 }
 
-void System::ShutdownMainProcess() {
-    impl->ShutdownMainProcess();
+void System::Shutdown() {
+    impl->Shutdown();
 }
 
 bool System::IsShuttingDown() const {

src/core/core.h

@@ -142,12 +142,6 @@ public:
     System(System&&) = delete;
     System& operator=(System&&) = delete;
 
-    /**
-     * Initializes the system
-     * This function will initialize core functionaility used for system emulation
-     */
-    void Initialize();
-
     /**
      * Run the OS and Application
      * This function will start emulation and run the relevant devices
@@ -172,8 +166,8 @@ public:
 
     void InvalidateCpuInstructionCacheRange(VAddr addr, std::size_t size);
 
-    /// Shutdown the main emulated process.
-    void ShutdownMainProcess();
+    /// Shutdown the emulated system.
+    void Shutdown();
 
     /// Check if the core is shutting down.
     [[nodiscard]] bool IsShuttingDown() const;

src/core/core_timing.cpp

@@ -40,9 +40,7 @@ struct CoreTiming::Event {
 CoreTiming::CoreTiming()
     : clock{Common::CreateBestMatchingClock(Hardware::BASE_CLOCK_RATE, Hardware::CNTFREQ)} {}
 
-CoreTiming::~CoreTiming() {
-    Reset();
-}
+CoreTiming::~CoreTiming() = default;
 
 void CoreTiming::ThreadEntry(CoreTiming& instance) {
     constexpr char name[] = "HostTiming";
@@ -55,7 +53,6 @@ void CoreTiming::ThreadEntry(CoreTiming& instance) {
 }
 
 void CoreTiming::Initialize(std::function<void()>&& on_thread_init_) {
-    Reset();
     on_thread_init = std::move(on_thread_init_);
     event_fifo_id = 0;
     shutting_down = false;
@@ -68,8 +65,17 @@ void CoreTiming::Initialize(std::function<void()>&& on_thread_init_) {
     }
 }
 
-void CoreTiming::ClearPendingEvents() {
-    event_queue.clear();
+void CoreTiming::Shutdown() {
+    paused = true;
+    shutting_down = true;
+    pause_event.Set();
+    event.Set();
+    if (timer_thread) {
+        timer_thread->join();
+    }
+    ClearPendingEvents();
+    timer_thread.reset();
+    has_started = false;
 }
 
 void CoreTiming::Pause(bool is_paused) {
@@ -190,6 +196,10 @@ u64 CoreTiming::GetClockTicks() const {
     return CpuCyclesToClockCycles(ticks);
 }
 
+void CoreTiming::ClearPendingEvents() {
+    event_queue.clear();
+}
+
 void CoreTiming::RemoveEvent(const std::shared_ptr<EventType>& event_type) {
     std::scoped_lock lock{basic_lock};
 
@@ -297,18 +307,6 @@ void CoreTiming::ThreadLoop() {
     }
 }
 
-void CoreTiming::Reset() {
-    paused = true;
-    shutting_down = true;
-    pause_event.Set();
-    event.Set();
-    if (timer_thread) {
-        timer_thread->join();
-    }
-    timer_thread.reset();
-    has_started = false;
-}
-
 std::chrono::nanoseconds CoreTiming::GetGlobalTimeNs() const {
     if (is_multicore) {
         return clock->GetTimeNS();

src/core/core_timing.h

@@ -61,14 +61,19 @@ public:
     /// required to end slice - 1 and start slice 0 before the first cycle of code is executed.
     void Initialize(std::function<void()>&& on_thread_init_);
 
-    /// Clear all pending events. This should ONLY be done on exit.
-    void ClearPendingEvents();
+    /// Tears down all timing related functionality.
+    void Shutdown();
 
     /// Sets if emulation is multicore or single core, must be set before Initialize
     void SetMulticore(bool is_multicore_) {
         is_multicore = is_multicore_;
     }
 
+    /// Check if it's using host timing.
+    bool IsHostTiming() const {
+        return is_multicore;
+    }
+
     /// Pauses/Unpauses the execution of the timer thread.
     void Pause(bool is_paused);
 
@@ -131,11 +136,12 @@ public:
 private:
     struct Event;
 
+    /// Clear all pending events. This should ONLY be done on exit.
+    void ClearPendingEvents();
+
     static void ThreadEntry(CoreTiming& instance);
     void ThreadLoop();
 
-    void Reset();
-
     std::unique_ptr<Common::WallClock> clock;
 
     s64 global_timer = 0;

src/core/crypto/key_manager.cpp

@@ -578,18 +578,18 @@ KeyManager::KeyManager() {
 
     if (Settings::values.use_dev_keys) {
         dev_mode = true;
-        LoadFromFile(yuzu_keys_dir / "dev.keys_autogenerated", false);
         LoadFromFile(yuzu_keys_dir / "dev.keys", false);
+        LoadFromFile(yuzu_keys_dir / "dev.keys_autogenerated", false);
     } else {
         dev_mode = false;
-        LoadFromFile(yuzu_keys_dir / "prod.keys_autogenerated", false);
         LoadFromFile(yuzu_keys_dir / "prod.keys", false);
+        LoadFromFile(yuzu_keys_dir / "prod.keys_autogenerated", false);
     }
 
-    LoadFromFile(yuzu_keys_dir / "title.keys_autogenerated", true);
     LoadFromFile(yuzu_keys_dir / "title.keys", true);
-    LoadFromFile(yuzu_keys_dir / "console.keys_autogenerated", false);
+    LoadFromFile(yuzu_keys_dir / "title.keys_autogenerated", true);
     LoadFromFile(yuzu_keys_dir / "console.keys", false);
+    LoadFromFile(yuzu_keys_dir / "console.keys_autogenerated", false);
 }
 
 static bool ValidCryptoRevisionString(std::string_view base, size_t begin, size_t length) {

src/core/debugger/debugger.cpp

@@ -27,19 +27,10 @@ static void AsyncReceiveInto(Readable& r, Buffer& buffer, Callback&& c) {
                 const u8* buffer_start = reinterpret_cast<const u8*>(&buffer);
                 std::span<const u8> received_data{buffer_start, buffer_start + bytes_read};
                 c(received_data);
-                AsyncReceiveInto(r, buffer, c);
             }
-        });
-}
 
-template <typename Callback>
-static void AsyncAccept(boost::asio::ip::tcp::acceptor& acceptor, Callback&& c) {
-    acceptor.async_accept([&, c](const boost::system::error_code& error, auto&& peer_socket) {
-        if (!error.failed()) {
-            c(peer_socket);
-            AsyncAccept(acceptor, c);
-        }
-    });
+            AsyncReceiveInto(r, buffer, c);
+        });
 }
 
 template <typename Readable, typename Buffer>
@@ -68,7 +59,9 @@ namespace Core {
 
 class DebuggerImpl : public DebuggerBackend {
 public:
-    explicit DebuggerImpl(Core::System& system_, u16 port) : system{system_} {
+    explicit DebuggerImpl(Core::System& system_, u16 port)
+        : system{system_}, signal_pipe{io_context}, client_socket{io_context} {
+        frontend = std::make_unique<GDBStub>(*this, system);
         InitializeServer(port);
     }
 
@@ -77,42 +70,39 @@ public:
     }
 
     bool SignalDebugger(SignalInfo signal_info) {
-        std::scoped_lock lk{connection_lock};
+        {
+            std::scoped_lock lk{connection_lock};
 
-        if (stopped || !state) {
-            // 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;
-        state->info = signal_info;
-
         // Write a single byte into the pipe to wake up the debug interface.
-        boost::asio::write(state->signal_pipe, boost::asio::buffer(&stopped, sizeof(stopped)));
-
+        boost::asio::write(signal_pipe, boost::asio::buffer(&stopped, sizeof(stopped)));
         return true;
     }
 
-    // These functions are callbacks from the frontend, and the lock will be held.
-    // There is no need to relock it.
-
     std::span<const u8> ReadFromClient() override {
-        return ReceiveInto(state->client_socket, state->client_data);
+        return ReceiveInto(client_socket, client_data);
     }
 
     void WriteToClient(std::span<const u8> data) override {
-        boost::asio::write(state->client_socket,
-                           boost::asio::buffer(data.data(), data.size_bytes()));
+        boost::asio::write(client_socket, boost::asio::buffer(data.data(), data.size_bytes()));
     }
 
     void SetActiveThread(Kernel::KThread* thread) override {
-        state->active_thread = thread;
+        active_thread = thread;
     }
 
     Kernel::KThread* GetActiveThread() override {
-        return state->active_thread;
+        return active_thread;
     }
 
 private:
@@ -123,78 +113,65 @@ private:
 
         // Run the connection thread.
         connection_thread = std::jthread([&, port](std::stop_token stop_token) {
-            Common::SetCurrentThreadName("Debugger");
-
             try {
                 // Initialize the listening socket and accept a new client.
                 tcp::endpoint endpoint{boost::asio::ip::address_v4::any(), port};
                 tcp::acceptor acceptor{io_context, endpoint};
 
-                AsyncAccept(acceptor, [&](auto&& peer) { AcceptConnection(std::move(peer)); });
+                acceptor.async_accept(client_socket, [](const auto&) {});
+                io_context.run_one();
+                io_context.restart();
 
-                while (!stop_token.stop_requested() && io_context.run()) {
+                if (stop_token.stop_requested()) {
+                    return;
                 }
+
+                ThreadLoop(stop_token);
             } catch (const std::exception& ex) {
                 LOG_CRITICAL(Debug_GDBStub, "Stopping server: {}", ex.what());
             }
         });
     }
 
-    void AcceptConnection(boost::asio::ip::tcp::socket&& peer) {
-        LOG_INFO(Debug_GDBStub, "Accepting new peer connection");
-
-        std::scoped_lock lk{connection_lock};
-
-        // Ensure everything is stopped.
-        PauseEmulation();
-
-        // Set up the new frontend.
-        frontend = std::make_unique<GDBStub>(*this, system);
-
-        // Set the new state. This will tear down any existing state.
-        state = ConnectionState{
-            .client_socket{std::move(peer)},
-            .signal_pipe{io_context},
-            .info{},
-            .active_thread{},
-            .client_data{},
-            .pipe_data{},
-        };
-
-        // Set up the client signals for new data.
-        AsyncReceiveInto(state->signal_pipe, state->pipe_data, [&](auto d) { PipeData(d); });
-        AsyncReceiveInto(state->client_socket, state->client_data, [&](auto d) { ClientData(d); });
-
-        // Set the active thread.
-        UpdateActiveThread();
-
-        // Set up the frontend.
-        frontend->Connected();
-    }
-
     void ShutdownServer() {
         connection_thread.request_stop();
         io_context.stop();
         connection_thread.join();
     }
 
-    void PipeData(std::span<const u8> data) {
-        std::scoped_lock lk{connection_lock};
+    void ThreadLoop(std::stop_token stop_token) {
+        Common::SetCurrentThreadName("Debugger");
 
-        switch (state->info.type) {
+        // Set up the client signals for new data.
+        AsyncReceiveInto(signal_pipe, pipe_data, [&](auto d) { PipeData(d); });
+        AsyncReceiveInto(client_socket, client_data, [&](auto d) { ClientData(d); });
+
+        // Set the active thread.
+        UpdateActiveThread();
+
+        // Set up the frontend.
+        frontend->Connected();
+
+        // Main event loop.
+        while (!stop_token.stop_requested() && io_context.run()) {
+        }
+    }
+
+    void PipeData(std::span<const u8> data) {
+        switch (info.type) {
         case SignalType::Stopped:
         case SignalType::Watchpoint:
             // Stop emulation.
             PauseEmulation();
 
             // Notify the client.
-            state->active_thread = state->info.thread;
+            active_thread = info.thread;
             UpdateActiveThread();
 
-            if (state->info.type == SignalType::Watchpoint) {
-                frontend->Watchpoint(state->active_thread, *state->info.watchpoint);
+            if (info.type == SignalType::Watchpoint) {
+                frontend->Watchpoint(active_thread, *info.watchpoint);
             } else {
-                frontend->Stopped(state->active_thread);
+                frontend->Stopped(active_thread);
             }
 
             break;
@@ -202,8 +179,8 @@ private:
             frontend->ShuttingDown();
 
             // Wait for emulation to shut down gracefully now.
-            state->signal_pipe.close();
-            state->client_socket.shutdown(boost::asio::socket_base::shutdown_both);
+            signal_pipe.close();
+            client_socket.shutdown(boost::asio::socket_base::shutdown_both);
             LOG_INFO(Debug_GDBStub, "Shut down server");
 
             break;
@@ -211,16 +188,17 @@ private:
     }
 
     void ClientData(std::span<const u8> data) {
-        std::scoped_lock lk{connection_lock};
-
         const auto actions{frontend->ClientData(data)};
         for (const auto action : actions) {
             switch (action) {
             case DebuggerAction::Interrupt: {
-                stopped = true;
+                {
+                    std::scoped_lock lk{connection_lock};
+                    stopped = true;
+                }
                 PauseEmulation();
                 UpdateActiveThread();
-                frontend->Stopped(state->active_thread);
+                frontend->Stopped(active_thread);
                 break;
             }
             case DebuggerAction::Continue:
@@ -228,15 +206,15 @@ private:
                 break;
             case DebuggerAction::StepThreadUnlocked:
                 MarkResumed([&] {
-                    state->active_thread->SetStepState(Kernel::StepState::StepPending);
-                    state->active_thread->Resume(Kernel::SuspendType::Debug);
-                    ResumeEmulation(state->active_thread);
+                    active_thread->SetStepState(Kernel::StepState::StepPending);
+                    active_thread->Resume(Kernel::SuspendType::Debug);
+                    ResumeEmulation(active_thread);
                 });
                 break;
             case DebuggerAction::StepThreadLocked: {
                 MarkResumed([&] {
-                    state->active_thread->SetStepState(Kernel::StepState::StepPending);
-                    state->active_thread->Resume(Kernel::SuspendType::Debug);
+                    active_thread->SetStepState(Kernel::StepState::StepPending);
+                    active_thread->Resume(Kernel::SuspendType::Debug);
                 });
                 break;
             }
@@ -276,14 +254,15 @@ private:
     template <typename Callback>
     void MarkResumed(Callback&& cb) {
         Kernel::KScopedSchedulerLock sl{system.Kernel()};
+        std::scoped_lock cl{connection_lock};
         stopped = false;
         cb();
     }
 
     void UpdateActiveThread() {
         const auto& threads{ThreadList()};
-        if (std::find(threads.begin(), threads.end(), state->active_thread) == threads.end()) {
-            state->active_thread = threads[0];
+        if (std::find(threads.begin(), threads.end(), active_thread) == threads.end()) {
+            active_thread = threads[0];
         }
     }
 
@@ -295,22 +274,18 @@ private:
     System& system;
     std::unique_ptr<DebuggerFrontend> frontend;
 
-    boost::asio::io_context io_context;
     std::jthread connection_thread;
     std::mutex connection_lock;
+    boost::asio::io_context io_context;
+    boost::process::async_pipe signal_pipe;
+    boost::asio::ip::tcp::socket client_socket;
 
-    struct ConnectionState {
-        boost::asio::ip::tcp::socket client_socket;
-        boost::process::async_pipe signal_pipe;
+    SignalInfo info;
+    Kernel::KThread* active_thread;
+    bool pipe_data;
+    bool stopped;
 
-        SignalInfo info;
-        Kernel::KThread* active_thread;
-        std::array<u8, 4096> client_data;
-        bool pipe_data;
-    };
-
-    std::optional<ConnectionState> state{};
-    bool stopped{};
+    std::array<u8, 4096> client_data;
 };
 
 Debugger::Debugger(Core::System& system, u16 port) {

src/core/debugger/gdbstub.cpp

@@ -606,8 +606,6 @@ void GDBStub::HandleQuery(std::string_view command) {
     } else if (command.starts_with("StartNoAckMode")) {
         no_ack = true;
         SendReply(GDB_STUB_REPLY_OK);
-    } else if (command.starts_with("Rcmd,")) {
-        HandleRcmd(Common::HexStringToVector(command.substr(5), false));
     } else {
         SendReply(GDB_STUB_REPLY_EMPTY);
     }
@@ -647,155 +645,6 @@ void GDBStub::HandleVCont(std::string_view command, std::vector<DebuggerAction>&
     }
 }
 
-constexpr std::array<std::pair<const char*, Kernel::Svc::MemoryState>, 22> MemoryStateNames{{
-    {"----- Free -----", Kernel::Svc::MemoryState::Free},
-    {"Io              ", Kernel::Svc::MemoryState::Io},
-    {"Static          ", Kernel::Svc::MemoryState::Static},
-    {"Code            ", Kernel::Svc::MemoryState::Code},
-    {"CodeData        ", Kernel::Svc::MemoryState::CodeData},
-    {"Normal          ", Kernel::Svc::MemoryState::Normal},
-    {"Shared          ", Kernel::Svc::MemoryState::Shared},
-    {"AliasCode       ", Kernel::Svc::MemoryState::AliasCode},
-    {"AliasCodeData   ", Kernel::Svc::MemoryState::AliasCodeData},
-    {"Ipc             ", Kernel::Svc::MemoryState::Ipc},
-    {"Stack           ", Kernel::Svc::MemoryState::Stack},
-    {"ThreadLocal     ", Kernel::Svc::MemoryState::ThreadLocal},
-    {"Transfered      ", Kernel::Svc::MemoryState::Transfered},
-    {"SharedTransfered", Kernel::Svc::MemoryState::SharedTransfered},
-    {"SharedCode      ", Kernel::Svc::MemoryState::SharedCode},
-    {"Inaccessible    ", Kernel::Svc::MemoryState::Inaccessible},
-    {"NonSecureIpc    ", Kernel::Svc::MemoryState::NonSecureIpc},
-    {"NonDeviceIpc    ", Kernel::Svc::MemoryState::NonDeviceIpc},
-    {"Kernel          ", Kernel::Svc::MemoryState::Kernel},
-    {"GeneratedCode   ", Kernel::Svc::MemoryState::GeneratedCode},
-    {"CodeOut         ", Kernel::Svc::MemoryState::CodeOut},
-    {"Coverage        ", Kernel::Svc::MemoryState::Coverage},
-}};
-
-static constexpr const char* GetMemoryStateName(Kernel::Svc::MemoryState state) {
-    for (size_t i = 0; i < MemoryStateNames.size(); i++) {
-        if (std::get<1>(MemoryStateNames[i]) == state) {
-            return std::get<0>(MemoryStateNames[i]);
-        }
-    }
-    return "Unknown         ";
-}
-
-static constexpr const char* GetMemoryPermissionString(const Kernel::Svc::MemoryInfo& info) {
-    if (info.state == Kernel::Svc::MemoryState::Free) {
-        return "   ";
-    }
-
-    switch (info.permission) {
-    case Kernel::Svc::MemoryPermission::ReadExecute:
-        return "r-x";
-    case Kernel::Svc::MemoryPermission::Read:
-        return "r--";
-    case Kernel::Svc::MemoryPermission::ReadWrite:
-        return "rw-";
-    default:
-        return "---";
-    }
-}
-
-static VAddr GetModuleEnd(Kernel::KPageTable& page_table, VAddr base) {
-    Kernel::Svc::MemoryInfo mem_info;
-    VAddr cur_addr{base};
-
-    // Expect: r-x Code (.text)
-    mem_info = page_table.QueryInfo(cur_addr).GetSvcMemoryInfo();
-    cur_addr = mem_info.base_address + mem_info.size;
-    if (mem_info.state != Kernel::Svc::MemoryState::Code ||
-        mem_info.permission != Kernel::Svc::MemoryPermission::ReadExecute) {
-        return cur_addr - 1;
-    }
-
-    // Expect: r-- Code (.rodata)
-    mem_info = page_table.QueryInfo(cur_addr).GetSvcMemoryInfo();
-    cur_addr = mem_info.base_address + mem_info.size;
-    if (mem_info.state != Kernel::Svc::MemoryState::Code ||
-        mem_info.permission != Kernel::Svc::MemoryPermission::Read) {
-        return cur_addr - 1;
-    }
-
-    // Expect: rw- CodeData (.data)
-    mem_info = page_table.QueryInfo(cur_addr).GetSvcMemoryInfo();
-    cur_addr = mem_info.base_address + mem_info.size;
-    return cur_addr - 1;
-}
-
-void GDBStub::HandleRcmd(const std::vector<u8>& command) {
-    std::string_view command_str{reinterpret_cast<const char*>(&command[0]), command.size()};
-    std::string reply;
-
-    auto* process = system.CurrentProcess();
-    auto& page_table = process->PageTable();
-
-    if (command_str == "get info") {
-        Loader::AppLoader::Modules modules;
-        system.GetAppLoader().ReadNSOModules(modules);
-
-        reply = fmt::format("Process:     {:#x} ({})\n"
-                            "Program Id:  {:#018x}\n",
-                            process->GetProcessID(), process->GetName(), process->GetProgramID());
-        reply +=
-            fmt::format("Layout:\n"
-                        "  Alias: {:#012x} - {:#012x}\n"
-                        "  Heap:  {:#012x} - {:#012x}\n"
-                        "  Aslr:  {:#012x} - {:#012x}\n"
-                        "  Stack: {:#012x} - {:#012x}\n"
-                        "Modules:\n",
-                        page_table.GetAliasRegionStart(), page_table.GetAliasRegionEnd(),
-                        page_table.GetHeapRegionStart(), page_table.GetHeapRegionEnd(),
-                        page_table.GetAliasCodeRegionStart(), page_table.GetAliasCodeRegionEnd(),
-                        page_table.GetStackRegionStart(), page_table.GetStackRegionEnd());
-
-        for (const auto& [vaddr, name] : modules) {
-            reply += fmt::format("  {:#012x} - {:#012x} {}\n", vaddr,
-                                 GetModuleEnd(page_table, vaddr), name);
-        }
-    } else if (command_str == "get mappings") {
-        reply = "Mappings:\n";
-        VAddr cur_addr = 0;
-
-        while (true) {
-            using MemoryAttribute = Kernel::Svc::MemoryAttribute;
-
-            auto mem_info = page_table.QueryInfo(cur_addr).GetSvcMemoryInfo();
-
-            if (mem_info.state != Kernel::Svc::MemoryState::Inaccessible ||
-                mem_info.base_address + mem_info.size - 1 != std::numeric_limits<u64>::max()) {
-                const char* state = GetMemoryStateName(mem_info.state);
-                const char* perm = GetMemoryPermissionString(mem_info);
-
-                const char l = True(mem_info.attribute & MemoryAttribute::Locked) ? 'L' : '-';
-                const char i = True(mem_info.attribute & MemoryAttribute::IpcLocked) ? 'I' : '-';
-                const char d = True(mem_info.attribute & MemoryAttribute::DeviceShared) ? 'D' : '-';
-                const char u = True(mem_info.attribute & MemoryAttribute::Uncached) ? 'U' : '-';
-
-                reply +=
-                    fmt::format("  {:#012x} - {:#012x} {} {} {}{}{}{} [{}, {}]\n",
-                                mem_info.base_address, mem_info.base_address + mem_info.size - 1,
-                                perm, state, l, i, d, u, mem_info.ipc_count, mem_info.device_count);
-            }
-
-            const uintptr_t next_address = mem_info.base_address + mem_info.size;
-            if (next_address <= cur_addr) {
-                break;
-            }
-
-            cur_addr = next_address;
-        }
-    } else if (command_str == "help") {
-        reply = "Commands:\n  get info\n  get mappings\n";
-    } else {
-        reply = "Unknown command.\nCommands:\n  get info\n  get mappings\n";
-    }
-
-    std::span<const u8> reply_span{reinterpret_cast<u8*>(&reply.front()), reply.size()};
-    SendReply(Common::HexToString(reply_span, false));
-}
-
 Kernel::KThread* GDBStub::GetThreadByID(u64 thread_id) {
     const auto& threads{system.GlobalSchedulerContext().GetThreadList()};
     for (auto* thread : threads) {

src/core/debugger/gdbstub.h

@@ -32,7 +32,6 @@ private:
     void ExecuteCommand(std::string_view packet, std::vector<DebuggerAction>& actions);
     void HandleVCont(std::string_view command, std::vector<DebuggerAction>& actions);
     void HandleQuery(std::string_view command);
-    void HandleRcmd(const std::vector<u8>& command);
     void HandleBreakpointInsert(std::string_view command);
     void HandleBreakpointRemove(std::string_view command);
     std::vector<char>::const_iterator CommandEnd() const;

src/core/device_memory.h

@@ -31,14 +31,12 @@ public:
                DramMemoryMap::Base;
     }
 
-    template <typename T>
-    T* GetPointer(PAddr addr) {
-        return reinterpret_cast<T*>(buffer.BackingBasePointer() + (addr - DramMemoryMap::Base));
+    u8* GetPointer(PAddr addr) {
+        return buffer.BackingBasePointer() + (addr - DramMemoryMap::Base);
     }
 
-    template <typename T>
-    const T* GetPointer(PAddr addr) const {
-        return reinterpret_cast<T*>(buffer.BackingBasePointer() + (addr - DramMemoryMap::Base));
+    const u8* GetPointer(PAddr addr) const {
+        return buffer.BackingBasePointer() + (addr - DramMemoryMap::Base);
     }
 
     Common::HostMemory buffer;

src/core/file_sys/card_image.cpp

@@ -232,8 +232,8 @@ const std::vector<std::shared_ptr<NCA>>& XCI::GetNCAs() const {
 
 std::shared_ptr<NCA> XCI::GetNCAByType(NCAContentType type) const {
     const auto program_id = secure_partition->GetProgramTitleID();
-    const auto iter =
-        std::find_if(ncas.begin(), ncas.end(), [type, program_id](const std::shared_ptr<NCA>& nca) {
+    const auto iter = std::find_if(
+        ncas.begin(), ncas.end(), [this, type, program_id](const std::shared_ptr<NCA>& nca) {
             return nca->GetType() == type && nca->GetTitleId() == program_id;
         });
     return iter == ncas.end() ? nullptr : *iter;

src/core/file_sys/control_metadata.cpp

@@ -1,7 +1,6 @@
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-#include "common/settings.h"
 #include "common/string_util.h"
 #include "common/swap.h"
 #include "core/file_sys/control_metadata.h"
@@ -38,27 +37,6 @@ std::string LanguageEntry::GetDeveloperName() const {
                                                        developer_name.size());
 }
 
-constexpr std::array<Language, 18> language_to_codes = {{
-    Language::Japanese,
-    Language::AmericanEnglish,
-    Language::French,
-    Language::German,
-    Language::Italian,
-    Language::Spanish,
-    Language::Chinese,
-    Language::Korean,
-    Language::Dutch,
-    Language::Portuguese,
-    Language::Russian,
-    Language::Taiwanese,
-    Language::BritishEnglish,
-    Language::CanadianFrench,
-    Language::LatinAmericanSpanish,
-    Language::Chinese,
-    Language::Taiwanese,
-    Language::BrazilianPortuguese,
-}};
-
 NACP::NACP() = default;
 
 NACP::NACP(VirtualFile file) {
@@ -67,13 +45,9 @@ NACP::NACP(VirtualFile file) {
 
 NACP::~NACP() = default;
 
-const LanguageEntry& NACP::GetLanguageEntry() const {
-    Language language = language_to_codes[Settings::values.language_index.GetValue()];
-
-    {
-        const auto& language_entry = raw.language_entries.at(static_cast<u8>(language));
-        if (!language_entry.GetApplicationName().empty())
-            return language_entry;
+const LanguageEntry& NACP::GetLanguageEntry(Language language) const {
+    if (language != Language::Default) {
+        return raw.language_entries.at(static_cast<u8>(language));
     }
 
     for (const auto& language_entry : raw.language_entries) {
@@ -81,15 +55,16 @@ const LanguageEntry& NACP::GetLanguageEntry() const {
             return language_entry;
     }
 
-    return raw.language_entries.at(static_cast<u8>(Language::AmericanEnglish));
+    // Fallback to English
+    return GetLanguageEntry(Language::AmericanEnglish);
 }
 
-std::string NACP::GetApplicationName() const {
-    return GetLanguageEntry().GetApplicationName();
+std::string NACP::GetApplicationName(Language language) const {
+    return GetLanguageEntry(language).GetApplicationName();
 }
 
-std::string NACP::GetDeveloperName() const {
-    return GetLanguageEntry().GetDeveloperName();
+std::string NACP::GetDeveloperName(Language language) const {
+    return GetLanguageEntry(language).GetDeveloperName();
 }
 
 u64 NACP::GetTitleId() const {

src/core/file_sys/control_metadata.h

@@ -101,9 +101,9 @@ public:
     explicit NACP(VirtualFile file);
     ~NACP();
 
-    const LanguageEntry& GetLanguageEntry() const;
-    std::string GetApplicationName() const;
-    std::string GetDeveloperName() const;
+    const LanguageEntry& GetLanguageEntry(Language language = Language::Default) const;
+    std::string GetApplicationName(Language language = Language::Default) const;
+    std::string GetDeveloperName(Language language = Language::Default) const;
     u64 GetTitleId() const;
     u64 GetDLCBaseTitleId() const;
     std::string GetVersionString() const;

src/core/file_sys/program_metadata.cpp

@@ -127,7 +127,7 @@ void ProgramMetadata::LoadManual(bool is_64_bit, ProgramAddressSpaceType address
 }
 
 bool ProgramMetadata::Is64BitProgram() const {
-    return npdm_header.has_64_bit_instructions.As<bool>();
+    return npdm_header.has_64_bit_instructions;
 }
 
 ProgramAddressSpaceType ProgramMetadata::GetAddressSpaceType() const {

src/core/file_sys/savedata_factory.cpp

@@ -5,7 +5,6 @@
 #include "common/assert.h"
 #include "common/common_types.h"
 #include "common/logging/log.h"
-#include "common/uuid.h"
 #include "core/core.h"
 #include "core/file_sys/savedata_factory.h"
 #include "core/file_sys/vfs.h"
@@ -60,36 +59,6 @@ bool ShouldSaveDataBeAutomaticallyCreated(SaveDataSpaceId space, const SaveDataA
             attr.title_id == 0 && attr.save_id == 0);
 }
 
-std::string GetFutureSaveDataPath(SaveDataSpaceId space_id, SaveDataType type, u64 title_id,
-                                  u128 user_id) {
-    // Only detect nand user saves.
-    const auto space_id_path = [space_id]() -> std::string_view {
-        switch (space_id) {
-        case SaveDataSpaceId::NandUser:
-            return "/user/save";
-        default:
-            return "";
-        }
-    }();
-
-    if (space_id_path.empty()) {
-        return "";
-    }
-
-    Common::UUID uuid;
-    std::memcpy(uuid.uuid.data(), user_id.data(), sizeof(Common::UUID));
-
-    // Only detect account/device saves from the future location.
-    switch (type) {
-    case SaveDataType::SaveData:
-        return fmt::format("{}/account/{}/{:016X}/1", space_id_path, uuid.RawString(), title_id);
-    case SaveDataType::DeviceSaveData:
-        return fmt::format("{}/device/{:016X}/1", space_id_path, title_id);
-    default:
-        return "";
-    }
-}
-
 } // Anonymous namespace
 
 std::string SaveDataAttribute::DebugInfo() const {
@@ -113,7 +82,7 @@ ResultVal<VirtualDir> SaveDataFactory::Create(SaveDataSpaceId space,
     PrintSaveDataAttributeWarnings(meta);
 
     const auto save_directory =
-        GetFullPath(system, dir, space, meta.type, meta.title_id, meta.user_id, meta.save_id);
+        GetFullPath(system, space, meta.type, meta.title_id, meta.user_id, meta.save_id);
 
     auto out = dir->CreateDirectoryRelative(save_directory);
 
@@ -130,7 +99,7 @@ ResultVal<VirtualDir> SaveDataFactory::Open(SaveDataSpaceId space,
                                             const SaveDataAttribute& meta) const {
 
     const auto save_directory =
-        GetFullPath(system, dir, space, meta.type, meta.title_id, meta.user_id, meta.save_id);
+        GetFullPath(system, space, meta.type, meta.title_id, meta.user_id, meta.save_id);
 
     auto out = dir->GetDirectoryRelative(save_directory);
 
@@ -165,9 +134,9 @@ std::string SaveDataFactory::GetSaveDataSpaceIdPath(SaveDataSpaceId space) {
     }
 }
 
-std::string SaveDataFactory::GetFullPath(Core::System& system, VirtualDir dir,
-                                         SaveDataSpaceId space, SaveDataType type, u64 title_id,
-                                         u128 user_id, u64 save_id) {
+std::string SaveDataFactory::GetFullPath(Core::System& system, SaveDataSpaceId space,
+                                         SaveDataType type, u64 title_id, u128 user_id,
+                                         u64 save_id) {
     // According to switchbrew, if a save is of type SaveData and the title id field is 0, it should
     // be interpreted as the title id of the current process.
     if (type == SaveDataType::SaveData || type == SaveDataType::DeviceSaveData) {
@@ -176,17 +145,6 @@ std::string SaveDataFactory::GetFullPath(Core::System& system, VirtualDir dir,
         }
     }
 
-    // For compat with a future impl.
-    if (std::string future_path =
-            GetFutureSaveDataPath(space, type, title_id & ~(0xFFULL), user_id);
-        !future_path.empty()) {
-        // Check if this location exists, and prefer it over the old.
-        if (const auto future_dir = dir->GetDirectoryRelative(future_path); future_dir != nullptr) {
-            LOG_INFO(Service_FS, "Using save at new location: {}", future_path);
-            return future_path;
-        }
-    }
-
     std::string out = GetSaveDataSpaceIdPath(space);
 
     switch (type) {
@@ -209,8 +167,7 @@ std::string SaveDataFactory::GetFullPath(Core::System& system, VirtualDir dir,
 
 SaveDataSize SaveDataFactory::ReadSaveDataSize(SaveDataType type, u64 title_id,
                                                u128 user_id) const {
-    const auto path =
-        GetFullPath(system, dir, SaveDataSpaceId::NandUser, type, title_id, user_id, 0);
+    const auto path = GetFullPath(system, SaveDataSpaceId::NandUser, type, title_id, user_id, 0);
     const auto relative_dir = GetOrCreateDirectoryRelative(dir, path);
 
     const auto size_file = relative_dir->GetFile(SAVE_DATA_SIZE_FILENAME);
@@ -228,8 +185,7 @@ SaveDataSize SaveDataFactory::ReadSaveDataSize(SaveDataType type, u64 title_id,
 
 void SaveDataFactory::WriteSaveDataSize(SaveDataType type, u64 title_id, u128 user_id,
                                         SaveDataSize new_value) const {
-    const auto path =
-        GetFullPath(system, dir, SaveDataSpaceId::NandUser, type, title_id, user_id, 0);
+    const auto path = GetFullPath(system, SaveDataSpaceId::NandUser, type, title_id, user_id, 0);
     const auto relative_dir = GetOrCreateDirectoryRelative(dir, path);
 
     const auto size_file = relative_dir->CreateFile(SAVE_DATA_SIZE_FILENAME);

src/core/file_sys/savedata_factory.h

@@ -95,8 +95,8 @@ public:
     VirtualDir GetSaveDataSpaceDirectory(SaveDataSpaceId space) const;
 
     static std::string GetSaveDataSpaceIdPath(SaveDataSpaceId space);
-    static std::string GetFullPath(Core::System& system, VirtualDir dir, SaveDataSpaceId space,
-                                   SaveDataType type, u64 title_id, u128 user_id, u64 save_id);
+    static std::string GetFullPath(Core::System& system, SaveDataSpaceId space, SaveDataType type,
+                                   u64 title_id, u128 user_id, u64 save_id);
 
     SaveDataSize ReadSaveDataSize(SaveDataType type, u64 title_id, u128 user_id) const;
     void WriteSaveDataSize(SaveDataType type, u64 title_id, u128 user_id,

src/core/frontend/applets/cabinet.cpp

@@ -1,20 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include "common/logging/log.h"
-#include "core/frontend/applets/cabinet.h"
-
-#include <thread>
-
-namespace Core::Frontend {
-
-CabinetApplet::~CabinetApplet() = default;
-
-void DefaultCabinetApplet::ShowCabinetApplet(
-    const CabinetCallback& callback, const CabinetParameters& parameters,
-    std::shared_ptr<Service::NFP::NfpDevice> nfp_device) const {
-    LOG_WARNING(Service_AM, "(STUBBED) called");
-    callback(false, {});
-}
-
-} // namespace Core::Frontend

src/core/frontend/applets/cabinet.h

@@ -1,37 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include <functional>
-#include "core/hle/service/nfp/nfp_types.h"
-
-namespace Service::NFP {
-class NfpDevice;
-} // namespace Service::NFP
-
-namespace Core::Frontend {
-
-struct CabinetParameters {
-    Service::NFP::TagInfo tag_info;
-    Service::NFP::RegisterInfo register_info;
-    Service::NFP::CabinetMode mode;
-};
-
-using CabinetCallback = std::function<void(bool, const std::string&)>;
-
-class CabinetApplet {
-public:
-    virtual ~CabinetApplet();
-    virtual void ShowCabinetApplet(const CabinetCallback& callback,
-                                   const CabinetParameters& parameters,
-                                   std::shared_ptr<Service::NFP::NfpDevice> nfp_device) const = 0;
-};
-
-class DefaultCabinetApplet final : public CabinetApplet {
-public:
-    void ShowCabinetApplet(const CabinetCallback& callback, const CabinetParameters& parameters,
-                           std::shared_ptr<Service::NFP::NfpDevice> nfp_device) const override;
-};
-
-} // namespace Core::Frontend

src/core/hid/emulated_console.cpp

@@ -19,26 +19,27 @@ void EmulatedConsole::ReloadFromSettings() {
 }
 
 void EmulatedConsole::SetTouchParams() {
+    // TODO(german77): Support any number of fingers
     std::size_t index = 0;
 
-    // We can't use mouse as touch if native mouse is enabled
+    // Hardcode mouse, touchscreen and cemuhook parameters
     if (!Settings::values.mouse_enabled) {
+        // We can't use mouse as touch if native mouse is enabled
         touch_params[index++] = Common::ParamPackage{"engine:mouse,axis_x:10,axis_y:11,button:0"};
     }
 
     touch_params[index++] =
-        Common::ParamPackage{"engine:cemuhookudp,axis_x:17,axis_y:18,button:65536"};
+        Common::ParamPackage{"engine:touch,axis_x:0,axis_y:1,button:0,touch_id:0"};
     touch_params[index++] =
-        Common::ParamPackage{"engine:cemuhookudp,axis_x:19,axis_y:20,button:131072"};
-
-    for (int i = 0; i < static_cast<int>(MaxActiveTouchInputs); i++) {
-        Common::ParamPackage touchscreen_param{};
-        touchscreen_param.Set("engine", "touch");
-        touchscreen_param.Set("axis_x", i * 2);
-        touchscreen_param.Set("axis_y", (i * 2) + 1);
-        touchscreen_param.Set("button", i);
-        touch_params[index++] = touchscreen_param;
-    }
+        Common::ParamPackage{"engine:touch,axis_x:2,axis_y:3,button:1,touch_id:1"};
+    touch_params[index++] =
+        Common::ParamPackage{"engine:touch,axis_x:4,axis_y:5,button:2,touch_id:2"};
+    touch_params[index++] =
+        Common::ParamPackage{"engine:touch,axis_x:6,axis_y:7,button:3,touch_id:3"};
+    touch_params[index++] =
+        Common::ParamPackage{"engine:cemuhookudp,axis_x:17,axis_y:18,button:65536,touch_id:0"};
+    touch_params[index++] =
+        Common::ParamPackage{"engine:cemuhookudp,axis_x:19,axis_y:20,button:131072,touch_id:1"};
 
     const auto button_index =
         static_cast<u64>(Settings::values.touch_from_button_map_index.GetValue());
@@ -46,7 +47,7 @@ void EmulatedConsole::SetTouchParams() {
 
     // Map the rest of the fingers from touch from button configuration
     for (const auto& config_entry : touch_buttons) {
-        if (index >= MaxTouchDevices) {
+        if (index >= touch_params.size()) {
             continue;
         }
         Common::ParamPackage params{config_entry};
@@ -59,6 +60,7 @@ void EmulatedConsole::SetTouchParams() {
         touch_button_params.Set("button", params.Serialize());
         touch_button_params.Set("x", x);
         touch_button_params.Set("y", y);
+        touch_button_params.Set("touch_id", static_cast<int>(index));
         touch_params[index] = touch_button_params;
         index++;
     }
@@ -176,38 +178,12 @@ void EmulatedConsole::SetMotion(const Common::Input::CallbackStatus& callback) {
 }
 
 void EmulatedConsole::SetTouch(const Common::Input::CallbackStatus& callback, std::size_t index) {
-    if (index >= MaxTouchDevices) {
+    if (index >= console.touch_values.size()) {
         return;
     }
     std::unique_lock lock{mutex};
 
-    const auto touch_input = TransformToTouch(callback);
-    auto touch_index = GetIndexFromFingerId(index);
-    bool is_new_input = false;
-
-    if (!touch_index.has_value() && touch_input.pressed.value) {
-        touch_index = GetNextFreeIndex();
-        is_new_input = true;
-    }
-
-    // No free entries or invalid state. Ignore input
-    if (!touch_index.has_value()) {
-        return;
-    }
-
-    auto& touch_value = console.touch_values[touch_index.value()];
-
-    if (is_new_input) {
-        touch_value.pressed.value = true;
-        touch_value.id = static_cast<u32>(index);
-    }
-
-    touch_value.x = touch_input.x;
-    touch_value.y = touch_input.y;
-
-    if (!touch_input.pressed.value) {
-        touch_value.pressed.value = false;
-    }
+    console.touch_values[index] = TransformToTouch(callback);
 
     if (is_configuring) {
         lock.unlock();
@@ -215,15 +191,11 @@ void EmulatedConsole::SetTouch(const Common::Input::CallbackStatus& callback, st
         return;
     }
 
-    // Touch outside allowed range. Ignore input
-    if (touch_index.value() >= MaxActiveTouchInputs) {
-        return;
-    }
-
-    console.touch_state[touch_index.value()] = {
-        .position = {touch_value.x.value, touch_value.y.value},
-        .id = static_cast<u32>(touch_index.value()),
-        .pressed = touch_input.pressed.value,
+    // TODO(german77): Remap touch id in sequential order
+    console.touch_state[index] = {
+        .position = {console.touch_values[index].x.value, console.touch_values[index].y.value},
+        .id = static_cast<u32>(console.touch_values[index].id),
+        .pressed = console.touch_values[index].pressed.value,
     };
 
     lock.unlock();
@@ -250,28 +222,6 @@ TouchFingerState EmulatedConsole::GetTouch() const {
     return console.touch_state;
 }
 
-std::optional<std::size_t> EmulatedConsole::GetIndexFromFingerId(std::size_t finger_id) const {
-    for (std::size_t index = 0; index < MaxTouchDevices; ++index) {
-        const auto& finger = console.touch_values[index];
-        if (!finger.pressed.value) {
-            continue;
-        }
-        if (finger.id == static_cast<int>(finger_id)) {
-            return index;
-        }
-    }
-    return std::nullopt;
-}
-
-std::optional<std::size_t> EmulatedConsole::GetNextFreeIndex() const {
-    for (std::size_t index = 0; index < MaxTouchDevices; ++index) {
-        if (!console.touch_values[index].pressed.value) {
-            return index;
-        }
-    }
-    return std::nullopt;
-}
-
 void EmulatedConsole::TriggerOnChange(ConsoleTriggerType type) {
     std::scoped_lock lock{callback_mutex};
     for (const auto& poller_pair : callback_list) {

src/core/hid/emulated_console.h

@@ -7,7 +7,6 @@
 #include <functional>
 #include <memory>
 #include <mutex>
-#include <optional>
 #include <unordered_map>
 
 #include "common/common_funcs.h"
@@ -21,8 +20,6 @@
 #include "core/hid/motion_input.h"
 
 namespace Core::HID {
-static constexpr std::size_t MaxTouchDevices = 32;
-static constexpr std::size_t MaxActiveTouchInputs = 16;
 
 struct ConsoleMotionInfo {
     Common::Input::MotionStatus raw_status{};
@@ -30,13 +27,13 @@ struct ConsoleMotionInfo {
 };
 
 using ConsoleMotionDevices = std::unique_ptr<Common::Input::InputDevice>;
-using TouchDevices = std::array<std::unique_ptr<Common::Input::InputDevice>, MaxTouchDevices>;
+using TouchDevices = std::array<std::unique_ptr<Common::Input::InputDevice>, 16>;
 
 using ConsoleMotionParams = Common::ParamPackage;
-using TouchParams = std::array<Common::ParamPackage, MaxTouchDevices>;
+using TouchParams = std::array<Common::ParamPackage, 16>;
 
 using ConsoleMotionValues = ConsoleMotionInfo;
-using TouchValues = std::array<Common::Input::TouchStatus, MaxTouchDevices>;
+using TouchValues = std::array<Common::Input::TouchStatus, 16>;
 
 struct TouchFinger {
     u64 last_touch{};
@@ -58,7 +55,7 @@ struct ConsoleMotion {
     bool is_at_rest{};
 };
 
-using TouchFingerState = std::array<TouchFinger, MaxActiveTouchInputs>;
+using TouchFingerState = std::array<TouchFinger, 16>;
 
 struct ConsoleStatus {
     // Data from input_common
@@ -169,10 +166,6 @@ private:
      */
     void SetTouch(const Common::Input::CallbackStatus& callback, std::size_t index);
 
-    std::optional<std::size_t> GetIndexFromFingerId(std::size_t finger_id) const;
-
-    std::optional<std::size_t> GetNextFreeIndex() const;
-
     /**
      * Triggers a callback that something has changed on the console status
      * @param type Input type of the event to trigger

src/core/hid/emulated_controller.cpp

@@ -970,7 +970,14 @@ bool EmulatedController::SetVibration(std::size_t device_index, VibrationValue v
            Common::Input::VibrationError::None;
 }
 
-bool EmulatedController::IsVibrationEnabled(std::size_t device_index) {
+bool EmulatedController::TestVibration(std::size_t device_index) {
+    if (device_index >= output_devices.size()) {
+        return false;
+    }
+    if (!output_devices[device_index]) {
+        return false;
+    }
+
     const auto player_index = NpadIdTypeToIndex(npad_id_type);
     const auto& player = Settings::values.players.GetValue()[player_index];
 
@@ -978,15 +985,31 @@ bool EmulatedController::IsVibrationEnabled(std::size_t device_index) {
         return false;
     }
 
-    if (device_index >= output_devices.size()) {
-        return false;
-    }
+    const Common::Input::VibrationStatus test_vibration = {
+        .low_amplitude = 0.001f,
+        .low_frequency = DEFAULT_VIBRATION_VALUE.low_frequency,
+        .high_amplitude = 0.001f,
+        .high_frequency = DEFAULT_VIBRATION_VALUE.high_frequency,
+        .type = Common::Input::VibrationAmplificationType::Test,
+    };
 
-    if (!output_devices[device_index]) {
-        return false;
-    }
+    const Common::Input::VibrationStatus zero_vibration = {
+        .low_amplitude = DEFAULT_VIBRATION_VALUE.low_amplitude,
+        .low_frequency = DEFAULT_VIBRATION_VALUE.low_frequency,
+        .high_amplitude = DEFAULT_VIBRATION_VALUE.high_amplitude,
+        .high_frequency = DEFAULT_VIBRATION_VALUE.high_frequency,
+        .type = Common::Input::VibrationAmplificationType::Test,
+    };
 
-    return output_devices[device_index]->IsVibrationEnabled();
+    // Send a slight vibration to test for rumble support
+    output_devices[device_index]->SetVibration(test_vibration);
+
+    // Wait for about 15ms to ensure the controller is ready for the stop command
+    std::this_thread::sleep_for(std::chrono::milliseconds(15));
+
+    // Stop any vibration and return the result
+    return output_devices[device_index]->SetVibration(zero_vibration) ==
+           Common::Input::VibrationError::None;
 }
 
 bool EmulatedController::SetPollingMode(Common::Input::PollingMode polling_mode) {
@@ -1025,7 +1048,6 @@ bool EmulatedController::HasNfc() const {
     case NpadStyleIndex::JoyconRight:
     case NpadStyleIndex::JoyconDual:
     case NpadStyleIndex::ProController:
-    case NpadStyleIndex::Handheld:
         break;
     default:
         return false;
@@ -1136,27 +1158,27 @@ bool EmulatedController::IsControllerSupported(bool use_temporary_value) const {
     const auto type = is_configuring && use_temporary_value ? tmp_npad_type : npad_type;
     switch (type) {
     case NpadStyleIndex::ProController:
-        return supported_style_tag.fullkey.As<bool>();
+        return supported_style_tag.fullkey;
     case NpadStyleIndex::Handheld:
-        return supported_style_tag.handheld.As<bool>();
+        return supported_style_tag.handheld;
     case NpadStyleIndex::JoyconDual:
-        return supported_style_tag.joycon_dual.As<bool>();
+        return supported_style_tag.joycon_dual;
     case NpadStyleIndex::JoyconLeft:
-        return supported_style_tag.joycon_left.As<bool>();
+        return supported_style_tag.joycon_left;
     case NpadStyleIndex::JoyconRight:
-        return supported_style_tag.joycon_right.As<bool>();
+        return supported_style_tag.joycon_right;
     case NpadStyleIndex::GameCube:
-        return supported_style_tag.gamecube.As<bool>();
+        return supported_style_tag.gamecube;
     case NpadStyleIndex::Pokeball:
-        return supported_style_tag.palma.As<bool>();
+        return supported_style_tag.palma;
     case NpadStyleIndex::NES:
-        return supported_style_tag.lark.As<bool>();
+        return supported_style_tag.lark;
     case NpadStyleIndex::SNES:
-        return supported_style_tag.lucia.As<bool>();
+        return supported_style_tag.lucia;
     case NpadStyleIndex::N64:
-        return supported_style_tag.lagoon.As<bool>();
+        return supported_style_tag.lagoon;
     case NpadStyleIndex::SegaGenesis:
-        return supported_style_tag.lager.As<bool>();
+        return supported_style_tag.lager;
     default:
         return false;
     }
@@ -1212,6 +1234,12 @@ bool EmulatedController::IsConnected(bool get_temporary_value) const {
     return is_connected;
 }
 
+bool EmulatedController::IsVibrationEnabled() const {
+    const auto player_index = NpadIdTypeToIndex(npad_id_type);
+    const auto& player = Settings::values.players.GetValue()[player_index];
+    return player.vibration_enabled;
+}
+
 NpadIdType EmulatedController::GetNpadIdType() const {
     std::scoped_lock lock{mutex};
     return npad_id_type;

src/core/hid/emulated_controller.h

@@ -206,6 +206,9 @@ public:
      */
     bool IsConnected(bool get_temporary_value = false) const;
 
+    /// Returns true if vibration is enabled
+    bool IsVibrationEnabled() const;
+
     /// Removes all callbacks created from input devices
     void UnloadInput();
 
@@ -336,7 +339,7 @@ public:
      * Sends a small vibration to the output device
      * @return true if SetVibration was successfull
      */
-    bool IsVibrationEnabled(std::size_t device_index);
+    bool TestVibration(std::size_t device_index);
 
     /**
      * Sets the desired data to be polled from a controller

src/core/hid/emulated_devices.cpp

@@ -145,7 +145,6 @@ void EmulatedDevices::UnloadInput() {
     for (auto& button : keyboard_modifier_devices) {
         button.reset();
     }
-    ring_analog_device.reset();
 }
 
 void EmulatedDevices::EnableConfiguration() {

src/core/hid/input_converter.cpp

@@ -200,6 +200,9 @@ Common::Input::TouchStatus TransformToTouch(const Common::Input::CallbackStatus&
     x = std::clamp(x, 0.0f, 1.0f);
     y = std::clamp(y, 0.0f, 1.0f);
 
+    // Limit id to maximum number of fingers
+    status.id = std::clamp(status.id, 0, 16);
+
     if (status.pressed.inverted) {
         status.pressed.value = !status.pressed.value;
     }

src/core/hle/ipc_helpers.h

@@ -86,13 +86,13 @@ public:
         u32 num_domain_objects{};
         const bool always_move_handles{
             (static_cast<u32>(flags) & static_cast<u32>(Flags::AlwaysMoveHandles)) != 0};
-        if (!ctx.GetManager()->IsDomain() || always_move_handles) {
+        if (!ctx.Session()->IsDomain() || always_move_handles) {
             num_handles_to_move = num_objects_to_move;
         } else {
             num_domain_objects = num_objects_to_move;
         }
 
-        if (ctx.GetManager()->IsDomain()) {
+        if (ctx.Session()->IsDomain()) {
             raw_data_size +=
                 static_cast<u32>(sizeof(DomainMessageHeader) / sizeof(u32) + num_domain_objects);
             ctx.write_size += num_domain_objects;
@@ -125,7 +125,7 @@ public:
         if (!ctx.IsTipc()) {
             AlignWithPadding();
 
-            if (ctx.GetManager()->IsDomain() && ctx.HasDomainMessageHeader()) {
+            if (ctx.Session()->IsDomain() && ctx.HasDomainMessageHeader()) {
                 IPC::DomainMessageHeader domain_header{};
                 domain_header.num_objects = num_domain_objects;
                 PushRaw(domain_header);
@@ -145,18 +145,18 @@ public:
 
     template <class T>
     void PushIpcInterface(std::shared_ptr<T> iface) {
-        if (context->GetManager()->IsDomain()) {
+        if (context->Session()->IsDomain()) {
             context->AddDomainObject(std::move(iface));
         } else {
             kernel.CurrentProcess()->GetResourceLimit()->Reserve(
-                Kernel::LimitableResource::SessionCountMax, 1);
+                Kernel::LimitableResource::Sessions, 1);
 
             auto* session = Kernel::KSession::Create(kernel);
-            session->Initialize(nullptr, iface->GetServiceName());
-            iface->RegisterSession(&session->GetServerSession(),
-                                   std::make_shared<Kernel::SessionRequestManager>(kernel));
+            session->Initialize(nullptr, iface->GetServiceName(),
+                                std::make_shared<Kernel::SessionRequestManager>(kernel));
 
             context->AddMoveObject(&session->GetClientSession());
+            iface->ClientConnected(&session->GetServerSession());
         }
     }
 
@@ -386,7 +386,7 @@ public:
 
     template <class T>
     std::weak_ptr<T> PopIpcInterface() {
-        ASSERT(context->GetManager()->IsDomain());
+        ASSERT(context->Session()->IsDomain());
         ASSERT(context->GetDomainMessageHeader().input_object_count > 0);
         return context->GetDomainHandler<T>(Pop<u32>() - 1);
     }
@@ -405,7 +405,7 @@ inline s32 RequestParser::Pop() {
 }
 
 // Ignore the -Wclass-memaccess warning on memcpy for non-trivially default constructible objects.
-#if defined(__GNUC__) && !defined(__clang__) && !defined(__INTEL_COMPILER)
+#if defined(__GNUC__)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wclass-memaccess"
 #endif
@@ -416,7 +416,7 @@ void RequestParser::PopRaw(T& value) {
     std::memcpy(&value, cmdbuf + index, sizeof(T));
     index += (sizeof(T) + 3) / 4; // round up to word length
 }
-#if defined(__GNUC__) && !defined(__clang__) && !defined(__INTEL_COMPILER)
+#if defined(__GNUC__)
 #pragma GCC diagnostic pop
 #endif
 

src/core/hle/kernel/board/nintendo/nx/k_system_control.h

@@ -8,10 +8,6 @@
 namespace Kernel::Board::Nintendo::Nx {
 
 class KSystemControl {
-public:
-    // This can be overridden as needed.
-    static constexpr size_t SecureAppletMemorySize = 4 * 1024 * 1024; // 4_MB
-
 public:
     class Init {
     public:

src/core/hle/kernel/global_scheduler_context.cpp

@@ -49,26 +49,4 @@ bool GlobalSchedulerContext::IsLocked() const {
     return scheduler_lock.IsLockedByCurrentThread();
 }
 
-void GlobalSchedulerContext::RegisterDummyThreadForWakeup(KThread* thread) {
-    ASSERT(IsLocked());
-
-    woken_dummy_threads.insert(thread);
-}
-
-void GlobalSchedulerContext::UnregisterDummyThreadForWakeup(KThread* thread) {
-    ASSERT(IsLocked());
-
-    woken_dummy_threads.erase(thread);
-}
-
-void GlobalSchedulerContext::WakeupWaitingDummyThreads() {
-    ASSERT(IsLocked());
-
-    for (auto* thread : woken_dummy_threads) {
-        thread->DummyThreadEndWait();
-    }
-
-    woken_dummy_threads.clear();
-}
-
 } // namespace Kernel

src/core/hle/kernel/global_scheduler_context.h

@@ -4,7 +4,6 @@
 #pragma once
 
 #include <atomic>
-#include <set>
 #include <vector>
 
 #include "common/common_types.h"
@@ -59,10 +58,6 @@ public:
     /// Returns true if the global scheduler lock is acquired
     bool IsLocked() const;
 
-    void UnregisterDummyThreadForWakeup(KThread* thread);
-    void RegisterDummyThreadForWakeup(KThread* thread);
-    void WakeupWaitingDummyThreads();
-
     [[nodiscard]] LockType& SchedulerLock() {
         return scheduler_lock;
     }
@@ -81,9 +76,6 @@ private:
     KSchedulerPriorityQueue priority_queue;
     LockType scheduler_lock;
 
-    /// Lists dummy threads pending wakeup on lock release
-    std::set<KThread*> woken_dummy_threads;
-
     /// Lists all thread ids that aren't deleted/etc.
     std::vector<KThread*> thread_list;
     std::mutex global_list_guard;